numpy

数组的创建

• 使用array函数从常规Python列表或元组中创建数组：

a = np.array([2,3,4])

• 原生数组的创建：
  • zeros(shape)将创建一个用指定形状用0填充的数组。默认的dtype是float64:

  np.zeros((2, 3)) 
  array([[ 0., 0., 0.], [ 0., 0., 0.]])	
  

  • ones(shape)将创建一个用1个值填充的数组。它在所有其他方面与zeros相同。
  • arange()将创建具有有规律递增值的数组:

  np.arange(2, 10, dtype=np.float)#(dtype:数据类型）
  array([ 2., 3., 4., 5., 6., 7., 8., 9.])
  np.arange(2, 3, 0.1)
  array([ 2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])
  

  • linspace()将创建具有指定数量元素的数组，并在指定的开始值和结束值之间平均间隔：

  np.linspace(1., 4., 6)
  array([ 1. ,  1.6,  2.2,  2.8,  3.4,  4. ])
  

• 基础知识
  • 乘法运算符 * 的运算在NumPy数组中是元素级别的。矩阵乘积可以使用 dot 函数或方法执行：

    A = np.array( [[1,1],
    		[0,1]] )
    B = np.array( [[2,0],
         	[3,4]] )
    A*B                         
    array([[2, 0],
    	[0, 4]])
    A.dot(B)                    
    array([[5, 4],
    	[3, 4]])
    np.dot(A, B)                
    array([[5, 4],
     	[3, 4]])
    

  • 迭代（Iterating） 多维数组是相对于第一个轴完成的：

    for row in b:
     print(row)
     [0 1 2 3]
     ......
     [40 41 42 43]
    

• 对数组中的每个元素执行操作，可以使用 flat 属性:

  	for element in b.flat:	
  	print(element)
  	0
  	1
  	...
  	43
  

形状操作

• 属性

  • ndarray.ndim：数组的轴（维度）的个数。在Python世界中，维度的数量被称为rank。
  • ndarray.shape：数组的维度。这是一个整数的元组，表示每个维度中数组的大小。对于有n行和m列的矩阵，shape将是(n,m)。因此，shape元组的长度就是rank或维度的个数 ndim。
  • ndarray.size：数组元素的总数。这等于shape的元素的乘积。
  • ndarray.dtype：一个描述数组中元素类型的对象。可以使用标准的Python类型创建或指定dtype。另外NumPy提供它自己的类型。例如numpy.int32、numpy.int16和numpy.float64。
  • ndarray.itemsize：数组中每个元素的字节大小。例如，元素为 float64 类型的数组的 itemsize 为8（=64/8），而 complex32 类型的数组的 itemsize 为4（=32/8）。它等于 ndarray.dtype.itemsize 。
  • ndarray.data：该缓冲区包含数组的实际元素。通常，我们不需要使用此属性，因为我们将使用索引访问数组中的元素。

• 更改数组形状

  • 返回一个修改后的数组，但不更改原始数组：a.ravel()，a.reshape(6,2) ，a.T（矩阵的转置）
  • 修改数组本身：ndarray.resize

• 数组的拼接

a = np.floor(10*np.random.random((2,2)))   #随机创建数组
b = np.floor(10*np.random.random((2,2)))
array([[ 8.,  8.],
       [ 0.,  0.]])    #a
array([[ 1.,  8.],
       [ 0.,  4.]])    #b

垂直拼接：

np.vstack((a,b))
array([[ 8.,  8.],
       [ 0.,  0.],
       [ 1.,  8.],
       [ 0.,  4.]])

水平拼接：

np.hstack((a,b))
array([[ 8.,  8.,  1.,  8.],
       [ 0.,  0.,  0.,  4.]])

线性代数之简单数组操作

a = np.array([[1.0, 2.0], [3.0, 4.0]])
print(a)
[[ 1.  2.]
 [ 3.  4.]]

a.transpose()
array([[ 1.,  3.],
       [ 2.,  4.]])

np.linalg.inv(a)
array([[-2. ,  1. ],
       [ 1.5, -0.5]])

u = np.eye(2) # unit 2x2 matrix; "eye" represents "I"
u
array([[ 1.,  0.],
       [ 0.,  1.]])
j = np.array([[0.0, -1.0], [1.0, 0.0]])

np.dot (j, j) # matrix product
array([[-1.,  0.],
       [ 0., -1.]])

np.trace(u)  # trace
2.0

y = np.array([[5.], [7.]])
np.linalg.solve(a, y)
array([[-3.],
       [ 4.]])

np.linalg.eig(j)
(array([ 0.+1.j,  0.-1.j]), array([[ 0.70710678+0.j        ,  0.70710678-0.j        ],
       [ 0.00000000-0.70710678j,  0.00000000+0.70710678j]]))