numpy如何使用
numpy介绍
创建numpy的数组
一维数组是什么样子
可以理解为格子纸的一行就是一个一维数据
two_arr = np.array([1, 2, 3])
二维数组什么样子
理解为一张格子纸, 多个一维数组构成一个二维数组
two_arr = np.array([ [1, 2, 3], [4, 5, 6], [7, 8, 9] ]) print(two_arr) [[1 2 3] # 三行三列的二维列表 [4 5 6] [7 8 9]]
三维数组什么样子
three_arr = np.array([ [ [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], ], [ [4, 5, 6], [4, 5, 6], [4, 5, 6], [4, 5, 6], ] ]) print(three_arr) # [[[1 2 3] # [1 2 3] # [1 2 3] # [1 2 3]] # # [[4 5 6] # [4 5 6] # [4 5 6] # [4 5 6]]]
np.array()
传入一个列表, 返回一个数组
li = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] arr = np.array(li) print(type(arr), arr) # <class 'numpy.ndarray'> [0 1 2 3 4 5 6 7 8 9]
np.arange(10)
类似于python中的range
arr = np.arange(10) print(type(arr), arr) <class 'numpy.ndarray'> [0 1 2 3 4 5 6 7 8 9] # 和python的range类型, 顾头不顾尾, 支持步长, 和python的range的区别在于, 起始值和步长支持小数 arr = np.arange(1.2, 10.5, 0.5) print(type(arr), arr) # <class 'numpy.ndarray'> [ 1.2 1.7 2.2 2.7 3.2 3.7 4.2 4.7 5.2 5.7 6.2 6.7 7.2 7.7 8.2 8.7 9.2 9.7 10.2]
拓展: 将一维数据变成多维数组
前提保证, reshape()中的行和列相乘等于数组中的全部元素的个数
将一维数组转换成二维数组
arr = np.arange(0, 15).reshape(3, 5) print(arr) # [[ 0 1 2 3 4] # [ 5 6 7 8 9] # [10 11 12 13 14]]
将一维数组转换成三维数组
arr = np.arange(30).reshape(3, 2, 5) print(arr) # [[[ 0 1 2 3 4] # [ 5 6 7 8 9]] # # [[10 11 12 13 14] # [15 16 17 18 19]] # # [[20 21 22 23 24] # [25 26 27 28 29]]] # 三维数组可以只给出两个数值, 另外一个用-1代替, 自动求剩下一个一个应该是多少 # 比如:arr = np.arange(30).reshape(3, 2, -1) 会自动求出-1位置的数应该是6
np.linspace(0, 10, 5)
把0到10范围的数分成长度为5的数组, 保证每个数之间的差是相等的, 前包后也包
arr = np.linspace(0, 10, 5) print(type(arr), arr) # <class 'numpy.ndarray'> [ 0. 2.5 5. 7.5 10. ]
np.zeros(10)
创建全0的数组
arr = np.zeros(10) print(arr) # [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] # 默认是float类型, 可以指定dtype, 可以指定创建几维的数据传一个元祖, 比如np.zeros(3,2,5), 就是创建一个3页2行5列的全0数组
np.ones(10)
创建全1的数组
arr = np.ones(10) print(arr) # [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.] # 默认使用float类型, 可以指定dtype, 可以指定创建几维的数据传一个元祖, 比如np.ones(3,2,5), 就是创建一个3页2行5列的全1数组
np.empty(10)
创建元素为随机的数组
# np.empty(10)的意义: 向内存要一个长度为10的内存, 并不进行赋值, 内存中原本的数据是什么就是什么, 之后可以对这个里面的值进行覆盖, 效率相对高一点 arr = np.empty(10) print(arr) # [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
np.eye(5)
创建单位矩阵, 方形的, 主对角线为1
arr = np.eye(5) # 类似于np.identity(5) print(arr) # [[1. 0. 0. 0. 0.] # [0. 1. 0. 0. 0.] # [0. 0. 1. 0. 0.] # [0. 0. 0. 1. 0.] # [0. 0. 0. 0. 1.]]
数组的常用方法
多维数组的转置
二维数组: 列转行
two_arr = np.array([ [1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12] ]) ret = two_arr.T print(ret) # 行: 0 列:1 # [[ 1 4 7 10] # [ 2 5 8 11] # [ 3 6 9 12]]
三维数组的转置
three_arr = np.array([ [ [1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], ], [ [21, 22, 23], [24, 25, 26], [27, 28, 29], [30, 31, 32], ] ]) # 页: 0 行:1 列:2 res = three_arr.transpose(0, 2, 1) print(res) # [[[ 1 4 7 10] # [ 2 5 8 11] # [ 3 6 9 12]] # # [[21 24 27 30] # [22 25 28 31] # [23 26 29 32]]]
矩阵的计算
创建两个矩阵
a1 = np.array([ [1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12] ]) a2 = np.array([ [1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12] ])
加法
两个矩阵的结构一致才能进行加法
a3 = a1 + a2 print(a3) # [[ 2 4 6] # [ 8 10 12] # [14 16 18] # [20 22 24]]
乘法
两个矩阵相乘, 结构必须满足以下条件才能相乘
矩阵一的结构: 3 x 4 矩阵二的结构: 4 x 3
n(行数) x d(列数) d(行数) x m(列数)
最后的结果矩阵结构就是n(行) x m(列)
# 矩阵一的结构 # [ # [1, 2, 3], # [4, 5, 6], # [7, 8, 9], # [10, 11, 12] # ] # 矩阵二的结构 # [[ 1 4 7 10] # [ 2 5 8 11] # [ 3 6 9 12]] # 相乘的结果是一个3 x 3的矩阵 # 计算过程: # 矩阵一的第一行和矩阵二的第一列计算, # 1x1 + 2x2 + 3x3 = 14 # 矩阵一的第一行和矩阵二的第二列计算, # 1x4 + 2x5 + 3x6 = 32 # 矩阵一的第一行和矩阵二的第三列计算, # 1x7 + 2x8 + 3x9 = 50 # 矩阵一的第一行和矩阵二的第四列计算, # 矩阵一的第二行和矩阵二的第一列计算, # 矩阵一的第二行和矩阵二的第二列计算, # 矩阵一的第二行和矩阵二的第三列计算, # 矩阵一的第二行和矩阵二的第四列计算, # 以此类推 print(a1 @ a2.T) # 矩阵的乘法用 @ # [[ 14 32 50 68] # [ 32 77 122 167] # [ 50 122 194 266] # [ 68 167 266 365]]
查看一个数组的结构 arr.shape
一维数组
one_arr = np.array([1, 2, 3, 4]) print(one_arr.shape) # (4,)
二维数组
a2 = np.array([ [1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12] ]) print(a2.shape) # (4, 3) (行, 列)
三维数组
three_arr = np.array([ [ [1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], ], [ [21, 22, 23], [24, 25, 26], [27, 28, 29], [30, 31, 32], ] ]) print(three_arr.shape) # (2, 4, 3) (页, 行, 列)
获取数组中元素的个数 arr.size
one_arr = np.array([1, 2, 3, 4, 5]) two_arr = np.array([ [1, 2, 3, 4], [1, 2, 3, 4], ]) three_arr = np.array([ [ [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], ], [ [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], ] ]) print(one_arr.size) print(two_arr.size) print(three_arr.size) # 5 # 8 # 2
查看数组是几维的 arr.ndim
one_arr = np.array([1, 2, 3, 4, 5]) two_arr = np.array([ [1, 2, 3, 4], [1, 2, 3, 4], ]) three_arr = np.array([ [ [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], ], [ [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], ] ]) print(one_arr.ndim) print(two_arr.ndim) print(three_arr.ndim) # 1 # 2 # 3
查看数组中的数据的数据类型 arr.dtype
数组中的元素类型是一致
two_arr = np.array([ [1, 2, 3, 4], [1, 2, 3, 4], ]) print(two_arr.dtype) # int32 #默认int类型是int32 最大:2147483647 最小: -2147483648
当数值正好是int32的最大最小的那个数值时, 在对这个属性进行加减, 就会从最大的回退到最小的, 最小的回退到最大的, 这是一个圈
arr = np.array([0, 2 ** 31 - 1]) print(arr) # [ 0 2147483647] int32最大的数值 ret = arr + 1 print(ret) # [ 1 -2147483648] # 从最大变成了最小
如何解决这个数值太大无法表示的问题?
方法一
定义数组时, 指定大一点的数据类型,指定数据类型为int64, 或更大的object
arr = np.array([0, 2 ** 31 - 1], dtype="int64") ret = arr + 10 print(ret) # [ 10 2147483657]
方法二
修改已经定义好数据类型的数组, 但是返回新数组, 新数组才是拥有新的数据类型的数组
arr = np.array([0, 2 ** 31 - 1]) new_arr = arr.astype("int64") # 返回一个数据类型是int64的数组 new_arr = new_arr + 10 print(new_arr)
方法三
使用小数(float), 当要存储的数特别大时, 还可以考虑使用小数(float)的数据类型
小数的计数法不会出现计算机无法表示的问题
arr = np.array([0, 2 ** 200], dtype="float") ret = arr + 200 print(ret) # [2.00000000e+02 1.60693804e+60]
注意: 当生成数组时会根据你存储的值的大小动态的使用响应的数据类型, 对数据中的值进行加减时不会在改变, 因为元素的数据类型在存储时已经确定了
常用的数据类型
ndarray数据类型：dtype： 布尔型：bool_ 整型：int int8 int16 int32 int 64 无符号整型：uint8 uint16 uint32 uint64 都是正数, 对int要大, 因为没有了负号 浮点型：float float16 float32 float64 复数型：complex complex64 complex128
索引切片
数组索引切片的特点: python的切片会产生新的数据, 修改新数据不会影响元数据
但是在数组中却不是这样的, 切片只是在元数据上做标记, 记录3:10这一段数据B可以拿到, 当对B进行修改时
元数据也会跟着变化, 这样做的目的就是节省时间和空间, 当数据较大时, 对数据进行切片比较快
对切片后的数据使用copy()可以进行拷贝, 修改数据不会再影响元数据
one_arr[0:5].copy()
普通索引
一维数组普通索引
one_arr = np.arange(10) print(one_arr) # [0 1 2 3 4 5 6 7 8 9] # 取前5个 print(one_arr[0:5]) # [0 1 2 3 4]
二维数组普通索引
two_arr = np.arange(15).reshape(3, 5) print(two_arr) # [[ 0 1 2 3 4] # [ 5 6 7 8 9] # [10 11 12 13 14]]
1. 取到第二行第三列的那个数
print(two_arr[2, 3]) # 13
2. 取第一行
print(two_arr[0,]) # two_arr[行: 列] # [0 1 2 3 4]
3. 取第一列
print(two_arr[0:,0]) # 所有的行0: 第一列0
4. 从中间去一个长方形
print(two_arr[0:2, 1:4]) # 切片是前包后不包的 # [[1 2 3] # [6 7 8]]
布尔型索引
1. 问题: 给出一个数组, 选出数组中所有大于5的数
python列表的做法
li = [random.randint(1, 10) for n in range(10)] # python列表的做法 # res = list(filter(lambda x: x > 5, li)) # print(res)
数组的做法
arr = np.array(li) print(arr[arr > 5]) # 为什么这样写? # 先看看arr > 5的结果是什么 print(arr > 5) # [ True True True True False False True True True True] # 返回一个全是布尔的数组 # 将5和原数组中的值进行比较返回布尔值 # 返回使用这些布尔值进行取值, 将对应位置上是True的值取出了 # arr[ True True True True False False True True True True] # 这样就把结果取出来了
2. 问题: 给出一个数组, 选出所有大于5, 并且是偶数的数
print(arr[(arr > 5) & (arr % 2 == 0)]) # 两个条件, 当两个条件都是True时才是True # 两个条件先分别计算, 得出两个全是布尔值的数组, 然后两个数组进行 & 计算, 在使用得出的结果取原数组中取值 # 注意 and 和 & 的区别 # and: 是python的关键字 # &: 是运算符 # 在这里要使用运算符
3. 问题: 给出一个数组, 选出所有除了大于5以外的数
print(arr[~(arr > 5)]) # 找出大于5的, 然后使用 ~ 取反
4. 问题: 给出一个数组, 计算该数组中大于5的数字占的比重
print((arr[arr > 5]).size / arr.size) # 计算出大于5的数量, 然后除以全部的数量
花式索引
给出一个数据取出索引为奇数的数值
一维数组
arr = np.arange(10) print(arr[[1, 3, 5, 7, 9]]) # 索引取值使用一个列表, 会取值和该列表值对应的索引位置的值, 保证列表中的元素都能作为索引, 不大于大最大索引 # [1 3 5 7 9]
二维数组
# 使用花式索引是, 行列不能同时使用花式索引, 例如print(arr[[1, 2], [0, 1]]) arr = np.arange(15).reshape(3, 5) print(arr) # [[ 0 1 2 3 4] # [ 5 6 7 8 9] # [10 11 12 13 14]] # print(arr[[1, 2], :][:, [0, 1]]) # [[ 5 6] # [10 11]]
通用函数
np.abs(arr) 绝对值
arr = np.arange(-5, 10).reshape(3, 5) print(arr) # [[-5 -4 -3 -2 -1] # [ 0 1 2 3 4] # [ 5 6 7 8 9]] print(np.abs(arr)) # [[5 4 3 2 1] # [0 1 2 3 4] # [5 6 7 8 9]]
np.sqrt(arr) 开根号
arr = np.arange(1, 16).reshape(3, 5) print(np.sqrt(arr)) # [[1. 1.41421356 1.73205081 2. 2.23606798] # [2.44948974 2.64575131 2.82842712 3. 3.16227766] # [3.31662479 3.46410162 3.60555128 3.74165739 3.87298335]]
np.exp() 指数
arr = np.arange(1, 16).reshape(3, 5) print(np.exp(arr)) # [[2.71828183e+00 7.38905610e+00 2.00855369e+01 5.45981500e+01 # 1.48413159e+02] # [4.03428793e+02 1.09663316e+03 2.98095799e+03 8.10308393e+03 # 2.20264658e+04] # [5.98741417e+04 1.62754791e+05 4.42413392e+05 1.20260428e+06 # 3.26901737e+06]]
取整
arr = np.array([3.4, 3.3, 4.6, 5.0]) print(np.ceil(arr)) # 向上取整 4.5取5 print(np.floor(arr)) # 向下取整 4.5取4 print(np.trunc(arr)) # 向0取整 print(np.rint(arr)) # 四舍五入取整
np.array() 将数组变成整数部分和小数部分两个数组
将数据分成两个数组, 一个是整数部分, 一个是小数部分, 都会带着各自的符号
arr = np.array([-3.4, 3.3, -4.6, 5.0]) print(np.modf(arr)) # (array([-0.4, 0.3, -0.6, 0. ]), array([-3., 3., -4., 5.]))
isnan (not a number)
**各种没有确定值的数据运算会返回nan, 比如对-1开根号
nan不等于任何数, 自己都不等于自己
a = float("nan") print(a == a) # False print(type(a), a) # <class 'float'> nan
为什么会有nan?
nan常用作表示数据缺失值, 有这个值, 但是暂时不知道的值叫缺失值
因为在array进行计算时, 加入要计算一亿个数, 但是其中有一个数是没有结果的, 正常情况下会报错
那么这次计算就白做了, 但是numpy的array为了让这次计算有效, 就使用了nan
那些情况会产生nan?
arr = np.array([0, 1, 2, 3]) print(arr / arr) # [nan 1. 1. 1.] # 因为0/0没有结果, 就用nan代替了
判断一个数组中是否有nan
arr = np.array([0, 1, 2, 3]) res = arr / arr print(np.isnan(res)) # [ True False False False] # 数组中的第一个元素就是nan
如何将排除数据中的nan?
print(arr[~np.isnan(res)]) # 通过布尔值索引 # [1 2 3]
如何将数组中的nan改为0?
arr[np.isnan(res)] = 0 # 所有为True的位置写一个0 print(arr)
如何创建一个nan?
print(np.nan) # nan print(np.NAN) # nan
np.isinf() 无穷大, 无穷小
inf: 无穷大, -inf: 无穷小
自己等于自己
常用的数学统计方法
常用函数
arr = np.arange(10) print(arr.sum()) # 求和 print(arr.mean()) # 求平局值 print(arr.max()) # 最大值 print(arr.min()) # 最小值 print(arr.var()) # 求方差 [1,2,3,4,5] 平均值:3, ((1-3**2) + (2-3**2) + (3-3**2) + (4-3**2) + (5-3**2)) / 5(长度) print(arr.std()) # 标准差 等于方差开根号 print(arr.cumsum()) # 前缀和 print(arr.argmin()) # 返回最小数的索引值 print(arr.argmax()) # 返回最大数的索引值
应用示例
1. 估算数组内数值的范围?
arr = np.array([random.uniform(10, 20) for n in range(100)]) print(arr.mean() - 2 * arr.std()) # 平均值 - 标准差 # 9.024533852997003 print(arr.mean() + 2 * arr.std()) # 平均值 + 标准差 # 20.533572296358937
2. 求某一区间的所有数值的和
arr = np.array([1, 2, 3, 7, 6, 5, 10]) a = arr.cumsum() print(a) # [ 0 1 3 6 10 15 21 28 36 45] # 求索引4到索引8之间的所有数值的和 6+5=11 res = a[5] - a[3] # 顾尾不顾头 print(res) # 11
随机数
和python的random用法基本一致, 区别在于可以直接将随机数生成到指定形状的数组中
np.random.random()
print(np.random.random()) # 生产0到1之间的小数 # 还可以生成到数组中 # 生成一维数组 print(np.random.random(10)) # [0.75789864 0.49982257 0.32940952 0.57216004 0.17562665 0.50703461 # 0.36919792 0.20893032 0.09530242 0.66015132] # 生成二维数组 print(np.random.random((3, 5))) # [[0.47324357 0.73385845 0.89099074 0.50889891 0.21902953] # [0.8889513 0.48389661 0.72072126 0.36994093 0.97653365] # [0.38499637 0.82375443 0.52682468 0.7266469 0.19659174]]
其他
print(np.random.randint(10, 20, (3, 5))) # 生成随机整数 print(np.random.uniform(10, 20, (3, 5))) # 生成随机小数, 每个数出现的次数大概相同 print(np.random.normal(6, 10)) # 随机小数, 有负数, 正态分布, 中间的数出现的几率大 print(np.random.choice([1, 2, 3, 4, ], 2)) # 给定的形状中随机选择, 可以指定个数 arr = np.arange(10).reshape(2, 5) np.random.shuffle(arr) # 打乱给定形状中的数据, 打乱的是元数据 print(arr)
