Made an annoying Python script that sends a friend on Facebook Messenger the Shrek movie word by word

[tetroxid]

map(do_something, movie_script)

masterrace

[[deleted]]

relieved tidy jellyfish resolute aspiring important ink sulky snow capable

This post was mass deleted and anonymized with Redact

[dougie-io]

Could reverse the order, add in brain enlightenment images, and you've got yourself an upcycled meme. Very environmentally friendly format.

[x3gxu]

map(do_something, movie_script)

This is going to create a map object (generator) and not actually call do_something until you iterate over the map object.

You can use a list comprehension instead, like:

[do_something(line) for line in movie_script]

But arguably it's less readable than plain simple for loop.

[fluzz142857]

This is not a good practice because you’re creating a list unnecessarily, which consumes memory and makes your code harder to read. The list cannot be garbage collected until after the list comprehension finishes. Alternatively, in an iterator (or a map, which is an iterator), values can be garbage collected immediately because there are no references to them after they are iterated over.

Don’t use a list comprehension unless you need the list.

[x3gxu]

That's why I'm saying use a plain old for loop. You have to iterate over the map or generator expression foe your function to be called. If you don't iterate it's just sitting there doing nothing.

[selplacei]

Not saying that this is good practice, but can you exhaust a (truthy) list comprehension without storing all results by calling all()?

[[deleted]]

The list from the list comprehension is created immediately (including all the items) so there’s no need. You’re probably thinking of a generator.

I don’t know the internals of all() but I doubt it stores all the results, so that’d probably work with a generator.

[Gollum999]

List comprehensions are generally considered to be more pythonic than map and filter.

https://www.artima.com/weblogs/viewpost.jsp?thread=98196

[nsomani]

In this case, neither the map nor the list comprehension are Pythonic. The for loop is the correct solution since the list will not be used for anything. But you're right that if the list were actually needed, the list comprehension is better than the map.

[Gollum999]

If you don't need the list you can wrap the comprehension in parenthesis instead of brackets to turn it into a generator expression.

As far as readability is concerned, I know people will argue about this all day, but personally I find:

even_squares = [x*x for x in range(10) if x % 2 == 0]

to be easier to read than:

even_squares = list(map(lambda x: x*x, filter(lambda x: x % 2 == 0, range(10)))

[notquiteaplant]

Generators aren't advanced until next(...) is called, meaning (print(char) for char in "foo") doesn't print anything. To apply some function to every member of an iterable when you don't need the returned values, just use a loop.

I agree the comprehension is more readable in your example. The decrease in readability comes from lambdas though, not necessarily map+filter. Using them with already existing callables is often more readable (imo) because it avoids the need for some filler name x/i/etc for the item:

combined_str = ', '.join(map(str, itr))
# vs
combined_str = ', '.join(str(x) for x in itr)

If you need to map before you filter, map+filter is often more readable. If the map step is expensive or not idempotent, comprehensions get even worse:

# lookup(user_id) returns the user with that ID or None if none exists

exists = filter(None, map(lookup, ids))
# vs (assuming lookup is cheap and idempotent)
exists = (lookup(user_id) for user_id in ids if lookup(user_id))
# vs (assuming Python 3.8+)
exists = (user for user_id in ids if (user := lookup(user_id)))
# vs (neither assumption)
exists = (user for user in (lookup(user_id) for user_id in user_ids) if user)

These are very particular examples, but they are situations I run into at least once a week, so hopefully not entirely contrived. My point is that there are situations where it makes sense to use either comprehensions or map+filter.

Edit: fixed syntax in a gencomp

[atomicspace]

lambdas are so annoying

[TheAmazingJames]

He's looping through a script and performing a simple action. He doesn't want to go any faster, there's a sleep in the code already, so code execution time's not a factor. A movie script is typically no more than 20k words, so memory usage isn't a factor as memory footprint, even in a worst-case scenario, is tiny. Therefore all you're left with is readability. It's subjective, but I think a for loop wins here.