text: I agree with Robert, don't use locals(). I should have added a disclaimer "this is very hackish and probably not a good idea", sorry ;) (interesting read:)
  From what you said I think what you really want is f to work in-place. This
  also has the advantage of minimizing memory allocations. If you can't directly modify f, you can also do:
  def f_inplace(x): x[:] = f(x)
  then just call map(f_inplace, [a, b, c, d]). However note that there will be some memory temporarily allocated to store the result of f(x) (so it is not as optimal as ensuring f directly works in-place).
  In addition to the dictionary workaround mentioned by Robert, if it is not practical to have all your variables of interest into a single dictionary, you can instead declare your variables as one-element lists, or use a class with a single field:
  1. a = [numpy.array(...)] a[0] = f(a[0])
  2. class ArrayHolder(object): def __init__(self, arr): self.arr = arr
  a = ArrayHolder(numpy.array(...)) a.arr = f(a.arr)
  But of course it is not as convenient to write a[0] or a.arr instead of just a.
  -=- Olivier
  2011/9/13 Robert Kern robert.kern@gmail.com
  On Tue, Sep 13, 2011 at 01:53, David Froger david.froger@gmail.com wrote:
  Thank you Olivier and Robert for your replies!
  Some remarks about the dictionnary solution:
  from numpy import *
  def f(arr): return arr + 100.
  arrs = {} arrs['a'] = array( [1,1,1] ) arrs['b'] = array( [2,2,2] ) arrs['c'] = array( [3,3,3] ) arrs['d'] = array( [4,4,4] )
  for key,value in arrs.iteritems(): arrs[key] = f(value)
  - about the memory
  Memory is first allocated with the array functions: arrs['a'] = array( [1,1,1] ) arrs['b'] = array( [2,2,2] ) arrs['c'] = array( [3,3,3] ) arrs['d'] = array( [4,4,4] )
  Are there others memory allocations with this assignemnt: arrs[key] = f(value) or is the already allocated memory used to store the result of f(value)?
  In other words, if I have N arrays of the same shape, each of them
  costing
  nbytes of memory, does it use N*nbytes memory, or 2*N*bytes?
  Temporarily, yes, for all of the variations mentioned. When the expression "f(value)" is evaluated, both the result array and the input array will exist simultaneously in memory. Once the assignment happens, the original input array will be destroyed and free up the memory. There is no difference memory-wise between assigning into a dictionary or assigning to a variable name.
  Sometimes, you can write your f() such that you just need to do
  f(value)
  and have the value object modified in-place. In that case, there is no need to reassign the result to a variable or dictionary key.
  I think this is well documented on the web and I can find it....
  - about individual array
  The problem is that now, if one want to use a individual array, one have
  now to
  use: arrs['a'] instead of just: a So I'm sometime tempted to use locals() instead of arrs...
  Seriously, don't. It makes your code worse, not better. It's also unreliable. The locals() dictionary is meant to be read-only (and even then for debugger tooling and the like, not regular code), and this is sometimes enforced. If you want to use variable names instead of dictionaries, use them, but write out each assignment