python3之numpy库

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 字符串函数
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 数学函数
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 统计函数
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 排序函数
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 的广播机制中，有一个很重要的概念叫做“相容的形状”。只有当两个数组具有“相容的形状”时，“广播”才能起作用；
# 所谓“相容的形状”，指的是参与运算的这两个数组各个维度要么相等；要么其中一个数组的对应维度为 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]]