1.Numpy是什么？
    NumPy是Python中科学计算的基础包。NumPy包的核心是 ndarray 对象。它封装了python原生的同数据类型的 n 维数组，为了保证其性能优良，其中有许多操作都是代码在本地进行编译后执行的。
    NumPy数组 和 原生Python Array（数组）之间有几个重要的区别：

    1. Numpy数组在创建时具有固定的大小，更改ndarray的大小将创建一个新数组并删除原来的数组。
    2. NumPy 数组中的元素都需要具有相同的数据类型，因此在内存中的大小相同。
    3. NumPy 数组有助于对大量数据进行高级数学和其他类型的操作。

    2.关于数组大小和速度
    举一个简单的例子，考虑将1维数组中的每个元素与相同长度的另一个序列中的相应元素相乘的情况。如果数据存储在两个Python 列表 a 和 b中，我们可以迭代每个元素，如下所示：

    1. c = []
    2. for i in range(len(a)):
    3.     c.append(a[i]*b[i])

    但当列表a和b非常庞大时，这个循环效率就显得比较低，我们可以通过在C中写入以下代码，增加速度

    1. for (i = 0; i < rows; i++): {
    2.   for (j = 0; j < columns; j++): {
    3.     c[i][j] = a[i][j]*b[i][j];
    4.   }
    5. }

    在NumPy中：该代码由预编译的C代码快速执行

    1. c = a * b

    3.矢量化和广播
    将大量的的for循环转换成为矩阵矢量计算，例如：
    邓光勇-Numpy学习1 - 图1->邓光勇-Numpy学习1 - 图2
    4.基本知识
    Numpy的对象通常是一个元素表，由非负整数元组索引。在Numpy中维度称为轴，例如：

    1. [1,2,1] # 具有一个轴，该轴有三个元素，所以长度为3.
    2. [[ 1, 0, 0],[ 0, 1, 2]] # 数组有2个轴。第一轴的长度为3，第二轴的长度为3。
    • 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。

    5.创建数组

    1. import numpy as np
    2. a = np.array([2,3,4])    # array([2, 3, 4])
    4. b = np.array([(1.5,2,3), (4,5,6)]) # array([[ 1.5,  2. ,  3. ],[ 4. ,  5. ,  6. ]])
    1. from numpy import pi
    2. np.linspace( 0, 2, 9 ) # 从0增加到2的9个数字
    3. # array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ,  1.25,  1.5 ,  1.75,  2.  ])
    4. x = np.linspace( 0, 2*pi, 100 )        # 
    5. f = np.sin(x)

    6.打印数组

    1. a = np.arange(6)   # 一维数组
    2. print(a)    # [0 1 2 3 4 5]
    4. b = np.arange(12).reshape(4,3)      # 二维数组
    5. print(b)    
    6. # [[ 0  1  2]
    7.      [ 3  4  5]
    8.      [ 6  7  8]
    9.      [ 9 10 11]]

    7.数组操作

    1. A = np.array( [[1,1], [0,1]])
    2. B = np.array( [[2,0], [3,4]])
    3. A * B # 元素相乘 array([[2, 0], [0, 4]])
    5. A @ B # 矩阵相乘 array([[5, 4], [3, 4]])
    7. A.dot(B)
    9. b = np.arange(12).reshape(3,4)
    10. b # array([[ 0,  1,  2,  3],
    11.        [ 4,  5,  6,  7],
    12.        [ 8,  9, 10, 11]])
    13. b.sum(axis=0) # 计算每一列的和 array([12, 15, 18, 21])
    14. b.min(axis=1) # 每一行的最小值 array([0, 4, 8])
    16. b = array(
    17.             [[0,  1,  2,  3],
    18.        [10, 11, 12, 13],
    19.        [20, 21, 22, 23],
    20.        [30, 31, 32, 33],
    21.        [40, 41, 42, 43]]
    22.        )
    23. b[2,3]    # 23
    24. b[0:5, 1]  # 每行的第二列的元素 array([1, 11, 21, 31, 41])
    25. b[ : , 1]  # 同上 array([ 1, 11, 21, 31, 41])
    27. # 迭代
    28. for row in b:
    29.     print(row)
    30. # [0 1 2 3]
    31. # [10 11 12 13]
    32. # [20 21 22 23]
    33. # [30 31 32 33]
    34. # [40 41 42 43]
    36. # 数组合并
    37. a # array([[ 8.,  8.],
    38.        [ 0.,  0.]])
    39. b # array([[ 1.,  8.],
    40.        [ 0.,  4.]])
    41. np.hstack((a,b))
    42. # array([[ 8.,  8.,  1.,  8.],
    43.        [ 0.,  0.,  0.,  4.]])
    44. np.vstack((a,b)) 
    45. # array([[ 8.,  8.],
    46.        [ 0.,  0.],
    47.        [ 1.,  8.],
    48.        [ 0.,  4.]])
    49. # 删除一列
    50. a = np.arange(4).shape(2,2)
    51. # array([[1,2],
    52. [3,4]
    53. ])
    54. np.delete(a, 0, axios=1)
    55. # array([[2],[4]
    56. ])

    8.线性代数操作

    1. import numpy as np
    2. a = np.array([[1.0, 2.0], [3.0, 4.0]])
    3. # print(a)
    4. [[ 1.  2.]
    5.  [ 3.  4.]]
    6. a.transpose()
    7. array([[ 1.,  3.],
    8.        [ 2.,  4.]])
    10. u = np.eye(2) # 单位矩阵
    11. # array([[ 1.,  0.],
    12.        [ 0.,  1.]])
    14. np.linalg.inv(a) # 矩阵的逆
    15. array([[-2. ,  1. ],
    16.        [ 1.5, -0.5]])