导入 numpy。

  1. import numpy as np

numpy 提供的最重要的数据结构是ndarray，它是 python 中list的扩展。

1. 依据现有数据来创建 ndarray

（a）通过array()函数进行创建。

  1. def array(p_object, dtype=None, copy=True, order='K', subok=False, ndmin=0):

【例】

  1. import numpy as np
  2. # 创建一维数组
  3. a = np.array([0, 1, 2, 3, 4])
  4. b = np.array((0, 1, 2, 3, 4))
  5. print(a, type(a))
  6. # [0 1 2 3 4] <class 'numpy.ndarray'>
  7. print(b, type(b))
  8. # [0 1 2 3 4] <class 'numpy.ndarray'>
  9. # 创建二维数组
  10. c = np.array([[11, 12, 13, 14, 15],
  11.               [16, 17, 18, 19, 20],
  12.               [21, 22, 23, 24, 25],
  13.               [26, 27, 28, 29, 30],
  14.               [31, 32, 33, 34, 35]])
  15. print(c, type(c))
  16. # [[11 12 13 14 15]
  17. #  [16 17 18 19 20]
  18. #  [21 22 23 24 25]
  19. #  [26 27 28 29 30]
  20. #  [31 32 33 34 35]] <class 'numpy.ndarray'>
  21. # 创建三维数组
  22. d = np.array([[(1.5, 2, 3), (4, 5, 6)],
  23.               [(3, 2, 1), (4, 5, 6)]])
  24. print(d, type(d))
  25. # [[[1.5 2.  3. ]
  26. #   [4.  5.  6. ]]
  27. #
  28. #  [[3.  2.  1. ]
  29. #   [4.  5.  6. ]]] <class 'numpy.ndarray'>

（b）通过asarray()函数进行创建

array()和asarray()都可以将结构数据转化为 ndarray，但是array()和asarray()主要区别就是当数据源是ndarray 时，array()仍然会 copy 出一个副本，占用新的内存，但不改变 dtype 时 asarray()不会。

  1. def asarray(a, dtype=None, order=None):
  2.     return array(a, dtype, copy=False, order=order)

【例】array()和asarray()都可以将结构数据转化为 ndarray

  1. import numpy as np
  2. x = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
  3. y = np.array(x)
  4. z = np.asarray(x)
  5. x[1][2] = 2
  6. print(x,type(x))
  7. # [[1, 1, 1], [1, 1, 2], [1, 1, 1]] <class 'list'>
  8. print(y,type(y))
  9. # [[1 1 1]
  10. #  [1 1 1]
  11. #  [1 1 1]] <class 'numpy.ndarray'>
  12. print(z,type(z))
  13. # [[1 1 1]
  14. #  [1 1 1]
  15. #  [1 1 1]] <class 'numpy.ndarray'>

【例】array()和asarray()的区别。(array()和asarray()主要区别就是当数据源是ndarray 时，array()仍然会 copy 出一个副本，占用新的内存，但不改变 dtype 时 asarray()不会。)

  1. import numpy as np
  2. x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
  3. y = np.array(x)
  4. z = np.asarray(x)
  5. w = np.asarray(x, dtype=np.int)
  6. x[1][2] = 2
  7. print(x,type(x),x.dtype)
  8. # [[1 1 1]
  9. #  [1 1 2]
  10. #  [1 1 1]] <class 'numpy.ndarray'> int32
  11. print(y,type(y),y.dtype)
  12. # [[1 1 1]
  13. #  [1 1 1]
  14. #  [1 1 1]] <class 'numpy.ndarray'> int32
  15. print(z,type(z),z.dtype)
  16. # [[1 1 1]
  17. #  [1 1 2]
  18. #  [1 1 1]] <class 'numpy.ndarray'> int32
  19. print(w,type(w),w.dtype)
  20. # [[1 1 1]
  21. #  [1 1 2]
  22. #  [1 1 1]] <class 'numpy.ndarray'> int32

【例】更改为较大的dtype时，其大小必须是array的最后一个axis的总大小（以字节为单位）的除数

  1. import numpy as np
  2. x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
  3. print(x, x.dtype)
  4. # [[1 1 1]
  5. #  [1 1 1]
  6. #  [1 1 1]] int32
  7. x.dtype = np.float
  8. # ValueError: When changing to a larger dtype, its size must be a divisor of the total size in bytes of the last axis of the array.

（c）通过fromfunction()函数进行创建

给函数绘图的时候可能会用到fromfunction()，该函数可从函数中创建数组。

  1. def fromfunction(function, shape, **kwargs):

【例】通过在每个坐标上执行一个函数来构造数组。

  1. import numpy as np
  2. def f(x, y):
  3.     return 10 * x + y
  4. x = np.fromfunction(f, (5, 4), dtype=int)
  5. print(x)
  6. # [[ 0  1  2  3]
  7. #  [10 11 12 13]
  8. #  [20 21 22 23]
  9. #  [30 31 32 33]
  10. #  [40 41 42 43]]
  11. x = np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
  12. print(x)
  13. # [[ True False False]
  14. #  [False  True False]
  15. #  [False False  True]]
  16. x = np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)
  17. print(x)
  18. # [[0 1 2]
  19. #  [1 2 3]
  20. #  [2 3 4]]

2. 依据 ones 和 zeros 填充方式

在机器学习任务中经常做的一件事就是初始化参数，需要用常数值或者随机值来创建一个固定大小的矩阵。

（a）零数组

  • zeros()函数：返回给定形状和类型的零数组。
  • zeros_like()函数：返回与给定数组形状和类型相同的零数组。
    1. def zeros(shape, dtype=None, order='C'):
    2. def zeros_like(a, dtype=None, order='K', subok=True, shape=None):

【例】

  1. import numpy as np
  2. x = np.zeros(5)
  3. print(x)  # [0. 0. 0. 0. 0.]
  4. x = np.zeros([2, 3])
  5. print(x)
  6. # [[0. 0. 0.]
  7. #  [0. 0. 0.]]
  8. x = np.array([[1, 2, 3], [4, 5, 6]])
  9. y = np.zeros_like(x)
  10. print(y)
  11. # [[0 0 0]
  12. #  [0 0 0]]

（b）1数组

  • ones()函数：返回给定形状和类型的1数组。
  • ones_like()函数：返回与给定数组形状和类型相同的1数组。
    1. def ones(shape, dtype=None, order='C'):
    2. def ones_like(a, dtype=None, order='K', subok=True, shape=None):

【例】

  1. import numpy as np
  2. x = np.ones(5)
  3. print(x)  # [1. 1. 1. 1. 1.]
  4. x = np.ones([2, 3])
  5. print(x)
  6. # [[1. 1. 1.]
  7. #  [1. 1. 1.]]
  8. x = np.array([[1, 2, 3], [4, 5, 6]])
  9. y = np.ones_like(x)
  10. print(y)
  11. # [[1 1 1]
  12. #  [1 1 1]]

（c）空数组

  • empty()函数：返回一个空数组，数组元素为随机数。
  • empty_like函数：返回与给定数组具有相同形状和类型的新数组。
    1. def empty(shape, dtype=None, order='C'): 
    2. def empty_like(prototype, dtype=None, order='K', subok=True, shape=None):

【例】

  1. import numpy as np
  2. x = np.empty(5)
  3. print(x)
  4. # [1.95821574e-306 1.60219035e-306 1.37961506e-306 
  5. #  9.34609790e-307 1.24610383e-306]
  6. x = np.empty((3, 2))
  7. print(x)
  8. # [[1.60220393e-306 9.34587382e-307]
  9. #  [8.45599367e-307 7.56598449e-307]
  10. #  [1.33509389e-306 3.59412896e-317]]
  11. x = np.array([[1, 2, 3], [4, 5, 6]])
  12. y = np.empty_like(x)
  13. print(y)
  14. # [[  7209029   6422625   6619244]
  15. #  [      100 707539280       504]]

（d）单位数组

  • eye()函数：返回一个对角线上为1，其它地方为零的单位数组。
  • identity()函数：返回一个方的单位数组。
    1. def eye(N, M=None, k=0, dtype=float, order='C'):
    2. def identity(n, dtype=None):

【例】

  1. import numpy as np
  2. x = np.eye(4)
  3. print(x)
  4. # [[1. 0. 0. 0.]
  5. #  [0. 1. 0. 0.]
  6. #  [0. 0. 1. 0.]
  7. #  [0. 0. 0. 1.]]
  8. x = np.eye(2, 3)
  9. print(x)
  10. # [[1. 0. 0.]
  11. #  [0. 1. 0.]]
  12. x = np.identity(4)
  13. print(x)
  14. # [[1. 0. 0. 0.]
  15. #  [0. 1. 0. 0.]
  16. #  [0. 0. 1. 0.]
  17. #  [0. 0. 0. 1.]]

（e）对角数组

  • diag()函数：提取对角线或构造对角数组。
    1. def diag(v, k=0):

【例】

  1. import numpy as np
  2. x = np.arange(9).reshape((3, 3))
  3. print(x)
  4. # [[0 1 2]
  5. #  [3 4 5]
  6. #  [6 7 8]]
  7. print(np.diag(x))  # [0 4 8]
  8. print(np.diag(x, k=1))  # [1 5]
  9. print(np.diag(x, k=-1))  # [3 7]
  10. v = [1, 3, 5, 7]
  11. x = np.diag(v)
  12. print(x)
  13. # [[1 0 0 0]
  14. #  [0 3 0 0]
  15. #  [0 0 5 0]
  16. #  [0 0 0 7]]

（f）常数数组

  • full()函数：返回一个常数数组。
  • full_like()函数：返回与给定数组具有相同形状和类型的常数数组。
    1. def full(shape, fill_value, dtype=None, order='C'):
    2. def full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None):

【例】

  1. import numpy as np
  2. x = np.full((2,), 7)
  3. print(x)
  4. # [7 7]
  5. x = np.full(2, 7)
  6. print(x)
  7. # [7 7]
  8. x = np.full((2, 7), 7)
  9. print(x)
  10. # [[7 7 7 7 7 7 7]
  11. #  [7 7 7 7 7 7 7]]
  12. x = np.array([[1, 2, 3], [4, 5, 6]])
  13. y = np.full_like(x, 7)
  14. print(y)
  15. # [[7 7 7]
  16. #  [7 7 7]]

3. 利用数值范围来创建ndarray

  • arange()函数：返回给定间隔内的均匀间隔的值。
  • linspace()函数：返回指定间隔内的等间隔数字。
  • logspace()函数：返回数以对数刻度均匀分布。
  • numpy.random.random() 返回一个由[0,1)内的随机数组成的数组。
  • numpy.random.randint(low, high=None, size=None, dtype='l')
    1. def arange([start,] stop[, step,], dtype=None): 
    2. def linspace(start, stop, num=50, endpoint=True, retstep=False, 
    3.            dtype=None, axis=0):
    4. def logspace(start, stop, num=50, endpoint=True, base=10.0, 
    5.            dtype=None, axis=0):
    6. def rand(d0, d1, ..., dn):

【例】

  1. import numpy as np
  2. x = np.arange(5)
  3. print(x)  # [0 1 2 3 4]
  4. x = np.arange(3, 7, 2)
  5. print(x)  # [3 5]
  6. x = np.linspace(start=0, stop=2, num=9)
  7. print(x)  
  8. # [0.   0.25 0.5  0.75 1.   1.25 1.5  1.75 2.  ]
  9. x = np.logspace(0, 1, 5)
  10. print(np.around(x, 2))
  11. # [ 1.    1.78  3.16  5.62 10.  ]            
  12.                                     #np.around 返回四舍五入后的值，可指定精度。
  13.                                    # around(a, decimals=0, out=None)
  14.                                    # a 输入数组
  15.                                    # decimals 要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置
  16. x = np.linspace(start=0, stop=1, num=5)
  17. x = [10 ** i for i in x]
  18. print(np.around(x, 2))
  19. # [ 1.    1.78  3.16  5.62 10.  ]
  20. x = np.random.random(5)
  21. print(x)
  22. # [0.41768753 0.16315577 0.80167915 0.99690199 0.11812291]
  23. x = np.random.random([2, 3])
  24. print(x)
  25. # [[0.41151858 0.93785153 0.57031309]
  26. #  [0.13482333 0.20583516 0.45429181]]

4. 结构数组的创建

结构数组，首先需要定义结构，然后利用np.array()来创建数组，其参数dtype为定义的结构。

（a）利用字典来定义结构

【例】

  1. import numpy as np
  2. personType = np.dtype({
  3.     'names': ['name', 'age', 'weight'],
  4.     'formats': ['U30', 'i8', 'f8']})
  5. a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],
  6.              dtype=personType)
  7. print(a, type(a))
  8. # [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]
  9. # <class 'numpy.ndarray'>

（b）利用包含多个元组的列表来定义结构

【例】

  1. import numpy as np
  2. personType = np.dtype([('name', 'U30'), ('age', 'i8'), ('weight', 'f8')])
  3. a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],
  4.              dtype=personType)
  5. print(a, type(a))
  6. # [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]
  7. # <class 'numpy.ndarray'>
  8. # 结构数组的取值方式和一般数组差不多，可以通过下标取得元素：
  9. print(a[0])
  10. # ('Liming', 24, 63.9)
  11. print(a[-2:])
  12. # [('Mike', 15, 67. ) ('Jan', 34, 45.8)]
  13. # 我们可以使用字段名作为下标获取对应的值
  14. print(a['name'])
  15. # ['Liming' 'Mike' 'Jan']
  16. print(a['age'])
  17. # [24 15 34]
  18. print(a['weight'])
  19. # [63.9 67.  45.8]