Numpy库及ndarrary基础知识
Numpy简介
Numpy是一个开源的Python科学计算基础库。
- 一个强大的N维数组对象 ndarray
- 广播功能函数
- 整合C/C++/Fortran代码的工具
- 线性代数、傅里叶变换、随机数生成等功能
Numpy是SciPy、Pandas等数据处理或科学计算库的基础。
Numpy的引用：
import numpy as np
引用使用别名np，尽管别名可以省略或更改，建议使用上述约定的别名。
N维数组对象：ndarray
例：计算A2+B3，其中，A和B是一维数组
def pySum():
a=[0,1,2,3,4]
b=[9,8,7,6,5]
c=[]
for i in range(len(a)):
c.append(a[i]**2 + b[i]**3)
return c
print(pySum())
import numpy as np
def npSum():
a=np.array([0,1,2,3,4])
b=np.array([9,8,7,6,5])
c=a**2+b**3
return c
print(npSum())
第二种方法使用Numpy库直接给出a,b两个数组即可，然后计算得到结果，不需要写循环。
数组对象可以去掉元素间运算所需的循环,使一维向量更像单个数据。
设置专门的数组对象，经过优化，可以提升这类应用的运算速度。
科学计算中，一个维度所有数据的类型往往都相同。数组对象采用相同的数据类型，有助于节省运算和存储空间。
N维数组对象：ndarray
ndarray是一个多维数组对象，由两部分构成：实际数据、描述这些数据的元数据（数据维度、数据类型等）
ndarray数组一般要求所有元素类型相同（同质），数组下标从0开始。
np.array()生成一个ndarray数组，ndarray在程序中的别名是array。np.array()输出成[]形式，元素由空格分割。
ndarray对象的属性：
| 属性 | 说明 |
|---|---|
| .ndim | 秩，即轴的数量或维度的数量 |
| .shape | ndarray对象的尺度，对于矩阵，n行m列 |
| .size | ndarray对象元素的个数，相当于.shape中n*m的值 |
| .dtype | ndarray对象的元素类型 |
| .itemsize | ndarray对象中每个元素的大小，以字节为单位 |
In[1]:
import numpy as np
arr1=np.array([1,2,3,4])
print('创建的数组为：',arr1)
arr2=np.array([[1,2,3,4],[2,3,4,5]])
print(arr2)
Out[1]:
创建的数组为： [1 2 3 4]
[[1 2 3 4]
[2 3 4 5]]
In[2]:
arr2.shape#查看数组结构
Out[2]:
(2, 4)
In[3]:
arr2.dtype#查看数组类型
Out[3]:
dtype('int32')
In[4]:
arr2.size#查看数组元素个数
Out[4]:
8
In[5]:
arr2.itemsize#查看数组每个元素大小
Out[5]:
4
In[6]:
arr2.ndim#数组的维度
Out[6]:
2
ndarray的元素类型：
| 数据类型 | 说明 |
|---|---|
| bool | 布尔类型，True或False |
| intc | 与C语言中的int类型一致，一般是int32或int64 |
| intp | 用于索引的整数，与C语言中ssize_t一致，int32或int64 |
| int8 | 字节长度的整数，取值：[-128,127] |
| int16 | 16位长度的整数，取值：[-32768, 32767] |
| int32 | 32位长度的整数，取值：[-231, 232-1] |
| int64 | 64位长度的整数，取值：[-263, 263-1] |
| uint8 | 8位无符号整数，取值[0,255] |
| uint16 | 16位无符号整数，取值：[0,65535] |
| uint32 | 32位无符号整数，取值：[0,232-1] |
| uint64 | 64位无符号整数，取值：[0,264-1] |
| float16 | 16位半精度浮点数：1位符号位，5位指数，10位尾数 |
| float32 | 32位半精度浮点数：1位符号位，8位指数，23位尾数 |
| float64 | 64位半精度浮点数：1位符号位，11位指数，52位尾数 |
| complex64 | 复数类型，实部和虚部都是32位浮点数 |
| complex128 | 复数类型，实部和虚部都是64位浮点数 |
对比：Python语法仅支持整数、浮点数和复数3种类型
科学计算涉及数据较多，对存储和性能都有较高要求。
对元素类型精细定义，有助于NumPy合理使用存储空间并优化性能。
对元素类型精细定义，有助于程序员对程序规模有合理评估。
ndarray数组可以由非同质对象构成。非同质ndarray元素为对象类型。
非同质ndarray对象无法有效发挥Numpy优势，尽量避免使用。
In[7]:
x=np.array([[0,1,2,3,4],[9,8,7,6]])
x.shape
Out[7]:
(2,)
In[8]:
x.dtype
Out[8]:
dtype('O') #O类型表示对象，元素维度数据不同，将每个元素都视为一个对象
In[9]:
x
Out[9]:
array([list([0, 1, 2, 3, 4]), list([9, 8, 7, 6])], dtype=object)
创建ndarray数组
- 从Python中的列表、元组等类型创建ndarray数组
x=np.array(list/tuple)
x=np.array(list/tuple, dtype=np.float32)
- 使用Numpy中函数创建ndarray数组，如：arange（注意，不是arrange！！！），ones，zeros等
In[1]: np.arange(0,1,0.1) #产生有起点和终点的固定步长的数组，起点默认0，步长默认1
Out[1]: array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
In[2]: np.linspace(0,1,12) #产生12个[0,1]区间的数
Out[2]: array([0. , 0.09090909, 0.18181818, 0.27272727, 0.36363636,
0.45454545, 0.54545455, 0.63636364, 0.72727273, 0.81818182,
0.90909091, 1. ])
In[3]: np.logspace(0,2,20)#产生[0,2]之间的等比数列
Out[3]: array([ 1. , 1.27427499, 1.62377674, 2.06913808,
2.6366509 , 3.35981829, 4.2813324 , 5.45559478,
6.95192796, 8.8586679 , 11.28837892, 14.38449888,
18.32980711, 23.35721469, 29.76351442, 37.92690191,
48.32930239, 61.58482111, 78.47599704, 100. ])
In[4]: np.eye(4)#产生单位矩阵
Out[4]: array([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])
In[5]: np.diag([1,2,3,4])
Out[5]: array([[1, 0, 0, 0],
[0, 2, 0, 0],
[0, 0, 3, 0],
[0, 0, 0, 4]])
In[6]: np.zeros((2,3))#产生0数组
Out[6]: array([[0., 0., 0.],
[0., 0., 0.]])
In[7]: np.ones([4,3])#产生全1数组
Out[7]: array([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])
#np.ones_like(a)根据数组a的形状生成一个全1数组
#np.zeros_like(a)根据数组a的形状生成一个全0数组
#np.full_like(a,val)根据数组a的形状生成一个数组，值全为val
In[8]: np.random.random(100)#无约束条件下生成随机数
Out[8]: array([0.67781333, 0.09641575, 0.81744244, 0.51278574, 0.98454235,
0.86534111, 0.33520735, 0.21342638, 0.06603498, 0.01996554])
In[9]: np.random.rand(4,5)#服从“0~1”均匀分布的数组
Out[9]: array([[0.68965255, 0.23693354, 0.08128558, 0.05926917, 0.85667476],
[0.0832 , 0.21984451, 0.39034674, 0.62013218, 0.58911233],
[0.20491853, 0.35134618, 0.79328201, 0.82678033, 0.41156243],
[0.95250391, 0.39173906, 0.93848367, 0.62982597, 0.76634915]])
#服从标准正态分布的数组，基本上取值主要在-1.96~+1.96之间
In[10]: np.random.randn(4,5)
Ou[10]: array([[-0.16638873, -0.07524763, -0.65528112, 0.03723065, 1.72830986],
[-2.54330122, 0.93422113, 0.94859713, -0.23486067, -0.03668511],
[-0.07051164, -0.0346533 , 1.13803941, 0.43895906, 1.58496663],
[-0.51918301, -0.30385197, 1.39331684, 0.52738113, 0.69320662]])
#生成给定范围的随机数，如最小值不小于2，最大值不大于10的2行5列数组
In[11]: np.random.randint(2,10,size=[2,5])
Out[11]: array([[7, 6, 5, 7, 7],
[2, 3, 7, 8, 2]])
常用随机数生成函数
| 函数 | 说明 |
|---|---|
| rand(d0,d1,…,dn) | 根据d0~dn创建随机数数组浮点数，[0,1]，均匀分布 |
| randn(d0,d1,…,dn) | 根据d0~dn创建随机数数组，标准正态分布 |
| randint(low[,high,shape]) | 根据shape创建随机整数或整数数组，范围是[low,high) |
| seed(s) | 随机数种子，s是给定的种子值 |
| permutation(a) | 根据数组a的第1轴产生一个新的乱序数组，不改变数组a |
| shuffle(a) | 根据数组a的第1轴进行随机排序，改变数组a |
| choice(a[,size,replace,p]) | 从一维数组a中以概率p抽取元素，形成size形状新数组，replace表示是否可以重用元素，默认为False |
| binomial | 产生二项分布的随机数 |
| normal(loc,scale,size) | 产生正太（高斯）分布的数组，loc均值，scale标准差，size形状 |
| poisson(lam,size) | 产生泊松分布的数组，lam随机事件发生率，size形状 |
| beta | 产生beta分布的随机数 |
| chisquare | 产生卡方分布的随机数 |
| gamma | 产生gamma分布的随机数 |
| uniform(low,high,size) | 产生在[low,high)均匀分布的随机数，size形状 |
-
从字节流中创建ndarray数组
-
从文件中读取特定格式，创建ndarray数组
访问数组
索引和切片
索引：获取特定位置的元素；
切片：获取数组元素子集。
一维数组的索引
In[0]: arr=np.arange(10)
arr[5]#整数下标访问，下标从0开始
Out[0]: 5
In[1]: arr[3:5]#范围访问，包括左边不包括右边
Out[1]: array([3, 4])
In[2]: arr[:5]#省略左下标，表示从arr[0]开始
Out[2]: array([0, 1, 2, 3, 4])
In[3]: arr[-1]#下标可以用负数，表示从后往前数的第几个元素
Out[3]: 9
In[4]:arr[2:4]=100,101 #下标修改元素
arr
Out[4]:array([ 0, 1, 100, 101, 4, 5, 6, 7, 8, 9])
In[5]:arr[1:-1:2] #开始编号：终止编号（不含）：步长，2表示隔一个取一个元素
Out[5]:array([ 1, 101, 5, 7])
In[6]:arr[5:1:-2] #步长为负数时，左下标必须>右下标
Out[6]:array([ 5, 101])
多维数组的索引
In[1]:arr=np.array([[1,2,3,4,5],[4,5,6,7,8],[7,8,9,10,11]])
arr
Out[1]:array([[ 1, 2, 3, 4, 5],
[ 4, 5, 6, 7, 8],
[ 7, 8, 9, 10, 11]])
In[2]:arr[0,3:5] #第0行中第3和第4列的元素
Out[2]:array([4, 5])
In[3]:arr[1:,2:] #第2和3行中第3—5列的元素
Out[3]:array([[ 6, 7, 8],
[ 9, 10, 11]])
#从两个序列的对应位置取出两个整数来组成下标：arr[0,1],arr[1,2],arr[2,3]
In[4]:arr[[(0,1,2),(1,2,3)]]
Out[4]:array([ 2, 6, 10])
# 第2、3行中第0、2、3列的元素
In[5]:arr[1:,(0,2,3)]
Out[5]:array([[ 4, 6, 7],
[ 7, 9, 10]])
# mask是一个布尔数组，它索引第1、3行中第2列的元素
In[6]:mask=np.array([1,0,1],dtype=np.bool)
arr[mask,2]
Out[6]:array([3, 9])
改变数组形状
In[1]:arr=np.arange(12)
arr
Out[1]:array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
In[2]:arr.reshape(3,4)#重新设置数组形状
Out[2]:array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
In[3]:arr.reshape(3,4).ndim #查看数组维度
Out[3]:2
使用ravel、flatten函数展平数组
In[1]:arr=np.arange(12).reshape(3,4)
arr
Out[1]:array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
In[2]:arr.ravel()
Out[2]:array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
In[3]:arr.flatten()#横向展平
Out[3]:array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
In[4]:arr.flatten('F') #纵向展平
Out[4]:array([ 0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11])
数组的运算
numpy一元函数
| 函数 | 说明 |
|---|---|
| np.abs(x) np.fabs(x) | 计算各元素的绝对值 |
| np.sqrt(x) | 平方根 |
| np.square(x) | 平方 |
| np.log(x) np.log10(x) np.log2(x) | 自然对数、10底对数和2底对数 |
| np.ceil(x) np.floor(x) | ceiling值或floor值 |
| np.rint(x) | 四舍五入值 |
| np.modf(x) | 将数组各元素的小数和整数部分以两个独立数组形式返回 |
| np.cos(x) np.cosh(x) np.sin(x) np.sinh(x) np.tan(x) np.tanh(x) | 普通型和双曲型三角函数 |
| np.exp(x) | 各元素的指数值 |
| np.sign(x) | 符号值，1（+），0，-1（-） |
numpy二元函数
| 函数 | 说明 |
|---|---|
| + - * / ** | 两个数组各元素进行对应运算 |
| np.maximum(x,y) np.fmax() np.maximum(x,y) np.fmax() | 元素级的最大值/最小值 |
| np.mod(x,y) | 元素级的模运算 |
| np.copysign(x,y) | 将数组y中各元素值的符号赋值给数组x对应元素 |
| > < >= <= == != | 算术比较，产生布尔型数组 |
梯度函数
梯度：连续值之间的变化率，即斜率。XY坐标轴连续三个X坐标对应的Y轴值：a,b,c，其中，b的梯度为：(c-a)/2
np.gradient(f)：计算数组f中元素的梯度，当f为多维时，返回每个维度梯度。
In[1] : import numpy as np
a=np.random.randint(0,20,(5))
a
Out[1]: array([ 5, 0, 10, 7, 8])
In[2] : np.gradient(a)#拿元素0举例，梯度=(10-5)/2
Out[2]: array([-5. , 2.5, 3.5, -1. , 1. ])
In[3] : c=np.random.randint(0,50,(3,5))
c
Out[3]: array([[45, 16, 20, 49, 27],
[25, 22, 18, 1, 15],
[34, 4, 17, 24, 13]])
In[4] : np.gradient(c)#会有两个数组，每个数组代表在第n维中的梯度
Out[4]: [array([[-20. , 6. , -2. , -48. , -12. ],
[ -5.5, -6. , -1.5, -12.5, -7. ],
[ 9. , -18. , -1. , 23. , -2. ]]),
array([[-29. , -12.5, 16.5, 3.5, -22. ],
[ -3. , -3.5, -10.5, -1.5, 14. ],
[-30. , -8.5, 10. , -2. , -11. ]])]
组合数组
- 横向组合：np.hstack((arr1,arr2))
- 纵向组合：np.vstack((arr1,arr2))
- 横向组合：np.concatenate((arr1,arr2),axis=1))
- 纵向组合：np.concatenate((arr1,arr2),axis=0))
切割数组
- hsplit实现横向分割：np.hsplit(arr1,2)
- vsplit实现横向分割：np.vsplit(arr,2)
- split实现横向分割：np.split(arr,2,axis=1)
- split实现纵向分割：np.split(arr,2,axis=0)
矩阵与通用函数
创建与组合矩阵
- 使用mat函数创建：matr1=np.mat(“1 2 3;4 5 6;7 8 9”)
- 使用matrix函数创建：matr2=np.matrix([[123],[456],[789]])
- 使用bmat函数合成矩阵：np.bmat(“arr1 arr2;arr1 arr2”)
矩阵运算
- 矩阵与数相乘：matr1*3
- 矩阵相加减：matr1±matr2
- 矩阵相乘：matr1*matr2
- 矩阵对应元素相乘：np.multiply(matr1,matr2)
- 矩阵特有属性：①T：返回自身的转置；②H：返回自身的共轭转置③I：返回自身的逆矩阵；④A：返回自身数据的2维数组的一个视图
ufunc函数
全称通用函数，是一种能够对数组中所有元素进行操作的函数。
- 四则运算:加(+）、减（-）、乘（*）、除（/)、幂（**）。数组间的四则运算表示对每个数组中的元素分别进行四则运算，所以形状必须相同。
- 比较运算: >、<、==、>=、=、!=。比较运算返回的结果是一个布尔数组，每个元素为每个数组对应元素的比较结果。
- 逻辑运算: np.any 函数表示逻辑“or”, np.all 函数表示逻辑“and”。运算结果返回布尔值。
广播机制
广播是指不同形状的数组之间执行算术运算的方式。需要遵循个原则：
- 让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐。
- 输出数组的shape是输入数组shape的各个轴上的最大值。
- 如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，否则出错。
- 当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值。
利用Numpy进行统计分析
CSV文件
CSV（Comma-Separated Value，逗号分隔值），用来存储批量数据。
CSV数据存取可以使用np.loadtxt()和np.savetxt()函数。
读写文件
主要有二进制文件的读写和文件列表形式的数据读写两种形式。
- save函数是以二进制的格式保存数据，np.save("…/tmp/save_arr",arr)
- load函数是从二进制的文件中读取数据，np.load("…/tmp/save_arr.npy")
- savez函数可以将多个数组保存到一个文件中，np.savez("…/tmp/savez_arr",arr1,arr2)
- 存储时可以省略扩展名，但读取时不能省略扩展名。
读取文本格式的数据
- savetxt
np.savetxt("…/tmp/arr.txt",arr,fmt="%d",delimiter=",")，将数组写到某种分隔符隔开的文本文件中。 - loadtxt
np.loadtxt("…/tmp/arr.txt",delimiter=",")，函数执行的是把文件加载到一个二维数组中。 - genfromtxt
np.genfromtxt("…/tmp/arr.txt",delimiter=".")，函数面向的是结构化数组和缺失数据。 - tofile
a.tofile(frame, sep=’,’, format=’%s’) ，其中frame是文件、字符串，sep是数据分割字符串，如果是空串，写入文件为二进制；format写入数据的格式。 - fromfile
np.fromfile(frame, dtype=float, count=-1, sep=’,’)，从文件读取数据，其中dtype是读取的数据类型，count读入元素个数，-1表示读取整个文件；sep数据分割字符串，如果是空串，写入文件为二进制。tofile和fromfile需要配合使用。
a=np.arange(100).reshape(5,20)
a
array([[ 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, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39],
[40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
56, 57, 58, 59],
[60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
76, 77, 78, 79],
[80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
96, 97, 98, 99]])
a.tofile('b.dat',sep=',',format='%d')#写入文件b.dat
c=np.fromfile('b.dat',dtype=np.int,sep=',').reshape(2,2,25)#从文件b.dat中读取
c
array([[[ 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, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49]],
[[50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
66, 67, 68, 69, 70, 71, 72, 73, 74],
[75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
91, 92, 93, 94, 95, 96, 97, 98, 99]]])
直接排序
arr.sort()
sort函数也可以指定一个axis参数，使得sort函数可以沿着指定轴对数据集进行排序。axis=1为沿横轴排序；axis=0为沿纵轴排序。
间接排序
argsort函数返回值为重新排序值的下标，arr.argsort()
lexsort函数返回值是按照最后一个传入数据排序的，np.lexsort((a,b,c))
去重与重复数据
- 通过unique函数可以找出数组中 唯一值并返回已排序的结果
- tile函数主要有两个参数，参数"A"指定重复的数组，参数"reps"指定重复的次数。np.tile(A, reps)
- repeat函数主要有三个参数，参数"a"是需要重复的数组元素，参数“repeats”是重复次数，参数“axis”指定沿着哪个轴进行重复，axis=0表示按行进行元素重复，axis=1表示按列进行元素重复。numpy.repeat(a, repeats,axis=None)
- 这两个函数的主要区别在于，tile函数是对数组进行重复操作，repeat函数是对数组中的每个元素进行重复操作。
常用统计函数
axis=None是统计函数的标配参数。当axis=0时，表示沿着纵轴计算。当axis=1时，表示沿着横轴计算，默认时计算一个总值。
| 函数 | 说明 |
|---|---|
| sum(a, axis=None) | 根据给定轴axis计算数组a的元素之和，axis整数或元组 |
| mean(a, axis=None) | 计算数组均值 |
| average(a, axis=None, weight=None) | 计算数组元素的加权平均值 |
| std(a, axis=None) | 计算数组标准差 |
| var(a, axis=None) | 计算数组方差 |
| min | 计算数组最小值 |
| max | 计算数组最大值 |
| argmin | 返回数组最小元素的降一维后下标 |
| argmax | 返回数组最大元素的降一维后下标 |
| unravel_index(index, shape) | 根据shape将一维下标index转换成多维下标 |
| ptp(a) | 计算数组a中元素最大值与最小值的差 |
| median(a) | 计算数组a中元素的中位数（中值） |
| cumsum | 计算所有元素的累计和 |
| cumprod | 计算所有元素的累计积 |