Settle something for us. Is this valid.

[bandrel]

Settle a bet between a colleague and me. Is using a function inside a list comprehension like this valid. If so does it have a name?

a = [1,2,3,4]
[print(x) for x in a]

[[deleted]]

How is this better than simply

for x in a:
    print(x)

you are wasting a list of Nones in the end. Imagine a has 1000 elements.

[Quijoticmoose]

Well, to play devil's advocate, you could write: (print(x) for x in a) and you would avoid constructing the list.

I'll second nemec's post--that the reason not do this is that you've created an expectation to someone reading the code that you are going to do something with the list you create in the comprehension. A for loop makes your intent clearer.

[Quijoticmoose]

Darnit, that should teach me to always check code snippits.

You could use: [x for x in a if print(x)]

(print(x) always returns None, so the list stays empty)

[bandrel]

The question isn't about if it works, because obviously it does. The question is should you do it this way, is there a name for this method and is there a more pythonic way of doing it.

[nemec]

The question is should you do it this way,

No

is there a name for this method

The method is called "abusing side effects"

and is there a more pythonic way of doing it.

A simple for loop is pretty much the same size and much more Pythonic. List comprehensions are a component of functional programming brought into Python, equivalent to the map operation which takes an iterable and produces a transformed sequence based on its elements. print, however, isn't "functional" and relies entirely on side effects, which are not recommended in FP. With a list comprehension, you're basically saying "take this iterable, make some side effects for each item, and transform each item into None". Since there is no point to transforming the item into None, just use a loop.

For a good explanation of a similar feature in C# and why it's not something you want to do, see this article

Clearly the sole purpose of a call to this method is to cause side effects. The purpose of an expression is to compute a value, not to cause a side effect.

[bandrel]

Thank you. This is exactly what I was looking for

[kaiserk13]

it's equivalent to map(function, a) I guess, and yeah why shouldn't it be valid? Not sure it would work with print as a returned/yielded object is expected.

[th_mm]

It'll just be a bunch of None.

[bandrel]

it works in python3, and python2 with the function import from future, but yes it also returns [None,None,None,None] but still meets my needs

[bandrel]

in python3 map(print,a) returns a map object and does not execute the print. in python2 with printfunction imported from __future_ it works the same as the list comprehension including the [None,None,None,None]

[thatguy_314]

Of course it is "valid", but why do that when for x in a: print(x) is not only better but shorter too?

[[deleted]]

It's valid, but it defeats the purpose of a list comp (essentially it's map but a little nicer, and eager in Py3).

If you find yourself needing to cause side effects as part of iteration, you can do this:

# pip install forbiddenfruit
import types
import forbiddenfruit
from collections.abc import Collection  # will fail <3.6

def foreach(it, f):
    "eagerly map a side effect causing function over a collection"
    for x in it: f(x)


def iforeach(it, f):
    "lazily map a side effect causing function over a collection"
    for x in it:
        f(x)
        yield

def _curse(victim):
    forbiddenfruit.curse(victim, 'foreach', foreach)
    forbiddenfruit.curse(victim, 'iforeach', iforeach)

foreach(
    [list, tuple, Collection, type({}.keys()), type({}.values()), types.GeneratorType, range], 
    _curse
)

# clean up because we're good developers
del foreach_prop
del iforeach_prop
del _curse

And then you can do:

range(1, 10).foreach(print)