Ref: http://scipy.github.io/oldwiki/pages/NumPy_for_Matlab_Users
Some Key Differences
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 2D 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 specialmatrix type for doing linear algebra, which is just a subclass of the array class. Operations on matrixclass 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 fullfledged applications is more or less an afterthought. 
NumPy is based on Python, which was designed from the outset to be an excellent generalpurpose programming language. While Matlab’s syntax for some array manipulations is more compact than NumPy’s, NumPy (by virtue of being an addon 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 passbyvalue semantics, with a lazy copyonwrite scheme to prevent actually creating copies until they are actually needed. Slice operations copy parts of the array. 
In NumPy arrays have passbyreference 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 commandprompt (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 addon application software, Mailing_Listsfor discussions, and the rest of this web site for additional community contributions. We encourage your participation! 
MATLAB® has an extensive set of optional, domainspecific addons (‘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 addons. However the list in Topical_Software certainly shows a growing trend in that direction. 
MATLAB® has a sophisticated 2d and 3d plotting system, with user interface widgets. 
Addon software can be used with Numpy to make comparable plots to MATLAB®. Matplotlib is a mature 2d plotting library that emulates the MATLAB® interface. PyQwtallows more robust and faster user interfaces than MATLAB®. And mlab, a “matlablike” 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, allinone, easytouse, builtin plotting solution for 2d and 3d. 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 Matlablike 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. 
‘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 elementwise 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 generalpurpose ndimensional 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 elementwise multiplication, and the dot() function is used for matrix multiplication.

For matrix, ‘*‘ means matrix multiplication, and the multiply() function is used for elementwise multiplication.

 Handling of vectors (rank1 arrays)

For array, the vector shapes 1xN, Nx1, and N are all different things. Operations like A[:,1] return a rank1 array of shape N, not a rank2 of shape Nx1. Transpose on a rank1 array does nothing.

For matrix, rank1 arrays are always upconverted to 1xN or Nx1 matrices (row or column vectors). A[:,1] returns a rank2 matrix of shape Nx1.


Handling of higherrank 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]").

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 
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 
shortcircuiting logical AND operator (Python native operator); scalar arguments only 

a  b 
a or b 
shortcircuiting logical OR operator (Python native operator); scalar arguments only 

1*i,1*j,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 RungeKutta 4,5 

ode15s 
scipy.integrate.ode(f).\ 
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[n1] 
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.], 
2×3 matrix literal 
[ a b; c d ] 
vstack([hstack([a,b]), 
bmat('a b; c d') 
construct a matrix from blocks a,b,c, and 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(end4: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 readonly 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 twentyfirst 

a(1:2:end,:) 
a[ ::2,:] 
every other row of a, starting with the first 

a(end:1:1,:) orflipud(a) 
a[ ::1,:] 
a with rows in reverse order 

a([1:end 1],:) 
a[r_[:len(a),0]] 
a with copy of the first row appended to the end 

a.' 
a.transpose() or a.T 
transpose of a 

a' 
a.conj().transpose() ora.conj().T 
a.H 
conjugate transpose of a 
a * b 
dot(a,b) 
a * b 
matrix multiply 
a .* b 
a * b 
multiply(a,b) 
elementwise multiply 
a./b 
a/b 
elementwise divide 

a.^3 
a**3 
power(a,3) 
elementwise exponentiation 
(a>0.5) 
(a>0.5) 
matrix whose i,jth element is (a_ij > 0.5) 

find(a>0.5) 
nonzero(a>0.5) 
find the indices where (a > 0.5) 

a(:,find(v>0.5)) 
a[:,nonzero(v>0.5)[0]] 
a[:,nonzero(v.A>0.5)[0]] 
extract the columms of a where vector v > 0.5 
a(:,find(v>0.5)) 
a[:,v.T>0.5] 
a[:,v.T>0.5)] 
extract the columms of a where column vector v > 0.5 
a(a<0.5)=0 
a[a<0.5]=0 
a with elements less than 0.5 zeroed out 

a .* (a>0.5) 
a * (a>0.5) 
mat(a.A * (a>0.5).A) 
a with elements less than 0.5 zeroed out 
a(:) = 3 
a[:] = 3 
set all values to the same scalar value 

y=x 
y = x.copy() 
numpy assigns by reference 

y=x(2,:) 
y = x[1,:].copy() 
numpy slices are by reference 

y=x(:) 
y = x.flatten(1) 
turn array into vector (note that this forces a copy) 

1:10 
arange(1.,11.) or 
mat(arange(1.,11.))or 
create an increasing vector see note ‘RANGES’ 
0:9 
arange(10.) or 
mat(arange(10.)) or 
create an increasing vector see note ‘RANGES’ 
[1:10]' 
arange(1.,11.)[:, newaxis] 
r_[1.:11.,'c'] 
create a column vector 
zeros(3,4) 
zeros((3,4)) 
mat(...) 
3×4 rank2 array full of 64bit floating point zeros 
zeros(3,4,5) 
zeros((3,4,5)) 
mat(...) 
3x4x5 rank3 array full of 64bit floating point zeros 
ones(3,4) 
ones((3,4)) 
mat(...) 
3×4 rank2 array full of 64bit floating point ones 
eye(3) 
eye(3) 
mat(...) 
3×3 identity matrix 
diag(a) 
diag(a) 
mat(...) 
vector of diagonal elements of a 
diag(a,0) 
diag(a,0) 
mat(...) 
square diagonal matrix whose nonzero values are the elements of a 
rand(3,4) 
random.rand(3,4) 
mat(...) 
random 3×4 matrix 
linspace(1,3,4) 
linspace(1,3,4) 
mat(...) 
4 equally spaced samples between 1 and 3, inclusive 
[x,y]=meshgrid(0:8,0:5) 
mgrid[0:9.,0:6.] or 
mat(...) 
two 2D arrays: one of x values, the other of y values 
ogrid[0:9.,0:6.] or 
mat(...) 
the best way to eval functions on a grid 

[x,y]=meshgrid([1,2,4],[2,4,5]) 
meshgrid([1,2,4],[2,4,5]) 
mat(...) 

ix_([1,2,4],[2,4,5]) 
mat(...) 
the best way to eval functions on a grid 

repmat(a, m, n) 
tile(a, (m, n)) 
mat(...) 
create m by n copies of a 
[a b] 
concatenate((a,b),1) or 
concatenate((a,b),1) 
concatenate columns of a and b 
[a; b] 
concatenate((a,b)) or 
concatenate((a,b)) 
concatenate rows of a and b 
max(max(a)) 
a.max() 
maximum element of a (with ndims(a)<=2 for matlab) 

max(a) 
a.max(0) 
maximum element of each column of matrix a 

max(a,[],2) 
a.max(1) 
maximum element of each row of matrix a 

max(a,b) 
maximum(a, b) 
compares a and b elementwise, and returns the maximum value from each pair 

norm(v) 
sqrt(dot(v,v)) or 
sqrt(dot(v.A,v.A))or 
L2 norm of vector v 
a & b 
logical_and(a,b) 
elementbyelement AND operator (Numpy ufunc) see note ‘LOGICOPS’ 

a  b 
logical_or(a,b) 
elementbyelement OR operator (Numpy ufunc) see note ‘LOGICOPS’ 

bitand(a,b) 
a & b 
bitwise AND operator (Python native and Numpy ufunc) 

bitor(a,b) 
a  b 
bitwise OR operator (Python native and Numpy ufunc) 

inv(a) 
linalg.inv(a) 
inverse of square matrix a 

pinv(a) 
linalg.pinv(a) 
pseudoinverse of matrix a 

rank(a) 
linalg.matrix_rank(a) 
rank of a matrix a 

a\b 
linalg.solve(a,b) if a is square 
solution of a x = b for x 

b/a 
Solve a.T x.T = b.T instead 
solution of x a = b for x 

[U,S,V]=svd(a) 
U, S, Vh = linalg.svd(a), V = Vh.T 
singular value decomposition of a 

chol(a) 
linalg.cholesky(a).T 
cholesky factorization of a matrix (chol(a) in matlab returns an upper triangular matrix, but linalg.cholesky(a) returns a lower triangular matrix) 

[V,D]=eig(a) 
D,V = linalg.eig(a) 
eigenvalues and eigenvectors of a 

[V,D]=eig(a,b) 
V,D = Sci.linalg.eig(a,b) 
eigenvalues and eigenvectors of a,b 

[V,D]=eigs(a,k) 
find the k largest eigenvalues and eigenvectors of a 

[Q,R,P]=qr(a,0) 
Q,R = Sci.linalg.qr(a) 
mat(...) 
QR decomposition 
[L,U,P]=lu(a) 
L,U = Sci.linalg.lu(a) or 
mat(...) 
LU decomposition (note: P(Matlab) == transpose(P(numpy)) ) 
conjgrad 
Sci.linalg.cg 
mat(...) 
Conjugate gradients solver 
fft(a) 
fft(a) 
mat(...) 
Fourier transform of a 
ifft(a) 
ifft(a) 
mat(...) 
inverse Fourier transform of a 
sort(a) 
sort(a) or a.sort() 
mat(...) 
sort the matrix 
[b,I] = sortrows(a,i) 
I = argsort(a[:,i]), b=a[I,:] 
sort the rows of the matrix 

regress(y,X) 
linalg.lstsq(X,y) 
multilinear regression 

decimate(x, q) 
Sci.signal.resample(x, len(x)/q) 
downsample with lowpass filtering 

unique(a) 
unique(a) 

squeeze(a) 
a.squeeze() 