多维数组定义
import numpy as np
# 多维数组定义
np.array((2, 3, 4)) # 类型为int32 的一维数组
np.array([2.0, 3.0, 4.0]) # 类型为flloat64 的一维数组
np.array(((2, 3, 4, 5), (4, 5, 6, 7))) # 类型为int32 的多维数组
float_array = np.array([[1, 2], [3, 4]], dtype="float64") # 指定多为数组类型
zero_array = np.zeros((3, 4)) # 全为 0 的多维数组,默认类型flloat64
one_array = np.ones((3, 4)) # 全为 1 的多维数组,默认类型flloat64
empty_array = np.empty((3, 4)) # 随机初始值 的多维数组,默认类型flloat64
array = np.full((3, 3), 2) # 填充为某个值
np.arange(10, 30, 5) # 第三个参数为步长
np.arange(0, 2, 0.3)
np.linspace(0.2, 0.3, 9) # 第三个参数为元素个数
多维数组的属性
# 多维数组的属性
arr = np.array([(2, 3, 4, 5), (4, 5, 6, 7)])
print(arr.ndim) # 2 多维数组的维数，或者说是'轴数'
print(arr.shape) # (2, 4) 多维数组整体的维度，或者说是多维数组的“形状”
print(arr.size) # 8 多维数组中元素的总个数
print(arr.dtype) # int32 多维数组中元素的数据类型
print(arr.itemsize) # 4 多维数组中每个元素的字节大小。
多维数组操作
# 多维数组降为一维数组 生成的原数组的视图，无需占有内存空间，但视图的改变会影响到原数组的变化。
print(arr.ravel())
# 多维数组降为一维数组 flatten方法返回的是真实值，其值的改变并不会影响原数组的更改
print(arr.flatten())
# 重整多维数组的大小,reshape还允许缺省 1 个参数（用-1占位），它会根据数组元素的总数和提供的其他参数自动求出一个合适的值
print(np.arange(12).reshape(2, 6))
print(np.arange(12).reshape(2, 3, 2))
print(np.arange(12).reshape(2, -1, 2))
# 返回数组的转置结果
print(arr.T)
# 横向拼接两个数组，但必须满足两个数组的行数相同
print(np.hstack((arr, arr)))
print(np.column_stack((arr, arr)))
# 纵向拼接两个数组，但必须满足两个数组的列数相同
print(np.vstack((arr, arr)))
print(np.row_stack((arr, arr)))
# 沿横轴分割数组
print(np.hsplit(arr, 3))
# 沿纵轴分割数组
print(np.vsplit(arr, 3))
# 将数组转换为列表
print(arr.tolist())
# 强制转换数组的数据类型
print(arr.astype(float))
数组索引
# 索引
arr = np.arange(9)
print(arr) # [0 1 2 3 4 5 6 7 8]
print(arr[2]) # 2
print(arr[-2]) # 7
print(arr[2:5]) # [2 3 4]
print(arr[1:7:2]) # [1 3 5]
print(arr[np.array((2, 4, 6))]) # [2 4 6] 使用数组来索引
arr.shape = (3, 3) # 等同于 arr = arr.reshape(3,3)
print(arr[1, 2]) # 5 推荐使用
print(arr[1, -1]) # 5 推荐使用
print(arr[0][1]) # 1 不推荐使用，效率较低
print(arr[0]) # [0 1 2] 返回数组的第1行
print(arr[:2]) # [[0 1 2] [3 4 5]] 返回数组的前2行
print(arr[[0, 2]]) # [[0 1 2] [6 7 8]] 返回指定的第1行和第3行
print(arr[:, 0]) # [0 3 6] 返回数组的第1列
print(arr[:, [0, 2]]) # [[0 2] [3 5] [6 8]] 返回数组的第1列和第3列
print(arr[np.array([0, 1]), np.array([0, 2])]) # [0 5]
# 布尔索引
b = arr % 2 == 0
print(b) # [[ True False True] [False True False] [ True False True]]
print(arr[b]) # [0 2 4 6 8]
print(arr[np.array([True, False, True])]) # [[0 1 2] [6 7 8]] 返回所有为True的对应行
c = np.array(["A", "B", "C"])
print(arr[c == "A"]) # [[0 1 2] [6 7 8]]
print(arr[(c == "A") | (c == "C")][:, [0, 2]]) # [[0 2] [6 8]]
# 花式索引
print(arr[[2, 0, 1]]) # [[6 7 8] [0 1 2] [3 4 5]] 按照指定顺序返回指定行
print(arr[[2, 0, 1]][:, [0, 2, 1]]) # [[6 8 7] [0 2 1] [3 5 4]]返回指定的行与列
print(arr[np.ix_([2, 1], [0, 2])]) # [[6 8] [3 5]] 返回指定的行与列
NumPy 字符串函数
# NumPy 字符串函数
print(np.char.add(["hello"], [" world"])) # ['hello world']
print(
np.char.add(["hello", "hi"], [" world", " lily"])
) # ['hello world' 'hi lily']
print(np.char.multiply("hello ", 3)) # hello hello hello
print(np.char.multiply(["hello", "hi"], 3)) # ['hellohellohello' 'hihihi']
print(np.char.center("hello", 7, fillchar="*")) # *hello*
print(np.char.center(["hello", "hi"], 6, fillchar="*")) # ['hello*' '**hi**']
print(np.char.capitalize("hello")) # Hello
print(np.char.title("i love china")) # I Love China
print(np.char.lower("GOOGLE")) # google
print(np.char.upper("google")) # GOOGLE
print(np.char.split("do you love china?")) # ['do', 'you', 'love', 'china?']
print(np.char.split("yes,i do", sep=",")) # ['yes', 'i do']
print(np.char.splitlines("I\rLove China")) # ['I', 'Love China'] 用换行符作为分隔符来分割字符串
print(np.char.splitlines("I\nLove China")) # ['I', 'Love China']
print(np.char.splitlines("I\r\nLove China")) # ['I', 'Love China']
print(
np.char.expandtabs("i\tlove\tchina", 3)
) # i love china 将字符串里面的 \t 转换成 N 个 tab
print(np.char.strip("it love china", "i")) # t love china
print(np.char.strip(["it", "love", "china"], "i")) # ['t' 'love' 'china']
print(np.char.lstrip(" china")) # china
print(np.char.rstrip("china ")) # china
print(np.char.join(":", "apple")) # a:p:p:l:e
print(np.char.join([":", "-"], ["apple", "pear"])) # ['a:p:p:l:e' 'p-e-a-r']
print(np.char.partition("apple", "p")) # ['a' 'p' 'ple']
print(
np.char.partition(["apple", "pear"], ["p", "p"])
) # [['a' 'p' 'ple'] ['' 'p' 'ear']]
print(np.char.replace("i love china", "ov", "ik")) # i like china
print(np.char.encode("中文", "utf-8")) # b'\xe4\xb8\xad\xe6\x96\x87'
a = np.char.encode("中文", "utf-8")
print(np.char.decode(a, "utf-8")) # 中文
NumPy 数学函数
# NumPy 数学函数
a = np.array([0, 30, 45, 60, 90])
sin = np.sin(a * np.pi / 180)
cos = np.cos(a * np.pi / 180)
tan = np.tan(a * np.pi / 180)
print(sin, cos, tan)
arcsin = np.arcsin(sin)
arccos = np.arccos(cos)
arctan = np.arctan(tan)
print(np.degrees(arcsin), np.degrees(arccos), np.degrees(arctan))
a = np.array([1, 2.0, 30.12, 129.567])
print(np.around(a)) # [1. 2. 30. 130.] 四舍五入
print(np.around(a, decimals=1)) # [1. 2. 30.1 129.6] 四舍五入
print(np.round(a)) # [1. 2. 30. 130.] 四舍五入
print(np.round(a, decimals=1)) # [1. 2. 30.1 129.6] 四舍五入
print(np.floor(a)) # [1. 2. 30. 129.]
print(np.ceil(a)) # [1. 2. 31. 130.]
a = np.arange(6, dtype=np.float_).reshape(2, 3)
b = np.array([2, 2, 2])
print(np.add(a, b)) # [[2. 3. 4.] [5. 6. 7.]]
print(np.subtract(a, b)) # [[-2. -1. 0.] [ 1. 2. 3.]]
print(np.multiply(a, b)) # [[ 0. 2. 4.] [ 6. 8. 10.]]
print(np.divide(a, b)) # [[0. 0.5 1. ] [1.5 2. 2.5]]
print(np.power(a, b)) # [[ 0. 1. 4.] [ 9. 16. 25.]]
print(np.mod(a, b)) # [[0. 1. 0.] [1. 0. 1.]]
a = np.array([1, 4, 9])
print(a**2) # [1 16 81] 计算每个元素的平方
print(np.sqrt(a)) # [1. 2. 3.] 计算每个元素的平方根
print(np.exp(a)) # 计算每个元素的指数值
print(np.log(a)) # 计算每个元素的自然对数值
print(np.abs(a)) # 计算每个元素的绝对值
NumPy 统计函数
# NumPy 统计函数
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(np.sum(a)) # 45 计算所有元素的和
print(np.sum(a, axis=0)) # [12 15 18] 对每一列求和
print(np.sum(a, axis=1)) # [ 6 15 24] 对每一行求和
print(np.cumsum(a)) # [ 1 3 6 10 15 21 28 36 45] 对每一个元素求累积和
print(np.cumsum(a, axis=0)) # [[ 1 2 3] [ 5 7 9] [12 15 18]] 计算每一列的累积和，并返回二维数组
print(np.cumsum(a, axis=1)) # [[ 1 3 6] [ 4 9 15] [ 7 15 24]] 计算每一行的累积和，并返回二维数组
print(np.cumprod(a)) # 对每一个元素求累积积
print(np.max(a)) # 计算所有元素的最大值
print(np.min(a)) # 计算所有元素的最小值
print(np.amin(a)) # 1
print(np.amin(a, axis=0)) # [1 2 3] 0轴最小值
print(np.amax(a, axis=1)) # [3 6 9] 1轴最大值
print(np.ptp(a)) # 8 计算数组中元素最大值与最小值的差
print(np.ptp(a, axis=1)) # [2 2 2]
print(np.percentile(a, 50)) # 5.0 百分位数
print(np.percentile(a, 50, axis=1)) # [2. 5. 8.] 百分位数
print(np.median(a)) # 5.0 中位数
print(np.median(a, axis=1)) # [2. 5. 8.] 中位数
print(np.mean(a)) # 5.0 算术平均值
print(np.mean(a, axis=1)) # 5.0 算术平均值
print(np.average(a)) # [2. 5. 8.] 加权平均值
print(np.average(a, weights=a)) # 6.333333333333333 加权平均值
print(np.average(a, weights=a, returned=True)) # (6.333333333333333, 45.0) 加权平均值
print(np.var(a)) # 6.666666666666667 方差
print(np.std(a)) # 2.581988897471611 标准差
print(np.where(a % 2 == 0, 1, 0)) # [[0 1 0] [1 0 1] [0 1 0]]
NumPy 排序函数、随机数函数、数组的交集并集
# NumPy 排序函数
a = np.array([[3, 7, 12, 45], [9, 1, 0, 34]])
print(np.sort(a))
print(np.sort(a, axis=0))
b = np.random.randint(1, 10, size=[10, 10])
print(b)
print(np.sort(b)) # 默认快速排序quicksort
print(np.sort(b, kind="heapsort"))
print(np.sort(b, kind="mergesort"))
dt = np.dtype([("name", "S10"), ("age", int)])
c = np.array([("lily", 21), ("rose", 25), ("daisy", 17), ("jane", 27)], dtype=dt)
print(np.sort(c, order="age")) # 按照字段排序
a = np.array([3, 4, 2])
b = np.argsort(a) # 返回排序的索引数组
print(b) # [2 0 1]
print(a[b]) # [2 3 4]
# 随机数生成
print(np.random.rand(size=[2, 2])) #
print(np.random.randint(1, 10, size=[2, 2])) # [[9 9] [1 7]]
print(np.random.normal(size=10)) # 生成正态随机数
print(np.random.binomial(9, 0.5, 10000)) # 生成二项分布随机数
a = np.array([[3, 7, 12, 5], [9, 5, 0, 3]])
print(np.unique(a)) # [ 0 3 5 7 9 12] 计算唯一元素，并返回有序结果
b = np.array([1, 2, 3, 5, 7])
print(np.intersect1d(a, b)) # [3 5 7] 计算公共元素，即交集
print(np.union1d(a, b)) # [ 0 1 2 3 5 7 9 12] 计算并集
print(np.setdiff1d(a, b)) # [ 0 9 12] 计算差集
print(np.setxor1d(a, b)) # [ 0 1 2 9 12] 计算对称差，即存在于一个数组中，但不同时存在于两个数组中
print(np.in1d(a, b)) # [True True False True False True False True] 判断a的元素是否包含于b中
NumPy 中的广播机制
# NumPy 中的广播机制
# NumPy 中，各种运算默认都是“逐元素”进行的。
# 在 NumPy 的广播机制中，有一个很重要的概念叫做“相容的形状”。只有当两个数组具有“相容的形状”时，“广播”才能起作用；
# 所谓“相容的形状”，指的是参与运算的这两个数组各个维度要么相等；要么其中一个数组的对应维度为 1（不存在的维度也是 1）。
# 而 NumPy 比较各个维度的顺序是从后往前，一次比较，就相当于把参与运算的数组形状右对齐，然后若相等就再往前看，若其中一个为 1 就将其在这个维度上扩展到更高的维度，直到第一个维度。
# 下面是对于上述规则一个更清晰的表述描述：
# Image (3d array): 256 x 256 x 3
# Scale (1d array): 3
# Result (3d array): 256 x 256 x 3
# A (4d array): 8 x 1 x 6 x 1
# B (3d array): 7 x 1 x 5
# Result (4d array): 8 x 7 x 6 x 5
a = np.arange(10).reshape(2, 5)
b = np.arange(5)
print(a + b) # [[ 0 2 4 6 8] [ 5 7 9 11 13]]
print(a * b) # [[ 0 1 4 9 16] [ 0 6 14 24 36]]
