NumPy 库是 Numerical Python 的缩写，以及 ndarray 或数组的概念。这个模块是引入数据科学的基础。NumPy 包具有执行数据分析和科学计算所需的内置函数。
我们用于数据分析的所有其他包都是基于这个模块构建的。这就是为什么在开始使用 DataFrame 或数据分析之前，必须掌握这个 Python numpy ndarray 数组模块。
创建 Python NumPy ndarray
Numpy 模块有一个 ndarray 对象，是 N 维或数组的缩写。像任何其他编程语言一样，这个 Python Numpy ndarray 对象允许您存储多个相同数据类型的数组项。
以下是 Python numpy ndarray 模块创建数组的可用函数列表。
- array 函数：它帮助您创建数组对象或将数据从列表、元组或任何项序列（类似于 range）转换为 ndarray。
- asarray 方法：使用它将输入数据转换为 Python numpy ndarray 数组。但是，如果给定的输入已经是 ndarray，它将不会复制。
- zeros：创建指定形状和类型的全零数组。
- zeros_like：与 zeros 相同。但是，它需要另一个参数来获取形状和 dtype。
- ones：创建给定形状和数据类型的全一数组。
- ones_like：它接受另一个参数来读取其形状和数据类型。
- empty, empty_like：这些方法通过为其分配一些内存来创建一个空数组。
- arange：这会在给定范围内创建或返回一个元素数组。与 range 方法相同。
- eye, identity：创建方单位矩阵。
使用函数创建 Python NumPy ndarray 数组
如前所述，Numpy array 方法将给定列表、元组或任何序列进行转换。这是一个简单的创建示例。
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]) print(arr)
[1 2 3 4 5 6 7 8 9]从列表中创建 Python NumPy ndarray 数组
在这里，我们声明了一个包含从 1 到 5 的整数列表。接下来，我们使用模块中可用的 Python numpy array 函数来转换该列表。我们还创建了一个包含混合项的新列表。
a = [1, 2, 3, 4, 5] arr = np.array(a) print(arr) b = [2.5, 3.5, 7, 4.5, 8] arr2 = np.array(b) print(arr2)
[1 2 3 4 5]
[2.5 3.5 7. 4.5 8. ]让我从列表的列表中创建一个 ndarray。在这里，我们声明了一个包含整数值的嵌套列表。接下来，我们使用此方法将列表转换为数组。
a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print('List of List = ', a)
print()
arr = np.array(a)
print(arr)
来自列表的列表或嵌套列表的矩阵输出。
List of List = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
[[1 2 3]
[4 5 6]
[7 8 9]]您可能会想，既然它们看起来一样，为什么我们不使用列表呢？这些是为了执行矢量化操作。当您执行任何操作或使用任何方法时，该操作会应用于每个项。
我们将在接下来的主题中展示这些操作。但是，我们使用一个简单的例子来向您展示相同的内容。
a = [1, 2, 3, 4, 5]
arr = np.array(a)
print('Original = ', arr)
print('Add 5 = ', arr + 5)
print('Multiply arr with 2 = ', arr * 2)
ndarray 输出上的向量操作。
Original = [1 2 3 4 5]
Add 5 = [ 6 7 8 9 10]
Multiply arr with 2 = [ 2 4 6 8 10]从元组创建 Python NumPy ndarray 数组
您还可以从元组创建一维对象。
tup = (10, 20, 30) arr = np.array(tup) print(arr)
元组到一维输出
[10 20 30]Python NumPy ndarray 二维数组
将两个列表放在 [] 括号内或嵌套起来会创建一个二维矩阵。
two_arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]) print(two_arr)
2D 输出
[[ 1 2 3 4 5]
[ 6 7 8 9 10]]Python NumPy ndarray 三维数组
在这里，我们正在创建一个 3 * 3 矩阵，即多维或三维矩阵。
three_arr = np.array([[1, 2, 3], [10, 20, 30], [6, 7, 8]]) print(three_arr)
三维数组输出。
[[ 1 2 3]
[10 20 30]
[ 6 7 8]]使用 srange 创建 NumPy 数组
在此示例中，我们使用 arange 函数创建一个从 0 到 n-1 的数字数组，其中 n 是给定数字。例如，np.arange(5) 返回从 0 到 4 的序列数字。
np.arange(5) np.arange(10) np.arange(15)
用于创建输出的 srange 方法。添加打印
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]使用 linspace 的 Python NumPy ndarray 数组
在此示例中，我们使用 linspace 方法创建它。其语法如下：
np.linspace(start, end_value, steps)
在这里，我们创建了三个从 0 到 n 且以步长分隔的数字数组。例如，np.linspace(0, 1, 5) 返回从 0 到 1 的五等分数字。
print(np.linspace(0, 1, 5)) print(np.linspace(0, 10, 5)) print(np.linspace(0, 1, 7)) print(np.linspace(10, 100, 20))
linspace 方法输出
[0. 0.25 0.5 0.75 1. ]
[ 0. 2.5 5. 7.5 10. ]
[0. 0.16666667 0.33333333 0.5 0.66666667 0.83333333
1. ]
[ 10. 14.73684211 19.47368421 24.21052632 28.94736842
33.68421053 38.42105263 43.15789474 47.89473684 52.63157895
57.36842105 62.10526316 66.84210526 71.57894737 76.31578947
81.05263158 85.78947368 90.52631579 95.26315789 100. ]
除了该方法，NumPy 模块还有其他一些方法来创建它。它们是 zeros、ones 和 empty 方法。
Python NumPy ndarray 零数组
zeros 方法创建全零数组。它接受参数来指定形状。例如，
- zeros(2) 表示一个包含两个 0 元素的一维数组。
- zeros(2, 3) 表示一个 2 * 3 的全零矩阵。
- 和 (2, 2, 7) 表示一个三维的全零数组。
print(np.zeros(3)) print(np.zeros((2, 2))) print(np.zeros((2, 3))) print(np.zeros((4, 7))) print(np.zeros((3, 2, 7)))
[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. 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. 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.]]]NumPy ndarray 全一数组
ones 函数用于创建全一数组。该 ones 方法接受参数来指定其项的数量。例如，
- ones(4) 表示一个包含四个 1 的一维数组。
- ones(2, 4) 表示一个 2 * 4 的全一矩阵，ones(2, 3, 4) 表示一个 3D = 2 * 3 * 4 的全一数组。
print(np.ones(5)) print(np.ones((3, 3))) print(np.ones((3, 5))) print(np.ones((3, 2, 9)))
[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. 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. 1. 1. 1. 1. 1.]]
[[1. 1. 1. 1. 1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1. 1. 1. 1.]]]Python NumPy 随机数组
使用 random 函数创建随机数数组。请访问随机文章。
print(np.random.random(5)) print(np.random.random((4, 4))) print(np.random.random((2, 3, 4)))
[0.17481245, 0.20246847, 0.95714739, 0.93449316, 0.00816149]
[[0.19520415, 0.73605745, 0.27957035, 0.39129715],
[0.3622134 , 0.10631005, 0.29756787, 0.49672655],
[0.32448671, 0.53070647, 0.09666927, 0.9382703 ],
[0.77069343, 0.75228313, 0.65435786, 0.13130023]]
[[[0.13560378, 0.41655648, 0.60812992, 0.87341762],
[0.82085101, 0.02908754, 0.1446217 , 0.1984121 ],
[0.97777709, 0.95961773, 0.75990116, 0.87158335]],
[[0.88883459, 0.55730694, 0.45067219, 0.89653719],
[0.39533872, 0.63479585, 0.23116183, 0.56565847],
[0.25483409, 0.7929711 , 0.80572657, 0.19862024]]]Python NumPy ndarray 数组 empty 函数
empty 函数创建空数组。它不总是空的，它可能会加载垃圾值或零等。所以，不要惊讶！
np.empty(3) np.empty((2, 3)) np.empty((2, 4)) np.empty((2, 3, 5))
[3., 2., 1.]
[[4.33404091e-311, 1.97626258e-323, 1.20871698e-315],
[2.14187885e-296, 8.58539581e-210, 6.25613152e-309]]
[[-0.00000000e+000, 4.33404091e-311, 1.97626258e-323,
nan],
[ 1.20871698e-315, 2.14187885e-296, -8.58539581e-210,
6.25613152e-309]]
[[[-0.00000000e+000, -0.00000000e+000, -7.90505033e-323,
0.00000000e+000, 2.12199579e-314],
[ 0.00000000e+000, 0.00000000e+000, 0.00000000e+000,
1.77229088e-310, 3.50977866e+064],
[ 0.00000000e+000, 0.00000000e+000, nan,
nan, 3.50977942e+064]],
[[ 0.00000000e+000, -0.00000000e+000, -0.00000000e+000,
-3.95252517e-323, 0.00000000e+000],
[ 2.12199579e-314, 0.00000000e+000, 0.00000000e+000,
0.00000000e+000, 1.77229088e-310],
[ 3.50977866e+064, 0.00000000e+000, 0.00000000e+000,
nan, nan]]]ndarray 数组 full 函数
full 函数创建一个给定数字的数组。
# Returns one dimensional of 4’s of size 5 np.full((5), 4) # Returns 3 * matrix of number 9 np.full((3, 4), 9) np.full((4, 4), 8) np.full((2, 3, 6), 7)
[4, 4, 4, 4, 4]
[[9, 9, 9, 9],
[9, 9, 9, 9],
[9, 9, 9, 9]]
[[8, 8, 8, 8],
[8, 8, 8, 8],
[8, 8, 8, 8],
[8, 8, 8, 8]]
[[[7, 7, 7, 7, 7, 7],
[7, 7, 7, 7, 7, 7],
[7, 7, 7, 7, 7, 7]],
[[7, 7, 7, 7, 7, 7],
[7, 7, 7, 7, 7, 7],
[7, 7, 7, 7, 7, 7]]]Python NumPy ndarray 相同数组
eye 函数创建一个相同的 N * N 矩阵，其中 N 是给定的参数值。
print(np.eye(2)) print(np.eye(3)) print(np.eye(5))
[[1., 0.],
[0., 1.]]
[[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]]
[[1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 0., 0., 1.]]NumPy ndarray 对角线数组
diag 函数用于创建相同的数组，其中对角线值填充列表值。
np.diag([3]) np.diag([1, 2]) np.diag([1, 2, 3, 4]) np.diag([1, 2, 3, 4, 5, 6])
>>> np.diag([3])
[[3]]
>>> np.diag([1, 2])
[[1, 0],
[0, 2]]
>>> np.diag([1, 2, 3, 4])
[[1, 0, 0, 0],
[0, 2, 0, 0],
[0, 0, 3, 0],
[0, 0, 0, 4]]
>>> np.diag([1, 2, 3, 4, 5, 6])
[[1, 0, 0, 0, 0, 0],
[0, 2, 0, 0, 0, 0],
[0, 0, 3, 0, 0, 0],
[0, 0, 0, 4, 0, 0],
[0, 0, 0, 0, 5, 0],
[0, 0, 0, 0, 0, 6]]访问 Python NumPy ndarray 数组项
我们可以使用索引位置访问单个元素。索引位置总是从 0 开始，到 n-1 结束，其中 n 是大小、行大小、列大小或维度。访问一维数组中的项。
arr = np.array([10, 15, 25, 35, 45, 55, 65]) arr arr[0] arr[2] arr[5] arr[7] arr[2:5]
访问一维项的输出
>>> arr = np.array([10, 15, 25, 35, 45, 55, 65])
>>> arr
array([10, 15, 25, 35, 45, 55, 65])
>>> arr[0]
10
>>> arr[2]
25
>>> arr[5]
55
>>> arr[7]
Traceback (most recent call last):
File "<pyshell#165>", line 1, in <module>
arr[7]
IndexError: index 7 is out of bounds for axis 0 with size 7
>>> arr[2:5]
array([25, 35, 45])如您所见，倒数第二条语句抛出了一个错误（索引超出范围），因为 n-1 (7-1) 是我们拥有的最后一个索引值。我们使用了 arr[2:5]，它返回数组的一部分以供查看。这称为切片。
此示例展示了如何使用索引访问二维项。
arr = np.array([[1, 2, 3, 4, 5],[12, 15, 61, 11, 19]]) arr[0][1] arr[0][4] arr[1][1] arr[1][4]
访问项的输出
>>> import numpy as np
>>> arr = np.array([[1, 2, 3, 4, 5],[12, 15, 61, 11, 19]])
>>> arr
array([[ 1, 2, 3, 4, 5],
[12, 15, 61, 11, 19]])
>>> arr[0][1]
2
>>> arr[0][4]
5
>>> arr[1][1]
15
>>> arr[1][4]
19更改 Python NumPy ndarray 数组项
与访问元素一样，您可以使用索引位置更改一维和二维项。这是一个从一维数组访问项的示例。
a = np.array([10, 20, 30, 40, 50]) a a[0] = 150 a a[3] = 111 a b = np.array([[10, 50, 100], [250, 500, 1000]]) b b[0, 0] = 99 b b[1, 1] = 222 b b[1, 2] = 444 b
更改项的输出
Python NumPy ndarray 数组切片
首先，我们声明一个单一或一维数组并对其进行切片。切片接受起始和结束点的索引位置。其语法是 array_name[Start_position, end_position]。
起始和结束位置都具有默认值 0 和 n-1（最大长度）。例如，arr1[1:5] 表示从索引位置 1 开始，到位置 5 结束。arr1[:7] 从 0 开始，到索引位置 7 结束。
一维切片输出
>>> arr1 = np.array([10, 25, 50, 75, 100, 125, 150, 200, 250])
>>> arr1
[ 10, 25, 50, 75, 100, 125, 150, 200, 250]
>>> arr1[1:5]
[ 25, 50, 75, 100]
>>> arr1[2:7]
[ 50, 75, 100, 125, 150]
>>> arr1[4:8]
[100, 125, 150, 200]
>>> arr1[3:9]
[ 75, 100, 125, 150, 200, 250]
>>> arr1[3:]
([ 75, 100, 125, 150, 200, 250]
>>> arr1[:7]
[ 10, 25, 50, 75, 100, 125, 150]这次，我们声明了一个二维数组，并使用索引值对其进行了切片。
arr2 = np.array([[26, 48, 91, 57, 120], [33, 95, 68, 109, 155],
[111, 194, 7, 22, 124], [ 82, 119, 18, 156, 81],
[ 38, 10, 151, 24, 14]])
print(arr2)
print(arr2[:2, :2])
print(arr2[:3, :4])
print(arr2[:3, ])
print(arr2[:3])
print(arr2[:4])
print(arr2[:,:4])
切片输出
[[ 26 48 91 57 120]
[ 33 95 68 109 155]
[111 194 7 22 124]
[ 82 119 18 156 81]
[ 38 10 151 24 14]]
[[26 48]
[33 95]]
[[ 26 48 91 57]
[ 33 95 68 109]
[111 194 7 22]]
[[ 26 48 91 57 120]
[ 33 95 68 109 155]
[111 194 7 22 124]]
[[ 26 48 91 57 120]
[ 33 95 68 109 155]
[111 194 7 22 124]]
[[ 26 48 91 57 120]
[ 33 95 68 109 155]
[111 194 7 22 124]
[ 82 119 18 156 81]]
[[ 26 48 91 57]
[ 33 95 68 109]
[111 194 7 22]
[ 82 119 18 156]
[ 38 10 151 24]]使用负值切片 ndarray
从上面的例子来看，让我使用负值作为起始和结束位置。
>>> arr1 = np.array([10, 25, 50, 75, 100, 125, 150, 200, 250])
>>> arr2 = np.array([[26, 48, 91, 57, 120], [33, 95, 68, 109, 155],
[111, 194, 7, 22, 124], [ 82, 119, 18, 156, 81],
[ 38, 10, 151, 24, 14]])
>>> arr1[:3]
[10, 25, 50]
>>> arr1[:-4]
[ 10, 25, 50, 75, 100]
>>> arr1[-4:]
[125, 150, 200, 250]
>>> arr2[:-2, :-1]
[[ 26, 48, 91, 57],
[ 33, 95, 68, 109],
[111, 194, 7, 22]]
>>> arr2[:-3, :-1]
[[ 26, 48, 91, 57],
[ 33, 95, 68, 109]]
>>> arr2[:-3,]
[[ 26, 48, 91, 57, 120],
[ 33, 95, 68, 109, 155]]
>>> arr2[:,:-3]
[[ 26, 48],
[ 33, 95],
[111, 194],
[ 82, 119],
[ 38, 10]]
>>> arr2[:,:-2]
[[ 26, 48, 91],
[ 33, 95, 68],
[111, 194, 7],
[ 82, 119, 18],
[ 38, 10, 151]]反转 Python NumPy ndarray 数组
使用负索引值，您可以反转值的行和列位置，这称为 NumPy 数组反转。
arr1 = np.array([10, 50, 100, 150, 250])
arr2 = np.array([[26, 48, 91, 57, 120], [33, 95, 68, 109, 155],
[111, 194, 7, 22, 124], [ 82, 119, 18, 156, 81],
[ 38, 10, 151, 24, 14]])
print(arr1[::-1])
# Reverse the row position only
print(arr2[::-1,])
# Reverse both the row and column position
print(arr2[::-1, ::-1])
[250, 150, 100, 50, 10]
[[ 38, 10, 151, 24, 14],
[ 82, 119, 18, 156, 81],
[111, 194, 7, 22, 124],
[ 33, 95, 68, 109, 155],
[ 26, 48, 91, 57, 120]]
[[ 14, 24, 151, 10, 38],
[ 81, 156, 18, 119, 82],
[124, 22, 7, 194, 111],
[155, 109, 68, 95, 33],
[120, 57, 91, 48, 26]]从现有数组创建数组
此示例展示了如何从现有数组创建数组。为此，我们使用切片概念。使用切片技术创建输出
>>> arr1 = np.array([10, 50, 100, 150, 250])
>>> arr2 = np.array([[26, 48, 91, 57, 120], [33, 95, 68, 109, 155],
[111, 194, 7, 22, 124], [ 82, 119, 18, 156, 81],
[ 38, 10, 151, 24, 14]])
>>> arr3 = arr1[2:7]
>>> arr3
[100, 150, 250]
>>> arr4 = arr1[3:]
>>> arr4
[150, 250]
>>> arr5 = arr2[::-1,]
>>> arr5
[[ 38, 10, 151, 24, 14],
[ 82, 119, 18, 156, 81],
[111, 194, 7, 22, 124],
[ 33, 95, 68, 109, 155],
[ 26, 48, 91, 57, 120]]
>>> arr6 = arr2[::-1, ::-1]
>>> arr6
[[ 14, 24, 151, 10, 38],
[ 81, 156, 18, 119, 82],
[124, 22, 7, 194, 111],
[155, 109, 68, 95, 33],
[120, 57, 91, 48, 26]]Python NumPy ndarray 数组布尔索引
NumPy ndarray 对象中的数组布尔索引是一个需要注意的重要部分。您可以使用此布尔索引检查数组中的每个项是否满足条件。
首先，x = arr1 > 40 根据条件 (arr1 > 40) 返回布尔值 True 和 False。我的意思是，如果值大于 40，则为 True；否则为 False。接下来，arr1[x] 返回一个值大于 40 的序列数组。多维数组也适用。
arr1 = np.array([10, 20, 50, 90, 5, 40, 60, 30, 25])
x = arr1 > 40
print(arr1)
print(Bool index : ", x)
print(arr1[x])
y = arr1 < 40
print("\nBool index : ", y)
print(arr1[y])
arr2 = np.array(np.random.randint(1, 10, size = (3, 8)))
z = arr2 > 4
print("\n-----Arr2------\n", arr2)
print("------Bool index------\n", z)
print("------Arr2 of Z------\n", arr2[z])
[10 20 50 90 5 40 60 30 25]
Bool index : [False False True True False False True False False]
[50 90 60]
Bool index : [ True True False False True False False True True]
[10 20 5 30 25]
----- Arr2 ------
[[3 1 5 9 9 8 9 9]
[7 8 8 6 6 7 5 3]
[8 8 2 6 8 2 2 8]]
------ Bool index ------
[[False False True True True True True True]
[ True True True True True True True False]
[ True True False True True False False True]]
------ Arr2 of Z ------
[5 9 9 8 9 9 7 8 8 6 6 7 5 8 8 6 8 8]替换 Python NumPy ndarray 数组中的无穷大和 NaN 值
在 ndarray 中用精确的数字或值替换“非数字”和“无穷大”值。在这里，我们声明了具有随机值的一维和二维数组。接下来，我们将无穷大和 NaN 替换为 11.56 和 29.16。
arr1 = np.array([10, 20, 50, 90, 5, 40, 60, 30, 25], dtype = 'float')
print(arr1)
arr1[2] = np.nan
arr1[4] = np.inf
print(arr1)
# Replace inf and nan With 11.56
x = np.isinf(arr1) | np.isnan(arr1)
arr1[x] = 11.56
print(arr1)
arr2 = np.array( [[9, 7, np.nan, 8, np.inf],
[np.nan, 3, 7, np.inf, 5],
[8, np.inf, 4, np.nan, 1]],
dtype = 'float')
print("\n-----------\n")
print( arr2)
# Replace inf and nan in arr2 With 29.16
y = np.isinf(arr2) | np.isnan(arr2)
arr2[y] = 29.16
print("\n-----------\n")
print(arr2)
替换 NaN 和无穷大值的输出
[10. 20. 50. 90. 5. 40. 60. 30. 25.]
[10. 20. nan 90. inf 40. 60. 30. 25.]
[10. 20. 11.56 90. 11.56 40. 60. 30. 25. ]
-----------
[[ 9. 7. nan 8. inf]
[nan 3. 7. inf 5.]
[ 8. inf 4. nan 1.]]
------------
[[ 9. 7. 29.16 8. 29.16]
[29.16 3. 7. 29.16 5. ]
[ 8. 29.16 4. 29.16 1. ]]Python NumPy ndarray 数组上的算术运算
它允许您使用算术运算符对一维、二维和多维数组执行算术运算。此示例展示了如何在 1D、2D 和多维数组上执行加、减和乘运算。
arr = np.array([10, 15, 25, 35, 45, 55, 65]) print(arr) print(arr + 4) print(arr - 8) print(arr * 3) two = np.array([[1, 2, 3, 4, 5],[12, 15, 61, 11, 19]]) print(two) print(two + 10) print(two - 3) print(two * 2) three = np.array([[1, 2, 3], [10, 20, 30], [6, 7, 8]]) print(three + 2) print(three - 5) print(three * 5)
[10 15 25 35 45 55 65]
[14 19 29 39 49 59 69]
[ 2 7 17 27 37 47 57]
[ 30 45 75 105 135 165 195]
[[ 1 2 3 4 5]
[12 15 61 11 19]]
[[11 12 13 14 15]
[22 25 71 21 29]]
[[-2 -1 0 1 2]
[ 9 12 58 8 16]]
[[ 2 4 6 8 10]
[ 24 30 122 22 38]]
[[ 3 4 5]
[12 22 32]
[ 8 9 10]]
[[-4 -3 -2]
[ 5 15 25]
[ 1 2 3]]
[[ 5 10 15]
[ 50 100 150]
[ 30 35 40]]Python NumPy ndarray 数组对象
以下属性有助于查找有关数组的信息。
- ndim 属性：返回维度。如果是一维，则为 1；二维为 2，以此类推。
- size：它显示或返回元素或项的数量。
- flags：有关内存布局的信息。
- itemsize：以字节为单位的长度。
- nbytes：它消耗的总字节数。
以下 ndarray 数组示例显示了相同的内容。
a = np.array([10, 50, 100, 150, 250])
b = np.array([[26, 48, 91, 57, 120], [33, 95, 68, 109, 155],
[111, 194, 7, 22, 124], [ 82, 119, 18, 156, 81],
[38, 10, 151, 24, 14]])
print('Dimension = ', a.ndim)
print('No of Elements = ', a.size)
print('Memory Layout = ', a.flags)
print('Length in Bytes = ', a.itemsize)
print('Total bytes consumed = ', a.nbytes)
print('\nDimension = ', b.ndim)
print('No of Elements = ', b.size)
print('Memory Layout = ', b.flags)
print('Length in Bytes = ', b.itemsize)
print('Total bytes consumed = ', b.nbytes)
Dimension = 1
No of Elements = 5
Memory Layout = C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False
Length in Bytes = 8
Total bytes consumed = 40
Dimension = 2
No of Elements = 25
Memory Layout = C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False
Length in Bytes = 8
Total bytes consumed = 200Python NumPy ndarray 数组形状
ndarray shape 对象有助于精确显示数组形状和维度。
- 如果是一维的，它将返回项的数量。
- 如果是 2D，它会返回行和列。通常，它会为我们创建的数组分配一个适当的数据类型。但是，array 函数也允许您使用 dtype 显式指定数据类型。使用此 dtype 对象，您可以查看隐式分配的数据类型，也可以显式分配自己的类型。
在此示例中，我们创建了一维、二维和三维数组。接下来，我们使用此 shape 对象返回它们的矩阵形状。
arr1 = np.array([10, 50, 100, 150, 250])
arr2 = np.array([[26, 48, 91, 57, 120], [33, 95, 68, 109, 155],
[111, 194, 7, 22, 124], [ 82, 119, 18, 156, 81],
[ 38, 10, 151, 24, 14]])
arr3 = np.array([[12, 11, 0, 9, 7], [10, 4, 11, 6, 9],
[9, 2, 10, 9, 11], [ 5, 14, 0, 11, 8]])
print("Arr 1. : ", arr1)
print("Arr 1 Shape : ", arr1.shape)
print("Arr 2 : \n", arr2)
print("Arr 2 Sp : ", arr2.shape)
print("Arr 3 : \n", arr3)
print("Arr 3 Sp : ", arr3.shape)
Arr 1. : [ 10 50 100 150 250]
Arr 1 Shape : (5,)
Arr 2 :
[[ 26 48 91 57 120]
[ 33 95 68 109 155]
[111 194 7 22 124]
[ 82 119 18 156 81]
[ 38 10 151 24 14]]
Arr 2 Sp : (5, 5)
Arr 3 :
[[12 11 0 9 7]
[10 4 11 6 9]
[ 9 2 10 9 11]
[ 5 14 0 11 8]]
Arr 3 Sp : (4, 5)Python NumPy ndarray 数组 dtype
通常，它会分配我们创建的适当数据类型。但是，此函数也允许您使用 dtype 显式指定数组的数据类型。使用此 dtype，您可以查看隐式分配给它的数据类型，也可以显式分配自己的数据类型。
可用于创建 ndarray 的数据类型列表。
| 数据类型 | 描述 | 代码 |
|---|---|---|
| int8 | 有符号 8 位整数类型 | i1 |
| uint8 | 无符号 8 位整数类型 | u1 |
| int16, uint16 | 有符号和无符号 16 位整数类型 | i2, u2 |
| int32, uint32 | 有符号和无符号 32 位整数类型 | i4, u4 |
| int64, uint64 | 有符号和无符号 64 位整数类型 | i8, u8 |
| float16 | 半精度浮点数 | f2 |
| float32 | 单精度浮点数 | f4 或 f |
| float64 | 双精度浮点数 | f8 或 d |
| float128 | 扩展精度浮点数 | f16 或 g |
| complex64, complex128, complex256 | 由 32、64、128 等表示的复数 | c8, c16, c32 |
| bool | 布尔真或假类型 | ? |
| object | 对象类型 | O |
| string_ | 字符串类型。您必须指定字符串长度（字符数）。例如，5 个字符表示 S5 | S |
| unicode_ | Unicode 类型。您必须指定字节数。例如，10 表示 U10。 | U |
在此示例中，我们创建了两个 ndarray。首先，我们创建了一个整数数组和混合值（浮点数和整数）数组。最后，我们使用 dtype 属性查找它们的数据类型。
arr1 = np.array([10, 20, 30, 40, 50])
print("Arr : ", arr1)
print("Type : ", arr1.dtype)
arr2 = np.array([1, 3.10, 4.60, 5, 7.96])
print("\nArr : ", arr2)
print("Type : ", arr2.dtype)
Arr : [10 20 30 40 50]
Type : int64
Arr : [1. 3.1 4.6 5. 7.96]
Type : float64NumPy dtype 属性并非用于查找数组数据类型。我们可以使用此属性创建我们自己的数据类型的 ndarray。
list1 = [10, 20, 30, 40, 50]
arr1 = np.array(list1, dtype = 'int')
print("Arr : ", arr1)
print("Type : ", arr1.dtype)
arr2 = np.array(list1, dtype = 'float')
print("Arr2 : ", arr2)
print("Type : ", arr2.dtype)
arr3 = np.array(list1, dtype = 'float16')
print("Arr3 : ", arr3)
print("Type : ", arr3.dtype)
Arr : [10 20 30 40 50]
Type : int64
Arr2 : [10. 20. 30. 40. 50.]
Type : float64
Arr3 : [10. 20. 30. 40. 50.]
Type : float16更多使用 dtype 创建我们自己的数据类型数组的示例
list1 = [1, 20, 0, 40, 0]
arr1 = np.array(list1, dtype = 'S')
print("Arr1 : ", arr1)
print("Arr1Type : ", arr1.dtype)
arr2 = np.array(list1, dtype = 'bool')
print("Arr2 : ", arr2)
print("Arr2 Type : ", arr2.dtype)
arr3 = np.array([1, 10, 'e', 'o', 9, 'Hi', 7], dtype = 'object')
print("Arr3 : ", arr3)
print("Arr3 Type : ", arr3.dtype)
dtype 属性输出
Arr1 : [b'1' b'20' b'0' b'40' b'0']
Arr1 Type : |S2
Arr2 : [ True True False True False]
Arr2 Type : bool
Arr3 : [1 10 'e' 'o' 9 'Hi' 7]
Arr3 Type : objectreshape 方法
Python NumPy ndarray 数组的 reshape 函数有助于根据您的要求重塑或更改大小。在这里，我们首先将一维数组更改为二维数组。接下来，我们将形状更改为 4 * 3 和 2 * 6。
arr1 = np.array([10, 20, 30, 40, 50, 60, 70, 80])
print("Arr : ", arr1)
x = arr1.reshape(2, 4)
print("------New Array 2 * 4------\n", x)
y = arr1.reshape(4, 2)
print("------New 4 * 2------\n", y)
arr2 = np.array( np.random.randint(1, 9, size = (3, 4)))
print("-----Arr2------\n", arr2)
a = arr2.reshape(4, 3)
print("------New Arr2 4 * 3------\n", a)
b = arr2.reshape(2, 6)
print("------New Arr2 2 * 6------\n", b)
Arr : [10 20 30 40 50 60 70 80]
------New Array 2 * 4------
[[10 20 30 40]
[50 60 70 80]]
------New 4 * 2------
[[10 20]
[30 40]
[50 60]
[70 80]]
-----Arr2------
[[6 2 5 5]
[8 6 2 1]
[4 3 1 8]]
------New Arr2 4 * 3------
[[6 2 5]
[5 8 6]
[2 1 4]
[3 1 8]]
------New Arr2 2 * 6------
[[6 2 5 5 8 6]
[2 1 4 3 1 8]]Python NumPy ndarray 数组的 flatten 和 ravel
flatten 和 ravel 方法都将任何大小的数组展平或转换为一维数组。虽然两者相同，但 ravel 保留了实际数组的引用。这意味着对 ravel 输出所做的任何更改也会反映在原始数组中。然而，这与 flatten 不同。
arr1 = np.array(np.random.randint(1, 20, size = (3, 6)))
print("-----Arr------\n", arr1)
x = arr1.flatten()
print("------flatten------\n", x)
y = arr1.ravel()
print("------ravel------\n", y)
arr2 = np.array(np.random.randint(10, 30, size = (2, 3, 4)))
print("-----2nd------\n", arr2)
a = arr2.flatten()
print("------flatten 2------\n", a)
b = arr2.ravel()
print("------ravel 2------\n", b)
flatten 和 ravel 方法输出
如何在 Python NumPy ndarray 数组中查找唯一项？
此模块有一个 unique 方法，用于从给定的一维、二维和三维或多维数组中查找并返回唯一值。
arr = np.random.randint(0, 5, size = 10)
print('Original = ', arr)
uniq = np.unique(arr)
print('Unique Items = ', uniq)
arr2 = np.random.randint(10, 100, size = (3, 5))
print('\n---2D Rand Original ----\n', arr2)
uniq2 = np.unique(arr2)
print('Unique Items = ', uniq2)
arr3 = np.random.randint(15, 25, size = (2, 3, 8))
print('\n----Three Dimensional Rand Original ----\n', arr3)
uniq3 = np.unique(arr3)
print('Unique Items = ', uniq3)
Original = [0 3 4 3 0 4 4 0 0 0]
Unique Items = [0 3 4]
---2D Rand Original ----
[[73 98 42 59 96]
[97 86 20 69 52]
[91 98 76 48 41]]
Unique Items = [20 41 42 48 52 59 69 73 76 86 91 96 97 98]
----Three Dimensional Rand Original ----
[[[19 21 19 24 19 15 20 20]
[24 20 19 19 21 21 16 17]
[22 23 23 16 23 20 18 17]]
[[24 23 23 21 18 19 17 21]
[15 21 22 18 16 17 24 23]
[17 15 21 19 20 15 15 15]]]
Unique Items = [15 16 17 18 19 20 21 22 23 24]统计唯一项
统计数组中每个项重复的总次数。为此，您必须使用带有 `return_counts` 参数的 `unique` 方法。如果我们将此参数值设置为 True，则它会统计项。
arr = np.random.randint(0, 5, size = 10)
print('Original = ', arr)
uniq, cnt = np.unique(arr, return_counts = True)
print('Unique Items = ', uniq)
print('Count Items = ', cnt)
arr2 = np.random.randint(10, 100, size = (3, 5))
print('\n---2D Random Original ----\n', arr2)
uniq2, cnt2 = np.unique(arr2, return_counts = True)
print('Unique Items = ', uniq2)
print('Count Items = ', cnt2)
arr3 = np.random.randint(15, 25, size = (2, 3, 8))
print('\n----Three Dimensional Random Original ----\n', arr3)
uniq3, cnt3 = np.unique(arr3, return_counts = True)
print('Unique Items = ', uniq3)
print('Count Items = ', cnt3)
Original = [0 1 1 0 2 4 2 3 4 0]
Unique Items = [0 1 2 3 4]
Count Items = [3 2 2 1 2]
---2D Random Original----
[[47 25 28 61 23]
[78 15 75 77 98]
[31 58 94 99 15]]
Unique Items = [15 23 25 28 31 47 58 61 75 77 78 94 98 99]
Count Items = [2 1 1 1 1 1 1 1 1 1 1 1 1 1]
----Three Dimensional Random Original ----
[[[17 16 18 20 18 24 20 22]
[24 22 17 17 19 18 18 21]
[15 19 19 18 16 24 19 21]]
[[24 16 16 24 24 16 19 19]
[17 15 17 15 15 17 23 20]
[22 15 24 16 21 22 24 22]]]
Unique Items = [15 16 17 18 19 20 21 22 23 24]
Count Items = [5 6 6 5 6 3 3 5 1 8]Python NumPy ndarray 数组转置
在 Python 中，我们有 T 和 transpose 函数来转置矩阵或数组。转置意味着行转换为列，列转换为行。
import numpy as np
a = np.array([[26, 48, 91, 57, 120], [33, 95, 68, 109, 155],
[111, 194, 7, 22, 124], [ 82, 119, 18, 156, 81],
[ 38, 10, 151, 24, 14]])
b = np.array([[12, 11, 0, 9, 7], [10, 4, 11, 6, 9],
[ 9, 2, 10, 9, 11], [ 5, 14, 0, 11, 8]])
print('Original')
print(a)
print('\nTransposed ')
print(a.T)
print('\nOriginal')
print(b)
print('\nTransposed')
print(np.transpose(b))
Original
[[ 26 48 91 57 120]
[ 33 95 68 109 155]
[111 194 7 22 124]
[ 82 119 18 156 81]
[ 38 10 151 24 14]]
Transposed
[[ 26 33 111 82 38]
[ 48 95 194 119 10]
[ 91 68 7 18 151]
[ 57 109 22 156 24]
[120 155 124 81 14]]
Original
[[12 11 0 9 7]
[10 4 11 6 9]
[ 9 2 10 9 11]
[ 5 14 0 11 8]]
Transposed
[[12 10 9 5]
[11 4 2 14]
[ 0 11 10 0]
[ 9 6 9 11]
[ 7 9 11 8]]内置函数
Python NumPy 拥有许多内置的 ndarray 函数来处理数组。我们已经在常规教程中用示例解释了所有这些方法。
| 运算符 | 函数列表 |
|---|---|
| 算术运算符 | +, -, *, / |
| 算术方法 | add, subtract, multiply, divide, mod, remainder |
| 聚合 | sum, average, prod, min, max, maximum, minimum, mean, median, var, std, cumsum, cumprod, percentile, argmin, argmax, corrcoef |
| 位运算符 | &, |, ~, ^, left_shift, right_shift |
| 位运算方法 | bitwise_and, bitwise_or, bitwise_not, bitwise_xor |
| 比较运算符 | <, <=, ==, <, >=, != |
| 比较方法 | equal, less, less_equal, greater, greater_equal, not_equal |
| 逻辑运算符 | and, or, not |
| 逻辑方法 | logical_and, logical_or, logical_not, logical_xor |
| 指数 | exp, exp2, expm1, log, log2, log10, log1p, logspace |
| 数学 | 数学方法列表：abs, ceil, floor, mod, modf, round, sinc, sign, trunc, square, reciprocal, power, sqrt, cbrt |
| 字符串函数 | add, multiply, capitalize, title upper, lower, center, split, splitlines, strip, join, replace, encode, and decode。 |
| 三角函数 | sin, cos, tan, arcsin, arccos, arctan, arctan2, radians, degrees, hypot, deg2rad, rad2deg, unwrap |
| 双曲函数 | sinh, acsinh, cosh, arccosh, tanh, atctanh |
| 谓词 | isfinite, isinf, isnan, signbit, digitize, tile |