【搬运】NumPy_for_Matlab_Users

搬运自：http://scipy.github.io/old-wiki/pages/NumPy_for_Matlab_Users.html.

1、Introduction

　　MATLAB和NumPy/SciPy有很多共同之处，但也有很多不同之处。创建NumPy和SciPy是为了用Python以最自然的方式进行数值和科学计算，而不是为了成为MATLAB的克隆。这个页面的目的是收集关于差异的智慧，主要是为了帮助精通MATLAB的用户成为精通NumPy和SciPy的用户。NumPyProConPage是另一个页面，用于好奇的人，他们正在考虑采用带有NumPy和SciPy而不是MATLAB的Python，并希望看到利弊列表。

2、Some Key Differences

Matlab	Numpy
In MATLAB, the basic data type is a multidimensional array of double precision floating point numbers. Most expressions take such arrays and return such arrays. Operations on the 2-D instances of these arrays are designed to act more or less like matrix operations in linear algebra.	In NumPy the basic type is a multidimensional array. Operations on these arrays in all dimensionalities including 2D are elementwise operations. However, there is a special matrix type for doing linear algebra, which is just a subclass of the array class. Operations on matrix-class arrays are linear algebra operations.
MATLAB uses 1 (one) based indexing. The initial element of a sequence is found using a(1). See note 'INDEXING'	Python uses 0 (zero) based indexing. The initial element of a sequence is found using a[0].
MATLAB's scripting language was created for doing linear algebra. The syntax for basic matrix operations is nice and clean, but the API for adding GUIs and making full-fledged applications is more or less an afterthought.	NumPy is based on Python, which was designed from the outset to be an excellent general-purpose programming language. While Matlab's syntax for some array manipulations is more compact than NumPy's, NumPy (by virtue of being an add-on to Python) can do many things that Matlab just cannot, for instance subclassing the main array type to do both array and matrix math cleanly.
In MATLAB, arrays have pass-by-value semantics, with a lazy copy-on-write scheme to prevent actually creating copies until they are actually needed. Slice operations copy parts of the array.	In NumPy arrays have pass-by-reference semantics. Slice operations are views into an array.
In MATLAB, every function must be in a file of the same name, and you can't define local functions in an ordinary script file or at the command-prompt (inlines are not real functions but macros, like in C).	NumPy code is Python code, so it has no such restrictions. You can define functions wherever you like.
MATLAB has an active community and there is lots of code available for free. But the vitality of the community is limited by MATLAB's cost; your MATLAB programs can be run by only a few.	NumPy/SciPy also has an active community, based right here on this web site! It is smaller, but it is growing very quickly. In contrast, Python programs can be redistributed and used freely. See Topical_Software for a listing of free add-on application software, Mailing_Lists for discussions, and the rest of this web site for additional community contributions. We encourage your participation!
MATLAB has an extensive set of optional, domain-specific add-ons ('toolboxes') available for purchase, such as for signal processing, optimization, control systems, and the whole SimuLink system for graphically creating dynamical system models.	There's no direct equivalent of this in the free software world currently, in terms of range and depth of the add-ons. However the list in Topical_Software certainly shows a growing trend in that direction.
MATLAB has a sophisticated 2-d and 3-d plotting system, with user interface widgets.	Addon software can be used with Numpy to make comparable plots to MATLAB. Matplotlib is a mature 2-d plotting library that emulates the MATLAB interface. PyQwt allows more robust and faster user interfaces than MATLAB. And mlab, a "matlab-like" API based on Mayavi2, for 3D plotting of Numpy arrays. See the Topical_Software page for more options, links, and details. There is, however, no definitive, all-in-one, easy-to-use, built-in plotting solution for 2-d and 3-d. This is an area where Numpy/Scipy could use some work.
MATLAB provides a full development environment with command interaction window, integrated editor, and debugger.	Numpy does not have one standard IDE. However, the IPython environment provides a sophisticated command prompt with full completion, help, and debugging support, and interfaces with the Matplotlib library for plotting and the Emacs/XEmacs editors.
MATLAB itself costs thousands of dollars if you're not a student. The source code to the main package is not available to ordinary users. You can neither isolate nor fix bugs and performance issues yourself, nor can you directly influence the direction of future development. (If you are really set on Matlab-like syntax, however, there is Octave, another numerical computing environment that allows the use of most Matlab syntax without modification.)	NumPy and SciPy are free (both beer and speech), whoever you are.

3、'array' or 'matrix'? Which should I use?

①Short answer

Use arrays.

• They are the standard vector/matrix/tensor type of numpy. Many numpy function return arrays, not matrices.
• There is a clear distinction between element-wise operations and linear algebra operations.
• You can have standard vectors or row/column vectors if you like.

The only disadvantage of using the array type is that you will have to use dot instead of * to multiply (reduce) two tensors (scalar product, matrix vector multiplication etc.).

②Long answer

Numpy contains both an array class and a matrix class. The array class is intended to be a general-purpose n-dimensional array for many kinds of numerical computing, while matrix is intended to facilitate linear algebra computations specifically. In practice there are only a handful of key differences between the two.

• Operator *, dot(), and multiply():

  • For array, '*' means element-wise multiplication, and the dot() function is used for matrix multiplication.
  • For matrix, '*' means matrix multiplication, and the multiply() function is used for element-wise multiplication.

• Handling of vectors (rank-1 arrays)

  • For array, the vector shapes 1xN, Nx1, and N are all different things. Operations like A[:,1] return a rank-1 array of shape N, not a rank-2 of shape Nx1. Transpose on a rank-1 array does nothing.
  • For matrix, rank-1 arrays are always upconverted to 1xN or Nx1 matrices (row or column vectors). A[:,1] returns a rank-2 matrix of shape Nx1.

• Handling of higher-rank arrays (rank > 2)

  • array objects can have rank > 2.
  • matrix objects always have exactly rank 2.

• Convenience attributes

  • array has a .T attribute, which returns the transpose of the data.
  • matrix also has .H, .I, and .A attributes, which return the conjugate transpose, inverse, and asarray() of the matrix, respectively.

• Convenience constructor

  • The array constructor takes (nested) Python sequences as initializers. As in, array([[1,2,3],[4,5,6]]).
  • The matrix constructor additionally takes a convenient string initializer. As in matrix("[1 2 3; 4 5 6]").

There are pros and cons to using both:

• array
  • You can treat rank-1 arrays as either row or column vectors. dot(A,v) treats v as a column vector, while dot(v,A) treats v as a row vector. This can save you having to type a lot of transposes.
  • Having to use the dot() function for matrix-multiply is messy -- dot(dot(A,B),C) vs. A*B*C.
  • Element-wise multiplication is easy: A*B.
  • array is the "default" NumPy type, so it gets the most testing, and is the type most likely to be returned by 3rd party code that uses NumPy.
  • Is quite at home handling data of any rank.
  • Closer in semantics to tensor algebra, if you are familiar with that.
  • All operations (*, /, +, ** etc.) are elementwise
• matrix
  •  Behavior is more like that of MATLAB® matrices.
  • Maximum of rank-2. To hold rank-3 data you need array or perhaps a Python list of matrix.
  • Minimum of rank-2. You cannot have vectors. They must be cast as single-column or single-row matrices.
  • Since array is the default in NumPy, some functions may return an array even if you give them a matrix as an argument. This shouldn't happen with NumPy functions (if it does it's a bug), but 3rd party code based on NumPy may not honor type preservation like NumPy does.
  • A*B is matrix multiplication, so more convenient for linear algebra.
  • Element-wise multiplication requires calling a function, multipy(A,B).
  • The use of operator overloading is a bit illogical: * does not work elementwise but / does.

The array is thus much more advisable to use, but in the end, you don't really have to choose one or the other. You can mix-and-match. You can use array for the bulk of your code, and switch over to matrix in the sections where you have nitty-gritty linear algebra with lots of matrix-matrix multiplications.

4、Facilities for Matrix Users

Numpy has some features that facilitate the use of the matrix type, which hopefully make things easier for Matlab converts.

• A matlib module has been added that contains matrix versions of common array constructors like ones(), zeros(), empty(), eye(), rand(), repmat(), etc. Normally these functions return arrays, but the matlib versions return matrix objects.
• mat has been changed to be a synonym for asmatrix, rather than matrix, thus making it concise way to convert an array to a matrix without copying the data.
• Some top-level functions have been removed. For example numpy.rand() now needs to be accessed as numpy.random.rand(). Or use the rand() from the matlib module. But the "numpythonic" way is to use numpy.random.random(), which takes a tuple for the shape, like other numpy functions.

5、Table of Rough MATLAB-NumPy Equivalents

The table below gives rough equivalents for some common MATLAB® expressions. These are not exact equivalents, but rather should be taken as hints to get you going in the right direction. For more detail read the built-in documentation on the NumPy functions.

Some care is necessary when writing functions that take arrays or matrices as arguments --- if you are expecting an array and are given a matrix, or vice versa, then '*' (multiplication) will give you unexpected results. You can convert back and forth between arrays and matrices using

• asarray: always returns an object of type array
• asmatrix or mat: always return an object of type matrix
• asanyarray: always returns an array object or a subclass derived from it, depending on the input. For instance if you pass in a matrix it returns a matrix.

These functions all accept both arrays and matrices (among other things like Python lists), and thus are useful when writing functions that should accept any array-like object.

In the table below, it is assumed that you have executed the following commands in Python:

Toggle line numbers

from numpy import *
import scipy as Sci
import scipy.linalg

Also assume below that if the Notes talk about "matrix" that the arguments are rank 2 entities.

THIS IS AN EVOLVING WIKI DOCUMENT. If you find an error, or can fill in an empty box, please fix it! If there's something you'd like to see added, just add it.

①General Purpose Equivalents

MATLAB	numpy	Notes
help func	info(func) or help(func) or func? (in Ipython)	get help on the function func
which func	(See note 'HELP')	find out where func is defined
type func	source(func) or func?? (in Ipython)	print source for func (if not a native function)
a && b	a and b	short-circuiting logical AND operator (Python native operator); scalar arguments only
a || b	a or b	short-circuiting logical OR operator (Python native operator); scalar arguments only
1i,1j,1i,1j	1j	complex numbers
eps	spacing(1)	Distance between 1 and the nearest floating point number
ode45	scipy.integrate.ode(f).set_integrator('dopri5')	integrate an ODE with Runge-Kutta 4,5
ode15s	scipy.integrate.ode(f).\set_integrator('vode', method='bdf', order=15)	integrate an ODE with BDF

②Linear Algebra Equivalents

The notation mat(...) means to use the same expression as array, but convert to matrix with the mat() type converter.

The notation asarray(...) means to use the same expression as matrix, but convert to array with the asarray() type converter.

MATLAB	numpy.array	numpy.matrix	Notes
ndims(a)	ndim(a) or a.ndim		get the number of dimensions of a (tensor rank)
numel(a)	size(a) or a.size		get the number of elements of an array
size(a)	shape(a) or a.shape		get the "size" of the matrix
size(a,n)	a.shape[n-1]		get the number of elements of the nth dimension of array a. (Note that MATLAB® uses 1 based indexing while Python uses 0 based indexing, See note 'INDEXING')
[ 1 2 3; 4 5 6 ]	array([[1.,2.,3.],	mat([[1.,2.,3.],	2x3 matrix literal
	[4.,5.,6.]])	[4.,5.,6.]]) or
		mat("1 2 3; 4 5 6")
[ a b; c d ]	vstack([hstack([a,b]),	bmat('a b; c d')	construct a matrix from blocks a,b,c, and d
	hstack([c,d])])
a(end)	a[-1]	a[:,-1][0,0]	access last element in the 1xn matrix a
a(2,5)	a[1,4]		access element in second row, fifth column
a(2,:)	a[1] or a[1,:]		entire second row of a
a(1:5,:)	a[0:5] or a[:5] or a[0:5,:]		the first five rows of a
a(end-4:end,:)	a[-5:]		the last five rows of a
a(1:3,5:9)	a[0:3][:,4:9]		rows one to three and columns five to nine of a. This gives read-only access.
a([2,4,5],[1,3])	a[ix_([1,3,4],[0,2])]		rows 2,4 and 5 and columns 1 and 3. This allows the matrix to be modified, and doesn't require a regular slice.
a(3:2:21,:)	a[ 2:21:2,:]		every other row of a, starting with the third and going to the twenty-first
a(1:2:end,:)	a[ ::2,:]		every other row of a, starting with the first
a(end