白乐天

道阻且长，行则将至。

Numpy

发表于 更新于 分类于
本文字数： 6.6k 阅读时长 ≈ 6 分钟

安装模块

1
pip install numpy

创建数组

array()

1
numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

  • object: 必需。输入数据，例如列表、元组、嵌套列表等。

  • dtype: 数据类型（如 int, float, complex 等）。默认为自动推断。

  • copy: 是否复制输入数据，默认为 True。

  • order: 内存存储顺序：

    • 'C'：按行优先（C-style，默认）。

    • 'F'：按列优先（Fortran-style）。

  • subok: 如果为 True，生成的数组会继承输入数据的子类，否则始终返回基础类 ndarray。

  • ndmin: 指定返回数组的最小维度。

1
2
3
4
5
6
7
import numpy as np
a = np.array([1,2,3,4])
print(type(a))
print(a)
>>>
<class 'numpy.ndarray'>
[1 2 3 4]
1
2
3
4
5
6
import numpy as np
b = np.array([[1, 2], [3, 4]])
print(b)
>>>
[[1 2]
 [3 4]]

shape

shape 是一个属性，用于返回数组的形状（即各维度的大小）。

它以元组的形式表示，元组中的每个值表示数组在该维度的大小。

1
2
3
4
5
import numpy as np
b = np.array([[1, 2], [3, 4]])
print(b.shape)
>>>
(2, 2)

arange()

arange() 函数用于生成一个指定范围内的等差数列数组。

1
numpy.arange([start, ]stop, [step, ]dtype=None)

  • start: 范围的起始值（可选）。默认是 0。

  • stop: 范围的结束值（不包括该值）。

  • step: 步长（可选）。默认为 1。可以是浮点数。

  • dtype: 返回数组的数据类型（可选）。默认会根据输入类型推断。

1
2
3
4
5
6
7
8
9
import numpy as np

# 从 0 到 9 的整数数组
a = np.arange(10)
print(a)  # 输出: [0 1 2 3 4 5 6 7 8 9]

# 从 1 到 9 的整数数组
b = np.arange(1, 10)
print(b)  # 输出: [1 2 3 4 5 6 7 8 9]
1
2
3
4
5
6
7
# 从 1 到 9，步长为 2
c = np.arange(1, 10, 2)
print(c)  # 输出: [1 3 5 7 9]

# 从 10 到 0，步长为 -2
d = np.arange(10, 0, -2)
print(d)  # 输出: [10 8 6 4 2]

random

numpy的random模块提供了多种功能，用于生成随机数和进行随机操作。

rand()

1
numpy.random.rand(d0, d1, ..., dn)

rand() 函数用于生成 [0, 1) 之间均匀分布的随机浮点数。它接受一个或多个整数参数，这些参数指定了输出数组的形状。

1
2
3
4
5
6
7
import numpy as np
a = np.random.rand(1,2,3)
print(a)

>>>
[[[0.10311541 0.37724536 0.0200087 ]
  [0.68078737 0.54724305 0.73788641]]]

random()

1
2
3
numpy.random.random(size=None)

size：指定输出数组的形状，可以是整数或元组。如果为 None，则返回一个标量。

random()函数用于生成 [0, 1) 之间的均匀分布随机数。它不接受维度参数，而是直接返回一个形状由参数决定的数组。

1
2
3
4
5
6
7
import numpy as np
a = np.random.random(size=(2,3))
print(a)

>>>
[[0.27557538 0.78651989 0.21555761]
 [0.07048964 0.05920274 0.36977286]]

randint()

1
numpy.random.randint(low, high=None, size=None, dtype=int)

  • low: 生成随机整数的下界（包含）。

  • high: 生成随机整数的上界（不包含）。如果未提供 high，则默认生成 0 到 low 的随机整数。

  • size: 输出数组的形状。如果是整数，返回一个该形状的数组；如果是元组，返回对应维度的数组。

  • dtype: 输出数组的数据类型，默认为 int。

1
2
3
# 生成一个长度为 5 的一维数组，值范围在 [10, 50) 之间
e = np.random.randint(10, 50, 5)
print(e)  # 输出类似: [28 31 11 45 39]

randn()

numpy.random.randn() 是一个用于生成标准正态分布（均值为 0，标准差为 1）的随机数的函数。与其他生成随机数的函数不同，randn() 生成的数值并不受指定范围的限制，而是符合标准正态分布。

1
numpy.random.randn(d0, d1, ..., dn)

d0, d1, ..., dn: 指定输出数组的形状。如果没有传入任何参数，则生成一个标量（单个值）。

normal()

numpy.random.normal() 是一个用于生成正态分布（高斯分布）随机数的函数。

1
numpy.random.normal(loc=0.0, scale=1.0, size=None)

  • loc: 正态分布的均值（默认为 0.0）。

  • scale: 正态分布的标准差（默认为 1.0）。标准差决定了数据的分布宽度。

  • size: 输出数组的形状。如果是单个整数，则生成一个具有该长度的一维数组；如果是元组，则生成一个形状为元组的多维数组。

copy()

copy() 函数用于创建数组的副本。

这是一个深拷贝操作，它会分配一个全新的内存空间，并复制原数组的所有数据。

1
numpy.ndarray.copy(order='C')

order: 决定数组在内存中的存储顺序（可选，默认值为 'C'）。

  • 'C': 按行存储（C 风格）。
  • 'F': 按列存储（Fortran 风格）。
  • 'A': 如果原数组是按行存储，则返回按行存储的副本；如果是按列存储，则返回按列存储的副本。
  • 'K': 尽可能保留原数组的存储顺序。

ndarray对象

ndarray 是 NumPy 中的核心对象，它是一个多维数组，能够高效地存储和操作同类型的数据。

属性

shape

数组的维度

ndim

数组的维度数

size

数组的元素总数

dtype

数组的元素类型

itemsize

数组中每个元素的大小，以字节为单位

方法

reshape()

通过 reshape方法，可以将一个数组转换成任意指定的形状，只要新形状与原数组的元素总数相同。

1
ndarray.reshape(shape, order='C')

  • shape: 指定新的形状，必须是一个整数元组，形状的各个维度大小的乘积需要与原数组的总元素数一致。

  • order: 表示读取和写入元素的顺序，默认是行优先（C 风格）。

    • 'C': 按行（C 风格）读取数据。

    • 'F': 按列（Fortran 风格）读取数据。

    • 'A': 如果数组存储在内存中是按行顺序，等同于 'C'；如果是按列顺序，等同于 'F'。

reshape 不会修改原数组，它返回的是一个新的数组。

1
2
3
4
5
6
7
8
9
10
11
import numpy as np

# 创建一维数组
arr = np.array([1, 2, 3, 4, 5, 6])

# 转换为二维数组
reshaped_arr = arr.reshape((2, 3))
print(reshaped_arr)
# 输出:
# [[1 2 3]
#  [4 5 6]]

ravel()

ravel() 方法用于将多维数组展平为一维数组。

1
ndarray.ravel(order='C')

order: 指定展平的顺序（可选，默认值为 'C'）。

  • 'C': 按行优先（C 风格）展平数据。
  • 'F': 按列优先（Fortran 风格）展平数据。
  • 'A': 如果数组是按行存储，等同于 'C'；如果是按列存储，等同于 'F'。
  • 'K': 尽可能保留原数组的存储顺序。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import numpy as np

# 创建二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])

# 展平数组
flattened_arr = arr.ravel()

print("Original Array:\n", arr)
# 输出:
# [[1 2 3]
#  [4 5 6]]

print("Flattened Array:", flattened_arr)
# 输出: Flattened Array: [1 2 3 4 5 6]

flatten()

flatten() 是一种将多维数组展平为一维数组的方法。

与 ravel() 不同，flatten() 总是返回数组的深拷贝，即它会创建一个全新的数组对象，因此对返回结果的修改不会影响原始数组。

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
import numpy as np

# 创建二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])

# 使用 ravel
ravel_arr = arr.ravel()
ravel_arr[0] = 99
print("Modified ravel Array:", ravel_arr)
# 输出: [99  2  3  4  5  6]
print("Original Array:\n", arr)  # 原数组被修改
# 输出:
# [[99  2  3]
#  [ 4  5  6]]

# 使用 flatten
flatten_arr = arr.flatten()
flatten_arr[0] = 88
print("Modified flatten Array:", flatten_arr)
# 输出: [88  2  3  4  5  6]
print("Original Array:\n", arr)  # 原数组未被修改
# 输出:
# [[99  2  3]
#  [ 4  5  6]]

切片和索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import numpy as np
arr = np.arange(1,10)
arr_r=arr.reshape(3,3)
print(arr_r)

for i in arr_r:
    print(i)

print(arr_r[1:3,1:3])

>>>
[[1 2 3]
 [4 5 6]
 [7 8 9]]

[1 2 3]
[4 5 6]
[7 8 9]

[[5 6]
 [8 9]]

数组的拼接

hstack()

np.hstack()是一个水平拼接（按列方向）函数。

它将多个数组沿水平方向（即列方向，axis=1）进行拼接，所有输入数组的行数（第一维大小）必须相同。

1
numpy.hstack((arr1, arr2, ...))

参数

**arr1, arr2, ...**：需要拼接的数组（可以是列表、元组或其他数组）。

  • 输入数组的行数必须相同。

返回值

  • 返回一个新数组，表示输入数组沿水平方向的拼接结果。
1
2
3
4
5
6
7
8
9
10
11
12
import numpy as np

# 定义两个二维数组
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])

# 水平拼接
result = np.hstack((arr1, arr2))
print(result)
# 输出:
# [[1 2 5 6]
#  [3 4 7 8]]

vstack()

np.vstack()用于垂直拼接（按行方向）的函数。

它将多个数组沿垂直方向（即行方向，axis=0）进行堆叠。所有输入数组的列数（第二维大小）必须相同。

1
numpy.vstack((arr1, arr2, ...))

参数

arr1, arr2, ...需要拼接的数组（可以是列表、元组或其他数组）。

  • 输入数组的列数必须相同。

返回值

  • 返回一个新数组，表示输入数组沿垂直方向堆叠的结果。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import numpy as np

# 定义两个二维数组
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7,8]])

# 垂直拼接
result = np.vstack((arr1, arr2))
print(result)
# 输出:
# [[1 2]
#  [3 4]
#  [5 6]
#  [7 8]]

concatenate()

np.concatenate()函数用于将多个数组沿指定轴（行或者列）进行拼接。它比 vstack 和 hstack 更加灵活，因为它可以拼接任意维度的数组，并且通过指定 axis 参数来决定拼接的方向。

1
numpy.concatenate((arr1, arr2, ...), axis=0, out=None)

参数

  • **arr1, arr2, ...**：要拼接的数组（可以是多个数组）。
  • **axis**：拼接的轴。默认为 0，表示沿行方向拼接。如果为 1，则表示沿列方向拼接。
  • **out**：可选参数，用于指定输出数组的存放位置。

返回值

  • 返回一个拼接后的新数组。
1
2
3
4
5
6
7
8
9
10
11
12
13
import numpy as np

arr1 = np.array([[1, 2], [3, 4]])  # 第一块数组
arr2 = np.array([[5, 6], [7, 8]])  # 第二块数组

result = np.concatenate((arr1, arr2), axis=0)
print(result)

>>>
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
1
2
3
4
5
6
7
8
9
10
11
import numpy as np

arr1 = np.array([[1, 2], [3, 4]])  # 第一块数组
arr2 = np.array([[5, 6], [7, 8]])  # 第二块数组

result = np.concatenate((arr1, arr2), axis=1)
print(result)

>>>
[[1 2 5 6]
 [3 4 7 8]]

数组的拆分

split()

np.split 是用于拆分数组的函数。

它将一个数组按照指定的分割点拆成多个子数组。

可以选择按照沿着哪个轴拆分数组，并指定拆分点的位置。

1
numpy.split(ary, indices_or_sections, axis=0)

参数

  • **ary**：要拆分的数组。
  • indices_or_sections：
    • 整数：表示将数组分成多少个部分。比如，3 就表示将数组均匀拆分成 3 个部分。
    • 数组：表示在指定的索引位置进行拆分。如果传入的是一个数组，数组中的每个元素就是一个拆分点。
  • **axis**：拆分的轴，默认为 0，即沿着行方向拆分。如果指定 axis=1，则表示沿着列方向拆分。

返回值

  • 返回一个列表，包含拆分后的多个子数组。

行方向拆分

1
2
3
4
5
6
7
8
9
import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

result = np.split(arr, 3, axis=0)
print(result)

>>>
[array([[1, 2, 3]]), array([[4, 5, 6]]), array([[7, 8, 9]])]

列方向拆分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

result = np.split(arr, 3, axis=1)
print(result)

>>>
[array([[1],
       [4],
       [7]]), array([[2],
       [5],
       [8]]), array([[3],
       [6],
       [9]])]

数组的转置

transpose()

np.transpose() 函数用于对数组进行转置操作。

1
2
3
4
5
6
7
8
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(np.transpose(arr))

>>>
[[1 4 7]
 [2 5 8]
 [3 6 9]]

算术运算

聚合函数