Python——NumPy（第二讲）

numpy的使用可以在 jupyter notebook中使用比较能直观看到输出结果，不需要每次都用print输出，按住 Shift+Enter便可以直接输出结果。 如果方法被接收则需要再次输入所接受的名字才可以输出结果。
下载jupyter notebook：

pip install jupyter notebook

一维数组索引和切片

ndarray对象的内容可以通过索引或切片来访问和修改，与 Python中 list 的切片操作一样。
ndarray 数组可以基于 0 - n 的下标进行索引，并设置 start, stop及 step 参数进行，从原数组中切割出一个新数组。

【示例】一维数组索引和切片的使用

x = np.arange(10)  # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
x[2]  # np.int64(2)
x[3:9]   # array([3, 4, 5, 6, 7, 8])
x[3:9:2]  # array([3, 5, 7])
x[-1]   # np.int64(9)
x[-3:-1]  # array([7, 8])
x[::-1]   # array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])

二维数组的索引和切片

【示例】索引直接获取

y = np.arange(12)
z = y.reshape(4,3)
z
'''
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])
'''
# 获取第二行
z[1]  # array([3, 4, 5])
# 获取第三行第二列
z[2][1]   # np.int64(7)

【示例】使用坐标获取数组[x,y]

x = np.arange(1, 13)
a = x.reshape(4, 3)
print(a)
'''
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
'''
# '所有行的第二列'
print(a[:, 1])  # [ 2  5  8 11]
# '获取第三行第二列'
print(a[2, 1])   # 8
# '奇数行的第一列'
print(a[::2, 0])   # [1 7]
# '同时获取第三行第二列，第四行第一列'
print(a[(2, 3), (1, 0)])   # [ 8 10]

【示例】二维数组负索引的使用

print('获取最后一行')
print(a[-1])
print('行进行倒序')
print(a[::-1])
print('行列都倒序')
print(a[::-1,::-1])

【示例】切片数组的复制

a = np.arange(1,13).reshape(3,4)
'''
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])
'''
sub_arry = a[:2,:2]  # 取a的1，2行，1，2列
'''
array([[1, 2],
       [5, 6]])
'''
# 改变索引位置的值
sub_arry[0][0]=10000  
'''
array([[10000,     2],
       [    5,     6]])
'''

改变数组的维度

通过reshape方法可以将一维数组变成二维、三维或者多维数组，
也可以通过reshape方法将多维数组变成一维。
【示例】改变数组的维度

a = np.arange(24).reshape(4,6)
'''
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]])
'''
# 退维
a.reshape(-1)
'''
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])
'''

通过ravel方法或flatten方法可以将多维数组变成一维数组。改变数组的维度还可以直接设置Numpy数组的shape属性（元组类型），通过resize方法也可以改变数组的维度。

#使用ravel函数将三维的b变成一维的数组
a1=b.ravel()
#使用flatten函数将二维的c变成一维的数组
a2=c.flatten() 
#使用shape属性将三维的b变成二维数组(6行4列)
b.shape=(6,4)
#使用resize修改数组的维度
b.resize((2,12))

数组的拼接

函数	描述
concatenate	连接沿现有轴的数组序列
hstack	水平堆叠序列中的数组（列方向）
vstack	竖直堆叠序列中的数组（行方向）

concatenate 函数用于沿指定轴连接相同形状的两个或多个数组，格式如下：

numpy.concatenate((a1, a2, ...), axis)

• a1, a2, …：相同类型的数组
• axis：沿着它连接数组的轴，默认为 0

【示例】列表的拼接

a=[1,2,3]
b=[4,5,6]
a.extend(b)   # [1, 2, 3, 4, 5, 6]

【示例】一维数组的拼接

x=np.arange(1,4)
y=np.arange(4,7)
print(np.concatenate([x,y]))
# array([1, 2, 3, 4, 5, 6])

【示例】二维数组的拼接

a=np.array([[1,2,3],[4,5,6]])
b=np.array([['a','b','c'],['d','e','f']])
print(np.concatenate([a,b]))
'''
[['1' '2' '3']
 ['4' '5' '6']
 ['a' 'b' 'c']
 ['d' 'e' 'f']]
'''
# 'x轴方向及垂直堆叠'
print(np.concatenate([a,b],axis=0))
'''
array([['1', '2', '3'],
       ['4', '5', '6'],
       ['a', 'b', 'c'],
       ['d', 'e', 'f']], dtype='<U21')
'''
# 'y轴方向及水平堆叠'
print(np.concatenate([a,b],axis=1))
'''
array([['1', '2', '3', 'a', 'b', 'c'],
       ['4', '5', '6', 'd', 'e', 'f']], dtype='<U21')
'''

hstack()、vstack()和dstack()的使用

numpy.hstack它通过水平堆叠来生成数组。
numpy.vstack 它通过垂直堆叠来生成数组。
【示例】vstack 与hstack的使用

print(np.vstack([a,b]))
print(np.hstack([a,b]))

【示例】三维数组的拼接

aa = np.arange(1, 37).reshape(3, 4, 3)
bb = np.arange(101, 137).reshape(3, 4, 3)
print(np.concatenate((aa, bb), axis=0))
# 6,4,3
print(np.concatenate((aa, bb), axis=1))
# 3,8,3
print(np.concatenate((aa, bb), axis=2))
# 3,4,6

axis=0可以使用vstack替换
axis=1可以使用hstack替换
axis=2可以使用dstack替换

数组的转置

将行与列对调，即第一行变成第一列…或第一列变成第一行…的操作
即使转置操作。
【示例】transpose进行转换

a = np.arange(1, 13).reshape(2, 6)
print('原数组a')
print(a)
print('转置后的数组')
print(a.transpose())
print(a.T)
# 多维数组转置
aaa = np.arange(1, 37).reshape(1, 3, 3, 4)
# 将1,3,3,4转换为3,3,4,1
print(np.transpose(aaa, [1, 2, 3, 0]).shape)
'''
原数组a
[[ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]]
转置后的数组
[[ 1  7]
 [ 2  8]
 [ 3  9]
 [ 4 10]
 [ 5 11]
 [ 6 12]]

[[ 1  7]
 [ 2  8]
 [ 3  9]
 [ 4 10]
 [ 5 11]
 [ 6 12]]

(3, 3, 4, 1)
'''

数组的分隔

split分隔
numpy.split 函数沿特定的轴将数组分割为子数组，格式如下：

numpy.split(ary, indices_or_sections, axis)

• ary：被分割的数组
• indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
• axis：沿着哪个维度进行切向，默认为0，横向切分。为1时，纵向切分

【示例】split分隔

x = np.arange(1,9)
# array([1, 2, 3, 4, 5, 6, 7, 8])
np.split(x,4)
# [array([1, 2]), array([3, 4]), array([5, 6]), array([7, 8])]
np.split(x,[3,5])
# [array([1, 2, 3]), array([4, 5]), array([6, 7, 8])]

水平分隔和垂直分隔

使用hsplit函数可以水平分隔数组，该函数有两个参数，第1个参数表示待分隔的数组，第2个参数表示要将数组水平分隔成几个小数组。
使用vsplit函数可以垂直分隔数组，该函数有两个参数，第1个参数表示待分隔的数组，第2个参数表示要将数组垂直分隔成几个小数组。
【示例】

xx = np.arange(12).reshape(2,6)
'''
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11]])
'''
a1, a2 = np.hsplit(xx,2)
'''
	a1:	array([[0, 1, 2],
		       [6, 7, 8]])
    a2: array([[ 3,  4,  5],
               [ 9, 10, 11]])
'''
yy = np.arange(12).reshape(4,3)
'''
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])
'''
# 垂直分成三部分
np.vsplit(yy,[1,3])
'''
[array([[0, 1, 2]]),
 array([[3, 4, 5],
        [6, 7, 8]]),
 array([[ 9, 10, 11]])]
'''

数学函数

Numpy支持向量处理ndarray对象，提高程序运算速度。

方法	说明
np.abs()、np.fabs()	计算整数、浮点数的绝对值
np.sqrt()	计算各元素的平方根
np.reciprocal()	计算各元素的倒数
np.square()	计算各元素的平方
np.exp()	计算各元素的指数ex
np.log() np.log10() np.log2()	计算各元素的自然对数、底数为10的对数、底数为2的对数
np.sign()	计算各元素的符号，1（整数）、0（零）、-1（负数）
np.ceil() np.floor() np.rint()	对各元素分别向上取整、向下取整、四舍五入
np.modf()	将各元素的小数部分和整数部分以两个独立的数组返回
np.cos() 、np.sin()、np.tan()	对各元素求对应的三角函数
np.add()、np.subtract()、np.multiply()、np.divide()	对两个数组的各元素执行加法、减法、乘法、除法
【示例】求每个元素的倒数

a=[3,4,5,6,7,8]
b=np.array(a)
result=[]
for i in a:
    result.append(1/i)
print('result1:',result)
print('result2:',[1/i for i in a])
#直接对列表求导数不可以，但ndarray类型可以直接求导数
# print('result3:',1/a)
print('result4:',1/b)
# result4: [0.33333333 0.25       0.2        0.16666667 0.14285714 0.125     ]

numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为4/1。
【示例】reciprocal()函数的使用

a=np.arange(1,10,dtype=np.float).reshape(3,3)
print(np.reciprocal(a))
'''
[[1.         0.5        0.33333333]
 [0.25       0.2        0.16666667]
 [0.14285714 0.125      0.11111111]]
'''

【示例】square()函数的使用

 # 一维数组
a = np.arange(1, 10)
print(np.square(a))
# 传统方式
print(np.array([i * i for i in a]))
# [ 1  4  9 16 25 36 49 64 81]
# 二维数组
aa = np.arange(1, 13).reshape(3, 4)
print(np.square(aa))
# 传统方式
bb = np.ones_like(aa)
for x in range(3):
    for y in range(4):
        bb[x, y] = aa[x, y] * aa[x, y]
print(bb)
'''
[[  1   4   9  16]
 [ 25  36  49  64]
 [ 81 100 121 144]]
'''

【示例】sign()函数的使用

a = np.arange(-5,5)
print(np.sign(a))
# [-1 -1 -1 -1 -1  0  1  1  1  1]

【示例】其他一些函数的使用

a = [1,2,3,4]
x = np.array(a)
print(x)
# array([1,2,3,4])
np.modf(np.reciprocal(x,dtype=float))
# (array([0.        , 0.5       , 0.33333333, 0.25      ]),array([1., 0., 0., 0.]))
np.cos(x)
# array([ 0.54030231, -0.41614684, -0.9899925 , -0.65364362])
np.around(np.cos(x),decimals=1)
# array([ 0.5, -0.4, -1. , -0.7])
np.around(np.cos(x),decimals=-1)
# array([ 0., -0., -0., -0.])
np.around(np.cos(x),decimals=2)
# array([ 0.54, -0.42, -0.99, -0.65])
np.ceil(np.cos(x))
# array([ 1., -0., -0., -0.])
np.rint(np.cos(x))
# array([ 1., -0., -1., -1.])

算术函数

如果参与运算的两个对象 都是ndarray，并且形状相同，那么会对位彼此之间进行**（+ - * /）**运算。NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。
【示例】算术函数的使用

a = np.arange(9,dtype=float).reshape(3,3)
'''
array([[0., 1., 2.],
       [3., 4., 5.],
       [6., 7., 8.]])
'''
b = np.array([10,11,12])
''' array([10, 11, 12])'''
np.add(a,b)
'''
array([[10., 12., 14.],
       [13., 15., 17.],
       [16., 18., 20.]])
'''
# 如果只有一个值  全部处理同一个值
# 如果有一列值  全部处理对应列的值
np.subtract(a,b)
'''
array([[-10., -10., -10.],
       [ -7.,  -7.,  -7.],
       [ -4.,  -4.,  -4.]])
'''
np.multiply(a,b)
'''
array([[ 0., 11., 24.],
       [30., 44., 60.],
       [60., 77., 96.]])
'''
np.divide(a,b)
'''
array([[0.        , 0.09090909, 0.16666667],
       [0.3       , 0.36363636, 0.41666667],
       [0.6       , 0.63636364, 0.66666667]])
'''

numpy.mod() 计算输入数组中相应元素的相除后的余数。函数numpy.remainder() 也产生相同的结果。
【示例】

# 沿用上面a,b的值
np.mod(a,b)
np.remainder(a,b)
'''
输出的结果相同
array([[0., 1., 2.],
       [3., 4., 5.],
       [6., 7., 8.]])
'''

统计函数

NumPy 提供了很多统计函数，用于从数组中查找最小元素，最大元素，百分位标准差和方差等。 具体如下：

函数名	说明
np.sum()	求和
np.prod()	所有元素相乘
np.mean()	平均值
np.std()	标准差
np.var()	方差
np.median()	中数
np.power()	幂运算
np.sqrt()	开方
np.min()	最小值
np.max()	最大值
np.argmin()	最小值的下标
np.argmax()	最大值的下标
np.cumsum()	对数组中元素累积求和，可指定轴
np.cumprod()	对数组中元素累积求积，可指定轴
np.ptp()	计算一组数中最大值与最小值的差，可指定轴
np.unique()	删除数组中的重复数据，并对数据进行排序
np.nonzero()	返回数组中非零元素的索引

numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。
【示例】 power()函数的使用

x = np.arange(1, 5)
print(np.power(x, 2))
# [ 1  4  9 16]

【示例】 median ()函数的使用

a = np.array([4, 2, 1, 5])
# 计算偶数的中位数
print('偶数的中位数：', np.median(a))
a = np.array([4, 2, 1])
print('奇数个的中位数：', np.median(a))
a = np.arange(1, 16).reshape(3, 5)
print(a)
print('调用median函数')
print(np.median(a))
print('调用median函数，axis=1 行的中值')
print(np.median(a, axis=1))
print('调用median函数，axis=0 列的中值')
print(np.median(a, axis=0))
'''
偶数的中位数： 3.0
奇数个的中位数： 2.0
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]]
调用median函数
8.0
调用median函数，axis=1 行的中值
[ 3.  8. 13.]
调用median函数，axis=0 列的中值
[ 6.  7.  8.  9. 10.]
'''

numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。
算术平均值是沿轴的元素的总和除以元素的数量。
【示例】 mean ()函数的使用

a = np.arange(1, 11).reshape(2, 5)
print(a)
print(np.mean(a))
print('调用mean函数 axis=0 列')
print(np.mean(a, axis=0))
print('调用mean函数 axis=1 行')
print(np.mean(a, axis=1))
'''
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]]
5.5
调用mean函数 axis=0 列
[3.5 4.5 5.5 6.5 7.5]
调用mean函数 axis=1 行
[3. 8.]
'''   

【示例】函数的使用

a = np.random.randint(10,50,size=20)
np.max(a)
np.sum(a)
np.min(a)
np.max(a)
np.ptp(a)
np.unique(a)
np.nonzero(a)

其他常用函数

方法	说明
np.tile()	将数组的数据按照行列复制扩展
np.repeat()	将数组中的每个元素重复若干次
roll()	沿指定轴对数组元素进行移位
resize()	重新调整数组的大小
place()/put()	将数组中满足条件的元素/指定的元素替换为指定的值
np.savetxt()	将数据保存到txt文件中
np.loadtxt()	从文件中加载数据
np.genfromtxt()	根据文件内容中生成数据，可以指定缺失值的处理等
np.any()	如果数组中存在一个为True的元素（或者能转为True的元素），则返回True
np.all()	如果数组中所有元素都为True（或者能转为True的元素），则返回True
np.where(条件,x,y)	如果条件为True，对应值为x，否则对应值为y
np.dot()	将矩阵相乘
np.sort()	对数组进行排序，返回一个新的排好序的数组，原数组不变
np.argsort()	返回的是数组值从小到大排序后元素对应的索引值

【示例】tile()和repeat()函数的使用

a = np.arange(4)
#复制2次
np.tile(a,2)
#行列复制
np.tile(a,(3,2))
np.repeat(a,2)
a = np.arange(1,13).reshape(3,4)
np.repeat(a,2)
np.repeat(a,2,axis=0)
np.repeat(a,2,axis=1)

【示例】roll()函数的使用

a = np.arange(4)
#一维数组
#向后调3个
np.roll(a,3)
#向前调1个
np.roll(a,-1)
#二维数组
np.roll(aa,2)
np.roll(aa,2,axis=0)

【示例】resize()函数的使用

# 修改维度，元素个数必须相同
aa.reshape(4,3)
#resize重新调整数组的大小，元素个数可以不相同
np.resize(aa,(5,6)) 

【示例】replace()和put()函数的使用

aa = np.random.randint(40,100,(3,4))
#小于60的 全部替换为0
np.place(aa,aa<60,0)
#put()指定的索引处的元素替换为指定的值
aa = np.arange(1,13).reshape(3,4)
np.put(aa,2,100)

【示例】savetxt()和loadtxt()函数的使用

# 保存
a = np.random.randint(-50,100,1000)
 np.savetxt('savetxt.txt',a,fmt='%d')
# 加载
b = np.loadtxt('savetxt.txt',dtype=int)

【示例】any()、all()函数的使用

#any函数 只要有一个元素为True，则结果返回True
#all函数 只有所有元素都为True，则结果返回True
x = np.array([False,True,True,1,None,0])
np.any(x)
np.all(x)

【示例】where()函数的使用

np.random.seed()
a = np.random.randint(20,100,10)
print(a)
print(np.where(a>50,True,False))

【示例】dot函数的使用

#dot函数 矩阵相乘
x = np.array([[1,2],[3,4]])
y = np.array([[2,3],[1,2]])
x.dot(y)
x.dot(3) #每个元素与3相乘
'''注意：矩阵相乘前提是，第一个矩阵的列数和第二个矩阵的行数要相同'''

数组排序

排序中主要用到的方法是np.sort和np.argsort。其中np.sort()是对数组直接排序。而np.argsort()是返回排序后的原始索引。
【示例】一维数组排序

a=np.array([5,2,4,6,1,9])
print('sort排序后：',np.sort(a))
print('argsort排序：',np.argsort(a))

【示例】二维数组排序

np.random.seed(44)
a=np.random.randint(100,size=(4,6))
#直接使用sort排序指定axis的值
print(np.sort(a,axis=0))
print(np.sort(a,axis=1))

上面的结果其实不是实际想要的，在实际中，其实想按某列或者某行进行排序，返回列所对应的行。
【示例】按最后一列进行排序

#可以先获取最后一列的数组
b=a[:,-1]
print(b)
#获取最后一列数组排序后的原始索引
index=np.argsort(b)
#使用facy_indexing汇总数组
print(a[index])

numpy广播机制

【示例】 两个数组相加

# 在numpy中存在广播机制
a=np.array([0,1,2])
print(a+5)
b=np.array([5,5,5])
print(a+b)
'''结果都是：[5 6 7]'''

【示例】维度不相同的数组相加

a=np.arange(3) #一行[0 1 2]
b=np.arange(3).reshape(3,1) 
'''
三行一列
[[0]
 [1]
 [2]]
'''
'''
广播的规则
1，如果两个数组维度个数不同，那么小维度的数组形状会在
左边补1
2，如果两个数组形状在任何一个维度上都不匹配，数组的形
状会沿着维度为1的维度扩展到匹配上另一个数组的形状
3，如果没有维度形状为1，则会引发异常
0 1 2         0 0 0
0 1 2         1 1 1
0 1 2         2 2 2
'''
print(a+b)
'''
[[0 1 2]
 [1 2 3]
 [2 3 4]]
'''

【示例】如果没有维度形状为1，则会引发异常

# 报错
a = np.arange(6).reshape(2, 3)
b = np.arange(6).reshape(3, 2)
print(a + b)

比较掩码

比较操作，会返回与参与运算数组形状相同的数组，其中，满足条件的为True，不满足的为False。
【示例】数组的比较操作

a=np.array([[1,2,30],[45,67,89]])
print(a<60)
'''
[[ True  True  True]
 [ True False False]]
'''

传入的数组，需要和a形状一致，且类型为Bool类型，这个叫做掩码式索引
【示例】掩码式索引取值，过滤掉不符合条件的

print(a[np.array([[ True , True , True],
 [ True, False, False]])])
 # [ 1  2 30 45]
print(a[a<60])
# [ 1  2 30 45]

【示例】元素值大于50的

np.random.seed(42)
a = np.random.randint(100, size=(3, 4))
# 取出数组中元素值大于50的
print(a[a > 50])
# [51 92 71 60 82 86 74 74 87 99]