介绍

为了让python能够更好地进行矩阵运算，numpy库应运而生。通过调入numpy库，python对矩阵进行操作变得非常容易, 处理多维数组

课件

Numpy课件.py
下载 之后修改后缀 .py 改成 .rar

安装

  1. pip install numpy
  2. pip3 install numpy

1.1 创建数组

np.array(5)
np.arange(5) 如果只有一个行参 那么默认0 - 5 #会打印 0 1 2 3 4

  1. # 知识点  np.array()  np.arange()
  3. import numpy as np
  5. # 创建数组有3种方法
  6. np.array([1, 2, 3, 4])
  7. np.array(range(1, 5))
  8. np.arange(1, 5)
  10. #########################array属性
  11. a = np.array(range(1, 5))
  12. print(a.shape)
  13. print(a.ndim)
  14. print(a.size)

array属性

  • shape：返回一个元组，表示 array的维度 [形状，几行几列] （2，3）两行三列，（2，2，3）两个两行三列
  • ndim：返回一个数字，表示array的维度的数目
  • size：返回一个数字，表示array中所有数据元素的数目
  • dtype：返回array中元素的数据类型

1.1.1 arange 创建数字序列

np.arange(开始, 结束, [,步长])

  1. import numpy as np
  2. a = np.arange(1,5)       # 打印  0  1  2  3  4
  3. a = np.arange(5)       # 打印  0  1  2  3  4
  4. a = np.arange(1,10,2)  # 2 表示步长  打印 1  3  5  7  9

1.1.2 ones 创建全是1的数组

np.ones(3) # 生成一维数组建议直接填
np.ones((2,3)) # 生成多维数组(2维 or 3维….) 传入 元组

  1. import numpy as np
  3. a = np.ones(3)  #  3 表示  创建  3个 1 的数组 
  4. print(a)  # 打印 [1,1,1]
  6. a = np.ones((2, 3))  # 传入元组 表示 2 行 3 列
  7. print(a)
  8. """
  9. [ [1. 1. 1.]
  10.   [1. 1. 1.]  ]
  11. """

参数：

  • shape：整数或者整型元组定义返回数组的形状；可以是一个数（创建一维向量），也可以是一个元组（创建多维向量）
  • dtype : 数据类型，可选定义返回数组的类型。
  • order : {‘C’, ‘F’}, 可选规定返回数组元素在内存的存储顺序：C（C语言）-rowmajor；F（Fortran）column-major。

1.1.3 zeros 创建全是0的数组

  1. import numpy as np
  3. a = np.zeros(3)  #  3 表示  创建  3个 1 的数组 
  4. print(a)  # 打印 [1,1,1]
  6. a = np.zeros((2, 3))  # 传入元组 表示 2 行 3 列
  7. print(a)
  8. """
  9. [ [0. 0. 0.]
  10.   [0. 0. 0.] ]
  11. """

参数：

  • shape：整数或者整型元组定义返回数组的形状；可以是一个数（创建一维向量），也可以是一个元组（创建多维向量）
  • dtype : 数据类型，可选定义返回数组的类型。
  • order : {‘C’, ‘F’}, 可选规定返回数组元素在内存的存储顺序：C（C语言）-rowmajor；F（Fortran）column-major。

1.1.4 full 创建指定值的数组

  1. import numpy as np
  3. # a = np.full(3,10)
  4. a = np.full((2,3,),10)
  5. print(a)
  7. """
  8. [ [10 10 10]
  9.   [10 10 10] ]
  10. """

参数：

  • shape：整数或者整型元组定义返回数组的形状；可以是一个数（创建一维向量），也可以是一个元组（创建多维向量）
  • fill_value：标量（就是纯数值变量）
  • dtype : 数据类型，可选定义返回数组的类型。
  • order : {‘C’, ‘F’}, 可选规定返回数组元素在内存的存储顺序：C（C语言）-rowmajor；F（Fortran）column-major。

1.1.5 ones_like 修改数组的值为全是1

np.ones_like(a) # a 是要被修改的 数组

  1. # 知识点  np.ones_like(a)
  3. import numpy as np
  4. a = np.array([[0,1,2], [3,4,5]])
  5. print(a)
  6. """
  7. [[0 1 2]
  8.  [3 4 5]]
  9. """
  10. b = np.ones_like(a)   # zeros_like
  11. print(b)
  12. """
  13. [[1 1 1]
  14.  [1 1 1]]
  15. """

1.1.6 zeros_like 修改数组的值为全是0

  1. # 知识点  np.ones_like(a)
  3. import numpy as np
  4. a = np.array([[0,1,2], [3,4,5]])
  5. print(a)
  6. """
  7. [[0 1 2]
  8.  [3 4 5]]
  9. """
  10. b = np.zeros_like(a)
  11. print(b)
  12. """
  13. [[0 0 0]
  14.  [0 0 0]]
  15. """

1.1.7 full_like 修改数组的值为全是 指定

  1. # 知识点  np.ones_like(a)
  3. import numpy as np
  4. a = np.array([[0,1,2], [3,4,5]])
  5. print(a)
  6. """
  7. [[0 1 2]
  8.  [3 4 5]]
  9. """
  10. b = np.full_like(a)
  11. print(b)
  12. """
  13. [[10 10 10]
  14.  [10 10 10]]
  15. """

1.1.8 random 生产随机数组

  1. import numpy as np
  2. a = np.random.rand()  # 一维 生成1个随机数
  3. a = np.random.rand(3)  # 生成3个随机数
  4. a = np.random.rand(2, 3)  # 2行 3列   二维
  5. a = np.random.rand(2, 3, 3)  # 2个 3行 3列  三维
  7. print(a)
  8. #  0.928313490819961
  10. """# 生成3个随机数
  11. [0.24002972 0.52984526 0.92602486]
  12. """
  14. """# 2行 3列   二维
  15.  [ [0.54630947 0.15047786 0.14924945]
  16.    [0.34366365 0.81492689 0.70474482] ]
  17. """
  19. """ # 2个 3行 3列  三维
  20. [ [ [0.69621973 0.90073822 0.68464174]
  21.     [0.49358927 0.10531875 0.60787824]
  22.     [0.5042075  0.00299158 0.21608138] ]
  24.   [ [0.52087987 0.64587557 0.03710203]
  25.     [0.47145618 0.68575485 0.4660773 ]
  26.     [0.17425526 0.63956613 0.34935802] ] ]
  28. """

1.2 给数组指定类型

1.2.1查看数据类型

  1. # 知识点  a.dtype
  3. import numpy as np
  5. a = np.array([1, 2, 3, 4])
  6. print(a.dtype)
  7. ----------------------打印
  8. Int32

1.2.2 指定数据类型

  1. # 知识点 dtype='int32'  dtype=int  dtype=float  dtype=float32  dtype=float64
  3. import numpy as np
  5. a = np.array(rangen(1,6),dtype='int32')
  6. b = np.arangen(rangen(1,6),dtype=float)

1.3 多维数组

  1. import numpy as np
  3. a = np.array([[1, 2, 3], [4, 5, 6]])
  4. print(a.shape)  # 打印  (2, 3)  表示 2行 3列的数组
  6. a =np.ones((2,3,3))  # 创建全是1的 2个 3行 3列的多维数组     如果要全是0 的话使用zeros
  7. print(a)
  8. """
  9. [ [ [1. 1. 1.]
  10.     [1. 1. 1.]
  11.     [1. 1. 1.] ]
  13.   [ [1. 1. 1.]
  14.     [1. 1. 1.]
  15.     [1. 1. 1.] ] ]
  17. """

image.png

1.3.1 reshape 不改值只修改形状

np.arange(30).reshape(2,15)
注意 这里的 2和15 相乘一定要等于 左边的 30 , 否则报错

np.arange(30).reshape(5,6)
注意 这里的 5和6 相乘一定要等于 左边的 30 , 否则报错

np.arange(10).reshape(5,2)
注意 这里的 5和2 相乘一定要等于 左边的 10 , 否则报错

  1. # 知识点 np.arange(30).reshape(5,6)
  3. import numpy as np
  4. a = np.arange(30).reshape(5,6) # 注意 这里的 2和15 相乘一定要等于 左边的 30 , 否则报错
  5. print(a)
  7. """ 2行 15列
  8. [[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
  9.  [15 16 17 18 19 20 21 22 23 24 25 26 27 28 29]]
  11. """
  13. """ 5行 6列
  14. [[ 0  1  2  3  4  5]
  15.  [ 6  7  8  9 10 11]
  16.  [12 13 14 15 16 17]
  17.  [18 19 20 21 22 23]
  18.  [24 25 26 27 28 29]]
  20. """

1.3.2 数组计算

对数组中的每一个元素进行运算 + - * / 等等

  1. import numpy as np
  2. a = np.arange(10)
  3. print(a)
  4. print(a+1)  # 表示对数组中的每一个元素进行运算  +  -  *  / 等等
  1. # a 和 b 的形状相同 每个元素都是 一 一 对应的
  2. import numpy as np
  3. a = np.arange(10).reshape(2,5)
  4. b = np.random.randn(2,5)
  5. print(a)
  6. print("_"*30)
  8. print(b)
  9. print("_"*30)
  10. print(a+b)
  12. """
  13. [[0 1 2 3 4]
  14.  [5 6 7 8 9]]
  15. ______________________________
  16. [[-1.84387296  0.81133958 -1.35249219 -1.27229604 -0.36994214]
  17.  [ 0.61755784  0.62548493  0.2411525  -0.43594004 -0.37085307]]
  18. ______________________________
  19. [[-1.84387296  1.81133958  0.64750781  1.72770396  3.63005786]
  20.  [ 5.61755784  6.62548493  7.2411525   7.56405996  8.62914693]]
  22. 进程已结束，退出代码为 0
  25. """
  2. import numpy as np
  3. a = np.arange(10).reshape(2,5)
  4. b = np.random.randn(5)
  6. """a
  7. [[0 1 2 3 4]
  8.  [5 6 7 8 9]]
  9. ______________________________b
  10. [-0.20755605 -0.93353318 -1.01339274 -0.71288535  0.86667488]
  12. ______________________________最终结果
  13. [[-0.20755605  0.06646682  0.98660726  2.28711465  4.86667488]
  14.  [ 4.79244395  5.06646682  5.98660726  7.28711465  9.86667488]]
  18. """
  19. a 的第一行 跟 b只有一行的元素　一　一　对应运算
  20. a 的第二行 跟 b只有一行的元素再　一　一　对应运算
  1. #
  3. import numpy as np 
  4. a = np.arange(10).reshape(2,5)
  5. b = np.arange(2).reshape(2,1)
  6. print(a)
  7. print("---"*30)
  8. print(b)
  10. print(a+b)
  11. """2行 5列
  12. [[0 1 2 3 4]
  13.  [5 6 7 8 9]]
  14. --------------------------------2行 1列
  15. [[0]
  16.  [1]]
  17. --------------------------------最终
  18. [[ 0  1  2  3  4]
  19.  [ 6  7  8  9 10]]
  21. """

1.3.3 广播规则

技巧, 只要最后面的列相同, 则表示兼容广播原则, 否则不兼容广播原则
后缘维相同的就能进行 加减乘除运算
检查数据是否支持广播原则 首先检查 最后边的列,如果大于,则不支持广播原则, 如果等于支持,如果小于再检查行的纬度是否相等,是的话也支持广播原则
思考：

  • （3，2，3）和（2，3）
  • （3，2，3）和（3，）
  • （3，2，2）和（2，1）
  • （3，2，3）和（2，4）

image.png

广播的原则:
如果两个数组的后缘维度（trailing dimension，即从末尾开始算起的维度）的轴长度相符，或其中的一方的长度为1，则认为它们是广播兼容的。广播会在缺失和（或）长度为1的维度上进行。
这句话乃是理解广播的核心。广播主要发生在两种情况，一种是两个数组的维数不相等，但是它们的后缘维度的轴长相符，另外一种是有一方的长度为1。

image.png
image.png
上例中x的shape为（4,3），y的shape为（3，）。可以说x是二维的，而y是一维的。但是它们的后缘维度相等，x的第二维长度为3，和y的维度相同。x和y的shape并不一样，但是它们可以执行相加操作，这就是通过广播完成的。

同样的例子还有：
image.png
从上面的图可以看到，（3,4,2）和（4,2）的维度是不相同的，前者为3维，后者为2维。但是它们后缘维度的轴长相同，都为（4,2）。同样，还有一些例子：（4,2,3）和（2,3）是兼容的，（4,2,3）还和（3）是兼容的，后者需要在两个轴上面进行扩展。
数组维度相同，其中有个轴为1：
image.png
x的shape为（4,3），y的shape为（4,1），它们都是二维的，但是第二个数组在1轴上的长度为1，所以可以进行广播。

1.4 索引切片

  1. import numpy as np
  3. a = np.array([[0,1,2,3,4], 
  4.               [5,6,7,8,9], 
  5.               [10,11,12,13,14], 
  6.               [15,16,17,18,19]])
  8. print(a[0:1])  # 取 0行的所有 和所有的 第一列
  9. print(a[0,1])  # 取 0行 1列
  10. print(a[-1,2]) # 取 最后1行的第2列
  11. print(a[0:-1]) # 取 所有, 除了最后一行
  12. print(a[0:2,2:4]) # 取 0和1行, 2和3列
  13. print(a[:,2])  # 取所有的行的,第2列
  1. # a[0,1] = 520
  3. import numpy as np
  4. a = np.array([[0,1,2,3,4], 
  5.               [5,6,7,8,9], 
  6.               [10,11,12,13,14], 
  7.               [15,16,17,18,19]])
  8. a[0,1] = 520
  9. a[0:1] = 520
  10. a[:1,:2] = 522  # 修改0行和第1列的所有值 
  11. print(a)

1.5 布尔索引

  1. import numpy as np
  3. A = np.arange(10)
  4. print(A)
  5. B = A > 5
  6. print(B)
  7. C = A[B]
  8. print(C)
  9. """
  10. [0 1 2 3 4 5 6 7 8 9]
  11. [False False False False False False  True  True  True  True]
  12. [6 7 8 9]
  14. """
  2. import numpy as np
  3. A = np.arange(10)
  4. A[A<=5] = 0  # 把所有小于5 or 等于5 的都置成 0
  5. A[A>5] = 1   # 把所有大于5 的都置成 1 
  6. print(A)
  8. """
  9. [0 0 0 0 0 0 1 1 1 1]
  10. """
  12. # 大于5 的自增  520
  14. A[A<=5] =0
  15. A[A>5] += 520
  16. print(A)
  17. """
  18. [  0   0   0   0   0   0 526 527 528 529]
  19. """

…..

1.6 神奇索引

3 numpy轴

3.1 transpose方法【行列转置】

  1. import numpy as np
  2. 数组=np.arange(24).reshape((4,6))
  3. print(数组)
  4. print("-"*30)
  5. print(数组.transpose())

image.png

3.2 swapaxes方法【轴转置】

  1. import numpy as np
  2. 数组=np.arange(24).reshape((4,6))
  3. print(数组)
  4. print("-"*30)
  5. print(数组.swapaxes(1,0))

image.png

7 使用数组进行面向编程

7.1 数学和统计方法

方法 描述
sum 沿着轴向计算所有元素的累和，0长度的数组累和为0
average 加权平均，参数可以指定weights
prod 所有元素的乘积
mean 数学平均，0长度的数组平均值为NaN
std,var 标准差和方差，可以选择自由度调整（默认分母是n）
min,max 最小和最大值
argmin,argmax 最小和最大值的位置
cumsum 从0开始元素累积和
cumprod 从1开始元素累积积
median 中位数
prercentile 0-100百分位数
quantile 0-1分位数