NumPy是Python的一种开源的数值计算扩展库,提供 数组支持以及相应的高效处理函数,它包含很多功能,如创建n维数组()矩阵,对数组进行函数运算,数值积分,线性代数计算,傅里叶变换和随机数产生等。
Why NumPy?
标准的Python用List(列表)保存值,可以当作数组使用,但因为列表中的元素可以是任何对象,所以浪费了CPU的运算时间和内存。NumPy的诞生弥补了这些缺陷,它提供了两种基本的对象:
- ndarry(n-dimensional array object):是存储单一数据类型的多维数组。
- ufunc(universal function object):是一种能够对数组进行处理的函数。
NumPy常用导入格式:
import numpy as np
一、数组对象的创建
1、使用 array 函数来创建数组对象:
- array 函数的格式:
np.array(object,dtype,ndmin)
array 函数的主要参数及其使用说明如下表所示:
参数名称 | 说明 |
---|---|
object | 接收array,表示想要创建的数组 |
dtype | 接收data-type,表示数组所需数据类型,未给定则选择保存数据对象所需的最小类型,默认为None。 |
ndmin | 接收int,指定生成数组应该具有的最小维数,默认为None。 |
#创建ndarray数组:
import numpy as np
data1 = [1,3,5,7] #列表
w1 = np.array(data1)
print('w1:',w1)
data2 = (1,2,3,4) #元组
w2 = np.array(data2)
print('w2:',w2)
data3 = [[1,2,3,6],[5,6,7,8]] #多维数组
w3 = np.array(data3)
print('w3:',w3)
#Output
#w1: [1 3 5 7]
#w2: [1 2 3 4]
#w3: [[1 2 3 6]
# [5 6 7 8]]
在创建数组时,NumPy会为新建的数组推断出一个合适的数据类型,并保存在dtype中,当序列中有整数和浮点数时,dtype会被定义为浮点数类型。
import numpy as np
data1 = [1,3,5,7.3] #列表
w1 = np.array(data1)
print(w1.dtype)
print('w1:',w1)
#Output
#float64
#w1: [1. 3. 5. 7.3]
2、专门创建数组的函数
1)arrange函数
- arange函数:创建等差一维数组,arrange函数类似于Python的内置函数range,但是arrange主要用来创建数组。
格式:np.arange([start, ]stop, [step, ]dtype)
#使用arrange创建数组
kk = np.arange(10)
print(kk)
#Output
#[0 1 2 3 4 5 6 7 8 9]
arrange函数可以通过指定初始值、终值和步长创建一维数组,创建的数组不包含终值。
kk = np.arange(0,15,1.5)
print(kk)
#Output
#[ 0. 1.5 3. 4.5 6. 7.5 9. 10.5 12. 13.5]
2)linspace 函数
当arrange函数的参数是浮点型的时候,由于浮点的精度有限,通常不太可能预测或者数组元素的数量,由于这个原因,通常选用更好的函数linspace,它接收元素数量作为参数,通过指定初始值,终值和元素格式创建一维数组,默认包括终值。
- linspace 函数:创建等差一维数组,接收元素数量作为参数。
格式:np.linspace(start, stop, num, endpoint, retstep=False, dtype=None)
参数说明:
start: scalar(标量), 序列的起始点
stop: scalar, 依据endpoint会有变化, endpoint为True, 则包含显示, 当为False, 不包含(生成序列相当于原始num上加1按endpoint = True生成, 结果只显示第一个到倒数第二个)
num: int, optional(可选), 生成样本数量, 必须是非负数
endpoint: bool, optional, 如果是真,则包括stop,如果为False,则没有stop
retstep: bool, optional
dtype: dtype, optional
#使用linspace函数创建数组
kk = np.linspace(1,10,4)
print(kk)
#Output
#[ 1. 4. 7. 10.]
3)logspace 函数
- logspace 函数和linspace 函数类似,不同的是它所创建的是等比数列数组。
格式:np.logspace(start, stop, num, endpoint=True,
base=10.0, dtype=None))
logspace的参数中,**start, stop代表的是10的幂,**默认基数base为10,第三个参数元素个数。
#生成1~10的具有5个元素的等比数列数组
kk = np.logspace(0,1,5)
print(kk)
#Output
#[ 1. 1.77827941 3.16227766 5.62341325 10. ]
4)zeros 函数
- zeros函数:创建指定长度或形状的全0数组
格式:np.zeros(shape, dtype=float, order=‘C’)
#使用zeros函数创建全零矩阵。
ll = np.zeros(4)
print(ll)
print("-----------------------")
kk = np.zeros(4,float)
print(kk)
print("-----------------------")
cc = np.zeros([3,3],int)
print(cc)
#Output
#[0. 0. 0. 0.]
#-----------------------
#[0. 0. 0. 0.]
#-----------------------
#[[0 0 0]
# [0 0 0]
# [0 0 0]]
可以看出,zeros函数默认类型为float64。
5)ones 函数
- ones函数:创建指定长度或形状的全1数组
格式:np. ones(shape, dtype=None, order=‘C’)
6)diag 函数
- diag函数:创建一个对角阵。
格式:np.diag(v, k=0)
参数:v可以是一维或二维的矩阵,k<0表示斜线在矩阵的下方,k>0表示斜线在矩阵的上方。
kk = np.diag([1,2,3,4])
print(kk)
#Output
# [[1 0 0 0]
# [0 2 0 0]
# [0 0 3 0]
# [0 0 0 4]]
7)eye 函数
- eye(n) 函数可以创建一个对角线为1,其余全0的矩阵,即单位阵。n为单位阵的维数。
kk = np.eye(4)
print(kk)
#Output
#[[1. 0. 0. 0.]
# [0. 1. 0. 0.]
# [0. 0. 1. 0.]
# [0. 0. 0. 1.]]
3、ndarray对象的属性和数据转换
NumPy创建的ndarray对象属性,主要有shape、size等属性。具体如下表所示:
属性 | 说明 |
---|---|
ndim | 秩,即数据轴的个数 |
shape | 数组的维数 |
size | 数组元素个数 |
dtype | 数据类型 |
itemsize | 数组中每个元素的字节大小 |
NumPy - 数据类型:
序号 | 数据类型及描述 |
---|---|
1 | bool_ 存储为一个字节的布尔值(真或假) |
2 | int_ 默认整数,相当于 C 的long,通常为int32或int64 |
3 | intc 相当于 C 的int,通常为int32或int64 |
4 | intp 用于索引的整数,相当于 C 的size_t,通常为int32或int64 |
5 | int8 字节(-128 ~ 127) |
6 | int16 16 位整数(-32768 ~ 32767) |
7 | int32 32 位整数(-2147483648 ~ 2147483647) |
8 | int64 64 位整数(-9223372036854775808 ~ 9223372036854775807) |
9 | uint8 8 位无符号整数(0 ~ 255) |
10 | uint16 16 位无符号整数(0 ~ 65535) |
11 | uint32 32 位无符号整数(0 ~ 4294967295) |
12 | uint64 64 位无符号整数(0 ~ 18446744073709551615) |
13 | float_ float64的简写 |
14 | float16 半精度浮点:符号位,5 位指数,10 位尾数 |
15 | float32 单精度浮点:符号位,8 位指数,23 位尾数 |
16 | float64 双精度浮点:符号位,11 位指数,52 位尾数 |
17 | complex_ complex128的简写 |
18 | |
19 | complex128 复数,由两个 64 位浮点表示(实部和虚部) |
二、生成随机数
在NumPy.random模块中,提供了多种随机数的生成函数。如randint函数生成指定范围的随机整数来构成指定形状的数组。
用法:np.random.randint(low, high = None, size = None),表示生成随机的整数型矩阵,low 表示最小值, high表示最大值,size 是一个元组类型 size = shape。
#生成随机整数
kk = np.random.randint(100,200,size=(2,4)) #在100-200数据间生成一个2行4列的随机数数组
print(kk)
#Output
#[[167 189 168 135]
# [116 188 157 102]]
类似的,还有:
1). np.random.randn( ):生成标准的正太分布,没有固定的参数,每多加一个数字,代表多增加一个维度,高斯正太分布=高斯分布 ,分布:是统计学中的。标准的高斯分布 的中间值是0 ,最好的范围是1 -1,超出范围的都是异常值。
2). np.random.random(size):生成0-1之间的元素数组,size 表形状,random随即生产的范围是0-1之间,每个随机数都是一个维度。
3). np.random.rand( ):生成0-1之间的元素数组,和 np.random.random有一样的功能,random 需要 size来描述形状,而rand只需要我们直接给值,通过值的数量来确定形状。
4). np.random.normal(loc,scale,size):生成一个正太分布的数组,location 是定位的的值, scale 是波动值,size 是数据长度。
函数 | 说明 |
---|---|
seed | 确定随机数生成器的种子 |
permutation | 返回一个序列的随机排列或返回一个随机排列的范围 |
shuffle | 对一个序列进行随机排序 |
binomial | 产生二项分布的随机数 |
normal | 产生正态(高斯)分布的随机数 |
beta | 产生beta分布的函数 |
chisquare | 产生卡方分布的随机数 |
gamma | 产生gamma分布的随机数 |
uniform | 产生在[0,1]中均匀分布的随机数 |
三、数组变换
3.1.数组重塑
对于已定义好的数组,可以通过reshape方法改变其数组维度,传入的参数为新维度的元组。reshape的参数中的其中一个可以设置为-1,表示数组的维度可以通过数据本身来推断。
kk0 = np.arange(8)
print("kk0: ",kk0)
kk1 = kk0.reshape(2,4)
print("kk1: ",kk1)
#Output
#kk0: [0 1 2 3 4 5 6 7]
#kk1: [[0 1 2 3]
# [4 5 6 7]]
- reshape 中的一个参数可以设置为-1,表示数组的维度可以通过数据本身来判断。
kk0 = np.arange(15)
print("kk0: ",kk0)
kk1 = kk0.reshape(5,-1)
print("kk1: ",kk1)
#Output
#kk0: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
#kk1: [[ 0 1 2]
# [ 3 4 5]
# [ 6 7 8]
# [ 9 10 11]
# [12 13 14]]
- 与reshape相反的方法是数据散开(ravel)或数据扁平化(flatten)。
kk0 = np.arange(15)
print("kk0: ",kk0)
kk1 = kk0.reshape(5,-1)
print("kk1: ",kk1)
kk2 = kk1.ravel()
print("kk2: ",kk2)
kk3 = kk1.flatten()
print("kk3: ",kk3)
#Output
#kk0: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
#kk1: [[ 0 1 2]
# [ 3 4 5]
# [ 6 7 8]
# [ 9 10 11]
# [12 13 14]]
#kk2: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
#kk3: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
- 需要注意的是,数据重塑不会改变原来的数组。
3.2.数组合并
数组合并用于多个数组间的操作,NumPy使用hstack函数、vstack函数、concatenate函数:完成数组的合并。
- hstack函数:实现横向合并
- hstack函数:实现横向合并
- concatenate函数:可以实现数组的横向或纵向合并,参数axis=1时进行横向合并,axis=0时进行纵向合并。
#横向合并:
kk1 = np.arange(6).reshape(3,2)
print(kk1)
print("----------")
kk2 = kk1 * 2
print(kk2)
print("----------")
kk3 = np.hstack((kk1,kk2))
print(kk3)
#Output
#[[0 1]
# [2 3]
# [4 5]]
#----------
#[[ 0 2]
# [ 4 6]
# [ 8 10]]
#----------
#[[ 0 1 0 2]
# [ 2 3 4 6]
# [ 4 5 8 10]]
3.3.数组分割
与数组合并相反,NumPy提供了hsplit函数、vsplit函数和split函数分别实现数组的横向、纵向和指定方向的分割。
arr = np.arange(16).reshape(4,4)
print('横向分割为:\n',np.hsplit(arr,2))
print('纵向组合为:\n',np.vsplit(arr,2))
#Output
#横向分割为:
# [array([[ 0, 1],
# [ 4, 5],
# [ 8, 9],
# [12, 13]]), array([[ 2, 3],
# [ 6, 7],
# [10, 11],
# [14, 15]])]
#纵向组合为:
# [array([[0, 1, 2, 3],
# [4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
# [12, 13, 14, 15]])]
同样,split在参数axis = 1时实现数组的横向分割,axis = 0时则进行纵向分割。
3.4.数组转置和轴对换
数组转置是数组重塑的一种特殊形式,可以通过transpose方法进行转置。transpose 方法需要传入轴编号组成的元组。除了使用transpose外,也可以直接利用数组的T属性进行数组转置。
kk = np.arange(6).reshape(3,2)
print('矩阵:',kk)
print('-------------')
print('转置矩阵:',kk.transpose(1,0)) //# np.transpose(kk))
#Output
# 矩阵: [[0 1]
# [2 3]
# [4 5]]
# -------------
# 转置矩阵: [[0 2 4]
# [1 3 5]]
数组的T属性转置:
kk = np.arange(6).reshape(3,2)
print('矩阵:',kk)
print('-------------')
print('转置矩阵:',kk.T)
#Output
# 矩阵: [[0 1]
# [2 3]
# [4 5]]
# -------------
# 转置矩阵: [[0 2 4]
# [1 3 5]]
ndarray 的 swapaxes 方法实现轴对换:
kk = np.arange(6).reshape(3,2)
print('矩阵:',kk)
print('-------------')
print('轴对换:',kk.swapaxes(0,1))
#Output
# 矩阵: [[0 1]
# [2 3]
# [4 5]]
# -------------
# 轴对换: [[0 2 4]
# [1 3 5]]
四、数组的索引和切片
4.1 一维数组的索引
一维数组的索引类似Python中的列表。
kk = np.arange(10)
print(kk)
print(kk[2])
print(kk[-1])
print(kk[2:5])
#Output
# [0 1 2 3 4 5 6 7 8 9]
# 2
# 9
# [2 3 4]
数组的切片返回的是原始数组的视图,不会产生新的数据,如果需要的并非视图而是要复制数据,则可以通过copy方法实现。
kk = np.arange(10)
print(kk)
kk1 = kk[1:3].copy()
print(kk1)
#Output
#[0 1 2 3 4 5 6 7 8 9]
#[1 2]
4.2 多维数组的索引
- 对于多维数组,它的每一个维度都有一个索引,各个维度的索引之间用逗号分隔。
- 也可以使用整数函数和布尔值索引访问多维数组。
kk = np.arange(12).reshape(3,4)
print(kk)
print(kk[0,1:3]) #索引第0行中第1列到第2列的元素
print(kk[ :,2]) #索引第2列元素
print(kk[:1,:1]) #索引第0行第0列元素
#Output
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# [1 2]
# [ 2 6 10]
# [[0]]
4.3 访问多维数组
kk = np.arange(12).reshape(3,4)
print(kk)
print('索引结果1: ',kk[(0,1),(1,3)]) #从两个序列的对应位置取出两个整数来组成下标:kk[0,1],kk[1,3]
print('索引结果2: ',kk[1:2,(0,2,3)]) #索引第一行中的0、2、3列元素
#Output
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# 索引结果1: [1 7]
# 索引结果2: [[4 6 7]]
五、NumPy中的数据统计与分析
在NumPy中,数组运算更为简洁而快速,通常比等价的Python方式快很多,尤其在处理数组统计计算与分析的情况下。
5.1 排序
NumPy 的排序方式有直接排序和间接排序。直接排序是对数据直接进行排序,间接排序是指根据一个或多个键值对数据进行排序。在NumPy中,直接排序使用函数sort,间接排序使用argsort函数和lexsort函数。
- Sort函数对数据直接进行排序,调用改变原始数组,无返回值。
格式:numpy.sort(a, axis, kind, order)
主要参数及其说明见下表:
参数 | 使用说明 |
---|---|
a | 要排序的数组 |
kind | 排序算法,默认为’quicksort’ |
order | 排序的字段名,可指定字段排序,默认为None |
axis | 使用sort函数可以沿着指定轴对数据集进行排序,axis = 1 为沿横轴排序,axis = 0 为沿纵轴排序,axis = None,将数组平坦化之后排序 |
例1:使用sort 函数进行排序。
kk = np.array([1,4,3,2,5,6,7,8,9])
print("原数组:",kk)
kk.sort()
print("排序后的数组:",kk)
#Output
#原数组: [1 4 3 2 5 6 7 8 9]
#排序后的数组: [1 2 3 4 5 6 7 8 9]
例2:带轴向参数的sort 排序。
kk = np.array([[4,2,9,5],[6,4,8,3],[1,6,2,4]])
print("原数组:",kk)
kk.sort(axis=1) #沿横向排序
print("排序后的数组:",kk)
#Output
# 原数组: [[4 2 9 5]
# [6 4 8 3]
# [1 6 2 4]]
# 排序后的数组: [[2 4 5 9]
# [3 4 6 8]
# [1 2 4 6]]
np.argsort函数和np.lexsort函数根据一个或多个键值对数据集进行排序。
- np.argsort(): 返回的是数组值从小到大的索引值。
- np.lexsort(): 返回值是按照最后一个传入数据排序的结果。
例3:使用argsort 函数进行排序。
kk = np.array([1,4,3,2,5,6,7,8,9])
print("原数组:",kk)
ll = kk.argsort()
print("排序后的数组:",kk)
print("数组下标:",ll) #返回值为数组排序后的下标排列
#Output
#原数组: [1 4 3 2 5 6 7 8 9]
#排序后的数组: [1 4 3 2 5 6 7 8 9]
#数组下标: [0 3 2 1 4 5 6 7 8]
可以看出来,argsort 函数仅仅只是将排序后数组的的下标进行展示,而原有数组不受影响。
例4:使用lexsort 函数进行排序。
a = [2,5,8,4,3,7,6]
b = [9,4,0,4,0,2,1]
c = np.lexsort((a,b))
print(c)
#Output
#[4 2 6 5 3 1 0]
lexsort()分为三个步骤
1.将索引与之一一对应。(a,b同时对应即可)
2. 因为lexsort((a,b))中,以b为基准,所以将b排序,再用索引与之对应。
3. 当索引遇见相同元素时,以a中元素的大小顺序排序。
5.2 重复数据与去重
在数理统计分析中,需要提前将重复数据剔除,在NumPy中,可以通过unique 函数找到数组中的唯一值并返回已排序的结果。
数组内数据去重。(unique(a))
a = np.array(['red','blue','yellow','red','red','white'])
print("原数组:",a)
print("去重后的数组:",np.uni
#Output
#原数组: ['red' 'blue' 'yellow' 'red' 'red' 'white']
#去重后的数组: ['blue' 'red' 'white' 'yellow']
统计分析中有时候需要把一个数据重复若干次,使用tile和repeat函数即可实现此功能。
- tile函数的格式:np.tile(A, reps)
其中,参数A表示要重复的数组,reps表示重复次数。
- repeat函数的格式:np.repeat(A, reps, axis = None)
其中, “a”: 是需要重复的数组元素,“repeats”: 是重复次数, “axis”: 指定沿着哪个轴进行重复,axis = 0表示按行进行元素重复;axis = 1表示按列进行元素重复。
#使用tile 函数实现数据重复。
kk = np.array([1,2,3])
print(kk)
ll = np.tile(kk,3) #将kk数组重复三次
print(ll)
#Output
#[1 2 3]
#[1 2 3 1 2 3 1 2 3]
#使用repeat 函数实现数据重复。
kk = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(kk)
print('------------')
# ll = np.tile(kk,3) #将kk数组重复三次
# print(ll)
ll = np.repeat(kk,2,axis=1)
print(ll)
print('------------')
ss = np.repeat(kk,2,axis=0)
print(ss)
#Output
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
# ------------
# [[1 1 2 2 3 3] #按列进行重复
# [4 4 5 5 6 6]
# [7 7 8 8 9 9]]
# ------------
# [[1 2 3] #按行进行重复
# [1 2 3]
# [4 5 6]
# [4 5 6]
# [7 8 9]
# [7 8 9]]
5.3 常用统计函数
NumPy中提供了很多用于统计分析的函数,常见的有sum、mean、std、var、min和max等。
几乎所有的统计函数在针对二维数组的时候需要注意轴的概念。axis=0时表示沿着纵轴进行计算,axis=1时沿横轴进行计算。用法:np.函数(数组)
函数 | 说明 |
---|---|
np.sum(a) | 数组的和 |
np.sum(a,axis = 0) | 数组纵轴的和 |
np.sum(a,axis = 0) | 数组横轴的和 |
np.mean(a) | 数组的均值 |
np.mean(a,axis = 0) | 数组纵轴的均值 |
np.mean(a,axis = 1) | 数组横轴的均值 |
np.std(a) | 数组的标准差 |
np.var(a) | 数组的标准差 |
np.average(a) | 数组的加权平均值 |
np.percentile(a) | 数组的分位数 |
np.ptp(a) | 数组的极差值 |
np.median(a) | 数组的中位数 |