Numpy
Numpy
每日鸡血
每个优秀的人，都有一段沉默的时光。那段时光，是付出了很多努力，却得不到结果的日子，我们把它叫作扎根
什么是Numpy
1:Numpy----Python开源的科学计算工具包,高级的数值编程工具
2:Numpy具有以下特点:
1:强大的N维的数组对象：ndarray
2:对数组结构数据进行运算(不用遍历循环)
3:随机数，线性代数，傅里叶变化等功能
4:许多高级工具的构建基础，比如pandas
Numpy基础数据结构
Numpy是一个多维的数组对象，称为ndarray,其有两个部分组成：
1：实际的数据
2：描述这些数据的元数据
Numpy基础代码
import numpy as np
ar = np.array([1,2,3,5,6])
print([1,2,3,5,6])
print(ar) # 注意与列表的差别：列表是逗号，数组没有
print(ar,type(ar)) #数组类型 <class 'numpy.ndarray'>
"""
注意：
数组的格式：中括号，元素之间没有逗号(和列表区分)
"""
# 1
print(ar.ndim) # 维数：输出数组维度的个数(轴数),或者说"秩",维度的数量也称rank
# (5,)
print(ar.shape) # 维度：数组的维度，对于n行m列的数组，shape为(n,m)
# 5
print(ar.size) # 数组的元素总数：对于n行m列的数组，元素总数为n*m
# int32
print(ar.dtype) # 数组中元素的类型：类似type(),注意：type()是函数，.dtype是方法
# 4
print(ar.itemsize) # 数组中每个元素的字节大小，int32类型字节为4，float64的字节为8
# <memory at 0x0000020EC564CDC8>
print(ar.data) # 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。
ar # 交互方式下输出，会有array(数组)
创建数组
1:array()函数
array()函数，括号内可以是列表、元组、数组、生成器等
2:arrange()函数
arange()，类似range()，在给定间隔内返回均匀间隔的值。
3:linspace()函数
linspace():返回在间隔[开始，停止]上计算的num个均匀间隔的样本。
参数如下：
start：起始值，stop：结束值
num：生成样本数，默认为50
endpoint：如果为真，则停止是最后一个样本。否则，不包括在内。默认值为True。
retstep：如果为真，返回（样本，步骤），其中步长是样本之间的间距 → 输出为一个包含2个元素的元祖，第一个元素为array，第二个为步长实际值
4:zeros()/zeros_like()/ones()/ones_like()
4.1:zeros():返回给定形状和类型的新数组，用零填充。
参数说明：
shape：数组纬度，二维以上需要用()，且输入参数为整数
dtype：数据类型，默认numpy.float64
order：是否在存储器中以C或Fortran连续（按行或列方式）存储多维数据。
4.2:zeros_like(): 返回具有与给定数组相同的形状和类型的零数组，这里ar4根据ar3的形状和dtype创建一个全0的数组
4.3:ones()/ones_like()和zeros()/zeros_like()一样，只是填充为1
5:eye():创建一个正方的N*N的单位矩阵，对角线值为1，其余为0
1:arrary()函数代码
import numpy as np
ar1 = np.array(range(10)) # 整型
ar2 = np.array([1,2,3.14,4,5]) # 浮点型
ar3 = np.array([[1,2,3],("A","B","C")]) # 二维数组：嵌套序列(元组，列表均可)
# [0 1 2 3 4 5 6 7 8 9] int32
print(ar1,ar1.dtype)
# [ 1. 2. 3.14 4. 5. ] float64
print(ar2,ar2.dtype)
'''
[['1' '2' '3']
['A' 'B' 'C']] <U11
'''
print(ar3,ar3.dtype)
# 比较ar3和ar4:注意嵌套序列数列不一样会怎么样
ar4 = np.array([[1,3,4],("a","b","c","d")])
# 若嵌套序列数列不一样 即变成一维数组
'''
[['1' '2' '3']
['A' 'B' 'C']] (2, 3) 2 6
'''
print(ar3,ar3.shape,ar3.ndim,ar3.size) #二维数组，共6个元素
# [[1, 3, 4] ('a', 'b', 'c', 'd')] (2,) 1 2
print(ar4,ar4.shape,ar4.ndim,ar4.size) # 一维数组，共2个元素
2:arrange()函数代码
import numpy as np
# [0 1 2 3 4 5 6 7 8 9]
print(np.arange(10)) #返回0-9，整型
# [ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
print(np.arange(10.0)) #返回0.0-9.0 浮点型
# [ 5 6 7 8 9 10 11]
print(np.arange(5,12)) #返回5-11
# [ 5. 7. 9. 11.]
print(np.arange(5,12.0,2)) # 返回5-12，步长为2
# [ 5. 7. 9. 11.]
print(np.arange(5.0,12.0,2)) # 返回5.0-12.0，步长为2
# [ 0 1 2 ..., 9997 9998 9999]
print(np.arange(10000)) # 如果数组太大而无法打印，NumPy会自动跳过数组的中心部分，并只打印边角：
3:linspace()函数代码
import numpy as np
# [ 2. 2.25 2.5 2.75 3. ]
ar1 = np.linspace(2.0,3.0,num=5)
# [ 2. 2.2 2.4 2.6 2.8]
ar2 = np.linspace(2.0,3.0,num=5,endpoint=False)
# (array([ 2. , 2.25, 2.5 , 2.75, 3. ]), 0.25)
ar3 = np.linspace(2.0,3.0,num = 5,retstep=True)
print(ar1)
print(ar2)
print(ar3)
zeros()/zeros_like()/ones()/ones_like()
import numpy as np
# [ 0. 0. 0. 0. 0.] float64
ar1 = np.zeros(5)
'''
[[0 0 0 0]
[0 0 0 0]] int32
'''
ar2 = np.zeros((2,4),dtype=np.int)
print(ar1,ar1.dtype)
print(ar2,ar2.dtype)
# =================================
"""
[[0 1 2 3 4]
[0 1 2 3 4]]
"""
ar3 = np.array([list(range(5)),list(range(5))])
"""
[[0 0 0 0 0]
[0 0 0 0 0]]
"""
ar4 = np.zeros_like(ar3)
print(ar3)
print(ar4)
# ==============================
# [ 1. 1. 1. 1. 1. 1. 1. 1. 1.]
ar5 = np.ones(9)
"""
[[[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]]
[[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]]]
"""
ar6 = np.ones((2,3,4))
"""
[[1 1 1 1 1]
[1 1 1 1 1]]
"""
ar7 = np.ones_like(ar3)
print(ar5)
print(ar6)
print(ar7)
"""
[[ 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.]]
"""
print(np.eye(5))
Numpy通用函数
1:.T/.reshape()/.resize()
1:.T方法：转置，例如原shape为(3,4)/(2,3,4)，转置结果为(4,3)/(4,3,2) → 所以一维数组转置后结果不变
2:.reshape():为数组提供新形状，而不更改其数据，所以元素数量需要一致！！
用法1：直接将已有数组改变形状
用法2：生成数组后直接改变形状
用法3：参数内添加数组，目标形状
3:.resize(a, new_shape)：返回具有指定形状的新数组，如有必要可重复填充所需数量的元素。
# 注意了：.T/.reshape()/.resize()都是生成新的数组！！！
.T/.reshape()/.resize()代码
import numpy as np
ar1 = np.arange(10)
ar2 = np.ones((5,2))
"""
[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]
"""
print(ar1,"\n",ar1.T)
"""
[[ 1. 1.]
[ 1. 1.]
[ 1. 1.]
[ 1. 1.]
[ 1. 1.]]
[[ 1. 1. 1. 1. 1.]
[ 1. 1. 1. 1. 1.]]
"""
print(ar2,"\n",ar2.T)
#=============================
ar3 = ar1.reshape(2,5) #用法1：直接将已有数组改变形状
ar4 = np.zeros((4,6)).reshape(3,8) #用法2：生成数组后直接改变形状
ar5 = np.reshape(np.arange(12),(3,4)) #用法3：参数内添加数组，目标形状
"""
[0 1 2 3 4 5 6 7 8 9]
[[0 1 2 3 4]
[5 6 7 8 9]]
"""
print(ar1,"\n",ar3)
"""
[[ 0. 0. 0. ..., 0. 0. 0.]
[ 0. 0. 0. ..., 0. 0. 0.]
[ 0. 0. 0. ..., 0. 0. 0.]]
"""
print(ar4)
"""
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
"""
print(ar5)
# ================================
ar6 = np.resize(np.arange(5),(3,4))
"""
[[0 1 2 3]
[4 0 1 2]
[3 4 0 1]]
"""
print(ar6)
2、数组的复制
import numpy as np
ar1 = np.arange(10)
ar2 = ar1 #True
print(ar1 is ar2)
ar1[2] =9
print(ar1,ar2) # [0 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]
# 回忆python的赋值逻辑：指向内存中生成的一个值 → 这里ar1和ar2指向同一个值，所以ar1改变，ar2一起改变
ar3 = ar1.copy()
print(ar3 is ar1) #False
ar1[0] = 9
print(ar1,ar3) #[9 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]
# copy方法生成数组及其数据的完整拷贝
# 再次提醒：.T/.reshape()/.resize()都是生成新的数组！！！
3、数组类型转换：.astype()
import numpy as np
ar1 = np.arange(10,dtype=float)
print(ar1,ar1.dtype) # 可以在参数位置设置数组类型
ar2 = ar1.astype(np.int32)
print(ar2,ar2.dtype) # 注意：养成好习惯，数组类型用np.int32，而不是直接int32
4、数组的堆叠
1:numpy.hstack(tup)：水平（按列顺序）堆叠数组
2:numpy.vstack(tup)：垂直（按列顺序）堆叠数组
3:numpy.stack(arrays, axis=0)：沿着新轴连接数组的序列，形状必须一样！
重点解释axis参数的意思，假设两个数组[1 2 3]和[4 5 6]，shape均为(3,0)
axis=0：[[1 2 3] [4 5 6]]，shape为(2,3)
axis=1：[[1 4] [2 5] [3 6]]，shape为(3,2)
堆叠的相关代码
水平堆叠
# 一维数组的行堆叠
a = np.arange(5) #a为一维数组，5个元素
b = np.arange(5,9) #b为一维数组，4个元素
ar1 = np.hstack((a,b)) #注意：((a,b)),这里形状可以不一致
print(a,a.shape) # [0 1 2 3 4] (5,)
print(a,b.shape) # [0 1 2 3 4] (4,)
print(ar1,ar1.shape) # [0 1 2 3 4 5 6 7 8] (9,)
#多维数组的行堆叠
"""
[[1]
[2]
[3]] (3, 1)
"""
a = np.array([[1],[2],[3]]) # a为二维数组，3行1列
"""
[['A']
['B']
['C']] (3, 1)
"""
b = np.array([["A"],["B"],["C"]]) # b为二维数组，3行1列
"""
[['1' 'A']
['2' 'B']
['3' 'C']] (3, 2)
"""
ar2 = np.hstack((a,b)) # ((a,b)),这里形状必须一致
print(a,a.shape)
print(b,b.shape)
print(ar2,ar2.shape)
垂直堆叠
import numpy as np
# 一维数组的垂直堆叠
a = np.arange(5)
b = np.arange(5,10)
ar1 = np.vstack((a,b))
print(a,a.shape) # [0 1 2 3 4] (5,)
print(b,b.shape) #[5 6 7 8 9] (5,)
"""
[[0 1 2 3 4]
[5 6 7 8 9]] (2, 5)
"""
print(ar1,ar1.shape)
#多维数组的垂直堆叠
a = np.array([[1],[2],[3]])
b = np.array([["a"],["b"],["c"],["d"]])
ar2 = np.vstack((a,b)) #这种形状可以不一样
"""
[[1]
[2]
[3]] (3, 1)
"""
print(a,a.shape)
"""
[['a']
['b']
['c']
['d']] (4, 1)
"""
print(b,b.shape)
"""
[['1']
['2']
['3']
['a']
['b']
['c']
['d']] (7, 1)
"""
print(ar2,ar2.shape)
stack函数
import numpy as np
a = np.arange(5) # [0 1 2 3 4] (5,)
b = np.arange(5,10) # [5 6 7 8 9] (5,)
"""
[[0 1 2 3 4]
[5 6 7 8 9]] (2, 5)
"""
ar1 = np.stack((a,b)) #默认按行堆叠
"""
[[0 5]
[1 6]
[2 7]
[3 8]
[4 9]] (5, 2)
"""
ar2 = np.stack((a,b),axis=1) #按列堆叠
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
print(ar2,ar2.shape)
5.数组的拆分
1:numpy.hsplit(ary, indices_or_sections)：将数组水平（逐列）拆分为多个子数组 → 按列拆分
2:indices_or_sections)：:将数组垂直（行方向）拆分为多个子数组 → 按行拆
拆分的代码
import numpy as np
"""
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
"""
ar = np.arange(16).reshape(4,4)
"""
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])] <class 'list'>
"""
ar1 = np.hsplit(ar,2)
print(ar)
print(ar1,type(ar1))
"""
[
array([[0, 1, 2, 3]]),
array([[4, 5, 6, 7]]),
array([[ 8, 9, 10, 11]]),
array([[12, 13, 14, 15]])] <class 'list'>
"""
ar2 = np.vsplit(ar,4)
print(ar2,type(ar2))
6.数组的简单运算
print(ar**0.5) #幂
print(ar.mean()) #求平均值
print(ar.max()) #求最大值
print(ar.min()) #求最小值
print(ar.std()) #求标准差
print(ar.var()) #求方差
# 求和，np.sum() → axis为0，按列求和；axis为1，按行求和
print(ar.sum(),np.sum(ar,axis=0))
print(np.sort(np.array([1,5,9,0,3,67,8]))) #排序
Numpy索引与切片
1.基本索引及切片
import numpy as np
# 一维数组索引及切片
ar = np.arange(20) # [ 0 1 2 ..., 17 18 19]
print(ar)
print(ar[4]) # 4
print(ar[3:6]) # [3 4 5]
# 二维数组索引及切片
ar = np.arange(16).reshape(4,4)
print(ar, '数组轴数为%i' %ar.ndim) # 4*4的数组
print(ar[2],'数组轴数为%i' %ar[2].ndim) # 切片为下一维度的一个元素，所以是一维数组
print(ar[2][1]) # 二次索引，得到一维数组中的一个值
print(ar[1:3],'数组轴数为%i' %ar[1:3].ndim) # 切片为两个一维数组组成的二维数组
print(ar[2,2]) # 切片数组中的第三行第三列 → 10
print(ar[:2,1:]) # 切片数组中的1,2行、2,3,4列 → 二维数组
# 三维数组索引及切片
ar = np.arange(8).reshape(2,2,2)
print(ar,'数组轴数为%i' %ar.ndim) # 2*2*2的数组
print(ar[0],'数组轴数为%i' %ar[0].ndim) # 三维数组的下一个维度的第一个元素 → 一个二维数组
print(ar[0][0], '数组轴数为%i' %ar[0][0].ndim) # 三维数组的下一个维度的第一个元素下的第一个元素 → 一个一维数组
print(ar[0][0][1], '数组轴数为%i' %ar[0][0][1].ndim)
2.布尔型索引及切片
ar = np.arange(12).reshape(3,4)
i = np.array([True,False,True])
j = np.array([True,True,False,False])
print(ar)
print(i)
print(j)
print(ar[i,:]) # 在第一维度做判断，只保留True，这里第一维度就是行，ar[i,:] = ar[i]（简单书写格式）
print(ar[:,j]) # 在第二维度做判断，这里如果ar[:,i]会有警告，因为i是3个元素，而ar在列上有4个
# 布尔型索引：以布尔型的矩阵去做筛选
作用
m = ar > 5
print(m) # 这里m是一个判断矩阵
print(ar[m]) # 用m判断矩阵去筛选ar数组中>5的元素 → 重点！后面的pandas判断方式原理就来自此处
3.数组索引及切片的值更改、复制
ar = np.arange(10)
print(ar)
ar[5] = 100
ar[7:9] = 200
print(ar)
# 一个标量赋值给一个索引/切片时，会自动改变/传播原始数组
ar = np.arange(10)
b = ar.copy()
b[7:9] = 200
print(ar) # [0 1 2 3 4 5 6 7 8 9]
print(b) # [ 0 1 2 3 4 5 6 200 200 9]
Numpy随机数
numpy.random包含多种概率分布的随机样本，是数据分析辅助的重点工具之一
1:np.random.normal(size=(4,4))
生成一个标准正太分布的4*4样本值
2:numpy.random.rand(d0, d1, ..., dn)：
生成一个[0,1)之间的随机浮点数或N维浮点数组 —— 均匀分布
3:numpy.random.randn(d0, d1, ..., dn)：
生成一个浮点数或N维浮点数组 —— 正态分布
4:numpy.random.randint(low, high=None, size=None, dtype='l')：
生成一个整数或N维整数数组
若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数，且high必须大于low
dtype参数：只能是int类型
随机数的相关代码
import numpy as np
import matplotlib.pyplot as plt # 导入matplotlib模块，用于图表辅助分析
samples = np.random.normal(size=(4,4))
print(samples) # 生成一个标准正太分布的4*4样本值
%matplotlib inline # 魔法函数，每次运行自动生成图表
a = np.random.rand()
print(a,type(a)) #生成一个随机浮动数
b = np.random.rand(4)
print(b,type(b)) # 生成形状为4的一维数组
c = np.random.rand(3,2) # 生成形状为2*3的二维数组，注意这里不是((2,3))
samples1 = np.random.rand(1000)
samples2 = np.random.randn(1000)
plt.scatter(samples1,samples2) # 生成1000个均匀分布的样本值
Numpy数据的输入输出
numpy读取/写入数组数据、文本数据
1:存储数组数据.npy文件
np.save("arraydata.npy",ar) #相对路径
np.save('C:/Users/Hjx/Desktop/arraydata.npy', ar) #绝对路径
2：读取数组数据 .npy文件
np.load('arraydata.npy')
np.load('C:/Users/Hjx/Desktop/arraydata.npy')
3：存储文本文件
np.savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ')：存储为文本txt文件
示例：
ar = np.random.rand(5,5)
np.savetxt('array.txt',ar, delimiter=',') # delimiter指定分隔符
4：读取文本文件
np.loadtxt('array.txt', delimiter=',')
输入输出相关代码
# 存储数组数据.npy文件
import os
os.chdir('C:/Users/Hjx/Desktop/')
ar = np.random.rand(5,5)
print(ar)
np.save("arraydata.npy",ar)
# 也可以直接
# np.save('C:/Users/Hjx/Desktop/arraydata.npy', ar)
# 读取数组数据 .npy文件
ar_load =np.load('arraydata.npy')
print(ar_load)
# 也可以直接
np.load('C:/Users/Hjx/Desktop/arraydata.npy')
# 存储/读取文本文件
ar = np.random.rand(5,5)
np.savetxt('array.txt',ar, delimiter=',')
# np.savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ')：存储为文本txt文件
ar_loadtxt = np.loadtxt('array.txt', delimiter=',')
print(ar_loadtxt)
# 也可以直接 np.loadtxt('C:/Users/Hjx/Desktop/array.txt')
版权声明：本文为ydz1993原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。