Python equivalent to Ruby Array.each method

You can use numpy for vectorized arithmetic over an array:

>>> import numpy as np
>>> a = np.array([1, 2, 3])
>>> a * 3
array([3, 6, 9])

You can easily define a lambda that can be used over each element of an array:

>>> array_lambda=np.vectorize(lambda x: x * x)
>>> array_lambda([1, 2, 3])
array([1, 4, 9])

But as others have said, if you want to just print each, use a loop.

The most idiomatic:

for x in [1,2,3]:
    print x

Does Python have a nice and short closure/lambda syntax for it?

Yes, but you don't want it in this case.

The closest equivalent to that Ruby code is:

new_values = map(print, [1, 2, 3])

That looks pretty nice when you already have a function lying around, like print. When you just have some arbitrary expression and you want to use it in map, you need to create a function out of it with a def or a lambda, like this:

new_values = map(lambda x: print(x), [1, 2, 3])

That's the ugliness you apparently want to avoid. And Python has a nice way to avoid it: comprehensions:

new_values = [print(x) for x in values]

However, in this case, you're just trying to execute some statement for each value, not accumulate the new values for each value. So, while this will work (you'll get back a list of None values), it's definitely not idiomatic.

In this case, the right thing to do is to write it explicitly—no closures, no functions, no comprehensions, just a loop:

for x in values:
    print x

There are also libraries that wrap objects to expose all the usual functional programming stuff.

• PyDash http://pydash.readthedocs.org/en/latest/
• underscorepy (Google github underscore.py)

E.g. pydash allows you to do things like this:

>>> from pydash import py_
>>> from __future__ import print_function
>>> x = py_([1,2,3,4]).map(lambda x: x*2).each(print).value()
2
4
6
8
>>> x
[2, 4, 6, 8]

(Just always remember to "trigger" execution and/or to un-wrap the wrapped values with .value() at the end!)