1、NumPy
NumPy全称 Numerical Python，是一款开源的 Python 数学库。它是 Python 的第三方扩展包，主要用来计算、处理一维或多维数组。支持N维数组运算、处理大型矩阵、成熟的广播函数库、矢量运算、线性代数、傅里叶变换、随机数生成，也为数组运算提供大量的数学函数库。
安装：pip install numpy==1.26.0 -i https://pypi.tuna.tsinghua.edu.cn/simple/
2、导入NumPy
import numpy as np #导入numpy并简写为np
3、数组
4、创建数组
在Python中，可以使用第三方库 numpy 来创建和操作数组。Numpy是Python的一个强大数学和科学计算库，为高效操作多维数组提供了丰富的函数和方法。
首先需要安装 numpy 库，可以使用以下命令安装：pip install numpy
4.1 array()
np.array ,建立一个数组
numpy.array(object, dtype = None, copy = True, order = None,ndmin = 0)
参数说明：
| 序号 | 参数 | 描述说明 |
|---|---|---|
| 1 | object | 表示一个数组序列 |
| 2 | dtype | 可选参数，通过它可以更改数组的数据类型 |
| 3 | copy | 可选参数，表示数组能否被复制，默认是 True |
| 4 | order | 以哪种内存布局创建数组，有 3 个可选值，分别是 C(行序列)/F(列序列)/A(默认) |
| 5 | ndmin | 用于指定数组的维度 |
案例：
import numpy as np #导入numpy库，并简写为np
a = np.array([1, 2, 3]) #建立一个1维数组
b = np.array([[1, 2, 3], [4, 5, 6]]) #建立一个2维数组
c = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]) #建立一个3维数组
print("a=",a)
print("b=",b)
print("c=",c)
4.2 zeros()
创建指定大小的数组，数组元素以 0 来填充
#创建全为0的矩阵
a = np.zeros((3)) #1维数组,1行3列
b = np.zeros((2,3)) #2维数组,2行3列
print(a)
print(b)
#a=[0. 0. 0.]
#b=[[0. 0. 0.]
# [0. 0. 0.]]
4.3 ones()
创建指定形状的数组，数组元素以 1 来填充
import numpy as np
#创建全为1的矩阵
a = np.ones((3))
b = np.ones((3,4))
print(a)
print(b
#a=[1. 1. 1.]
#b=[[1. 1. 1. 1.]
# [1. 1. 1. 1.]
# [1. 1. 1. 1.]]
4.4 full()
full()用于创建一个填充指定值的数组。
格式：
numpy.full(shape, fill_value, dtype=None, order='C')
| 参数 | 描述 |
|---|---|
| shape | 数组的形状（如 (2, 3) 表示 2 行 3 列的数组） |
| fill_value | 填充的值 |
| dtype | 数组的数据类型（如 np.float32） |
| order | 数组的内存布局（如 'C' 表示 C 风格，'F' 表示 Fortran 风格） |
import numpy as np
#full()
a = np.full((3,3), 10)
b = np.full((3,3), 15)
c = np.full((3,3), fill_value='a')
print(a)
print(b)
print(c)
#a=[[10 10 10]
# [10 10 10]
# [10 10 10]]
#b=[[15 15 15]
# [15 15 15]
# [15 15 15]]
#c=[['a' 'a' 'a']
# ['a' 'a' 'a']
# ['a' 'a' 'a']]
4.5 arange()
arange() 函数用于创建一个等差数列的数组。它类似于 Python 内置的 range() 函数，但返回的是一个 NumPy 数组而不是一个列表。
格式：
numpy.arange(start, stop, step, dtype)
根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。
| 参数 | 描述 |
|---|---|
| start | 起始值，默认为 0 |
| stop | 终止值（不包含） |
| step | 步长，默认为 1 |
| dtype | 返回 ndarray 的数据类型，如果没有提供，则会使用输入数据的类型 |
import numpy as np
#arange(start, stop, step)函数用于生成一个等差数列
a = np.arange(1, 11, 1)
b = np.arange(10, 0, -1)
print(a)
print(b)
#[ 1 2 3 4 5 6 7 8 9 10]
#[10 9 8 7 6 5 4 3 2 1]
4.6 linspace
在指定的数值区间内，返回均匀间隔的一维等差数组，默认均分 50 份
格式：
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
| 参数 | 描述 |
|---|---|
| start | 起始值，默认为 0 |
| stop | 终止值（默认包含） |
| num | 表示数值区间内要生成多少个均匀的样本，默认值为 50 |
| endpoint | 默认为 True，表示数列包含 stop 终止值，反之不包含 |
| retstep | 表示是否返回步长。如果为 True，则返回一个包含数组和步长的元组；如果为 False，则只返回数组。默认为 False。 |
| dtype | 返回 ndarray 的数据类型，默认为 None，表示根据输入参数自动推断数据类型。 |
import numpy as np
# linspace(start, stop, num) 产生等差数列
a = np.linspace(0,10,5 )
b = np.linspace(0,10,11)
print(a)
print(b)
[ 0. 2.5 5. 7.5 10. ]
[ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
4.7其他
- np.arange() 线性序列数组: np.arange(start, stop, step, dtype)
- np.linspace() 等差数组: np.linspace(start, stop, num, endpoint, retstep, dtype)
- np.logspace() 等比数组: np.logspace(start, stop, num, endpoint, base, dtype)
- np.zeros() 全零的数组
- np.ons() 全一的数组 float型: np.ones(shape, dtype, order
- np.full() 返回给定形状和类型的新数组
- np.identity(),np.eye() 单位矩阵形成的数组: np.identity(n, dtype=None)
- np.identity(),np.eye() 单位矩阵形成的数组: np.eye(N, M=None, k=0, dtype=float)
- np.diag() 对角数组: np.diag(v, k=0)
- np.empty() 空数组，元素取值随机: np.empty(shape, dtype=float, order='C')
- np.random 生成随机数: np.random.rand(d0, d1, ..., dn)
- np.random.randint(low, high=None, size=None, dtype='l') 随机整数
#np.linspace() 等差数组
#np.logspace() 等比数组: np.logspace(start, stop, num, endpoint, base, dtype)
#start: 开始值
#stop: 结束值
#num: 元素个数
#endpoint: 是否包含结束值
#base: 底数
#dtype: 数据类型
a = np.logspace(1, 10, 10, endpoint=True, base=2.0, dtype=np.float32)
print(a)
# np.identity(),np.eye() 单位矩阵形成的数组: np.identity(n, dtype=None)
a = np.identity(3)
b = np.eye(3)
print(a)
print(b)
#[[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]
# np.diag() 对角数组: np.diag(v, k=0)
a = np.diag([1, 2, 3])
print(a)
#[[1 0 0]
# [0 2 0]
#[0 0 3]]
# np.empty() 空数组，元素取值随机: np.empty(shape, dtype=float, order='C')
a = np.empty((3, 2))
b = np.empty((3, 2),dtype=int)
print(b)
print(a)
# np.random 生成随机数: np.random.rand(d0, d1, ..., dn)
a = np.random.rand(3, 2)
print(a)
# np.random.randint(low, high=None, size=None, dtype='l') 随机整数
#low: 整数，生成的随机整数的下限，默认值为0。
#high: 整数，生成的随机整数的上限，默认值为None，表示上限取决于low。
#size: 整数或元组，生成的随机整数的形状，默认值为None，表示生成单个数值。
#dtype: 数据类型，默认值为'l'，表示生成整数。
a = np.random.randint(1, 10, size=(3, 2))
print(a)
5、数据类型
NumPy 提供了比 Python 更加丰富的数据类型，如下所示：
| 序号 | 数据类型 | 语言描述 |
|---|---|---|
| 1 | bool_ | 布尔型数据类型（True 或者 False） |
| 2 | int_ | 默认整数类型，类似于 C 语言中的 long，取值为 int32 或 int64 |
| 3 | intc | 和 C 语言的 int 类型一样，一般是 int32 或 int 64 |
| 4 | intp | 用于索引的整数类型（类似于 C 的 ssize_t，通常为 int32 或 int64） |
| 5 | int8 | 代表与1字节相同的8位整数。值的范围是-128到127 |
| 6 | int16 | 代表 2 字节（16位）的整数。范围是-32768至32767 |
| 7 | int32 | 代表 4 字节（32位）整数。范围是-2147483648至2147483647 |
| 8 | int64 | 表示 8 字节（64位）整数。范围是-9223372036854775808至9223372036854775807 |
| 9 | uint8 | 1字节（8位）无符号整数 |
| 10 | uint16 | 2 字节（16位）无符号整数 |
| 11 | uint32 | 4 字节（32位）无符号整数 |
| 12 | uint64 | 8 字节（64位）无符号整数 |
| 13 | float_ | float64 类型的简写 |
| 14 | float16 | 半精度浮点数，包括：1 个符号位，5 个指数位，10个尾数位 |
| 15 | float32 | 单精度浮点数，包括：1 个符号位，8 个指数位，23个尾数位 |
| 16 | float64 | 双精度浮点数，包括：1 个符号位，11 个指数位，52个尾数位 |
| 17 | complex_ | 复数类型，与 complex128 类型相同 |
| 18 | complex64 | 表示实部和虚部共享 32 位的复数 |
| 19 | complex128 | 表示实部和虚部共享 64 位的复数 |
| 20 | str_ | 表示字符串类型，等价于unicode_ |
| 21 | bytes_ | 表示字节串类型，基于字节 |
| 22 | string_ | 表示字节串类型，等价于bytes_，基于字节，NumPy 2.0以后版本被移除，使用bytes_代替 |
| 23 | unicode_ | 表示字节串类型，基于字符，NumPy 2.0以后版本被移除，使用str_`代替 |
5.1数据类型对象
1.可以在创建数组时指定 dtype 参数来定义数组中元素的数据类型。
import numpy as np
# 创建一个 int32 类型的数组
arr_int = np.array([1, 2, 3], dtype=np.int32)
print(arr_int.dtype) # 输出: int32
# 创建一个 float64 类型的数组
arr_float = np.array([1, 2, 3], dtype=np.float64)
print(arr_float.dtype) # 输出: float64
arr_str = np.array([1,2,3],dtype=np.string_)
print(arr_str)
#输出：
AttributeError: `np.string_` was removed in the NumPy 2.0 release. Use `np.bytes_` instead.
arr_str = np.array([1,2,3],dtype=np.bytes_)
print(arr_str)
#输出：
[b'1' b'2' b'3']
arr_str = np.array([1,2,3],dtype=np.unicode_)
print(arr_str)
# 输出：
AttributeError: `np.unicode_` was removed in the NumPy 2.0 release. Use `np.str_` instead.
arr_str = np.array([1,2,3],dtype=np.str_)
print(arr_str)
# 输出：
['1' '2' '3']
2.可以使用数组的 dtype 属性来获取数组中元素的数据类型。
例如：
arr = np.array([1, 2, 3])
print(arr.dtype) # 输出: int32
3.可以使用 astype() 方法来转换数组中元素的数据类型。
例如：
arr = np.array([1, 2, 3])
arr_float = arr.astype(np.float64)
print(arr_float.dtype) # 输出: float64
5.2数据类型标识码
NumPy 中每种数据类型都有一个唯一标识的字符码，int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替，如下所示：
| 字符 | 对应类型 |
|---|---|
| b | 代表布尔型 |
| i | 带符号整型 |
| u | 无符号整型 |
| f | 浮点型 |
| c | 复数浮点型 |
| m | 时间间隔（timedelta） |
| M | datatime（日期时间） |
| O | Python对象 |
| S,a | 字节串（S）与字符串（a） |
| U | Unicode |
| V | 原始数据（void） |
以下是 NumPy 中常见的数据类型标识码及其对应的详细列表：
整数类型
| 数据类型 | 标识码 | 描述 |
|---|---|---|
| int8 | i1 | 8 位有符号整数 |
| int16 | i2 | 16 位有符号整数 |
| int32 | i4 | 32 位有符号整数 |
| int64 | i8 | 64 位有符号整数 |
| uint8 | u1 | 8 位无符号整数 |
| uint16 | u2 | 16 位无符号整数 |
| uint32 | u4 | 32 位无符号整数 |
| uint64 | u8 | 64 位无符号整数 |
浮点数类型
| 数据类型 | 标识码 | 描述 |
|---|---|---|
| float16 | f2 | 16 位浮点数（半精度） |
| float32 | f4 | 32 位浮点数（单精度） |
| float64 | f8 | 64 位浮点数（双精度） |
复数类型
| 数据类型 | 标识码 | 描述 |
|---|---|---|
| complex64 | c8 | 64 位复数（单精度） |
| complex128 | c16 | 128 位复数（双精度） |
布尔类型
| 数据类型 | 标识码 | 描述 |
|---|---|---|
| bool | b1 | 布尔类型 |
字符串类型
| 数据类型 | 标识码 | 描述 |
|---|---|---|
| bytes | S10 | 长度为 10 的字节串 |
| str | U10 | 长度为 10 的 Unicode 字符串 |
Python 对象类型
| 数据类型 | 标识码 | 描述 |
|---|---|---|
| O | O | Python 对象类型 |
例如：自定义一个int32的数据类型
dt=np.dtype('i4')
data = np.array([1,2,3,4],dtype=dt)
print(data) #输出：[1 2 3 4]
print(data.dtype) #输出：int32
可以自定义复杂的数据结构：
dt=np.dtype([('name','S10'),('age','i4')])
data = np.array([('zhangsan',20),('lisi',21)],dtype=dt)
print(data) #输出：[(b'zhangsan', 20) (b'lisi', 21)]
print(data.dtype) #输出：[('name', 'S10'), ('age', '<i4')]
说明：
在编程中，字节序标记用于指定数据的字节顺序。常见的字节序标记包括：
-
<: 小端序，数据的最低有效字节存储在内存的最低地址，而最高有效字节存储在内存的最高地址。 -
>: 大端序，数据的最高有效字节存储在内存的最低地址，而最低有效字节存储在内存的最高地址。
6、数组属性
6.1数组维度
数组的维度就是一个数组中的某个元素，当用数组下标表示的时候，需要用几个数字来表示才能唯一确定这个元素，这个数组就是几维
ndmin 是 NumPy 中用于创建数组时指定最小维度的参数。它通常在 numpy.array() 函数中使用。通过 ndmin，你可以确保生成的数组至少具有指定的维度。
ndim 是 NumPy 数组的一个属性，用于返回数组的维度数（即数组的秩）。它表示数组有多少个维度。
import numpy as np
#数组维度
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr.shape) #输出(2, 3)
print(arr.ndim) #输出2
6.2 shape
返回数组的形状，即各维度大小的元组。
返回一个元组，元组中的每个元素表示数组在对应维度上的大小。元组的长度等于数组的维度数。
shape 属性功能：
-
返回一个由数组维度构成的元组
-
通过赋值，可以用来调整数组维度的大小
import numpy as np
#shape:返回数组的形状，即各维度大小的元组。
a = np.array([[1,2,3],[4,5,6]])
print("a=",a)
print("a的形状为：",a.shape)
a.shape = (3,2) #修改数组的形状
print('a修改后的形状为：',a.shape)
print('a修改后的数组为：')
print(a)
a= [[1 2 3]
# [4 5 6]]
# a的形状为： (2, 3)
# a修改后的形状为： (3, 2)
# a修改后的数组为：
# [[1 2]
# [3 4]
# [5 6]]
shape属性修改数组的形状，则修改的是原数组的形状，
reshape修改数组的形状会返回一个新数组，不修改原数组的形状。
6.3 flags
-
返回 ndarray 数组的内存信息
import numpy as np
#flags:
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(a.flags)
# C_CONTIGUOUS : True
# F_CONTIGUOUS : False
# OWNDATA : True
# WRITEABLE : True
# ALIGNED : True
# WRITEBACKIFCOPY : False
7、切片
ndarray 对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样；
在 Python 中，slice 可以作为一个对象来使用。你可以创建一个 slice 对象，然后使用它来获取序列的片段。
参数：
-
start 是切片开始的位置（包含该位置）。
-
stop 是切片结束的位置（不包含该位置）。
-
step 是切片的步长，即选取元素的间隔。
一维：
#切片
#切片操作可以从数组中提取一部分元素，并生成一个新的数组。
#语法：array[start:end:step]
#start：起始索引，默认为0
#end：结束索引，默认为数组长度
#step：步长，默认为1
#1. 切片操作
#从数组中提取一部分元素，并生成一个新的数组。
#创建一个数组
a = np.arange(10)
print(a)
#使用切片操作提取数组的前5个元素
b = a[:5]
print(b)
#使用切片操作提取数组的后5个元素
c = a[-5:]
print(c)
#2. 步长
#step参数可以指定切片的步长，可以提取数组的子集。
print(a[0:10:2]) #[0 2 4 6 8]
多维：
import numpy as np
#切片
#多维
b = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(b)
print("*************")
print(b[1,...]) #提取第2行的所有元素
print("*************")
print(b[...,1]) #提取第2列的所有元素
print("*************")
print(b[0:2,1:3]) #提取第1行到第2行，第2列到第3列的元素
8、高级索引
8.1 整数数组索引
整数数组索引是指使用一个数组来访问另一个数组的元素。这个数组中的每个元素都是目标数组中某个维度上的索引值。
适用于需要访问非连续元素或特定位置元素的场景。
注意：返回的新数组是一个副本，修改它不会影响原数组。
import numpy as np
#整数数组索引
#创建数组
arr = np.array([1, 2, 3, 4, 5])
#索引数组
index = np.array([0, 2, 4]) #索引数组,
#使用索引数组获取数组元素
result = arr[index] #获取索引数组对应的元素,获取数组arr的索引为0,2,4对应的元素
print(result) #输出[1 3 5]
print(arr[[1,2,4]]) #输出[2 3 5]
import numpy as np
#整数数组索引
#创建数组
a = np.array([[1,2,3], [4,5,6], [7,8,9]])
print(a[[0,1,2],[0,1,2]])
#[0,1,2]代表行索引
# [0,1,2]代表列索引
#取出索引坐标为(0,0),(1,1),(2,2)的元素
#输出[1,5,9]
8.2布尔索引
布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。
import numpy as np
# 布尔索引
a = np.array([1, 2, 3, 4, 5])
b = np.array([True, False, True, False, True])
c = a[b]
print(c) # [1 3 5]
x = a>3
print(x) # [False False False True True]
print(a[x]) # [4 5]
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a>3)
print(a[a > 3]) # 输出[4 5 6 7 8 9]
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 1. 索引第3个元素大于3的所有行
print(arr[arr[:, 2] > 3])
print("*************")
# 2. 索引第2行 值大于3 的所有的元素 所在的列
print(arr[:,arr[1] > 3])
9、广播（*）
广播（Broadcast）是 numpy 对不同形状（shape）的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。这要求维数相同，且各维度的长度相同，如果不相同，可以通过广播机制，这种机制的核心是对形状较小的数组，在横向或纵向上进行一定次数的重复，使其与形状较大的数组拥有相同的维度。
广播规则
-
维度匹配：如果两个数组的维度数不同，维度数较少的数组会在前面补上长度为 1 的维度。
import numpy as np # 示例 1：维度匹配 a = np.array([[1, 2, 3], [4, 5, 6]]) # 形状: (2, 3) b = np.array([10, 20, 30]) # 形状: (3,) c = a + b print(c) # 输出: # [[11 22 33] # [14 25 36]] -
形状匹配：如果两个数组在某个维度上的长度不同，但其中一个数组在该维度上的长度为 1，则该数组会沿着该维度进行广播。
import numpy as np # 示例 2：形状匹配 # 1.d是2维数组，e是一维数组，e自动广播为2为数组：[[10 20 30] [10 20 30]]，形状为(2,3) # 2.d和e在行维度上都为2，d在列维度上是一维，自动广播为：[[1 1 1] [2 2 2]]，形状为(2,3) d = np.array([[1], [2]]) # 形状: (2, 1) e = np.array([10, 20, 30]) # 形状: (3,) f = d + e print(f) # 输出: [[11 21 31] [12 22 32]] print(f) # 输出: # [[11 21 31] # [12 22 32]] -
不匹配：如果两个数组在某个维度上的长度既不相同也不为 1，则广播失败，抛出 ValueError。
10、遍历数组
10.1 遍历数组的第一维度
import numpy as np
#遍历数组
arr = np.array([1, 2, 3, 4, 5])
for i in arr:
print(i)
# 1
# 2
# 3
# 4
# 5
10.2 nditer逐个访问元素
nditer 是 NumPy 中的一个强大的迭代器对象，用于高效地遍历多维数组。nditer 提供了多种选项和控制参数，使得数组的迭代更加灵活和高效。
控制参数
nditer 提供了多种控制参数，用于控制迭代的行为。
1.order 参数
order 参数用于指定数组的遍历顺序。默认情况下，nditer 按照 C 风格（行优先）遍历数组。
-
C（行优先）: order='C'
-
F（列优先）: order='F'
import numpy as np
#遍历数组:nditer()函数
arr = np.array([[1,2,3],[4,5,6],[7,8,9]])
for x in np.nditer(arr, order='C'): # 按行遍历
print(x)
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
arr = np.array([[1,2,3],[4,5,6],[7,8,9]])
for x in np.nditer(arr, order='F'): # 按列遍历
print(x)
# 1
# 4
# 7
# 2
# 5
# 8
# 3
# 6
# 9
2.flags 参数
flags 参数用于指定迭代器的额外行为。
-
multi_index: 返回每个元素的多维索引。
-
external_loop: 返回一维数组而不是单个元素，减少函数调用的次数，从而提高性能
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
