Numpy_04_数组的运算与排序

一、NumPy运算特点：

1、向量化运算，运算速度快。
2、利用广播机制，对不同形状的数组进行算数运算。
3、数组通用函数能对数组中所有元素进行操作。

二、数组运算

1、算数运算

1.1、算数运算符

import numpy as np

# 准备数据
a = np.array([2,4,1])
a
# array([2, 4, 1])

# 数组与数进行加法运算
a + 1
# array([3, 5, 2])

# 数组与数进行除法运算
a / 2
array([1. , 2. , 0.5])

'''
数组与数组进行运算
形状相同，两数组对应位置的数据进行算数运算
a
# array([2, 4, 1])
b
# array([2, 4, 1])
a * b
# [a[0] * b[0], a[1] * b[1], a[2] * b[2]]
'''
a * b
# array([ 4, 16,  1])

** 广播机制**：
数组形状不同时 ，满足以下两个条件，进行运算时会自动进行广播，匹配形状。
（1）数组后缘维度的轴长一致（从后往左看，数组间的维度大小一致）
（2）其中有个轴长为1（两个数组存在一些维度大小不相等时，有一个数组的差异维度大小为1）

以此类推。

'''
数组形状不同时，运用广播机制进行运算

t1:
array([[1., 1.],
       [1., 1.],
       [1., 1.]])
t2:      
array([4, 5])

t1的形状：
(3, 2)

t2的形状：
(2,)

比较t1和t2的形状，从后缘维度进行比较，t1最后一个维度大小是2，t2最后一个维度大小也是2，相等，符合广播机制，
t2被广播成：
[[4, 5],
 [4, 5],
 [4, 5]]
然后与t1相同位置进行运算

'''
t1 = np.ones((3,2))

t2 = np.array([4,5])

t1 + t2
# array([[5., 6.],
#        [5., 6.],
#        [5., 6.]])

'''
t1.shape
# (3, 2, 2)
t2.shape
# (2, 1)
比较t1和t2的形状，从后缘维度开始
t1:2
t2:1
符合广播机制，维度大小不相等，其中一个为1
继续比较下一个维度
t1:2
t2:2
维度相等，对t2进行广播机制后，在与t1进行运算。
'''
t1 = np.ones((3,2,2))
t1 
# array([[[1., 1.],
#         [1., 1.]],

#        [[1., 1.],
#         [1., 1.]],

#        [[1., 1.],
#         [1., 1.]]])

t2 = np.ones((2,1))
t2
# array([[1.],
#        [1.]])

t1 - t2
# array([[[0., 0.],
#         [0., 0.]],

#        [[0., 0.],
#         [0., 0.]],

#        [[0., 0.],
#         [0., 0.]]])

1.2、算数运算函数

np.add(a, b) 加法函数

'''
np.add(a,b)  加法函数
一次只能进行两个数组的加法
'''
n1 = np.arange(8).reshape(2,4)
n1
# array([[0, 1, 2, 3],
#        [4, 5, 6, 7]])

n2 = np.linspace(2,5,4)
n2
# array([2., 3., 4., 5.])

n3 = np.logspace(2,5,num = 4,base = 2)
n3
# array([ 4.,  8., 16., 32.])

# n1 + n2
np.add(n1 , n2)
# array([[ 2.,  4.,  6.,  8.],
#        [ 6.,  8., 10., 12.]])

# ni + n2 + n3
np.add(np.add(n1 , n2),n3)
# array([[ 6., 12., 22., 40.],
#        [10., 16., 26., 44.]])

subtract(a,b) 减法函数

'''
subtract() 减法函数

'''
np.subtract(n2,n1)
# array([[ 2.,  2.,  2.,  2.],
#        [-2., -2., -2., -2.]])

np.divide（a,b） 除法
np.multiply（a,b） 乘法
np.power(a,n) 幂（a**n）
… …

2、逻辑运算

2.1、逻辑运算符（== 、>、<等）

# 创建随机数组
t1 = np.random.random((1,10))
t1
# array([[0.05503196, 0.99515516, 0.91066442, 0.57828342, 0.29459532,
#         0.43893072, 0.13264361, 0.52598413, 0.60986848, 0.45367128]])

# 运用逻辑运算符，返回True/False
t1>0.3
# array([[False,  True,  True,  True, False,  True, False,  True,  True,
#          True]])

# 布尔索引，取出True值对应的数据
t1[t1>0.3]
# array([0.99515516, 0.91066442, 0.57828342, 0.43893072, 0.52598413,
#        0.60986848, 0.45367128])

2.2、通用判断函数

np.all()

'''
np.all() 
数组中全部为True,返回True,否则返回False
'''
t2 = np.random.randint(2,8,(3,4))
t2
# array([[7, 6, 4, 3],
#        [5, 2, 4, 2],
#        [7, 4, 6, 3]])

t2>5
# array([[ True,  True, False, False],
#        [False, False, False, False],
#        [ True, False,  True, False]])

np.all(t2>5)
# False

(t2>5).all()
# False

np.any()

'''
np.any() 数组中只要有一个True,返回True,否则返回False
'''

# 同(t2>5).any()
np.any(t2>5)
# True

2.3、三元运算符

np.where(expr，True的值，False的值)

'''
np.where(expr，True的值，False的值)
expr返回True， 取第二个参数值
expr返回False，取第三个参数值
'''
t3 = np.array([2,6,1,7])
t3
# array([2, 6, 1, 7])

np.where(t3>5,10,5)
# array([ 5, 10,  5, 10])

相似的还有一个函数np.extract(expr,ndarray)

'''
np.extract(expr,ndarray)
返回ndarray数组中符合条件expr的数据
'''
t3
# array([2, 6, 1, 7])

np.extract(t3>5,t3)
# array([6, 7])

2.4、复合运算

逻辑与:np.logical_and(条件1，条件2)

'''
逻辑与:np.logical_and(条件1，条件2) 

满足所有条件，返回True，否则返回False
'''

t4 = np.random.randint(2,10,(3,4))
t4
# array([[5, 8, 8, 2],
#        [4, 2, 3, 4],
#        [2, 7, 3, 4]])

# 逻辑与 np.logical_and(条件1，条件2) ,同时满足两个条件返回True
np.logical_and(t4<7,t4>3 )
# array([[ True, False, False, False],
#        [ True, False, False,  True],
#        [False, False, False,  True]])

逻辑或: np.logical_any(条件1，条件2)

'''
逻辑或: np.logical_any(条件1，条件2)

满足其中一个条件即返回True，否则返回False
'''

np.logical_or(t4<7,t4>3 )
# array([[ True,  True,  True,  True],
#        [ True,  True,  True,  True],
#        [ True,  True,  True,  True]])

2.5、裁剪： ndarry.clip(self, min=None, max=None, out=None)

'''
 ndarry.clip(self, min=None, max=None, out=None)
 
 min: 数组中小于min的函数替换成min
 max: 数组中大于max的函数替换成max
'''

t4
# array([[5, 8, 8, 2],
#        [4, 2, 3, 4],
#        [2, 7, 3, 4]])

# 小于4的元素替换成4，大于7的元素替换成7
t4.clip(4,7)
# array([[5, 7, 7, 4],
#        [4, 4, 4, 4],
#        [4, 7, 4, 4]])

3、集合运算

3.1、对集合数据进行去重

np.unique(ndarry)

'''
np.unique(ndarry) 对数据进行去重操作

'''

n4 = np.random.randint(1,10,(2,3))
n4
# array([[2, 6, 5],
#        [4, 7, 5]])

np.unique(n4)
# array([2, 4, 5, 6, 7])

set(一维数组)

'''
set(一维数组)

1、先将数组展开铺平成一维数组
2、set集合类型自动去重
'''

n4.flatten()
# array([2, 6, 5, 4, 7, 5])

set(n4.flatten())
# {2, 4, 5, 6, 7}

3.2、查看集合交集

np.in1d(集合A，集合B)

'''
'np.in1d(集合A，集合B)
集合A中每个元素是否存在于B集合之中,存在则返回True，不存在返回False。
'''
a = np.array([11,5,7,53])
a
# array([11,  5,  7, 53])

b = np.arange(10).reshape(2,5)
b
# array([[0, 1, 2, 3, 4],
#        [5, 6, 7, 8, 9]])

np.in1d(a,b)
# array([False,  True,  True, False])

np.intersect1d(集合A，集合B)

'''
np.intersect1d(集合A，集合B)
返回集合A中每与B集合的交集
'''
np.intersect1d(a,b)
# array([5, 7])

4、统计运算

4.1、ndarry.max(axis=) 最大值

"""
1、ndarry.max(axis=) 

（1）默认不指定axis，取数组中的元素最大值
（2）当指定axis = 0，取出每一列的最大值
（3）当指定axis = 1，取出行一列的最大值
"""

t4
# array([[5, 8, 8, 2],
#        [4, 2, 3, 4],
#        [2, 7, 3, 4]])

# 默认不指定axis，取数组中的元素最大值
t4.max()
# 8

# 按照行的方向，求每列最大值
t4.max(axis = 0)
# array([5, 8, 8, 4])

# 按照列的方向，求每行最大值
t4.max(axis = 1)
array([8, 4, 7])

4.2、ndarry.min(axis=) 最小值
原理同ndarry.max(axis=)

4.3、ndarry.std(axis=) 标准差

# 求标准差
t4.std()
# 2.1343747458109497

# 求每列标准差
t4.std(axis = 0)
# array([1.24721913, 2.62466929, 2.3570226 , 0.94280904])

4.4、ndarry.var(axis=) 方差

4.5、ndarry.mean(axis=) 平均数

4.6、np.median(ndarry,axis=) 中位数

4.7、np.argmax(ndarry,axis) 搜索数组中最大值的索引

t4
# array([[5, 8, 8, 2],
#        [4, 2, 3, 4],
#        [2, 7, 3, 4]])

# 求每行最大元素的位置
np.argmax(t4,axis = 1)

'''
按照列方向，求每行最大元素的位置，第一行最大的元素是8，它的列索引是1，以此类推
'''
# array([1, 0, 1], dtype=int64)

# 求每列最大元素的位置
np.argmax(t4,axis = 0)
'''
按照行方向，求每列最大元素的位置，第一列最大的元素是5，它的行索引是0，以此类推
'''
# array([0, 0, 0, 1], dtype=int64)

4.8、np.argmin(ndarry,axis) 搜索数组中最小值的索引

4.9、np.cumsum(ndarry,axis) 累加

'''
np.cumsum(a, axis=None, dtype=None, out=None)

参数说明：
    a：数组
    axis：0代表行，纵向；1代表列，横向
    
函数作用：
对数组a中前n个数进行累加
'''
import numpy as np
a = np.array([[1,2,3],[2,3,2],[4,3,1]])
a
# array([[1, 2, 3],
#        [2, 3, 2],
#        [4, 3, 1]])

# 不指定axis，默认横向累加，返回一维数组
np.cumsum(a)
# array([ 1,  3,  6,  8, 11, 13, 17, 20, 21], dtype=int32)

# 指定axis=0，纵向累加
np.cumsum(a,axis=0)
# array([[1, 2, 3],
#        [3, 5, 5],
#        [7, 8, 6]], dtype=int32)

# 指定axis=1，横向累加
np.cumsum(a,axis=1)
# array([[1, 3, 6],
#        [2, 5, 7],
#        [4, 7, 8]], dtype=int32)

4.10、np.cumprod(ndarry,axis) 累乘

4.11、np.cummax(ndarry,axis) 累计最大数

4.12、np.cummin(ndarry,axis) 累计最小数

4.13、np.percentile(ndarry,axis) 分位数

'''
np.percentile(a, q, axis=None, out=None, overwrite_input=False, interpolation='linear', keepdims=False)

参数说明：
    a：数组
    q: 等份
    axis：0代表行，纵向；1代表列，横向
    
函数作用：
对数组a中前n个数进行累加
'''

a = np.arange(20).reshape(4,5)
a
# array([[ 0,  1,  2,  3,  4],
#        [ 5,  6,  7,  8,  9],
#        [10, 11, 12, 13, 14],
#        [15, 16, 17, 18, 19]])

# 横向在20%这个位置的分位数
np.percentile(a,20,axis = 1)
# array([ 0.8,  5.8, 10.8, 15.8])

还有很多统计运算的函数，用法都差不多

二、数组的排序

np.sort(ndarray)或ndarray.sort() ：返回排序数据
ndarray.argsort()： 返回排序数据的下标

'''
np.sort(ndarray)：对数组进行排序，不改变原数组的数据

ndarray.sort()：对数组进行排序，直接操作原数组

ndarray.argsort()：返回按照升序排序的元素在原数组中的下标
'''

a = np.array([11,5,7,10])
a
# array([11,  5,  7, 10])

a.sort()
# 原数组发生了变化
a
3 array([ 5,  7, 10, 11])

# 有返回值
np.sort(a)
# array([ 5,  7, 10, 11])

# 原数组未发生变化
a
# array([11,  5,  7, 10])

'''
原数组：
array([11,  5,  7, 10])
排序后：
# array([ 5,  7, 10, 11])
排序后第一个元素为5，在原数组的索引为1，第二个元素为7，在原数组中索引为2，以此类推
a.argsort()：
array([1, 2, 3, 0]

'''
a.argsort()
# array([1, 2, 3, 0], dtype=int64)

sorted(序列,reverse = False)

'''
sorted(序列,reverse = False)

reverse 默认为 False，序列按照升序排序
当设置reverse为Ture时，序列按照降序排序
'''

# 返回数据为原生list
sorted(a)
# [5, 7, 10, 11]

# 降序排序
sorted(a,reverse = True)
[11, 10, 7, 5]