You could make your own "each" function:

def each(fn, items):
    for item in items:
        fn(item)


# called thus
each(lambda x: installWow(x, 'installed by me'), wowList)

Basically it's just map, but without the results being returned. By using a function you'll ensure that the "item" variable doesn't leak into the current scope.

You don't. The point of map is to perform a conversion of the input (not an in-place mutation). Using map (or comprehensions) for side-effects is bad style and makes for confusing code.

What you do is a normal for loop:

for person in ['Michale','Joe']: b.addPerson(person)

Incidentally, your

member = ''

is at best useless and at worst actively harmful. It defines a class attribute member which is not of any use because it's shadowed by the instance attribute of the same name.

and

def addPerson(self, member):
    self.member += member

while this sort of thing can be useful, Python developers generally avoid them unless they're actually useful / necessary. Here, I don't personally feel this method pulls its weight. And the naming is not conventional, it should be add_person.

What you are seeing here is the effect of lazy-evaluation. Python 3 made most functions like this (map, filter, zip etc) work lazily where they used to work eagerly in Python 2, that is, instead of immediately returning and materializing a data-structure when you call map(f, some_iterable), instead, map returns a map-object, which can then be iterated over to either materialize a data structure or work with the elements one-by-one (letting you work in a memory-efficient way).

>>> result = []
>>> m = map(lambda x: result.append(x), range(10))
>>> m
<map object at 0x10a0b7278>
>>> result
[]
>>> next(m)
>>> result
[0]
>>> next(m)
>>> result
[0, 1]
>>> list(m)
[None, None, None, None, None, None, None, None]
>>> result
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

However!

You should not be using map or filter or list-comprehensions for their side-effects. These are all functional constructs, and you should avoid mutating state when using them. It is simply bad style, and also, as you noticed when I called list on my map object, it creates and immediately discards a useless list of None (because functions that don't return anything implicitely return None).

So, to answer your question, yes you can use "map() for functions that does not return a value" but you shouldn't. Just use a for-loop.

You cannot assign in a lambda, but lambda is just shorthand for a function so you could:

def set_it(x):
    x.attribute = new_value
map(set_it, li)

compared with the obvious:

for x in li:
    x.attribute = new_value

A general rule of thumb for map vs a for loop (whether a list comprehension or written out in full) is that map may be faster if and only if it doesn't call a function written in Python. So expect that map will be slower in this case. Also the straight for loop doesn't create and then throw away an unwanted intermediate list so expect the map to lose out even more than usual.

See also:
https://stackoverflow.com/a/7731274
https://stackoverflow.com/a/11768129
https://stackoverflow.com/a/42399676

Each None that you see is what print function returns. To understand what map does, try the following code:

>>> T = map(lambda x: x**2, [1, 2, 3])
>>> t = list(T)
>>> print(t)
[1, 4, 9]

When you use print instead:

>>> T = map(print, [1, 2, 3])
>>> t = list(T)
1
2
3
>>> print(t)
[None, None, None]

This is not surprising, because:

>>> a = print("anything")
anything
>>> print(a)
None

Because in python-3.x a map is not evaluate immediately. It works as a generator where elements are generated on the fly by need: this can be more efficient since it is possible you for instance only need the first three elements so why would you calculate all elements? So as long as you do not materialize the output of map in a way, you have not really calculated the map.

You can for instance use list(..) to force Python to evaluate the list:

list(map(lambda x: not x in list2 and list2.append(x), list1))

In that case python-3.x will generate the same result for list2.

t.join() always returns None. That's because the return value of a thread target is ignored.

You'll have to collect your results by some other means, like a Queue object:

from Queue import Queue

results = Queue()

def upload_to_s3(filepath, unique_id):
    # do something
    print s3_url # <-- Confirming that this `s3_url` variable is not None
    results.put(s3_url)


threads = []
for num, list_of_paths in enumerate(chunked_paths_as_list):
    for filepath in list_of_paths:
        t = threading.Thread(target=upload_to_s3, args=(filepath, self.unique_id))
        t.start()
        threads.append(t)
for t in threads:
    t.join()

while not results.empty():
    print results.get()

Alternatively, use multiprocessing.dummy module to get the multiprocessing.Pool behaviour but with threads, which can do what you want; collect return values from the async function calls.

I think the reason why map still exists at all when generator expressions also exist, is that it can take multiple iterator arguments that are all looped over and passed into the function:

>>> list(map(min, [1,2,3,4], [0,10,0,10]))
[0,2,0,4]

That's slightly easier than using zip:

>>> list(min(x, y) for x, y in zip([1,2,3,4], [0,10,0,10]))

Otherwise, it simply doesn't add anything over generator expressions.

map cannot directly filter out items. It outputs one item for each item of input. You can use a list comprehension to filter out None from your results.

r = [x for x in map(calc, range(1,10)) if x is not None]

(This only calls calc once on each number in the range.)

Aside: there is no need to write lambda num: calc(num). If you want a function that returns the result of calc, just use calc itself.