Initialize Multiple Numpy Arrays (Multiple Assignment) - Like MATLAB deal()

Question

I was unable to find anything describing how to do this, which leads to be believe I\'m not doing this in the proper idiomatic Python way. Advice on the \'proper\' Python w

Answer 1

If you put your data in a collections.defaultdict you won't need to do any explicit initialization. Everything will be initialized the first time it is used.

import numpy as np
import collections
n = 100
data = collections.defaultdict(lambda: np.zeros(n))
for i in range(1, n):
    data['g'][i] = data['d'][i - 1]
    # ...

Answer 2

Nothing wrong or un-Pythonic with

dData = np.zeros(n)
gData = np.zeros(n)
etc.

You could put them on one line, but there's no particular reason to do so.

dData, gData = np.zeros(n), np.zeros(n)

Don't try dData = gData = np.zeros(n), because a change to dData changes gData (they point to the same object). For the same reason you usually don't want to use x = y = [].

The deal in MATLAB is a convenience, but isn't magical. Here's how Octave implements it

function [varargout] = deal (varargin)
  if (nargin == 0)
    print_usage ();
  elseif (nargin == 1 || nargin == nargout)
    varargout(1:nargout) = varargin;
  else
    error ("deal: nargin > 1 and nargin != nargout");
  endif

endfunction

In contrast to Python, in Octave (and presumably MATLAB)

one=two=three=zeros(1,3)

assigns different objects to the 3 variables.

Notice also how MATLAB talks about deal as a way of assigning contents of cells and structure arrays. http://www.mathworks.com/company/newsletters/articles/whats-the-big-deal.html

Answer 3

If you're really motivated to do this in a one-liner you could create an (n_vars, ...) array of zeros, then unpack it along the first dimension:

a, b, c = np.zeros((3, 5))
print(a is b)
# False

Another option is to use a list comprehension or a generator expression:

a, b, c = [np.zeros(5) for _ in range(3)]   # list comprehension
d, e, f = (np.zeros(5) for _ in range(3))   # generator expression
print(a is b, d is e)
# False False

Be careful, though! You might think that using the * operator on a list or tuple containing your call to np.zeros() would achieve the same thing, but it doesn't:

h, i, j = (np.zeros(5),) * 3
print(h is i)
# True

This is because the expression inside the tuple gets evaluated first. np.zeros(5) therefore only gets called once, and each element in the repeated tuple ends up being a reference to the same array. This is the same reason why you can't just use a = b = c = np.zeros(5).

Unless you really need to assign a large number of empty array variables and you really care deeply about making your code compact (!), I would recommend initialising them on separate lines for readability.

Answer 4

How about using map:

import numpy as np
n = 10  # Number of data points per array
m = 3   # Number of arrays being initialised
gData, pData, qData = map(np.zeros, [n] * m)