介绍numpy
NumPy是一个开源的Python科学计算库,它提供了一个强大的多维数组对象(例如数组和矩阵)以及用于处理这些数组的各种函数。NumPy的核心是ndarray(N-dimensional array)对象,它是一个快速而灵活的大数据集容器。
以下是NumPy的一些主要特点和功能:
1. **多维数组对象**:NumPy提供了ndarray对象,可以存储多维数组,这些数组可以是一维、二维甚至更高维。
2. **广播功能**:NumPy支持广播功能,使得在不同形状的数组上进行数学运算变得更加方便和高效。
3. **数学函数**:NumPy包含许多内置的数学函数,用于数组的操作,如求和、平均值、最小值、最大值、标准差等。
4. **线性代数运算**:NumPy提供了丰富的线性代数函数库,包括矩阵乘法、求逆、特征值等。
5. **随机数生成**:NumPy有强大的随机数生成功能,可以用于模拟和生成随机数据。
6. **索引和切片**:NumPy提供了灵活的索引和切片功能,可以方便地访问数组中的元素。
7. **性能优化**:NumPy的底层实现是用C语言编写的,因此在处理大型数据集时具有很高的性能。
总的来说,NumPy是Python科学计算领域中不可或缺的工具之一,许多其他科学计算库(如SciPy、Pandas等)都是基于NumPy构建的。通过NumPy,用户可以高效地进行数据处理、数学计算、统计分析等操作。
import numpy as np
print(np.__version__)
查看numpy版本。
numpy的用法
生成数组
array()函数
用于生成数组。
函数格式
numpy.array(object, dtype=None, copy=True, order='K',subok=False, ndmin=0)
参数解释
-
列表或元组:最常见的用法是将Python的列表或元组作为参数传递给
numpy.array()
函数。这些列表或元组中的元素将会被转换为NumPy数组的元素。 -
dtype参数:dtype参数用于指定所创建数组的数据类型。例如,
dtype=np.float32
表示创建一个数据类型为单精度浮点数的数组。如果不指定dtype,则NumPy会根据输入数据自动推断数据类型。 -
ndmin参数:ndmin参数用于指定数组的最小维度。例如,
ndmin=2
表示至少创建一个二维数组。如果输入数据的维度小于ndmin指定的值,NumPy会自动添加轴来满足最小维度要求。 -
copy参数:copy参数默认为True,表示会复制输入的数据以避免原始数据被修改。如果设置为False,则创建的数组与输入数据共享相同的内存,对数组的操作可能会影响原始数据。
-
order参数:order参数用于指定创建数组时使用的内存布局。常用的取值有'C'和'F',分别表示按行(C顺序)和按列(Fortran顺序)存储。这个参数在处理多维数组时尤为重要。
-
subok参数:subok参数用于控制是否返回子类数组。如果subok为True,则返回一个子类数组,否则返回一个基类数组。这对于需要返回特定类型的数组对象时很有用。
arr1=np.array([1,2,3])
arr2=np.array([4,5,6])
print(arr1)
print(arr2)
np.asarray函数
该函数将python序列转换为数组。
函数结构
numpy.asarray(a, dtype = None, order = None)
参数及描述
1.a 任意形式的输入参数,比如列表、列表的元组、元组、元组的元组、元组的列表
2.dtype 通常,输入数据的类型会应用到返回的ndarray
3.order 'C'为按行的 C 风格数组,'F'为按列的 Fortran 风格数组
arange()函数
函数格式
arange(start, stop, step, dtype)
- start:序列的起始值,生成的数列从该值开始。
- stop:序列的结束值,生成的数列不包含该值,即在数列中不会出现等于stop的元素。
- step:两个相邻值之间的差值,也称为步长。step可以是正数、负数或零,控制数列中相邻元素之间的间隔。
- dtype:可选参数,指定所创建数组的数据类型。如果不指定dtype,则NumPy会根据输入参数自动推断数据类型。
arr3=np.arange(10)
print(arr3)
arr4=np.arange(1,10)
print(arr4)
arr5=np.arange(1,10,2)
print(arr5)
linspace()函数
函数的作用:在指定区间内生成指定个数的数组。
函数格式
linspace(start,stop,num)
start
:数列的起始值。stop
:数列的结束值。num
:生成的等差数列中包含的元素个数。
该函数的数据区间为闭区间。 endpoint=False,使生成数据区间变为左闭右开区间。
arr6=np.linspace(1,10,20)
print(arr6)
linspace(0, 10, 5, endpoint=False)
zeros()和ones()函数
np.zeros()函数生成的数组由0来填充,
np.ones()生成的数组由1来填。
arr7=np.zeros((3,4))
print(arr7)
arr8=np.ones((3,4))
print(arr8)
zeros_like和ones()函数
这两个函数需要借助别的数组进行操作,生成一个新的数组不对原来的数组进行修改。
arr9=np.ones_like(arr7)
print(arr9)
print(arr7)
数组的属性
np.ndim
返回int。表示数组的维数。
print(np.ndim(arr7))
结果是2
np.shape
返回tuple,表示数组的尺寸,对于n行m列的矩阵,形状为(n,m)
print(np.shape(arr7))
(3,4)
np.size
返回int,表示数组的元素总数,等于数组形状的乘积。
print(np.size(arr7))
12
np.dtype
函数结构
numpy.dtype(object, align, copy)
Object:被转换为数据类型的对象。
Align:如果为true,则向字段添加间隔,使其类似 C 的结构体。
Copy :生成dtype对象的新副本,如果为flase,结果是内建数据类型对象的引用。
可以使用 np.dtype
来指定数组的数据类型,或者通过已有数组的 dtype
属性来获取其数据类型
import numpy as np
# 指定数组的数据类型为整数
arr_int = np.array([1, 2, 3, 4], dtype=np.int32)
# 获取数组的数据类型
arr_float = np.array([1.1, 2.2, 3.3])
dtype_float = arr_float.dtype
print(arr_int)
print(dtype_float)
print(arr7.dtype)
float64
数据类型
数据类型及描述
1.bool_ 存储为一个字节的布尔值(真或假)
2.int_ 默认整数,相当于 C 的long,通常为int32或int64
3.intc 相当于 C 的int,通常为int32或int64
4.intp 用于索引的整数,相当于 C 的size_t,通常为int32或int64
5.int8 字节(-128 ~ 127)
6.int16 16 位整数(-32768 ~ 32767)
7.int32 32 位整数(-2147483648 ~ 2147483647)
8.int64 64 位整数(-9223372036854775808 ~ 9223372036854775807)
9.uint8 8 位无符号整数(0 ~ 255)
10.uint16 16 位无符号整数(0 ~ 65535)
11.uint32 32 位无符号整数(0 ~ 4294967295)
12.uint64 64 位无符号整数(0 ~ 18446744073709551615)
13.float_ float64的简写
14.float16 半精度浮点:符号位,5 位指数,10 位尾数
15.float32 单精度浮点:符号位,8 位指数,23 位尾数
16.float64 双精度浮点:符号位,11 位指数,52 位尾数
17.complex_ complex128的简写
18.complex64 复数,由两个 32 位浮点表示(实部和虚部)
19.complex128 复数,由两个 64 位浮点表示(实部和虚部)
np.itemsize
返回int。表示数组的每一个元素的大小。
print(arr7.itemsize)
8
np.reshape()
可以对原数组进行重构。但生成的是一个新的数组,原数组不变。
print(arr1.reshape(3,1))
print(arr1)
[[1]
[2]
[3]]
[1 2 3]
numpy.resize
该函数返回指定大小的新数组。如果新数组大于原数组大小,则包含原数组的重复副本
numpy.resize(arr, shape)
arr:要修改大小的输入数组
shape:返回数组的新形状
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.shape)
print(a)
b = np.resize(a,(3,2))
print(b)
c=np.resize(a,(3,3))
print(c)
(2, 3)
[[1 2 3]
[4 5 6]]
[[1 2]
[3 4]
[5 6]]
[[1 2 3]
[4 5 6]
[1 2 3]]
numpy.append()
该函数在输入数组的末尾添加值。
numpy.append(arr, values, axis)
arr:输入数组
values:要向arr添加的值,比如和arr形状相同(除了要添加的轴)
axis:沿着它完成操作的轴。如果没有提供,两个参数都会被展开,0是行,1是列。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.shape)
print(a)
b=np.append(a,[7,8,9])
print(b)
c=np.append(a,[[7,8,9]],axis=0)
print(c)
d=np.append(a,[[1,1,1],[2,2,2]],axis=1)
print(d)
(2, 3)
[[1 2 3]
[4 5 6]]
[1 2 3 4 5 6 7 8 9]
[[1 2 3]
[4 5 6]
[7 8 9]]
[[1 2 3 1 1 1]
[4 5 6 2 2 2]]
数组的运算
一维数组被称为向量,二维数组被称为矩阵。
np.sin(), np.cos(), np.tan(): 三角函数
# 数学函数示例
arr = np.array([0, np.pi/4, np.pi/2, 3*np.pi/4, np.pi])
sin_arr = np.sin(arr)
print(sin_arr) # 计算数组中每个元素的正弦值
np.exp(), np.log(), np.log10(): 指数和对数函数
np.sqrt(), np.power(): 平方根和幂函数
np.abs(): 绝对值函数
exp_value = np.exp(2) # 计算 e 的幂次方
log_value = np.log(10) # 计算自然对数
sqrt_value = np.sqrt(16) # 计算平方根
abs_value = np.abs(-5) # 计算绝对值
print(exp_value, log_value, sqrt_value, abs_value)
7.38905609893065 2.302585092994046 4.0 5
np.sum(), np.mean(), np.max(), np.min(): 求和、均值、最大值、最小值 矩阵操作:
data = np.array([1, 2, 3, 4, 5])
sum_value = np.sum(data)
mean_value = np.mean(data)
max_value = np.max(data)
min_value = np.min(data)
print(sum_value, mean_value, max_value, min_value)
15 3.0 5 1
np.dot(): 矩阵乘法
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
product = np.dot(matrix1, matrix2)
print(product) # 计算两个矩阵的乘积
[[19 22]
[43 50]]
np.transpose(), np.reshape(): 转置和改变数组形状
即将矩阵的行和列互换位置,得到的转置矩阵
transposed_matrix = np.transpose(matrix1)
reshaped_matrix = np.reshape(matrix1, (1, 4))
print(transposed_matrix, reshaped_matrix)
[[1 3]
[2 4]]
[[1 2 3 4]]
np.linalg.inv(), np.linalg.det(): 求逆矩阵和行列式
逆矩阵是指对于矩阵 A,存在一个矩阵 B,使得 A * B = B * A = I,其中 I 是单位矩阵。
行列式是一个与方阵相关的标量值,可以用来判断矩阵是否可逆以及计算变换的缩放比例等信息。对于 2x2 矩阵,行列式的计算方法为 ad - bc。
inv_matrix = np.linalg.inv(matrix1)
det_value = np.linalg.det(matrix1)
print(inv_matrix, det_value)
[[-2. 1. ]
[ 1.5 -0.5]]
-2.0000000000000004
np.logical_and(), np.logical_or(), np.logical_not(): 逻辑与、或、非
np.all(), np.any(): 全部为真和任意为真
bool_arr1 = np.array([True, False, True])
bool_arr2 = np.array([False, False, True])
result_and = np.logical_and(bool_arr1, bool_arr2)
result_or = np.logical_or(bool_arr1, bool_arr2)
result_not = np.logical_not(bool_arr1)
print(result_and, result_or, result_not)
[False False True] [ True False True] [False True False]
np.concatenate(), np.vstack(), np.hstack(): 数组拼接
np.split(), np.hsplit(), np.vsplit(): 数组分割
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6]])
concatenated = np.concatenate((arr1, arr2), axis=0)
split_array = np.split(arr1, 2)
print(concatenated, split_array)
[[1 2]
[3 4]
[5 6]]
[array([[1, 2]]), array([[3, 4]])]
1. `np.concatenate((arr1, arr2), axis=0)`:
- `arr1` 和 `arr2`:这是要连接的两个数组。
- `axis=0`:这是指定连接的轴方向。在这里,`axis=0` 表示沿着行的方向进行连接。如果 `axis=1`,则表示沿着列的方向进行连接。
2. `np.split(arr1, 2)`:
- `arr1`:这是要分割的数组。
- `2`:这是指定分割的位置或分割成几部分。在这里,`2` 表示将数组分割为两部分。如果想要分割成不同大小的部分,可以传递一个数组作为参数,其中包含分割点的索引。
广播
广播(broadcasting)是 NumPy 中一种强大的机制,它允许不同形状的数组在算术运算时表现得好像它们的形状相同。这样我们可以直接对数组进行运算,而不需要手动扩展数组的形状。广播的原则如下:
- 如果两个数组的维度不相同,那么小维度数组的形状会在最左边补1,直到形状一致。
- 如果两个数组的形状在任何维度上不匹配且不为1,那么会引发错误。
加法 # 创建一个二维数组 a = np.array([[1, 2, 3], [4, 5, 6]]) b = np.array([10, 20, 30]) # 对数组 a 和 b 进行加法运算(b会被自动扩展为与a相同的形状) result = a + b print(result) 乘法 A = np.array([[1, 2, 3], [4, 5, 6]]) B = np.array([[10, 20, 30]]) result = A * B print(result) [[11 22 33] [14 25 36]] [[ 10 40 90] [ 40 100 180]]
numpy切片
-
基本切片:
- 使用
:
分隔起始索引和结束索引,如array[start:end]
。 - 可以使用负数索引,表示从末尾开始计数。
- 使用
-
多维数组切片:
- 对于多维数组,可以使用逗号
,
分隔不同维度的切片。 - 例如,
array[start_row:end_row, start_col:end_col]
可以同时对行和列进行切片。
- 对于多维数组,可以使用逗号
-
步长切片:
- 使用
start:end:step
的形式,可以指定切片的步长。 - 例如,
array[::2]
表示从头到尾,步长为 2 进行切片。
- 使用
import numpy as np
# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 切片操作示例
print("原始数组:\n", arr)
# 获取第一行
print("第一行:", arr[0])
# 获取第一列
print("第一列:", arr[:, 0])
# 获取子矩阵:第一行到第二行,第一列到第二列
print("子矩阵:\n", arr[0:2, 0:2])
# 按步长切片
print("按步长切片:", arr[::2])
# 使用负数索引
print("负数索引切片:", arr[-2:, -2:])
原始数组:
[[1 2 3]
[4 5 6]
[7 8 9]]
第一行: [1 2 3]
第一列: [1 4 7]
子矩阵:
[[1 2]
[4 5]]
按步长切片: [[1 2 3]
[7 8 9]]
负数索引切片: [[5 6]
[8 9]]
numpy索引
-
基本索引:
- 使用整数索引来访问数组中的单个元素,如
array[index]
。 - 对于多维数组,可以使用逗号
,
分隔不同维度的索引。
- 使用整数索引来访问数组中的单个元素,如
-
切片索引:
- 使用切片操作来获取数组的子集,如
array[start:end]
。 - 可以针对单个维度或多个维度同时进行切片索引。
- 使用切片操作来获取数组的子集,如
-
布尔索引:
- 使用布尔数组作为索引,可以根据条件选择数组中的元素。
- 布尔数组的长度必须与原数组对应维度的长度相匹配。
import numpy as np
# 创建一个一维数组和二维数组
arr1d = np.array([1, 2, 3, 4, 5])
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 基本索引示例
print("一维数组第三个元素:", arr1d[2])
print("二维数组第二行第三列元素:", arr2d[1, 2])
# 切片索引示例
print("一维数组切片:", arr1d[1:4])
print("二维数组切片:\n", arr2d[:2, 1:])
# 布尔索引示例
mask = arr1d > 2
mask1 = arr2d > 2
print("一维数组大于2的元素:", arr1d[mask])
print("二维数组", arr2d[mask1])
一维数组第三个元素: 3
二维数组第二行第三列元素: 6
一维数组切片: [2 3 4]
二维数组切片:
[[2 3]
[5 6]]
一维数组大于2的元素: [3 4 5]
二维数组 [3 4 5 6 7 8 9]