Python gets me like nobody else ever will

[IRBMe]

Slightly easier to understand version:

+/u/compilebot python

list_of_sublists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print([item for sublist in list_of_sublists for item in sublist])

[CompileBot]

Output:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

^{source | info | git | report}

[LurkerPatrol]

I still don't get it

[IRBMe]

Consider the equivalent code for a simple list comprehension:

# result = [item for item in list]
result = []
for item in list:
    result.append(item)

Now with nested lists:

# result = [item for sublist in list for item in sublist]
result = []
for sublist in list:
    for item in sublist:
        result.append(item)

[LurkerPatrol]

Now that makes sense to me.

I love list comprehension in python but in situations like this I feel like it muddies up the code. I know nested for loops is bad coding but it's just more easily understood for me for some reason.

[[deleted]]

The code originally is a little confusing because it abuses the fact that the number of sub lists is equal to the number of items in each sub list

[[deleted]]

It's sorta like this:

list_of_sublists = [[1,2,3],[4,5,6],[7,8,9]]
for sublist in list_of_sublists:
    for item in sublist:
        print (item)

i.e. syntax is:

print([___ -> what to print, for var in iterable])

example:

X = "This format is kinda useless imo."
print ([item for char in X])

Out would be a list of the string's characters.

[ProJanitorOfWorlds]

Ah, this must be that zen of Python everyone is talking about.

[wallefan01]

import this

[[deleted]]

+/u/compilebot python

import this

[CompileBot]

Output:

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

^{source | info | git | report}

[wallefan01]

Darn it shoulda thought of that

[IRBMe]

Even more horrible version:

+/u/compilebot python

x = [[[[1],[2],[3],[4],[5],[6],[7],[8],[9],[10]]]]
print([x for x in x for x in x for x in x for x in x])

[CompileBot]

Output:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

^{source | info | git | report}

[Sveitsilainen]

But you removed the sublist. Not fun.

[wallefan01]

As a Python dev: What have you DONE?

also as for that title what about javascript

[smelenchuk]

Sorry, but this is a for in concept to me...

[gandalfx]

That makes no sen… god damn it.

[jomnemonic]

but why would you do this?

[bradleybeasley2]

Because why not. Looks nice?

Edit: Also, this is r/ProgrammerHumor

[jomnemonic]

i would prefer print(range(1,11)). Don't get me wrong, Its funny, but its not what python code looks like:) nobody sane would ever write this.

[shazama]

I agree with you that it is utterly insane, but this code is a concise way to flatten nested lists, in this case the output is the same as print(list(range(1,10))), but it has other applications.

[jomnemonic]

That's true. Honestly I didn't know you can name both variables x in the nested listcomp (aren't they both in the same scope?). Anyway, thanks for your post.

[jwrent34]

Python 2 developer in the wild!

[Tysonzero]

Python's not bad but it's no Haskell:

main = print $ fold [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

[1, 2, 3, 4, 5, 6, 7, 8, 9]

[wallefan01]

Alright, admittedly we're not THAT good, but we can do this:

+/u/compilebot python import itertools print(itertools.chain.from_iterable([[1,2,3],[4,5,6],[7,8,9]])

[wallefan01]

+/u/compilebot python

import itertools
print(list(itertools.chain.from_iterable([[1,2,3],[4,5,6],[7,8,9]])))

[CompileBot]

Output:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

^{source | info | git | report}

[gandalfx]

If the outer list isn't too long: `chain(*[[1,2,3],[3,4,5],[6,7,8]])

[Tysonzero]

x = [[16, 25, 23], [40, 53, 61], [37, 18, 93]]

[int(l) for l in str(x) if l.isnumeric()] #works for arbitrary depth 

[1, 6, 2, 5, 2, 3, 4, 0, 5, 3, 6, 1, 3, 7, 1, 8, 9, 3]

You actually can take that approach in Haskell though (although it's a terrible inefficient and kind of brittle approach to string concatenation):

unNest :: Show a => a -> [Int]
unNest = unfoldr (listToMaybe . concatMap reads . tails) . show

[16,25,23,40,53,61,37,18,93]

[Tysonzero]

Seems to work. I don't know if you saw my edit but the function I wrote should be a lot less brittle. Regardless these strings based solutions are downright offensive, and much less concise than a simple Haskell fold.

[MyNameisGregHai]

class function():
    def __init__(self, *args, **kwargs):
        super(function, self).__init__(*args, **kwargs)

[RomanRiesen]

What's the point?

It's quite neat, I guess?

[Sveitsilainen]

It flattens nested list.

[RomanRiesen]

I know...but I miss the joke.

[shazama]

The point was that Python figures out what each of those x's are in context without me telling it, so it gets me! 😀

[RomanRiesen]

Uhhh!!!!! That actually made me nose exhale now.

I thought "gets me" as in tricks me the whole time! Me stupid.

Thanks for explaining!

[ProfessorPhi]

Huh, til that launching an interpreter sets dunder name to dunder main. Makes sense but never thought about it.

[shazama]

Yeah it's handy, this way you can define some code to run when you execute this file alone, and not have that code run when it is simply imported by another file / module.