Is there a map without result in python?

Question

Sometimes, I just want to execute a function for a list of entries -- eg.:

for x in wowList:
   installWow(x, 'installed by me')

Sometimes I need this stuff for module initialization, so I don't want to have a footprint like x in global namespace. One solution would be to just use map together with lambda:

map(lambda x: installWow(x, 'installed by me'), wowList)

But this of course creates a nice list [None, None, ...] so my question is, if there is a similar function without a return-list -- since I just don't need it.

(off course I can also use _x and thus not leaving visible footprint -- but the map-solution looks so neat ...)

Answer 1

You might try this:

filter(lambda x: installWow(x, 'installed by me') and False, wowList)

That way, the return result is an empty list no matter what.

Or you could just drop the and False if you can force installWow() to always return False (or 0 or None or another expression that evaluates false).

Answer 2

Every expression evaluates to something, so you always get a result, whichever way you do it. And any such returned object (just like your list) will get thrown away afterwards because there's no reference to it anymore.

To clarify: Very few things in python are statements that don't return anything. Even a function call like

doSomething()

still returns a value, even if it gets discarded right away. There is no such thing as Pascal's function / procedure distinction in python.

Answer 3

You could use a filter and a function that doesn't return a True value. You'd get an empty return list since filter only adds the values which evaluates to true, which I suppose would save you some memory. Something like this:

#!/usr/bin/env python
y = 0
def myfunction(x):
  global y
  y += x

input = (1, 2, 3, 4)

print "Filter output: %s" % repr(filter(myfunction, input))
print "Side effect result: %d" % y

Running it produces this output:

Filter output: ()
Side effect result: 10

Answer 4

How about this?

for x in wowList:
    installWow(x, 'installed by me')
del x

Answer 5

if it is ok to distruct wowList

while wowList: installWow(wowList.pop(), 'installed by me')

if you do want to maintain wowList

wowListR = wowList[:]
while wowListR: installWow(wowListR.pop(), 'installed by me')

and if order matters

wowListR = wowList[:]; wowListR.reverse()
while wowListR: installWow(wowListR.pop(), 'installed by me')

Though as the solution of the puzzle I like the first :)

Answer 6

I can not resist myself to post it as separate answer

reduce(lambda x,y: x(y, 'installed by me') , wowList, installWow)

only twist is installWow should return itself e.g.

def installWow(*args):
    print args
    return installWow

Answer 7

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.

Answer 8

first rewrite the for loop as a generator expression, which does not allocate any memory.

(installWow(x,  'installed by me') for x in wowList )

But this expression doesn't actually do anything without finding some way to consume it. So we can rewrite this to yield something determinate, rather than rely on the possibly None result of installWow.

( [1, installWow(x,  'installed by me')][0] for x in wowList )

which creates a list, but returns only the constant 1. this can be consumed conveniently with reduce

reduce(sum, ( [1, installWow(x,  'installed by me')][0] for x in wowList ))

Which conveniently returns the number of items in wowList that were affected.

Answer 9

Just make installWow return None or make the last statement be pass like so:

def installWow(item, phrase='installed by me'):
  print phrase
  pass

and use this:

list(x for x in wowList if installWow(x))

x won't be set in the global name space and the list returned is [] a singleton