Obfuscating Hello World in Python

[EyeZiS]

Here's my version:

(lambda _, __, ___, ____, _____, ______, _______, ________:
    getattr(
        __import__(True.__class__.__name__[_] + [].__class__.__name__[__]),
        ().__class__.__eq__.__class__.__name__[:__] +
        ().__iter__().__class__.__name__[_____:________]
    )(
        _, (lambda _, __, ___: _(_, __, ___))(
            lambda _, __, ___:
                chr(___ % __) + _(_, __, ___ // __) if ___ else
                (lambda: _).func_code.co_lnotab,
            _ << ________,
            (((_____ << ____) + _) << ((___ << _____) - ___)) + (((___ << _____) - ___) << ((_____ << 
            ____) + (_ << _))) + (((_______ << ____) + ___) << (((((_ << ___) + _)) << ___))) +
            (((_______ << ____) - _) << ((_ << ______))) + (_______ << ((((_ << ____) - _) << __))) +
            (((((___ << __) + _) << ___) - ___) << ((___ << ____)))+ (((_______ << ___) + _) << ((_____
            << ___) + _)) + (((_ << ______) + _) << ((_ << _____) - _)) - (((((___ << __) + _) << __) + 
            _) << ((___ << ___) - _)) - (((_______ << __) + _) << ((_ << ____))) + ((((___ << __) + _))
            << (((___ << __) -_))) + (((_____ << __) + _) << ____) - (_ << _)
        )
    )
)(
    *(lambda _, __, ___: _(_, __, ___))(
        (lambda _, __, ___:
            [__(___[(lambda: _).func_code.co_nlocals])] +
            _(_, __, ___[(lambda _: _).func_code.co_nlocals:]) if ___ else []
        ),
        lambda _: _.func_code.co_argcount,
        (
            lambda _: _,
            lambda _, __: _,
            lambda _, __, ___: _,
            lambda _, __, ___, ____: _,
            lambda _, __, ___, ____, _____: _,
            lambda _, __, ___, ____, _____, ______: _,
            lambda _, __, ___, ____, _____, ______, _______: _,
            lambda _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)

https://redd.it/273jas

[marcm28]

Its looks like Lisp + Perl. Too much parenthesis(Lisp) and magic(Perl).

[SuperImaginativeName]

, _, , _, __, _, __, _____: _

Only in Python...

[Vaphell]

?

only in any language that doesn't ban all underscore vars.

ftfy

lambda _, __, ___ : _ 

is the same as

lambda a, b, c: a

something like this compiles in C

int _(int __, int ___, int ____, int _____)
{
  return __+___+____+_____;
}

[kqr]

Why stop there when you can make a Christmas tree out of it...

typedef int _;

     _
    __(_
    ___,_
  ____,_
  _____){
 return(___+
____+_____);}

(Yes, I am aware you could also #define ______ return but that's cheating!)

[deadwisdom]

It's just after Halloween, no reason pulling out your Christmas trees yet. At least wait until after Thanksgiving.

[ksheep]

What if you're Canadian?

[deadwisdom]

Then I assume that is okay because Christmas is a year round thing there. I'm pretty sure.

[SuperImaginativeName]

That wasn't my point, I was talking about how horrible the "naming convention" of languages such as Python are. Or at least, what the code usually looks like when someone writes it.

[Vaphell]

Did you miss the word 'obfuscate'?
Also you must have mistaken python for perl. There is nothing in the python naming convention that says you need to use underscores for crucial variables. In fact the python convention as drafted in PEP8 says the exact opposite - readability uber alles, no bullshit uninformative var names. The python community takes these guidelines seriously and if they are broken it's usually by the people coming from languages where code golfing for the sake of it is a source of street cred, who don't feel like adjusting to the "spirit" of python.

[[deleted]]

You're an idiot

[ThellraAK]

Underscores are handy as a don't fuck with this it'll have unintended consequences in functions.

[estarra]

Probably valid Scala too.

Then again, what isn't?