numpy数组

import numpy as np

# 一、索引
array1 = np.array([1,2,3,4,5])
array1[2]

array2 = np.array([[1,2,3],[4,5,6]])
# 普通索引
array2[0][0]

# 高级索引
array2[1,0]

array3 = np.random.randint(0,9,size=(2,3,4))
array3

array3[0,0,3]

# 用列表作为索引访问
array2[[0,1]]

# 布尔列表作为索引访问
bool_list = [True,True,False,False,False]
array1[bool_list]

array1 > 3  # 输出：array([False, False, False,  True,  True])

array1[array1 > 3]  # 输出：array([4, 5])

# 对于赋值，和访问一样
# 略

# 二、切片
list1 = [1,2,3]
list1[0:]

# array2 = np.array([[1,2,3],[4,5,6]])
array2[0:1,0:2]  # 行的第一行，列的0，1列

array2[:,0:2]  # 也可以省略第一个，这切的是每行的0,1列

"""
array3 = array(
       [[[6, 5, 2, 3],
        [6, 3, 3, 4],
        [1, 6, 6, 4]],

       [[5, 3, 3, 7],
        [5, 4, 2, 8],
        [2, 1, 6, 1]]], dtype=int32)
"""
array3[0:1,0:2]  # 最后一个:可省略

array3[:,:,0:2]  # 最后一个:可省略

# 反转
# array1 = np.array([1,2,3,4,5])
array1[::-1]  # array([5, 4, 3, 2, 1])

array3[:,:,::-1]  # 将三维中的每个一维反转

array4 = np.random.randint(1,9,size=(2,3))
array4
# 三、变形,注意：变形前后元素数量要一致，否则报错
array4.reshape((6))  # array([2, 7, 6, 7, 7, 1], dtype=int32)

# display()输出格式优化

# 四、级联，如果想做横向级联，行需相同；如果想做纵向级联，列需相同
array5 = np.random.randint(1,9,size=(2,3))
array6 = np.random.randint(1,9,size=(2,3))
display(array5,array6)

np.concatenate((array5, array6), axis=1)  # axis=1水平 输出：array([[8, 2, 1, 2, 8, 6],[7, 3, 7, 2, 2, 7]], dtype=int32)

np.hstack((array5, array6))  # horizontal水平，相当于axis=1

np.vstack((array5, array6))  # vertical垂直

# 五、切分,需要满足切分方向可被切分数整除
arr7 = np.random.randint(0,100,size=(6,6))
arr7

# indices_or_section
# indices：index的复数
# section：部分
part1,part2 = np.split(arr7, indices_or_sections=2)  # 默认从纵向中间分一半
display(part1,part2)

part1,part2 = np.split(arr7, indices_or_sections=2, axis=1)  # 横向分一半
display(part1,part2)

part1,part2,part3 = np.split(arr7, indices_or_sections=[2,5], axis=1)  # 切分成三份：[0:2], [2:5], [5:]
display(part1,part2,part3)

np.hsplit(arr7, indices_or_sections=2)

np.vsplit(arr7, indices_or_sections=2)

# 六、副本，copy()后赋给新数组，新数组与旧数组互不干扰
arr8 = np.array([1,2,4,5], dtype=np.int32)
copy_arr = arr8.copy()  # array([1, 2, 4, 5], dtype=int32)
copy_arr[0] = 10
display(copy_arr, arr8)

# 七、聚合函数
arr9 = np.random.randint(0,10,size=10)
arr9  # array([3, 9, 6, 1, 9, 3, 5, 0, 9, 1], dtype=int32)

arr9.sum()  # np.int64(46)

# 求平均值
arr9.mean()  

arr9.max()

arr9.min()

# 返回最大值元素的索引
arr9.argmax()

# 返回最小值元素的索引
arr9.argmin()

# 标准方差，标准差=sqrt(方差)
arr9.std()

# 方差
arr9.var()

# 中位数
np.median(arr9)

# percentile百分位数
arr10 = np.arange(1,10,step=1)
arr10

"""
第一四分位数（Q1），也称为下四分位数，是数据中 25% 位置处的值。即有 25% 的数据小于等于 Q1。
第二四分位数（Q2）就是中位数，将数据分为两半，有 50% 的数据小于等于 Q2。
第三四分位数（Q3），也称为上四分位数，是数据中 75% 位置处的值。即有 75% 的数据小于等于 Q3。
"""
np.percentile(arr10, [50])  # 返回中位数 array([5.])

np.percentile(arr10, [25, 75])  # 返回下四分位数，上四分位数 array([3., 7.])

# any与all

# any：检测一个布尔数组中，如果True至少有一个，返回True
bool_list = np.array([True,False,False,False])
bool_list.any()  # 输出：np.True_

# all：检测一个布尔数组中，如果全为True，返回True
bool_list2 = np.array([True,True,True,True])
bool_list2.all()  # 输出：np.True_

# 案例：找出一组数据中，所有大于该组数据平均值的值

# 定义数组
arr11 = np.random.randint(0,10,size=(10))
arr11

# 求平均值
mid = arr11.mean()

# 广播运算，支持np.array和任意一个数运算，返回布尔列表
bool_list = arr11 > mid  # array([ True,  True, False, False, False, False,  True,  True,  True, True])

# 大于平均数的元素列表
res = arr11[bool_list]

display(arr11, mid, res)

# any案例：查看一个数组中，是否存在至少一个大于10的数

arr12 = np.random.randint(0,15,size=(5))

res = (arr12 > 10).any()

display(arr12, arr12 > 10, res)

# 八、广播机制
# 两个规则
# 规则一：为缺失的维度补1
# 规则二：假定缺失元素用已有值填充

# 示例：二维数组与单个数（0维）运算，将0维变形为2维，并用其值填充
a1 = np.ones((2,3))
a1 + 3      
"""
运行结果
array([[4., 4., 4.],
       [4., 4., 4.]])
"""

# 示例：二维与一维相加
a2 = np.array([1,2,3])
a1 + a2

"""
运行结果
array([[2., 3., 4.],
       [2., 3., 4.]])
"""

# 数学中的矩阵运算
a3 = np.array([[1,2],[3,4]])
a4 = np.array([[1,2],[3,4]])
np.dot(a3,a4)

a3 * a4  # 注意：这不是矩阵运算，而是将对于位置元素两两相乘
"""
运行结果
array([[ 1,  4],
       [ 9, 16]])
"""

# 九、排序

# 会改变原数组的排序
a5 = np.random.randint(0,10,size=(5))
a5

a5.sort()  # 默认快排，可以更换
a5

# 不改变原数组的排序
a6 = np.random.randint(0,10,size=(5))
a6

np.sort(a6)
a6

# 十、部分排序
# 有的时候我们不是对全部数据感兴趣，我们可能只对最小或最大的一部分感兴趣。
# 当k为正时，我们想要得到最小的k个数
# 当k为负时，我们想要得到最大的k个数

a7 = np.random.permutation(1000)
a7

# 获取前4个最小值
np.partition(a7,4)[:4]

# 获取前4个最大值
np.partition(a7,-4)[-4:]