Most of the time, the array module is used to interface with C code. The array module is kind of one of those things that you probably don't have a need for if you don't know why you would use it (and take note that I'm not trying to say that in a condescending manner!). To make a long story short: array.array is useful when you need a homogeneous C array of data for reasons other than doing math. However, if you want to do math on a homogeneous array of numeric data, then you're much better off using NumPy, which can automatically vectorize operations on complex multi-dimensional arrays. However, Python 2.6+ and 3.x offer a mutable byte string as bytearray.

Mostly, you should use it when you need to expose a C array to an extension or a system call (for example, ioctl or fctnl).Īrray.array is also a reasonable way to represent a mutable string in Python 2.x ( array('B', bytes)). It can hold only homogeneous data (that is to say, all of the same type) and so it uses only sizeof(one object) * length bytes of memory. The array.array type, on the other hand, is just a thin wrapper on C arrays. But they use a lot more space than C arrays, in part because each item in the list requires the construction of an individual Python object, even for data that could be represented with simple C types (e.g. If you need to shrink and grow your list time-efficiently and without hassle, they are the way to go. The idiomatic way is to import numpy as np.Basically, Python lists are very flexible and can hold completely heterogeneous, arbitrary data, and they can be appended to very efficiently, in amortized constant time. * Importing the entire contents of a module into your global namespace using import * is considered bad practice for several reasons. You could do the same operation more explicitly using np.concatenate like this: print(np.concatenate((a, b), axis=2).shape) If c = np.dstack((a, b)), then c = a and c = b. This is equivalent to indexing them in the third dimension with np.newaxis (or alternatively, None) like this: print(a.shape) Since a and b are both two dimensional, np.dstack expands them by inserting a third dimension of size 1. print(np.hstack((a, b)).shape)Īnd np.dstack concatenates along the third dimension. Np.hstack concatenates along the second dimension. Np.vstack concatenates along the first dimension. Using your two example arrays: print(a.shape, b.shape) It's easier to understand what np.vstack, np.hstack and np.dstack* do by looking at the. However, I was of the impression that I understood these terms in the context of vstack and hstack just fine.įirst of all, a and b don't have a third axis so how would I stack them along ' the third axis' to begin with? Second of all, assuming a and b are representations of 2D-images, why do I end up with three 2D arrays in the result as opposed to two 2D-arrays 'in sequence'? So either I am really stupid and the meaning of this is obvious or I seem to have some misconception about the terms 'stacking', 'in sequence', 'depth wise' or 'along an axis'. This is a simple way to stack 2D arrays (images) into a single Takes a sequence of arrays and stack them along the third axis Stack arrays in sequence depth wise (along third axis). The documentation is rather sparse and just says: I have some trouble understanding what numpy's dstack function is actually doing.

Np stack python