Python之numpy使用知识汇总
一、numpy简介
NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。
NumPy 的前身 Numeric 最早是由 Jim Hugunin 与其它协作者共同开发，2005 年，Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色，并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。
1.1 功能
NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：
1.一个强大的N维数组对象 ndarray
2.广播功能函数
3.整合 C/C++/Fortran 代码的工具
4.线性代数、傅里叶变换、随机数生成等功能
1.2 应用
NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用， 这种组合广泛用于替代 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习。
SciPy 是一个开源的 Python 算法库和数学工具包。
SciPy 包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。
Matplotlib 是 Python 编程语言及其数值数学扩展包 NumPy 的可视化操作界面。它为利用通用的图形用户界面工具包，如 Tkinter, wxPython, Qt 或 GTK+ 向应用程序嵌入式绘图提供了应用程序接口（API）。
二、环境
numpy是Python的一个外部资源包，所以其使用需要在Python的使用环境下，有关Python的安装，可以查看这里Python相关安装汇总（持续更新）。
三、使用
3.1 使用原因
numpy的使用主要是数组的处理计算快速，高效，以便于进行如向量，矩阵运算等科学运算，对于其使用效率与Python普通逻辑运行比较，可以查看这里Python之向量相加中使用到list元素求和、合并
3.2 数组对象
3.2.1 数组创建函数
| 函数 | 说明 |
|---|---|
| array | 将输入数据（列表、元组、数组或其他序列类型）转换为ndarray，默认直接复制输入数据。 |
| asarray | 将输入转换为ndarray，如果输入本身就是一个ndarray就不进行复制。 |
| arange | 类似于内置的range，但返回的是一个ndarray而不是列表。 |
| ones、ones_like | 根据指定的形状和dtype创建一个全数组。one_like以另一个数组为参数，并根据其形状和dtype创建一个全1数组。 |
| zero、zero_like | 类似于ones和one_like，只不过产生的是全0数组。 |
| empty、empty_like | 创建新数组，只分配内存空间但不填充任何值。 |
| eye、identity | 创建一个正方的NxN单位矩阵（对角线为1，其余为0）。 |
有关ndarray,N维数组对象可以参考这里numpy之ndarray对象
import numpy as np
# numpy数组
a = np.arange(5)
print("\n\r1.创建数组\n\r", a)
print("---------------\n\r", a.dtype)
print("---------------\n\r", a.shape)
# 创建多维数组
m = np.array([np.arange(2), np.arange(2)])
print("\n\r2.创建多维数组\n\r", m)
print("---------------\n\r", m.shape)
print("---------------\n\r", m.dtype)
# 创建空数组
print("\n\r3.空数组\n\r", np.zeros(10))
print("---------------\n\r", np.zeros((3, 6)))
print("---------------\n\r", np.empty((2, 3, 2)))
# 选取数组元素
a = np.array([[1, 2], [3, 4]])
print("\n\r4.选取数组元素In: a=\r\n", a)
print("---------------\n\rIn: a[0,0]=", a[0, 0])
print("---------------\n\rIn: a[0,1]=", a[0, 1])
print("---------------\n\rIn: a[1,0]=", a[1, 0])
print("---------------\n\rIn: a[1,1]=", a[1, 1])
结果
1.创建数组
[0 1 2 3 4]
---------------
int32
---------------
(5,)
2.创建多维数组
[[0 1]
[0 1]]
---------------
(2, 2)
---------------
int32
3.空数组
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
---------------
[[0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0.]]
---------------
[[[ 4.44659081e-323 0.00000000e+000]
[ 0.00000000e+000 0.00000000e+000]
[ 0.00000000e+000 2.35175247e-321]]
[[ 0.00000000e+000 0.00000000e+000]
[ 0.00000000e+000 -4.76336535e-312]
[ 0.00000000e+000 0.00000000e+000]]]
4.选取数组元素In: a=
[[1 2]
[3 4]]
---------------
In: a[0,0]= 1
---------------
In: a[0,1]= 2
---------------
In: a[1,0]= 3
---------------
In: a[1,1]= 4
3.2.2 数组元素数据类型
| 类型 | 类型代码 | 说明 |
|---|---|---|
| int8、uint8 | i1、u1 | 有符号和无符号的8位（1个字节）整型 |
| int16、uint16 | i2、u2 | 有符号和无符号的16位（2个字节）整型 |
| int32、uint32 | i4、u4 | 有符号和无符号的32位（4个字节）整型 |
| int64、uint64 | i8、u8 | 有符号和无符号的64位（8个字节）整型 |
| float16 | f2 | 半精度浮点数 |
| float32 | f4或f | 标准的单精度浮点数。与C的float兼容 |
| float64 | f8或d | 标准的双精度浮点数。与C的double和Python的float对象兼容 |
| float128 | f16或g | 扩展精度浮点数 |
| complex64、complex128、complex256 | c8、c16 、c32 | 分别用两个32位、64位或128位浮点数表示的复数 |
| bool | ? | 存储True和False值的布尔类型 |
| object | O | Python对象类型 |
| string_ | S | 固定长度的字符串类型（每个字符1个字节）。例如，要创建一个长度为10的字符串，应使用S10 |
| unicode_ | U | 固定长度的unicode类型（字节数有平台决定）。跟字符串的定义方式一样（如U10） |
import numpy as np
# numpy数据类型
# 数据类型转换
# 1.整型换浮点型
print("\n\r1.整型换浮点型\n\rfloat64(42)=", np.float64(42))
# 2.浮点型换整型
print("\n\r2.浮点型换整型\n\rint8(42.0)=", np.int8(42.0))
# 3.整型转布尔型
print("\n\r3.整型转布尔型\n\rbool(42)=", np.bool(42), "\n\r---------------\n\rbool(0)=", np.bool(0), "\n\r浮点型转布尔型\n\rbool(42.0)=", np.bool(42.0))
# 4.布尔型转浮点型
print("\n\r4.布尔型转浮点型\n\rfloat(True)=", np.float(True), "\n\r---------------\n\rfloat(False)=", np.float(False))
# 5.定义数组元素类型
print("\n\r5.16位整型元素的数组\n\rarange(7, dtype=uint16)=", np.arange(7, dtype=np.uint16))
# 6.复数不能转其他数据类型
try:
print("\n\r6.转换失败\n\rint(42.0 + 1.j)\n\r", np.int(42.0 + 1.j))
except TypeError:
print("\n\r6.转换失败,复数不能转其他数据类型\n\rTypeError:int(42.0 + 1.j)\n\r")
# 7.astype转换数据类型
arr = np.array([1, 2, 3, 4, 5])
print("\n\r7.astype转换数据类型\n\r", arr.dtype, arr)
float_arr = arr.astype(np.float64)
print("转为", float_arr.dtype, float_arr)
arr = np.array([3.7, -1.2, -2.6, 0.5, 12.9, 10.1])
print("---------------\n\r", arr, "转为32位整型", arr.astype(np.int32))
numeric_strings = np.array(['1.25', '-9.6', '42'], dtype=np.string_)
print("---------------\n\r['1.25', '-9.6', '42'] 字符串转为浮点型", numeric_strings.astype(float))
# 8.字符编码
print("\n\r8.字符编码\n\r", np.arange(7, dtype='f'))
print("---------------\n\r", np.arange(7, dtype='D'))
print("---------------\n\r", np.dtype(float))
print("---------------\n\r", np.dtype('f'))
print("---------------\n\r", np.dtype('d'))
print("---------------\n\r", np.dtype('f8'))
print("---------------\n\r", np.dtype('float64'))
# 9.dtype类的属性
t = np.dtype('float64')
print("\n\r9.dtype类的属性\n\r", t.char)
print("---------------\n\r", t.type)
print("---------------\n\r", t.str)
print("---------------\n\r", t.itemsize)
# 10.创建自定义数据类型
t = np.dtype([('name', np.str_, 40), ('numitems', np.int32), ('price', np.float32)])
print("\n\r10.创建自定义数据类型\n\r", t)
print("---------------\n\r", t['name'])
itemz = np.array([('Meaning of life DVD', 42, 3.14), ('Butter', 13, 2.72)], dtype=t)
print("---------------\n\r", itemz)
print("---------------\n\r", itemz[1])
# 11.复数数组的转换
b = np.array([1. + 1.j, 3. + 2.j])
print("\n\r11.复数数组的转换\n\rb=", b)
print("\n\r---------------\n\r数组转换为列表\n\r", b.tolist())
print("\n\r---------------\n\r数组元素转换字符串格式\n\r", b.tostring())
print("\n\r---------------\n\r字符串转换回复数\n\r", np.fromstring(b.tostring(), dtype=complex))
print("\n\r---------------\n\r按要求输出数组\n\r", np.fromstring('20:42:52', sep=':', dtype=int))
print("\n\r---------------\n\rastype复数转换成整数\n\r", b.astype(int))
print("\n\r---------------\n\rastype复数转换成整数\n\r", b.astype(int).astype('complex'))
结果
1.整型换浮点型
float64(42)= 42.0
2.浮点型换整型
int8(42.0)= 42
3.整型转布尔型
bool(42)= True
---------------
bool(0)= False
浮点型转布尔型
bool(42.0)= True
4.布尔型转浮点型
float(True)= 1.0
---------------
float(False)= 0.0
5.16位整型元素的数组
arange(7, dtype=uint16)= [0 1 2 3 4 5 6]
6.转换失败,复数不能转其他数据类型
TypeError:int(42.0 + 1.j)
7.astype转换数据类型
int32 [1 2 3 4 5]
转为 float64 [1. 2. 3. 4. 5.]
---------------
[ 3.7 -1.2 -2.6 0.5 12.9 10.1] 转为32位整型 [ 3 -1 -2 0 12 10]
---------------
['1.25', '-9.6', '42'] 字符串转为浮点型 [ 1.25 -9.6 42. ]
8.字符编码
[0. 1. 2. 3. 4. 5. 6.]
---------------
[0.+0.j 1.+0.j 2.+0.j 3.+0.j 4.+0.j 5.+0.j 6.+0.j]
---------------
float64
---------------
float32
---------------
float64
---------------
float64
---------------
float64
9.dtype类的属性
d
---------------
<class 'numpy.float64'>
---------------
<f8
---------------
8
10.创建自定义数据类型
[('name', '<U40'), ('numitems', '<i4'), ('price', '<f4')]
---------------
<U40
---------------
[('Meaning of life DVD', 42, 3.14) ('Butter', 13, 2.72)]
---------------
('Butter', 13, 2.72)
11.复数数组的转换
b= [1.+1.j 3.+2.j]
---------------
数组转换为列表
[(1+1j), (3+2j)]
---------------
数组元素转换字符串格式
b'\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x08@\x00\x00\x00\x00\x00\x00\x00@'
---------------
字符串转换回复数
[1.+1.j 3.+2.j]
---------------
按要求输出数组
[20 42 52]
---------------
astype复数转换成整数
[1 3]
---------------
astype复数转换成整数
[1.+0.j 3.+0.j]
3.2.3 数组的运算
数组之间，数组与标量的运算
import numpy as np
# 数组与标量的运算
arr = np.array([[1., 2., 3.], [4., 5., 6.]])
print(arr)
print("---------------\n\r1.数组间相乘\n\r", arr * arr)
print("---------------\n\r2.数组间相减\n\r", arr - arr)
print("---------------\n\r3.数组与标量的除法\n\r", 1 / arr)
print("---------------\n\r4.数组的幂运算\n\r", arr ** 0.5)
结果
[[1. 2. 3.]
[4. 5. 6.]]
---------------
1.数组间相乘
[[ 1. 4. 9.]
[16. 25. 36.]]
---------------
2.数组间相减
[[0. 0. 0.]
[0. 0. 0.]]
---------------
3.数组与标量的除法
[[1. 0.5 0.33333333]
[0.25 0.2 0.16666667]]
---------------
4.数组的幂运算
[[1. 1.41421356 1.73205081]
[2. 2.23606798 2.44948974]]
3.2.4 数组的索引和切片
索引相当于定位（行、列、元素）的标号，切片slice用于作为索引的条件而提前设定的规则，相当于切片是索引的工具
import numpy as np
# 一维数组的索引与切片
a = np.arange(9)
print(a)
# 索引
print("\n\r1.一维数组索引\n\r1.1 3到7位\n\r", a[3:7])
print("---------------\n\r1.2 0到7位间隔2\n\r", a[:7:2])
print("---------------\n\r1.3 一维数组首尾互换\n\r", a[::-1])
# 切片
s = slice(3, 7, 2)
print("\n\r------------------------------\n\r2.一维数组切片\n\r2.1 s=[3:7:2]切片\n\ra[s]=", a[s])
s = slice(None, None, -1)
print("---------------\n\r2.2 s=[::-1]切片\n\ra[s]=", a[s])
# 多维数组的切片与索引
b = np.arange(24).reshape(2, 3, 4)
print("\n\r------------------------------\n\r3.多维数组索引\n\r", b.shape)
print("---------------\n\r2行的3行4列数组\n\r", b)
print("---------------\n\r3.1 第1行中第1行第1列的元素\n\r", b[0, 0, 0])
print("---------------\n\r3.2 每行中第1行第1列的元素\n\r", b[:, 0, 0])
print("---------------\n\r3.3 第1行元素\n\r", b[0])
print("---------------\n\r3.4 第1行中每行每列元素\n\r", b[0, :, :])
print("---------------\n\r3.5 同上\n\r", b[0, ...])
print("---------------\n\r3.6 第1行中第1行元素\n\r", b[0, 1])
print("---------------\n\r3.7 第1行中第2行元素从0间隔2取出\n\r", b[0, 1, ::2])
print("---------------\n\r3.8 每行中每行的第2列所有元素\n\r", b[..., 1])
print("---------------\n\r3.9 每行中第2行所有元素\n\r", b[:, 1])
print("---------------\n\r3.10 第1行中每行第第2个元素\n\r", b[0, :, 1])
print("---------------\n\r3.11 第1行中每行最后1个元素\n\r", b[0, :, -1])
print("---------------\n\r3.12 第1行中每行首尾互换后最后1个元素\n\r", b[0, ::-1, -1])
print("---------------\n\r3.13 第1行中从0间隔2取行最后1个元素\n\r", b[0, ::2, -1])
print("---------------\n\r3.14 行首尾互换\n\r", b[::-1])
s = slice(None, None, -1)
print("\n\r------------------------------\n\r4.多维数组切片\n\rs=[::-1]切片\n\rb[(s, s, s)]=", b[(s, s, s)])
# 布尔型索引
names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
data = np.random.randn(7, 4)
print("\n\r------------------------------\n\r5.布尔型索引\n\rnames=", names)
print("---------------\n\r标准正态分布中随机返回一个7行4列数组\n\r", data)
print("---------------\n\r5.1 数组每元素与Bob相等比较输出布尔结果\n\r", names == 'Bob')
print("---------------\n\r5.2 data数组以布尔数组为索引输出TRUE的行\n\r", data[names == 'Bob'])
print("---------------\n\r5.3 data数组以布尔数组为索引输出TRUE的行，取第3位到结束的元素\n\r", data[names == 'Bob', 2:])
print("---------------\n\r5.4 data数组以布尔数组为索引输出TRUE的行，取第4位元素\n\r", data[names == 'Bob', 3])
print("---------------\n\r5.5 数组每元素与Bob不等比较输出布尔结果\n\r", names != 'Bob')
print("---------------\n\r5.6 data数组以布尔数组为索引输出TRUE的行\n\r", data[~(names == 'Bob')])
# print("---------------\n\r5.6 data数组以布尔数组为索引输出TRUE的行\n\r", data[names != 'Bob'])
mask = (names == 'Bob') | (names == 'Will')
print("---------------\n\r5.7 输出布尔结果数组\n\r", mask)
print("\n\r正态分布数组\n\r", data[mask])
data[data < 0] = 0
print("---------------\n\r5.8 data数组小于0的元素换成0\n\r", data)
data[names != 'Joe'] = 7
print("---------------\n\r5.9 names != 'Joe'的布尔数组\n\r", names != 'Joe')
print("\n\r在以上基础上names不为Joe的行元素换成7\n\r", data)
# 花式索引
arr = np.empty((8, 4))
for i in range(8):
arr[i] = i
print("\n\r------------------------------\n\r6.花式索引\n\rarr=", arr)
print("\n\r6.1 按正序索引取出行\n\r", arr[[4, 3, 0, 6]])
print("\n\r6.2 按倒序（负数）索引取出行\n\r", arr[[-3, -5, -7]])
arr = np.arange(32).reshape((8, 4))
print("---------------\n\r8行4列元素从0到31数组\n\rarr=", arr)
print("---------------\n\r6.3 按定位输出元素的数组\n\r", arr[[1, 5, 7, 2], [0, 3, 1, 2]])
print("---------------\n\r6.4 先选行再根据列排序输出数组\n\r", arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]])
print("---------------\n\r6.5 同上\n\r", arr[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])])
结果
[0 1 2 3 4 5 6 7 8]
1.一维数组索引
1.1 3到7位
[3 4 5 6]
---------------
1.2 0到7位间隔2
[0 2 4 6]
---------------
1.3 一维数组首尾互换
[8 7 6 5 4 3 2 1 0]
------------------------------
2.一维数组切片
2.1 s=[3:7:2]切片
a[s]= [3 5]
---------------
2.2 s=[::-1]切片
a[s]= [8 7 6 5 4 3 2 1 0]
------------------------------
3.多维数组索引
(2, 3, 4)
---------------
2行的3行4列数组
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
---------------
3.1 第1行中第1行第1列的元素
0
---------------
3.2 每行中第1行第1列的元素
[ 0 12]
---------------
3.3 第1行元素
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
---------------
3.4 第1行中每行每列元素
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
---------------
3.5 同上
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
---------------
3.6 第1行中第1行元素
[4 5 6 7]
---------------
3.7 第1行中第2行元素从0间隔2取出
[4 6]
---------------
3.8 每行中每行的第2列所有元素
[[ 1 5 9]
[13 17 21]]
---------------
3.9 每行中第2行所有元素
[[ 4 5 6 7]
[16 17 18 19]]
---------------
3.10 第1行中每行第第2个元素
[1 5 9]
---------------
3.11 第1行中每行最后1个元素
[ 3 7 11]
---------------
3.12 第1行中每行首尾互换后最后1个元素
[11 7 3]
---------------
3.13 第1行中从0间隔2取行最后1个元素
[ 3 11]
---------------
3.14 行首尾互换
[[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]]
------------------------------
4.多维数组切片
s=[::-1]切片
b[(s, s, s)]= [[[23 22 21 20]
[19 18 17 16]
[15 14 13 12]]
[[11 10 9 8]
[ 7 6 5 4]
[ 3 2 1 0]]]
------------------------------
5.布尔型索引
names= ['Bob' 'Joe' 'Will' 'Bob' 'Will' 'Joe' 'Joe']
---------------
标准正态分布中随机返回一个7行4列数组
[[-0.42600999 0.21224879 1.35029406 -0.06526245]
[ 0.16415119 0.40493706 1.12169965 0.85823128]
[ 0.78534466 -0.7900605 -0.63397618 0.43810447]
[ 0.07447693 0.80547575 -0.86037143 0.674715 ]
[-0.02449371 0.2353252 -0.61689085 0.4302597 ]
[ 1.34903171 -1.66070123 -0.15466236 -0.4926818 ]
[ 0.59603701 -0.00788726 1.28354217 2.54836975]]
---------------
5.1 数组每元素与Bob相等比较输出布尔结果
[ True False False True False False False]
---------------
5.2 data数组以布尔数组为索引输出TRUE的行
[[-0.42600999 0.21224879 1.35029406 -0.06526245]
[ 0.07447693 0.80547575 -0.86037143 0.674715 ]]
---------------
5.3 data数组以布尔数组为索引输出TRUE的行，取第3位到结束的元素
[[ 1.35029406 -0.06526245]
[-0.86037143 0.674715 ]]
---------------
5.4 data数组以布尔数组为索引输出TRUE的行，取第4位元素
[-0.06526245 0.674715 ]
---------------
5.5 数组每元素与Bob不等比较输出布尔结果
[False True True False True True True]
---------------
5.6 data数组以布尔数组为索引输出TRUE的行
[[ 0.16415119 0.40493706 1.12169965 0.85823128]
[ 0.78534466 -0.7900605 -0.63397618 0.43810447]
[-0.02449371 0.2353252 -0.61689085 0.4302597 ]
[ 1.34903171 -1.66070123 -0.15466236 -0.4926818 ]
[ 0.59603701 -0.00788726 1.28354217 2.54836975]]
---------------
5.7 输出布尔结果数组
[ True False True True True False False]
正态分布数组
[[-0.42600999 0.21224879 1.35029406 -0.06526245]
[ 0.78534466 -0.7900605 -0.63397618 0.43810447]
[ 0.07447693 0.80547575 -0.86037143 0.674715 ]
[-0.02449371 0.2353252 -0.61689085 0.4302597 ]]
---------------
5.8 data数组小于0的元素换成0
[[0. 0.21224879 1.35029406 0. ]
[0.16415119 0.40493706 1.12169965 0.85823128]
[0.78534466 0. 0. 0.43810447]
[0.07447693 0.80547575 0. 0.674715 ]
[0. 0.2353252 0. 0.4302597 ]
[1.34903171 0. 0. 0. ]
[0.59603701 0. 1.28354217 2.54836975]]
---------------
5.9 names != 'Joe'的布尔数组
[ True False True True True False False]
在以上基础上names不为Joe的行元素换成7
[[7. 7. 7. 7. ]
[0.16415119 0.40493706 1.12169965 0.85823128]
[7. 7. 7. 7. ]
[7. 7. 7. 7. ]
[7. 7. 7. 7. ]
[1.34903171 0. 0. 0. ]
[0.59603701 0. 1.28354217 2.54836975]]
------------------------------
6.花式索引
arr= [[0. 0. 0. 0.]
[1. 1. 1. 1.]
[2. 2. 2. 2.]
[3. 3. 3. 3.]
[4. 4. 4. 4.]
[5. 5. 5. 5.]
[6. 6. 6. 6.]
[7. 7. 7. 7.]]
6.1 按正序索引取出行
[[4. 4. 4. 4.]
[3. 3. 3. 3.]
[0. 0. 0. 0.]
[6. 6. 6. 6.]]
6.2 按倒序（负数）索引取出行
[[5. 5. 5. 5.]
[3. 3. 3. 3.]
[1. 1. 1. 1.]]
---------------
8行4列元素从0到31数组
arr= [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]
[24 25 26 27]
[28 29 30 31]]
---------------
6.3 按定位输出元素的数组
[ 4 23 29 10]
---------------
6.4 先选行再根据列排序输出数组
[[ 4 7 5 6]
[20 23 21 22]
[28 31 29 30]
[ 8 11 9 10]]
---------------
6.5 同上
[[ 4 7 5 6]
[20 23 21 22]
[28 31 29 30]
[ 8 11 9 10]]
3.2.5 数组维度的改变
改变数组的维度，从低维重构为高维，从高维展开为低维
import numpy as np
# 数组转置
arr = np.arange(15).reshape((3, 5))
print("\n\r1.数组转置\n\rarr=", arr)
print("---------------\n\r转置\n\r", arr.T)
# 改变数组的维度
b = np.arange(24).reshape(2, 3, 4)
print("\n\r------------------------------\n\r2.改变数组的维度\n\r2.1 降维展开\n\rb=", b)
print("---------------\n\r降维展开\n\r", b.ravel())
print("---------------\n\r同上\n\r", b.flatten())
b.shape = (6, 4)
print("\n\r---------------\n\r2.2 重构\n\r升维重构\n\rb=", b)
print("---------------\n\r转置\n\rb.T=", b.transpose())
b.resize((2, 12))
print("---------------\n\r降维重构\n\rb=", b)
结果
1.数组转置
arr= [[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
---------------
转置
[[ 0 5 10]
[ 1 6 11]
[ 2 7 12]
[ 3 8 13]
[ 4 9 14]]
------------------------------
2.改变数组的维度
2.1 降维展开
b= [[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
---------------
降维展开
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
---------------
同上
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
---------------
2.2 重构
升维重构
b= [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]
---------------
转置
b.T= [[ 0 4 8 12 16 20]
[ 1 5 9 13 17 21]
[ 2 6 10 14 18 22]
[ 3 7 11 15 19 23]]
---------------
降维重构
b= [[ 0 1 2 3 4 5 6 7 8 9 10 11]
[12 13 14 15 16 17 18 19 20 21 22 23]]
3.2.6 数组的组合和分割
数组间拼接组合或元素对应拼接，数组元素分割
import numpy as np
# 组合数组
a = np.arange(9).reshape(3, 3)
print("\n\r1.数组组合\n\ra=", a)
b = 2 * a
print("\n\rb=", b)
print("\n\r---------------\n\r1.1 横向拼接组合\n\r", np.hstack((a, b)))
print("\n\r---------------\n\r1.2 concatenate 1 横向拼接组合\n\r", np.concatenate((a, b), axis=1))
print("\n\r---------------\n\r1.3 纵向拼接组合\n\r", np.vstack((a, b)))
print("\n\r---------------\n\r1.4 concatenate 0 纵向拼接组合\n\r", np.concatenate((a, b), axis=0))
print("\n\r---------------\n\r1.5 对位元素横向拼接再纵向组合形成单列\n\r", np.dstack((a, b)))
oned = np.arange(2)
print("\n\r---------------\n\r", oned)
twice_oned = 2 * oned
print("\n\r", twice_oned)
print("\n\r---------------\n\r1.6 对位行横向拼接再纵向组合\n\r", np.column_stack((oned, twice_oned)))
# print("\n\r---------------\n\r纵向拼接组合\n\r", np.dstack((oned, twice_oned)))
print("\n\r---------------\n\r1.7 对位行横向拼接再纵向组合\n\r", np.column_stack((a, b)))
print("\n\r---------------\n\r1.8 大于一维时column_stack与hstack拼接效果相同\n\r", np.column_stack((a, b)) == np.hstack((a, b)))
print("\n\r---------------\n\r1.9 横向拼接组合\n\r", np.row_stack((oned, twice_oned)))
print("\n\r---------------\n\r1.10 横向拼接组合\n\r", np.row_stack((a, b)))
print("\n\r---------------\n\r1.11 row_stack与vstack拼接效果相同\n\r", np.row_stack((a, b)) == np.vstack((a, b)))
# 数组的分割
a = np.arange(9).reshape(3, 3)
print("\n\r------------------------------\n\r2.数组的分割\n\ra=", a)
print("\n\r---------------\n\r2.1 横向分割\n\r", np.hsplit(a, 3))
print("\n\r---------------\n\r2.2 split 1 横向分割\n\r", np.split(a, 3, axis=1))
print("\n\r---------------\n\r2.3 纵向分割\n\r", np.vsplit(a, 3))
print("\n\r---------------\n\r2.4 split 0 纵向分割\n\r", np.split(a, 3, axis=0))
c = np.arange(27).reshape(3, 3, 3)
print("\n\r---------------\n\rc=", c)
print("\n\r---------------\n\r2.5 多维下对位元素纵向分割\n\r", np.dsplit(c, 3))
结果
1.数组组合
a= [[0 1 2]
[3 4 5]
[6 7 8]]
b= [[ 0 2 4]
[ 6 8 10]
[12 14 16]]
---------------
1.1 横向拼接组合
[[ 0 1 2 0 2 4]
[ 3 4 5 6 8 10]
[ 6 7 8 12 14 16]]
---------------
1.2 concatenate 1 横向拼接组合
[[ 0 1 2 0 2 4]
[ 3 4 5 6 8 10]
[ 6 7 8 12 14 16]]
---------------
1.3 纵向拼接组合
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 0 2 4]
[ 6 8 10]
[12 14 16]]
---------------
1.4 concatenate 0 纵向拼接组合
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 0 2 4]
[ 6 8 10]
[12 14 16]]
---------------
1.5 对位元素横向拼接再纵向组合形成单列
[[[ 0 0]
[ 1 2]
[ 2 4]]
[[ 3 6]
[ 4 8]
[ 5 10]]
[[ 6 12]
[ 7 14]
[ 8 16]]]
---------------
[0 1]
[0 2]
---------------
1.6 对位行横向拼接再纵向组合
[[0 0]
[1 2]]
---------------
1.7 对位行横向拼接再纵向组合
[[ 0 1 2 0 2 4]
[ 3 4 5 6 8 10]
[ 6 7 8 12 14 16]]
---------------
1.8 大于一维时column_stack与hstack拼接效果相同
[[ True True True True True True]
[ True True True True True True]
[ True True True True True True]]
---------------
1.9 横向拼接组合
[[0 1]
[0 2]]
---------------
1.10 横向拼接组合
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 0 2 4]
[ 6 8 10]
[12 14 16]]
---------------
1.11 row_stack与vstack拼接效果相同
[[ True True True]
[ True True True]
[ True True True]
[ True True True]
[ True True True]
[ True True True]]
------------------------------
2.数组的分割
a= [[0 1 2]
[3 4 5]
[6 7 8]]
---------------
2.1 横向分割
[array([[0],
[3],
[6]]), array([[1],
[4],
[7]]), array([[2],
[5],
[8]])]
---------------
2.2 split 1 横向分割
[array([[0],
[3],
[6]]), array([[1],
[4],
[7]]), array([[2],
[5],
[8]])]
---------------
2.3 纵向分割
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
---------------
2.4 split 0 纵向分割
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
---------------
c= [[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]]
[[ 9 10 11]
[12 13 14]
[15 16 17]]
[[18 19 20]
[21 22 23]
[24 25 26]]]
---------------
2.5 多维下对位元素纵向分割
[array([[[ 0],
[ 3],
[ 6]],
[[ 9],
[12],
[15]],
[[18],
[21],
[24]]]), array([[[ 1],
[ 4],
[ 7]],
[[10],
[13],
[16]],
[[19],
[22],
[25]]]), array([[[ 2],
[ 5],
[ 8]],
[[11],
[14],
[17]],
[[20],
[23],
[26]]])]
3.2.7 数组的属性
涉及数组的维度，元素数量，元素大小，数组大小等
import numpy as np
# 数组的属性
b = np.arange(24).reshape(2, 12)
print("\n\r数组的属性\n\rb=", b)
print("\n\r1 数组的维度\n\r", b.ndim)
print("\n\r2 数组的元素个数\n\r", b.size)
print("\n\r3 数组元素大小\n\r", b.itemsize)
print("\n\r4 数组总大小\n\r", b.nbytes)
b = np.array([1. + 1.j, 3. + 2.j])
print("\n\r---------------\n\rb=", b)
print("\n\r5 复数数组的实位\n\r", b.real)
print("\n\r6 复数数组的虚位\n\r", b.imag)
b = np.arange(4).reshape(2, 2)
print("\n\r---------------\n\rb=", b)
print("\n\r7 b展开为一维数组的属性\n\r", b.flat)
print("\n\r8 b展开的一维数组下标为2的元素\n\r", b.flat[2])
结果
数组的属性
b= [[ 0 1 2 3 4 5 6 7 8 9 10 11]
[12 13 14 15 16 17 18 19 20 21 22 23]]
1 数组的维度
2
2 数组的元素个数
24
3 数组元素大小
4
4 数组总大小
96
---------------
b= [1.+1.j 3.+2.j]
5 复数数组的实位
[1. 3.]
6 复数数组的虚位
[1. 2.]
---------------
b= [[0 1]
[2 3]]
7 b展开为一维数组的属性
<numpy.flatiter object at 0x000000000930C910>
8 b展开的一维数组下标为2的元素
2
3.3 通用函数
通用函数（ufunc）是一种对ndarray中的数据执行元素级运算的函数
3.3.1 一元通用函数
| 函数 | 说明 |
|---|---|
| abs、fabs | 计算整数、浮点数或复数的绝对值。对于非复数值，可以使用更快的fabs |
| sqrt | 计算各元素的平方根。相当于arr**0.5 |
| square | 计算各元素的平方。相当于arr**2 |
| exp | 计算各元素的指数e^x |
| log、log10、log2、log1p | 分别为自然对数（底数为e）、底数为10的对数、底数为2的对数、log(1+x) |
| sign | 计算各元素的正负号：1（正数）、0（零）、-1（负数） |
| cell | 计算各元素的celling值，即大于等于该值的最小整数 |
| floor | 计算各元素的floor值，即小于等于该值的最大整数 |
| rint | 将各元素四舍五入到最接近的整数，保留dtype |
| modf | 将数组的小数和整数部分以两个独立数组的形式返回 |
| isnan | 返回一个表示“哪些值是NaN（不是数字）”的布尔型数组 |
| isfinite、isinf | 分别返回一个表示“哪些元素是有穷的（非inf，非NaN）”或“哪些元素是无穷的”的布尔型数组 |
| cos、cosh、sin、sinh、tan、tanh | 普通型和双曲型三角函数 |
| arccos、arccosh、arcsin、arcsinh、arctan、arctanh | 反三角函数 |
| logical_not | 计算各元素not x的真值。相当于-arr |
import numpy as np
# 通用函数
arr = np.arange(10)
print("\n\r通用函数\n\rarr=", arr)
print("\n\r---------------\n\r1 元素开根号\n\r", np.sqrt(arr))
print("\n\r---------------\n\r2 计算自然系数为低元素次幂\n\r", np.exp(arr))
x = np.random.randn(8)
y = np.random.randn(8)
print("\n\r---------------\n\r3 在标准正态分布任意8个取值组成数组\n\rx=", x)
print("\n\r---------------\n\r与上面比较\n\ry=", y)
# 元素级最大值
print("\n\r---------------\n\r4 取对应x和y的最大值组成新数组\n\r", np.maximum(x, y))
arr = np.random.randn(7) * 5
print("\n\r---------------\n\r5 分割元素的浮点和整型，返回两个数组\n\rarr=", arr)
print("\n\rmodf分割元素\n\r", np.modf(arr))
结果
通用函数
arr= [0 1 2 3 4 5 6 7 8 9]
---------------
1 元素开根号
[0. 1. 1.41421356 1.73205081 2. 2.23606798
2.44948974 2.64575131 2.82842712 3. ]
---------------
2 计算自然系数为低元素次幂
[1.00000000e+00 2.71828183e+00 7.38905610e+00 2.00855369e+01
5.45981500e+01 1.48413159e+02 4.03428793e+02 1.09663316e+03
2.98095799e+03 8.10308393e+03]
---------------
3 在标准正态分布任意8个取值组成数组
x= [ 1.79624032 -0.85653307 0.48329579 -1.2550472 0.17196245 0.47773163
0.7910105 0.02678305]
---------------
与上面比较
y= [ 0.40893775 -0.00629137 -0.78160298 0.51824077 -0.54439549 -2.16652065
1.04953327 -0.12640976]
---------------
4 取对应x和y的最大值组成新数组
[ 1.79624032 -0.00629137 0.48329579 0.51824077 0.17196245 0.47773163
1.04953327 0.02678305]
---------------
5 分割元素的浮点和整型，返回两个数组
arr= [-4.4322398 1.49530569 -2.85360734 0.0703675 0.66182129 1.85413929
-2.26015824]
modf分割元素
(array([-0.4322398 , 0.49530569, -0.85360734, 0.0703675 , 0.66182129,
0.85413929, -0.26015824]), array([-4., 1., -2., 0., 0., 1., -2.]))
3.3.2 二元通用函数
| 函数 | 说明 |
|---|---|
| add | 将数组中对应的元素相加 |
| subtract | 从第一个数组中减去第二个数组中的元素 |
| multiply | 数组元素相乘 |
| divide、floor_divide | 除法或向下圆整除法（丢弃余数） |
| power | 对第一个数组中的元素A，根据第二个数组中的相应元素B，计算A^B |
| maximum、fmax | 元素级的最大值计算。fmax将忽略NaN |
| minimum、fmin | 元素级的最小值计算。fmin将忽略NaN |
| mod | 元素级的求模计算（除法的余数） |
| copysign | 将第二个数组中的值的符号复制给第一个数组中的值 |
| greater、greater_equal、less、less_equal、equal、not_equal | 执行元素级的比较运算，最终产生布尔型数组。相当于比较运算符>、>=、<、<=、==、！= |
| logical_and、logical_or、logical_xor | 执行元素级的真值逻辑运算。相当于逻辑运算符&、|、 ^ |
3.4 利用数组进行数据处理
3.4.1 向量化处理
import numpy as np
# 向量化
points = np.arange(-5, 5, 0.01)
xs, ys = np.meshgrid(points, points)
print("向量化\n\rpoints=", points)
print("\n\rxs=", xs)
print("\n\rys=", ys)
import matplotlib.pyplot as plt
z = np.sqrt(xs ** 2 + ys ** 2)
print("\n\rz=", z)
plt.imshow(z, cmap=plt.cm.gray); plt.colorbar()
plt.title("Image plot of $\sqrt{x^2 + y^2}$ for a grid of values")
plt.draw()
结果
xs= [[-5. -4.99 -4.98 ... 4.97 4.98 4.99]
[-5. -4.99 -4.98 ... 4.97 4.98 4.99]
[-5. -4.99 -4.98 ... 4.97 4.98 4.99]
...
[-5. -4.99 -4.98 ... 4.97 4.98 4.99]
[-5. -4.99 -4.98 ... 4.97 4.98 4.99]
[-5. -4.99 -4.98 ... 4.97 4.98 4.99]]
ys= [[-5. -5. -5. ... -5. -5. -5. ]
[-4.99 -4.99 -4.99 ... -4.99 -4.99 -4.99]
[-4.98 -4.98 -4.98 ... -4.98 -4.98 -4.98]
...
[ 4.97 4.97 4.97 ... 4.97 4.97 4.97]
[ 4.98 4.98 4.98 ... 4.98 4.98 4.98]
[ 4.99 4.99 4.99 ... 4.99 4.99 4.99]]
z= [[7.07106781 7.06400028 7.05693985 ... 7.04988652 7.05693985 7.06400028]
[7.06400028 7.05692568 7.04985815 ... 7.04279774 7.04985815 7.05692568]
[7.05693985 7.04985815 7.04278354 ... 7.03571603 7.04278354 7.04985815]
...
[7.04988652 7.04279774 7.03571603 ... 7.0286414 7.03571603 7.04279774]
[7.05693985 7.04985815 7.04278354 ... 7.03571603 7.04278354 7.04985815]
[7.06400028 7.05692568 7.04985815 ... 7.04279774 7.04985815 7.05692568]]
3.4.2 将条件逻辑表达为数组运算
# 将条件逻辑表达为数组运算
xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
cond = np.array([True, False, True, True, False])
result = [(x if c else y)
for x, y, c in zip(xarr, yarr, cond)]
print("\n\r将条件逻辑表达为数组运算\n\r使用条件逻辑符进行数组运算\n\rresult=", result)
result = np.where(cond, xarr, yarr)
print("\n\r根据布尔条件使用where抓取相应元素\n\rresult=", result)
arr = randn(4, 4)
print("\n\r---------------\n\rarr=", arr)
print("\n\r使用where大于0的元素换成2否则-2\n\r", np.where(arr > 0, 2, -2))
print("\n\r使用where大于0的元素换成2否则保持原来元素\n\r", np.where(arr > 0, 2, arr))
# Not to be executed
# result = []
# for i in range(n):
# if cond1[i] and cond2[i]:
# result.append(0)
# elif cond1[i]:
# result.append(1)
# elif cond2[i]:
# result.append(2)
# else:
# result.append(3)
# Not to be executed
# np.where(cond1 & cond2, 0,
# np.where(cond1, 1,
# np.where(cond2, 2, 3)))
# Not to be executed
# result = 1 * cond1 + 2 * cond2 + 3 * -(cond1 | cond2)
结果
将条件逻辑表达为数组运算
使用条件逻辑符进行数组运算
result= [1.1, 2.2, 1.3, 1.4, 2.5]
根据布尔条件使用where抓取相应元素
result= [1.1 2.2 1.3 1.4 2.5]
---------------
arr= [[ 0.02948417 1.54829243 0.46535017 -0.5125148 ]
[-0.48569965 0.23835301 -0.12091516 0.11554869]
[-0.54821917 -1.14253461 -0.0061593 -0.54583693]
[-2.23389591 -1.25179571 -0.81582903 -0.70252879]]
使用where大于0的元素换成2否则-2
[[ 2 2 2 -2]
[-2 2 -2 2]
[-2 -2 -2 -2]
[-2 -2 -2 -2]]
使用where大于0的元素换成2否则保持原来元素
[[ 2. 2. 2. -0.5125148 ]
[-0.48569965 2. -0.12091516 2. ]
[-0.54821917 -1.14253461 -0.0061593 -0.54583693]
[-2.23389591 -1.25179571 -0.81582903 -0.70252879]]
3.4.3 数学与统计方法
| 方法 | 说明 |
|---|---|
| sum | 对数组中全部或某轴向的元素求和。零长度的数组的sum为0 |
| mean | 算术平均数。零长度的数组的mean为NaN |
| std、var | 分别为标准差和方差，自由度可调（默认为n） |
| min、max | 最大值和最小值 |
| argmin、argmax | 分别为最大和最小元素的索引 |
| cumsum | 所有元素的累计和 |
| cumprod | 所有元素的累计积 |
# 数学与统计方法
arr = np.random.randn(5, 4)
print("数学与统计方法\n\rarr=", arr)
print("\n\r1 算术平均数\n\rarr=", arr.mean())
print("\n\r2 同上\n\rarr=", np.mean(arr))
print("\n\r3 数组元素全部求和\n\rarr=", arr.sum())
print("\n\r4 数组元素横向求和\n\rarr=", arr.mean(axis=1))
print("\n\r5 数组元素纵向求和\n\rarr=", arr.sum(0))
arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
print("\n\r---------------\n\rarr=", arr)
print("\n\r6 从上到下元素纵向的累计和\n\rarr=", arr.cumsum(0))
print("\n\r7 从左到右元素横向的累计积\n\rarr=", arr.cumprod(1))
# 用于布尔型数组的方法
arr = randn(10)
# arr = np.arange(0, 5)
print("\n\r------------------------------\n\r用于布尔型数组的方法\n\rarr=", arr)
# 正值的数量
print("\n\r1 大于0的元素数量\n\r(arr > 0).sum()=", (arr > 0).sum())
bools = np.array([False, False, True, False])
print("\n\r---------------\n\rbools=", bools)
print("\n\r2 检查元素是否有true或1\n\rbools.any()=", bools.any())
print("\n\r3 检查元素是否都为true或1\n\rbools.all()=", bools.all())
结果
数学与统计方法
arr= [[-1.67457291 -1.19066356 1.34168359 2.05443681]
[ 1.71175338 -0.63952677 -1.57802347 0.52268096]
[ 0.67695635 0.54925072 -1.60177647 1.08718361]
[-0.16493695 -0.58348551 1.32004931 0.2424066 ]
[ 1.80955618 1.11763669 0.16263767 -0.46755765]]
1 算术平均数
arr= 0.23478442884964562
2 同上
arr= 0.23478442884964562
3 数组元素全部求和
arr= 4.695688576992913
4 数组元素横向求和
arr= [0.13272098 0.00422102 0.17790355 0.20350836 0.65556822]
5 数组元素纵向求和
arr= [ 2.35875606 -0.74678842 -0.35542937 3.43915032]
---------------
arr= [[0 1 2]
[3 4 5]
[6 7 8]]
6 从上到下元素纵向的累计和
arr= [[ 0 1 2]
[ 3 5 7]
[ 9 12 15]]
7 从左到右元素横向的累计积
arr= [[ 0 0 0]
[ 3 12 60]
[ 6 42 336]]
------------------------------
用于布尔型数组的方法
arr= [ 0.18432441 0.88377243 -0.69380731 -0.64423612 -1.99785451 1.61098809
-0.81030206 1.44927166 0.36766577 0.50401257]
1 大于0的元素数量
(arr > 0).sum()= 6
---------------
bools= [False False True False]
2 检查元素是否有true或1
bools.any()= True
3 检查元素是否都为true或1
bools.all()= False
3.4.4 排序
# 排序
arr = randn(8)
print("排序\n\rarr=", arr)
arr.sort()
print("\n\r1 sort()元素从小到大排序\n\rarr=", arr)
arr = randn(5, 3)
print("\n\r---------------\n\rarr=", arr)
arr.sort(1)
print("\n\r2 sort(1)行元素从小到大排序\n\rarr=", arr)
large_arr = randn(20)
print("\n\r---------------\n\rlarge_arr=", large_arr)
large_arr.sort()
print("\n\rsort()排序完\n\rlarge_arr=", large_arr)
print("\n\rlen(large_arr)=", len(large_arr))
print("\n\rint(0.05 * len(large_arr))=", int(0.05 * len(large_arr)))
print("\n\r3 通过排序计算输出相应元素\n\rlarge_arr[int(0.05 * len(large_arr))]=", large_arr[int(0.05 * len(large_arr))])
结果
排序
arr= [ 1.21296266 0.15892717 -0.71023592 -1.65471653 -1.41768971 0.57564294
-0.2729862 -0.15451825]
1 sort()元素从小到大排序
arr= [-1.65471653 -1.41768971 -0.71023592 -0.2729862 -0.15451825 0.15892717
0.57564294 1.21296266]
---------------
arr= [[ 0.73819739 1.47218862 -1.2735912 ]
[ 0.94595136 2.20224837 -0.60134241]
[ 1.01313023 0.06139422 -0.47196999]
[-0.09354794 -2.62981361 -0.59865937]
[ 0.37138429 0.72034317 0.7254328 ]]
2 sort(1)行元素从小到大排序
arr= [[-1.2735912 0.73819739 1.47218862]
[-0.60134241 0.94595136 2.20224837]
[-0.47196999 0.06139422 1.01313023]
[-2.62981361 -0.59865937 -0.09354794]
[ 0.37138429 0.72034317 0.7254328 ]]
---------------
large_arr= [-0.26474631 1.76080225 0.8876206 -0.79397561 -0.09712605 1.95263135
0.01504706 0.33984667 1.11669809 0.49778116 -0.52075247 -1.23712549
-0.43501455 0.58620006 -0.10865193 0.42942413 -2.82788575 0.84332105
0.17078459 -0.5009054 ]
sort()排序完
large_arr= [-2.82788575 -1.23712549 -0.79397561 -0.52075247 -0.5009054 -0.43501455
-0.26474631 -0.10865193 -0.09712605 0.01504706 0.17078459 0.33984667
0.42942413 0.49778116 0.58620006 0.84332105 0.8876206 1.11669809
1.76080225 1.95263135]
len(large_arr)= 20
int(0.05 * len(large_arr))= 1
3 通过排序计算输出相应元素
large_arr[int(0.05 * len(large_arr))]= -1.2371254923705686
3.4.5 唯一化以及其他集合逻辑
| 方法 | 说明 |
|---|---|
| unique(x) | 计算x中的唯一元素，并返回有序结果 |
| intersect1d(x, y) | 计算x和y中的公共元素，并返回有序结果 |
| union1d(x, y) | 计算x和y中的并集，并返回有序结果 |
| in1d(x) | 得到一个表示“x的元素是否包含于y”的布尔型数组 |
| setdiff1d(x, y) | 集合的差，即元素在x中且不在y中 |
| setxor1d(x, y) | 集合的对称差，即存在于一个数组中但不同时存在于两个数组中的元素 |
# 唯一化以及其他的集合逻辑
names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
print("\n\r唯一化以及其他的集合逻辑\n\rnames=", names)
print("\n\r1 unique()剔除重复元素，唯一化\n\runique(names)=", np.unique(names))
ints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4])
print("\n\rints=", ints)
print("\n\r2 unique()剔除重复元素，唯一化，元素默认从小到大排序\n\runique(ints)=", np.unique(ints))
sorted(set(names))
print("\n\r3 使用sorted(set())达到同样效果\n\rsorted(set(names))=", sorted(set(names)))
values = np.array([6, 0, 0, 3, 2, 5, 6])
print("\n\rvalues=", values)
print("\n\r4 in1d()根据条件进行数组元素校验输出对应布尔数组\n\rin1d(values, [2, 3, 6])=", np.in1d(values, [2, 3, 6]))
结果
唯一化以及其他的集合逻辑
names= ['Bob' 'Joe' 'Will' 'Bob' 'Will' 'Joe' 'Joe']
1 unique()剔除重复元素，唯一化
unique(names)= ['Bob' 'Joe' 'Will']
ints= [3 3 3 2 2 1 1 4 4]
2 unique()剔除重复元素，唯一化，元素默认从小到大排序
unique(ints)= [1 2 3 4]
3 使用sorted(set())达到同样效果
sorted(set(names))= ['Bob', 'Joe', 'Will']
values= [6 0 0 3 2 5 6]
4 in1d()根据条件进行数组元素校验输出对应布尔数组
in1d(values, [2, 3, 6])= [ True False False True True False True]
3.5 线性代数
常用的numpy.linalg函数
| 方法 | 说明 |
|---|---|
| diag | 以一维数组的形式返回方阵的对角线（或非对角线）元素，或将一维数组转换为方阵（非对角线元素为0） |
| dot | 矩阵乘法 |
| trace | 计算对角线元素的和 |
| det | 计算矩阵行列式 |
| eig | 计算方阵的本征值和本征向量 |
| inv | 计算方阵的逆 |
| pinv | 计算矩阵的Moore-Penrose伪逆 |
| qr | 计算QR分解 |
| svd | 计算奇异分解（SVD） |
| solve | 解线性方程组Ax=b，其中A为一个方阵 |
| lstsq | 计算Ax=b的最小二乘解 |
import numpy as np
# 线性代数
x = np.array([[1., 2., 3.], [4., 5., 6.]])
y = np.array([[6., 23.], [-1, 7], [8, 9]])
print("\n\rx=", x)
print("\n\ry=", y)
print("\n\r1 dot()矩阵乘法,x.dot(y)等价于np.dot(x, y)\n\rx.dot(y)=", x.dot(y))
print("\n\rnp.ones(3)=", np.ones(3))
print("\n\r2 np.dot(x, np.ones(3))=", np.dot(x, np.ones(3)))
from numpy.linalg import inv, qr
X = np.random.randn(5, 5)
print("\n\r---------------\n\rX=", X)
mat = X.T.dot(X)
print("\n\r3 X转置再与X矩阵相乘\n\rmat=", mat)
print("\n\r4 int()计算mat的逆矩阵\n\rinv(mat)=", inv(mat))
print("\n\r5 mat与mat的逆矩阵进行矩阵相乘\n\rmat.dot(inv(mat))=", mat.dot(inv(mat)))
q, r = qr(mat)
print("\n\r---------------\n\rmat=", mat)
print("\n\r6 qr()计算QR分解\n\rq=", q)
print("\n\rr=", r)
结果
x= [[1. 2. 3.]
[4. 5. 6.]]
y= [[ 6. 23.]
[-1. 7.]
[ 8. 9.]]
1 dot()矩阵乘法,x.dot(y)等价于np.dot(x, y)
x.dot(y)= [[ 28. 64.]
[ 67. 181.]]
np.ones(3)= [1. 1. 1.]
2 np.dot(x, np.ones(3))= [ 6. 15.]
---------------
X= [[ 0.61005077 1.46745367 -0.45859055 -0.07259387 0.0853 ]
[ 1.5361048 -0.13779114 -0.52272623 -1.03220104 -1.18373113]
[ 1.67505974 0.11659841 0.14043725 -0.38260824 0.58470202]
[-0.73076434 0.78325995 0.83690615 -0.99304312 -0.9356941 ]
[-0.3190458 0.32197472 -0.08497221 0.49276034 -1.03326625]]
3 X转置再与X矩阵相乘
mat= [[ 6.17341178 0.20376579 -1.43195615 -1.7022792 0.22654421]
[ 0.20376579 2.90316573 0.04359759 -0.62806604 -0.70912054]
[-1.43195615 0.04359759 1.21090281 -0.35383786 -0.03352576]
[-1.7022792 -0.62806604 -0.35383786 2.44604532 1.4119764 ]
[ 0.22654421 -0.70912054 -0.03352576 1.4119764 3.69353453]]
4 int()计算mat的逆矩阵
inv(mat)= [[ 0.55220065 0.02626111 0.84117609 0.67359614 -0.27869683]
[ 0.02626111 0.37168087 0.04860782 0.10294313 0.03083593]
[ 0.84117609 0.04860782 2.15145099 1.18336255 -0.47511286]
[ 0.67359614 0.10294313 1.18336255 1.38767602 -0.5412953 ]
[-0.27869683 0.03083593 -0.47511286 -0.5412953 0.49637311]]
5 mat与mat的逆矩阵进行矩阵相乘
mat.dot(inv(mat))= [[ 1.00000000e+00 1.59952917e-17 -1.40076817e-16 4.95111332e-17
-1.22920033e-16]
[-2.28825020e-19 1.00000000e+00 -6.83612766e-17 2.34017465e-17
-6.70801547e-17]
[ 3.57045376e-17 -2.36430756e-18 1.00000000e+00 -6.50400111e-17
1.23445106e-16]
[ 1.44204377e-17 -2.39820504e-17 2.91039548e-17 1.00000000e+00
-1.79497343e-16]
[ 9.16245590e-17 3.97057791e-17 2.03883234e-16 1.54661692e-16
1.00000000e+00]]
---------------
mat= [[ 6.17341178 0.20376579 -1.43195615 -1.7022792 0.22654421]
[ 0.20376579 2.90316573 0.04359759 -0.62806604 -0.70912054]
[-1.43195615 0.04359759 1.21090281 -0.35383786 -0.03352576]
[-1.7022792 -0.62806604 -0.35383786 2.44604532 1.4119764 ]
[ 0.22654421 -0.70912054 -0.03352576 1.4119764 3.69353453]]
6 qr()计算QR分解
q= [[-0.93977575 0.05995702 -0.00829046 -0.14526343 -0.30340814]
[-0.03101918 -0.95291117 0.12992866 -0.27016607 0.03357007]
[ 0.21798605 -0.04386254 -0.76844781 -0.30415301 -0.51723986]
[ 0.25913721 0.17200266 0.62269366 -0.41018567 -0.58929052]
[-0.03448672 0.23844626 -0.06921261 -0.80321074 0.5403852 ]]
r= [[-6.56902646 -0.41034433 1.51778886 2.12727801 0.04030515]
[ 0. -3.03327034 -0.24936887 1.26935457 1.81435552]
[ 0. 0. -1.13099165 1.62982515 0.55533913]
[ 0. 0. 0. -1.61286545 -3.37699041]
[ 0. 0. 0. 0. 1.08866735]]
3.6 随机数生成
部分numpy.random函数
| 方法 | 说明 |
|---|---|
| seed | 确定随机数生成器的种子 |
| permutation | 返回一个序列的随机排列或一个随机排列的范围 |
| shuffle | 对一个序列就地随机排列 |
| rand | 产生均匀分布的样本值 |
| randint | 从给定的上下限范围内随机选取整数 |
| randn | 产生正态分布（平均值为0，标准差为1）的样本值，类似于MATLAB接口 |
| binomial | 产生二项分布的样本值 |
| normal | 产生正态（高斯）分布的样本值 |
| beta | 产生beta分布的样本值 |
关于random.seed()的使用，可以查看这里：numpy之random.seed()的使用
import numpy as np
# 随机数生成
samples = np.random.normal(size=(4, 4))
print("\n\r随机数生成\n\rsamples=", samples)
# 随机漫步
import random
position = 0
walk = [position]
steps = 20
for i in range(steps):
step = 1 if random.randint(0, 1) else -1
position += step
walk.append(position)
print("\n\r---------------\n\r随机漫步\n\rwalk=", walk)
# 设定随机数种子
np.random.seed(12345)
nsteps = 20
draws = np.random.randint(0, 2, size=nsteps)
steps = np.where(draws > 0, 1, -1)
# 返回累计和数组
walk = steps.cumsum()
print("\n\rdraws=", draws)
print("\n\rsteps=", steps)
print("\n\rwalk=", walk)
print("\n\rwalk.min()=", walk.min())
print("\n\rwalk.max()=", walk.max())
print("\n\rnp.abs(walk)=", np.abs(walk))
# argmax()返回最大值下标
print("\n\r(np.abs(walk) > 4).argmax()=", (np.abs(walk) > 4).argmax())
# 一次模拟多个随机漫步
nwalks = 6
nsteps = 5
draws = np.random.randint(0, 2, size=(nwalks, nsteps))
steps = np.where(draws > 0, 1, -1)
walks = steps.cumsum(1)
print("\n\r---------------\n\r一次模拟多个随机漫步\n\rdraws=", draws)
print("\n\rsteps=", steps)
print("\n\rwalks=", walks)
print("\n\rwalks.max()=", walks.max())
print("\n\rwalks.min()=", walks.min())
hits5 = (np.abs(walks) >= 5).any(1)
print("\n\rhits4=", hits5)
# 到达30或-30的数量
print("\n\rhits5.sum()=", hits5.sum())
steps = np.random.normal(loc=0, scale=0.25, size=(5, 5))
print("\n\r产生正态分布样本数组\n\rsteps=", steps)
结果
随机数生成
samples= [[ 0.10201541 0.05959839 1.45885809 0.71503014]
[ 0.39247585 0.01273717 -0.98286759 0.01369837]
[-1.19084665 -1.47631433 1.18943177 -1.26645618]
[ 1.26670189 0.08011613 -0.61134426 -0.67390727]]
---------------
随机漫步
walk= [0, -1, -2, -3, -2, -3, -4, -3, -2, -1, -2, -1, -2, -3, -4, -3, -2, -3, -2, -1, -2]
draws= [0 1 1 1 0 1 0 0 1 0 1 1 0 1 1 0 1 1 1 0]
steps= [-1 1 1 1 -1 1 -1 -1 1 -1 1 1 -1 1 1 -1 1 1 1 -1]
walk= [-1 0 1 2 1 2 1 0 1 0 1 2 1 2 3 2 3 4 5 4]
walk.min()= -1
walk.max()= 5
np.abs(walk)= [1 0 1 2 1 2 1 0 1 0 1 2 1 2 3 2 3 4 5 4]
(np.abs(walk) > 4).argmax()= 18
---------------
一次模拟多个随机漫步
draws= [[0 0 1 1 1]
[0 1 0 0 1]
[1 1 1 1 0]
[1 1 1 1 1]
[1 0 0 1 1]
[0 0 1 1 1]]
steps= [[-1 -1 1 1 1]
[-1 1 -1 -1 1]
[ 1 1 1 1 -1]
[ 1 1 1 1 1]
[ 1 -1 -1 1 1]
[-1 -1 1 1 1]]
walks= [[-1 -2 -1 0 1]
[-1 0 -1 -2 -1]
[ 1 2 3 4 3]
[ 1 2 3 4 5]
[ 1 0 -1 0 1]
[-1 -2 -1 0 1]]
walks.max()= 5
walks.min()= -2
hits4= [False False False True False False]
hits5.sum()= 1
产生正态分布样本数组
steps= [[ 2.64906579e-01 1.61112043e-01 -1.94979397e-03 -1.12300887e-01
6.12240680e-01]
[ 1.66806548e-01 2.00731378e-01 1.43930213e-01 3.45479553e-01
2.48095349e-04]
[-3.58731182e-02 -5.15704362e-02 -5.55980383e-02 -4.20600845e-01
4.52914845e-01]
[-8.78263518e-02 3.20791387e-02 -3.28388561e-01 1.24581765e-01
-1.53984808e-01]
[ 4.35179624e-02 1.70175243e-01 -8.85204543e-03 -2.98515680e-01
2.59334826e-01]]
参考
以上为个人整理总结的知识，如有遗漏或错误欢迎留言指出、点评，如要引用，请联系通知，未经允许谢绝转载。
[1]: http://www.runoob.com/numpy/numpy-tutorial.html
991
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
