Python之numpy使用知识汇总(持续更新)

Python之numpy使用知识汇总

  • 一、numpy简介
    • 1.1 功能
    • 1.2 应用
  • 二、环境
  • 三、使用
    • 3.1 使用原因
    • 3.2 数组对象
      • 3.2.1 数组创建函数
      • 3.2.2 数组元素数据类型
      • 3.2.3 数组的运算
      • 3.2.4 数组的索引和切片
      • 3.2.5 数组维度的改变
      • 3.2.6 数组的组合和分割
      • 3.2.7 数组的属性
    • 3.3 通用函数
      • 3.3.1 一元通用函数
      • 3.3.2 二元通用函数
    • 3.4 利用数组进行数据处理
      • 3.4.1 向量化处理
      • 3.4.2 将条件逻辑表达为数组运算
      • 3.4.3 数学与统计方法
      • 3.4.4 排序
      • 3.4.5 唯一化以及其他集合逻辑
    • 3.5 线性代数
    • 3.6 随机数生成
  • 参考

一、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', '), ('numitems', '), ('price', ')]
---------------
 <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 37[3 4 5 6]
---------------
1.2 07位间隔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行的34列数组
 [[[ 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.11行中第1行第1列的元素
 0
---------------
3.2 每行中第1行第1列的元素
 [ 0 12]
---------------
3.31行元素
 [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
---------------
3.41行中每行每列元素
 [[ 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.61行中第1行元素
 [4 5 6 7]
---------------
3.71行中第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.101行中每行第第2个元素
 [1 5 9]
---------------
3.111行中每行最后1个元素
 [ 3  7 11]
---------------
3.121行中每行首尾互换后最后1个元素
 [11  7  3]
---------------
3.131行中从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']
---------------
标准正态分布中随机返回一个74列数组
 [[-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.]]
---------------
84列元素从031数组
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]]

Python之numpy使用知识汇总(持续更新)_第1张图片

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

你可能感兴趣的:(python)