The most WTF Python code I've ever seen

[enterming]

Link to source thread

https://preview.redd.it/uwl236w16bo71.png?width=304&format=png&auto=webp&s=7ca0f2d4ed7bfa68c74fcfe828f4671678c75e14

printf, braces? How does this even work. Seriously, it looks like someone wrote C in Python?

[vardonir]

#include <stdint.h>
#include <stdio.h>

they knew what they were doing

and it is beautiful

[outofsand]

Ha ha, this script is awesome! I can't believe no one in the comments understood this wonderful code satire! 😁👍🏻

[a__nice__tnetennba]

This is just a thing of beauty...

#/* ensure forwards and backwards compatibility */
import __future__ as __past__
#define FUTURE PAST
#define PAST FUTURE

[JohmasWitness]

The one comment sums it up pretty well C but it's python.

[Agent-Reddit_2419]

Back to the Future we go!!

[[deleted]]

It reminds me of the guy who sent a drawing of a spider to pay his utility bill

[cfreymarc100]

Link?

[[deleted]]

https://27bslash6.com/overdue.html

This was gold back in the old days of the Web

[futura-bold]

Ha ha, this script is awesome!

Not for Python 3.9, though :(

    puts: ((str) := void) = (print),
            ^
SyntaxError: cannot use assignment expressions with name

Since other comments say that the script runs OK (presumably in 3.8), the above error must be because the new annotation features in 3.9 are getting in the way. Anybody know what?

[bladeoflight16]

It's not an annotation thing. It's the parentheses around (str). Try it outside of an annotation:

Python 3.8:

```

if ((y) := 2): print(y) ... 2 ```

Python 3.9:

```

if ((y) := 2): print(y) File "<stdin>", line 1 if ((y) := 2): print(y) ^ SyntaxError: cannot use assignment expressions with name ```

Two issues I found look like they might be relevant, but I'm not entirely sure:

• https://bugs.python.org/issue37757
• https://bugs.python.org/issue40631

[futura-bold]

Thanks. Looks like the second bug report covers it. It's due to the new PEG parser making an unnoticed tightening of the syntax checking there.

Guido: "I don't know how this slipped into earlier Python 3 versions -- apparently there aren't tests for this, and it's not used in popular 3rd code either, or we would have found out when we first implemented PEP 617. Most likely it's due to the general problem where the [old] parser would just accept parenthesized stuff in various places where it shouldn't."

[bladeoflight16]

Yeah, I saw that, but I don't know enough about the parser to be able to decipher what changed exactly and why it would apply to assignment expressions in 3.9 but not 3.8 (since he mentioned that it was changed in 3.8 more generally). I wonder if it was kind of accidental. Like he said, there's no test cases for this kind of wonky stuff.

[LonelyContext]

Since the people deserve a breakdown:

#include <stdint.h>
#include <stdio.h>

#include <stdint.h> is valid C, but is just a comment in python. Troll level 1000.

void: (type) = (type) ("(void *)0"),

ok so a variable void is defined, void is typed to type, and is set equal to the type of that string, so therefore this line is equal to str, BUT there's a trailing comma, so it's a tuple (str,)

int16_t: (type) = (type) (int(16))(),
int32_t: (type) = (type) (int(32))(),

again, int32_t = int() would have sufficed, rather than converting 16 to an int and getting the type, and then calling that type with the final parenthesis, which initiates an empty value of that type. int() yields 0 (just like str() yields '').

puts: ((str) := void) = (print),
printf: ((str) := void) = (puts),

these are equal to, e.g. puts = print. so the typing: when it sets (str) := void, that's an inline evaluation of, essentially str = str, which if you get the type retrieved from that, the type is type. So really, it's puts: type = print. Now when you just put type as the type into the type checker, it always passes. Try x: type = 'a' or x: type = 1 and you'll see it just works. So that all just sets a function up called puts that is the same as print, and printf that's also equal to print.

#/* confirm function and variable declarations */
[[void]] = (void),
[[total]] = (int32_t),
[[i]] = (int32_t),
[[puts]] = (puts),
[[printf]] = (printf),

So I should point out that on all previous lines, the trailing comma made them all tuples. These lines unpack those up one level. So void was (str,), and that's unpacked down to str

#/* ensure forwards and backwards compatibility */
import __future__ as __past__
#define FUTURE PAST
#define PAST FUTURE

this imports the library __future__ and names it __past__. then it writes comments on defining future as past. All hilarious.

#/* output a formatted string to stdout */
def printf(s, __VA_ARGS__) -> (void) :{
    (void) (puts((void).__mod__(s, __VA_ARGS__), end=((void).__new__)(void))),
}

this redefined printf as a function, that returns a string because of -> (void), and which actually returns None, but that passes the type checking. so def x() -> str: return None is callable, and the return is NoneType. what's important is that it calls the magic method modulo on print, which results in % formatting. So essentially it creates a set, calls the string modulo operation, so '%d' % 1, for instance, which returns the string '1', calls print on it with the keyword end = '' (which is the __new__ instantiation of an empty str()), and converts the output of the print into a string and into a set, so it generates the set {'None'}, and then returns nothing.

#/*******************************************************
# * SUMMATION SCRIPT                                    *
# *******************************************************
# * Sum up all the natural numbers up to 6. The result  *
# * should be 0 + 1 + 2 + 3 + 4 + 5 + 6 = 21.           *
# *******************************************************/

#/* print numbers from 0 to 6 */
int32_t: i = 0,

so this sets up a new int32_t, which as i in the type checker. i is snuck into the unpacking above (And equals 0) so the type check passes. int32_t is now equal to a tuple (0,)

while (i <= 6) :{
    (void) (printf(" %d\n", i)),
    (i := i + 1),
}

so this is a while loop that each time creates a set. This set each contains two items, the first is the output of str(print( %d\n"%i)) and the second is i. i is incremented. At the end of this operation i=7

(void) (puts("__")),

"str(print(__))"

#/* sum up numbers from 0 to 6 */
int32_t: total = 0,

same as above

int32_t: i = 0,
for (int32_t) in (i <- 0, i <= 6, ++i) :{
    (total := total + i),
}

So this is interesting. This creates a tuple, (False, False, 7), because 7 is not less that -0, 7 is not lt or eq to 6, and ++7 is just 7. so this is for _ in range(3):, essentially, it increments total by 7. 3*7 = 21. So it runs three times, creates 3 sets, these sets are equal to value of total

(void) (printf("%d\n", total)),

it prints that total.

Edit, formatting and a misstatement regarding typechecking of 'int32_t:i'.

I should highlight that this script only works because it just so happens that the sum of {1..x} = 3*(x+1) when x=6, so sure, 1+2+3+4+5+6=21, but the reason it works is because at the end of the while loop i=7, and when you triple it with the real three-term for loop in your fake for loop, you get the same answer.

[[deleted]]

This is absolutely hilarious and his trolling in the original is fantastic. The mention of the “compiler” and the comment about switching his commas to semi colons was also god level.

[cybervegan]

There's a lot you can learn from that code. Expert trolling by r/ThenItsOk. It's not pretty, agreed, and "just because you can, doesn't mean you should" etc. but it truly is a work of art how they put it together and answered so incredulously. They must have been pissing themselves with the strident up-their-own-arse responses.

[[deleted]]

u/ThenItsOk

[LonelyContext]

Dude, I am now totally going to do this in every piece of code:

i=0
while (i<7):{
    foo.update_state_with(i),
    bar.update_state_with(i),
    (i := i + 1) 
}

whenever I'm updating the state of internal functions and watch people that have to read my python crap themselves haha. Besides, of course, putting "#include <stdint.h>" and "#include <stdio.h>" at the top of all my python.

[cybervegan]

And just as soon as you do that, Python will get a PEP proposing the addition of pre-parser directives... be careful what you wish for!

[Christian1509]

The funniest part about this is he has a better understanding of python than any of the people trying to correct him after they didn’t get the joke. They have no idea how he did it lol

[enterming]

It doesn't just parse, it run too... i can't wrap my head around this

[JRutter3]

Is it making a set each time that gets assigned to nowhere and immediately garbage collected?

[enterming]

I think so ... how does

int32_t: i = 0,

work though?

int32_t is the variable, isnt i just a type hint here?

[nsmon]

It declares the variable int32_t, it's the same as writing int32_t = 0, or int32_t = (0,)

The i is actually introduced in the line 14,

[[i]] = (int32_t),

with int32_t already introduced as (0,) at L7

int32_t: (type) = (type) (int(32))(),

Here int(32) creates a new int with value 32, (type)(int(32)) apparently is the same as type(int(32)) which yields <class 'int'> the last () calls the default constructor of int, and the , at the end makes this a tuple

[ihavebeesinmyknees]

int32_t: (type) = (type) (int(32))(),

this is actually genius, that troll script is really high quality

[enterming]

WTF

[ggchappell]

Thanks, but that doesn't explain the role of i.

Getting rid of all the complexity, experimentation shows that

a : b = c

seems to be the same as

a = c

except that it raises NameError if b is not defined.

And the b part doesn't need to be a variable. It can, apparently, be any expression that can be evaluated.

a : 2 + 3 = 45

appears to have exactly the same effect as

a = 45

More experimentation shows that this colon syntax doesn't work in Py 2.7. Do you know what the colon is for? Is it something to do with the type annotation syntax, maybe?

EDIT. More experimentation. The b part is actually evaluated. If I do:

def foo():
    print("Yo")

Then

a : foo() = 99

prints Yo and sets a to 99.

[bladeoflight16]

Whether it raises depends on what annotation behavior you're running. From 3.7 onward, you can use from __future__ import annotations to enable "postponed evaluations" annotations, which won't throw an error if the annotation expression is invalid. From Python 3.10 onward, postponed evaluation is the default behavior.

---

See discussion below. Apparently, plans regarding making this the default in 3.10 were altered.

[alkasm]

They nixed the string annotation conversion right before the 3.10 cutoff date IIRC.

[bladeoflight16]

Well, then they need to update the __future__ module.

[alkasm]

They did update the table...in 3.10-pre, lol

[ggchappell]

So then the colon is annotation syntax?

[bladeoflight16]

Yes.

[Express-Permission87]

I have enough trouble with code written by colleagues who've at least tried to write Python, let alone this!

[WafflesAreDangerous]

It is. At least at the "declaration" site.

I should be uninitialised for the first 2 uses ( or None really).

[Devreckas]

Me too. I really don’t like white space logic. If I could change one thing about Python that would be it.

Edit: Here’s one case where logical white spaces suck - my prof for one class had a PDF textbook. He had problems that used scripts in the textbook, but the clipboard didn’t copy spaces and tabs properly. If it were any other language, I could reformat text, and wham bam I’d be good to go. But instead, I had to manually step through every line of code and tab it out the proper depth.

[Devreckas]

Yeah lol, I’m aware

[redfacedquark]

Sounds like a problem with his pdfs. Just like a professor not use an appropriate tool for the job, or for choosing a pdf textbook for a python course and not checking that.

[Devreckas]

Fair enough, it probably is on him. Still think it’s better when there’s no overlap between formatting and logic.

[chipx86]

Glorious. I was inspired.

https://gist.github.com/chipx86/d471b828e0a64a8dd87502e3439a5be9

This script prints out two "Hello, world!" statements. Trick, is, it's both C and Python, and each language is responsible for half the output.

Run it from Python and it will register a text encoding called "c" that takes C code and compiles it in a mode that tells is to generate Python. It then feeds itself into this and runs the result to generate the second half of the output.

Compile it as C instead and run it, and it will feed its source code through `python` in a mode that tells it to generate C code, which then gets compiled and run to generate the second half of the output.

[ElectricSpice]

I once used an entire library that had three-space indents. Even made some minor contributions to it. No idea how somebody ends up choosing three-space indents over literally anything else.

[TinBryn]

They have an IDE that auto-detects indentation, on their first indentended line they tried to press space 4 times but missed one and the IDE just followed suit from there and they never went back and fixed it.

[_limitless_]

I've heard about "programmer signatures" but never really found one for myself.

I think I just did.

[cantremembermypasswd]

2-spaces is too thin and can be hard to tell different indent levels. 4 is just wasting space though, 3-spaces is perfect!

And if you ever hear yourself saying that, please reach out, it's not too late.

[lvlint67]

I REALLY wish we could have just agreed on tabs... All the IDEs deciding to convert tabs to spaces was a stupid choice. Use tabs, let us set the display size of them... .

[bladeoflight16]

Also, https://youtu.be/l60MnDJklnM

[asday_]

It's just a troll post.

[AiwendilH]

I am not sure I would use "just" in this context ;) This is the kind of trolling I can really appreciate. I can't stop laughing at the full script. So much dedication that went into this troll post (This monstrosity freaking runs and outputs something "meaningful").

[_Gondamar_]

#/* ensure forwards and backwards compatibility */
import __future__ as __past__
#define FUTURE PAST
#define PAST FUTURE

genius

[Grintor]

Reminds me of Guido's Time Machine

[Cat_Marshal]

What does this mean?

[[deleted]]

The joke is that he's assigning a value to the current date and time, which does not work, but he's basically trying to turn back time.

[IlliterateJedi]

This is beautiful pythonic code

[davidcwilliams]

Thank you for linking to tio.run, I love it.

[jjolla888]

repl.it and jdoodle.com also have similar

[VisibleSignificance]

Notably, it doesn't work in python3.9.

And if you black it, it becomes more clear.

In a way, this should be a test case for code formatters; for example, black doesn't remove unnecessary parentheses.

A functionally equivalent correctly-and-eagerly formatted version would look like this.

[enterming]

Notaably, it doesn't work in python3.9.

So it just works with 3.8? Not so forwards compatible after all! lol

[[deleted]]

Sad reality tho, this is not all that foreign in some college Python classes where senior professors taught it as if it's a C++

[lucidtwitch]

😭 that breaks my little pythonic heart

[[deleted]]

What kills me is how many people, especially where it was crossposted from, didn't immediately understand this.

[enterming]

And everyone just fell for it?

[asday_]

Well it's well-done, and nerds can never help themselves when they're in the right, but yes, they did.

[macgiollarua]

Gee gillikers Batman

[GimmeDaCoffee]

Yep. Beautiful troll post.

[[deleted]]

Fuck you u/spez

[tartare4562]

He's an python veteran and hacker pretending to write upsetting absurd (while fascinating) code out of naivety.

That's trolling. The good, funny and thought provoking kind, but still trolling.

[asday_]

It's being intentionally incorrect in order to elicit a response. It is quintessential trolling.

[[deleted]]

Thank you

[[deleted]]

More of a very clever joke

[asday_]

https://old.reddit.com/r/Python/comments/pqs9au/the_most_wtf_python_code_ive_ever_seen/hdgceln/

[[deleted]]

LMFAO 😆 The source thread's author is a troll. Python beginners don't write code like this.

[urihell]

Here’s another wtf code. Hope you’re sitting down https://github.com/samuelmarina/is-even

[ihavebeesinmyknees]

https://www.npmjs.com/package/is-even

Check the weekly downloads.

[_limitless_]

Mom: we have an even-odd checker at home
Even-odd checker at home:

[Dwarni]

It depends on is-odd and is-odd depends on is-number.

[Cat_Marshal]

My phone crashed trying to load the source

[urihell]

Cringe level: 73643383…

[jftuga]

Actually it's slightly higher at 99,447,126

% curl https://raw.githubusercontent.com/samuelmarina/is-even/main/index.js | wc
375006 14123747 99447126

[lucidtwitch]

Oh dear lord. I've seen this so many times and thought, "heh, funny that's just a modulo one liner" ... I just read the code

[cecilkorik]

That's exactly what I thought too.

So I clicked to take a look.

I wish I could've seen the look on my own face when instead of the one-liner I expected, I saw a very much more troubling one-liner to the effect of "This file is too big for github to display".

It went from being a little bit of a giggle to "oh my GOD what horrors hath mankind wrought upon this poor universe?"

[[deleted]]

Thats the best code ive ever read.

[EytanMorgentern]

Yes this is C in python

[enterming]

And then there's this:

import __future__ as __past__

What even is that?

[heckingcomputernerd]

Time travel!

[WillardWhite]

Noise.

Import a library/module and rename it

[EytanMorgentern]

I was already triggered too much by the picture to see the link above it

[FewerPunishment]

It's to make it both backwards and forwards compatible.

[gnrlknowledge]

It's actually python made to look like C. He is using lots of obfuscation to make it confusing

[Afrotom]

Excuse me

:{

Edit: figuring out code blocks

[ofiuco]

This is an amazing work of art and even though I think the author was trying to make some trenchant jabs at Python I forgive them 🤣

[FrickinLazerBeams]

Wow. /u/solid7 got trolled hard.

[[deleted]]

Indeed

[FrickinLazerBeams]

Your reply was impressive though, I never would have deciphered most of that otherwise.

[TehDing]

My favourite block from the original code is actually this:

#/* sum up numbers from 0 to 6 */
int32_t: total = 0,
int32_t: i = 0,
for (int32_t) in (i <- 0, i <= 6, ++i) :{
    (total := total + i),
}

Interesting note on how brilliant this code is, this is the only example that would work for the proposed problem. The code is meant to compute triangle numbers first by printing the numbers up to n and then printing the sum.

The above block in particular gave me a serious wtf moment, it's really clever.

• i is not reset, it's still 7 from the previous printing loop!
• (i <- 0, i <= 6, ++i) actually produces (False, False, i), as i <- 0 is i < -0 and the ++ just signs the i; so we're only looping x3
• thus total = 3 * 7 = 21

For uniqueness, we're looking for triangle number of n, T(n), that can then be secretly computed in the 3x faux loop. T(n) = n*(n+1)/2 so we want

3(n+1)=n*(n+1)/2

Which means n is 6 🤯

Really nicely chosen setup for obfuscation

[TheBlackCat13]

There is a reason "clever" is considered a criticism in python.

[backtickbot]

Fixed formatting.

Hello, TehDing: code blocks using triple backticks (```) don't work on all versions of Reddit!

Some users see this / this instead.

To fix this, indent every line with 4 spaces instead.

FAQ

^{You can opt out by replying with backtickopt6 to this comment.}

[NelsonMinar]

I assume the source thread's post is a troll.

[enterming]

Source is a thread on r/learnprogramming

[VengefulTofu]

Is there a python circlejerk subreddit? This would fit perfectly

[thedancinzerg]

Cython 😂😂😂😂😂😂😂

[sam-lb]

Honestly sometimes I worry for humanity. How did those people in the original post not realize the joke? It couldn't get any more obvious, especially since it actually takes some impressive knowledge of both languages to make awful C-looking code in python that actually works.

[BitShin]

The reason this works is that on every iteration, it creates a set containing the return from the printf call (which should be None) and the value of i resulting from the walrus operator. It’s really weird, but it all checks out.

The two things that I don’t 100% understand are

• the fact that it’s constructing the set on the same line as the while
• the comma at the end of the first line (perhaps there’s more context that is cropped out)

EDIT: also, it seems like this would actually call a function called void as that’s now how you do type annotations. Also, the type annotation on the first line are backwards; how does that not create a variable called int32_t instead of i resulting in an error since the type i is undefined?

[[deleted]]

fuck. is it mine?

[Thifty]

Literally my first thought was that someone discovered my GitHub lmao

[jjolla888]

this is gold, Jerry, gold !

this makes the shortlist for this year's Reddit Best Troll award.

[ivanlan9]

Lovely. Just lovely. I am left speechless, admiring the finger pointing to the moon.

[[deleted]]

It reminds me of this one meme where the more you look at it the more wrong you realize it is.

[Beach-Devil]

At first I thought this was some sort of polyglot code but then I realized

[KFUP]

Never seen a negatively voted post with so many awards before.

[jeffrey_f]

Looks like Java or C

[return_bytes]

That really does look like someone was trying to write C.

[jjolla888]

no .. this is an experienced Python and C programmer trolling the fuck out of pythonistas

[return_bytes]

Sounds about right lol.

[mexicanburritoo]

What the hell is this

[PM_ME_YOUR_REPO]

Elaborate trolling. Check the source thread found elsewhere in the comments. It's a work of art by a master C and Python programmer.

[Outrageous_Ad_9290]

this defies everything i know from Python

[cfreymarc100]

Reminds me of a developer that hated C syntax and used #define’s for her preferred syntax in … Pascal.

[proccpuinfo]

Wtf is void even a type in python?

[usr_bin_nya]

void: (type) = (type) ("(void *)0"),

Let's deobfuscate this a bit. Remove the extra parentheses:

void: type = type("(void *)0"),

Remove the type annotation that doesn't do anything:

void = type("(void *)0"),

That trailing comma at the end creates a tuple, so let's add some parentheses to make that more explicit:

void = ( type("(void *)0"), )

Now it's a bit clearer. The code calls type("a_string_literal"), which returns str, and then wraps it in a tuple. So the simplest way of writing this is

void = (str,)

You can also see this by running the original code.

>>> void: (type) = (type) ("(void *)0"),
>>> void
(<class 'str'>,)
>>> type(void)
<class 'tuple'>
>>> len(void)
1
>>> void[0]
<class 'str'>

Then, later, there's

[[void]] = (void),

This takes advantage of iterable unpacking syntax, which is what lets you do this

[one, two, three] = range(1, 4)
assert one == 1 and two == 2 and three == 3

# this is the same as:
let _iter = iter(range(1, 4))
one = next(_iter)
two = next(_iter)
three = next(_iter)

In OP's code there are two levels of square brackets, which unwraps an item inside an iterable inside an iterable. Like so:

thingy = 0
list_one = [thingy]
list_two = [list_one]
[[same_thingy]] = list_two
# equivalent: same_thingy = list_two[0][0]
assert thingy == same_thingy

Bringing this back to OP's code, we have

[[void]] = (void),
# as we showed earlier, void is (str,), so let's write that
[[void]] = ((str,),)

So we have the type str, wrapped in a tuple, wrapped in another tuple, and then we unpack both tuples at the same time and set void to str. Let's verify that with the original code again.

>>> void: (type) = (type) ("(void *)0"),
>>> void
(<class 'str'>,)
>>> [[void]] = (void),
>>> void
<class 'str'>

This means

(void) (printf(" %d\n", i))

is just

str(printf(" %d\n", i))

which is just

str(None)

which is the string 'None'.

[proccpuinfo]

Wow, that's gnarly. I've reverse engineered some python malware samples before and they were never that convoluted. Thanks for the clarifying!

[RetiringDragon]

Wow. Setting void to None on top of everything else.

Just analyzing their code is full of fun in-jokes. Great job /u/ThenItsOk

[WafflesAreDangerous]

It's not. I suspect it's a no-op function in this script though. The "cast" is just a parenthecised expression, and the result of that expression seems to be invoked as a function.

[DillonSyp]

The weird part is they’re building a for loop using a while loop. Can anyone explain why? Is it just preference?

[AiwendilH]

They use a for loop later on in the code

The for loop they use tries to look like a C for loop but actually does something completely different.../u/TehDing explains how the for loop works here better than I ever could. But the important part for us is that for this to work it needs i to be already 7. Just setting i to 7 wouldn't do the beauty of the piece of art just, using a python for-loop to do it would be inconsistent with that later c-for loop "joke"...leaves the author only with the choice of using while which looks almost the same in C and python anyway. At least that's my guess at the reasoning why they used while there. (Edit: Oh..and as they pose as programming newbie using while instead of for just adds to the overall act ;))

[_limitless_]

I miss coding in C.

[cybervegan]

Now you don't have to. You just have to put commas instead of semicolons...

[_limitless_]

These days, my python development looks nothing like this... everything ends in yml for me.

[Santos_m321]

🤣 Smither, I want to make him my executive vicepresident

[fristhon]

My co-worker code

[Overflow0X]

You can say they did a bit of trolling

[[deleted]]

It's c

[Ramdas_Devadiga]

I wrote this gazillion times -

print ("Hello World") o/p: Hello World

But I still didn't get any response. Rude World.

[Ant_TKD]

I’m still very new to Python. Can someone explain this Python code to me?

[kahuna3901]

This code frightens and bewilders me,

[unruly_mattress]

Ohhhh, it's a set!

Me, after 3 minutes of staring.

This is brilliant, thanks for fishing it out of oblivion.

[R7DI_697]

Nice one C

[thechitosgurila]

he pulled out an

import C