# Python NumPy 实例教程 [译]
*在本教程中，您将找到使用NumPy解决数值计算和科学计算问题的解决方案。*
NumPy（Numerical Python的缩写）是一个用于科学计算的开源Python库。
它提供了创建多维数组对象和执行更快的数学运算的能力，包含很多常用的数学方法，比如傅立叶变换（FT）和随机数发生器（RNG）之类的线性代数和复数运算的方法。
我们在Python数据分析中经常使用的类库，例如 **scikit-learn**， **SciPy** 和 **Pandas**都使用了NumPy的一些功能。
------
## 创建NumPy数组
要创建NumPy数组，我们需要将方括号内的元素值列表作为参数传递给`np.array()`方法。
三维数组是二维数组的矩阵。 也可以将三维数组称为列表的嵌套，其中每个元素也是元素列表。
例：
```
import numpy as np
array1d = np.array([1, 2, 3, 4, 5, 6])
array2d = np.array([[1, 2, 3], [4, 5, 6]])
array3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print(array1d)
print("-" * 10)
print(array2d)
print("-" * 10)
print(array3d)
```
输出：
```
[1 2 3 4 5 6]
----------
[[1 2 3]
[4 5 6]]
----------
[[[ 1 2 3]
[ 4 5 6]]
[[ 7 8 9]
[10 11 12]]]
```
NumPy中多维数组的主要数据结构是**ndarray**类。其基本属性如下所示：
| 属性 | 描述 |
| ------ | -------------------------------------- |
| Shape | 一个元组，表示数组每个维度的元素数量。 |
| Size | 数组中的元素总数。 |
| Ndim | 数组的维数。 |
| nbytes | 用于存储数据的字节数。 |
| dtype | 存储在数组中的元素的数据类型。 |
------
### NumPy支持的数据类型
`dtype`方法确定存储在NumPy数组中的元素的数据类型。您还可以使用`dtype`选项作为创建数组方法的参数，显式定义元素的数据类型。
| dtype | 变量 | 描述 |
| ---------- | ----------------------------------- | --------------------- |
| `int` | int8, int16, int32, int64 | 整型 |
| `uint` | uint8, uint16, uint32, uint64 | 无符号（非负）整数 |
| `bool` | Bool | 布尔值 (True或 False) |
| code>float | float16, float32, float64, float128 | 浮点数 |
| `complex` | complex64, complex128, complex256 | 复数 |
例：
```
import numpy as np
type1 = np.array([1, 2, 3, 4, 5, 6])
type2 = np.array([1.5, 2.5, 0.5, 6])
type3 = np.array(['a', 'b', 'c'])
type4 = np.array(["Canada", "Australia"], dtype='U5')
type5 = np.array([555, 666], dtype=float)
print(type1.dtype)
print(type2.dtype)
print(type3.dtype)
print(type4.dtype)
print(type5.dtype)
print(type4)
```
输出：
```
int32
float64
float64 ['Canad' 'Austr'] ``` ------ ### 数组的大小 `shape`方法以（m，n）的形式确定NumPy数组的大小，即（行数）x（列数）。 例： ``` import numpy as np array1d = np.array([1, 2, 3, 4, 5, 6]) array2d = np.array([[1, 2, 3], [4, 5, 6]]) array3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]) print(array1d.shape) print(array2d.shape) print(array3d.shape) ``` 输出： ``` (6,) (2, 3) (2, 2, 3) ``` ------ ### 数组的维度 `ndim`方法确定NumPy数组的维数。 例： ``` import numpy as np array1d = np.array([1, 2, 3, 4, 5, 6]) print(array1d.ndim) # 1 array2d = np.array([[1, 2, 3], [4, 5, 6]]) print(array2d.ndim) # 2 array3d = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]) array3d = array3d.reshape(2, 3, 2) print(array3d.ndim) # 3 ``` ------ ### 修改数组维度 `resize()`方法修改现有的维度大小和数组本身。 例： ``` import numpy as np thearray = np.array([1, 2, 3, 4, 5, 6, 7, 8]) thearray.resize(4) print(thearray) print("-" * 10) thearray = np.array([1, 2, 3, 4, 5, 6, 7, 8]) thearray.resize(2, 4) print(thearray) print("-" * 10) thearray = np.array([1, 2, 3, 4, 5, 6, 7, 8]) thearray.resize(3, 3) print(thearray) ``` 输出： ``` [1 2 3 4] ---------- [[1 2 3 4] [5 6 7 8]] ---------- [[1 2 3] [4 5 6] [7 8 0]] ``` ------ ### 修改数组维度 `reshape()`方法修改数组现有维度大小，但原始数组保持不变。 例： ``` import numpy as np thearray = np.array([1, 2, 3, 4, 5, 6, 7, 8]) thearray = thearray.reshape(2, 4) print(thearray) print("-" * 10) thearray = thearray.reshape(4, 2) print(thearray) print("-" * 10) thearray = thearray.reshape(8, 1) print(thearray) ``` 输出： ``` [[1 2 3 4] [5 6 7 8]] ---------- [[1 2] [3 4] [5 6] [7 8]] ---------- [[1] [2] [3] [4] [5] [6] [7] [8]] ``` ------ ### 将List或Tuple转换为NumPy数组 `array()`函数也可以接受列表，元组和其他**numpy.ndarray** 对象来创建新的数组对象。 例： ``` import numpy as np thelist = [1, 2, 3] print(type(thelist)) # array1 = np.array(thelist) print(type(array1)) # thetuple = ((1, 2, 3)) print(type(thetuple)) # array2 = np.array(thetuple) print(type(array2)) # array3 = np.array([thetuple, thelist, array1]) print(array3) ``` 输出： ``` [[1 2 3] [1 2 3] [1 2 3]] ``` ------ ## 用于创建数组的特殊NumPy函数 ### arange() `arange()`函数创建一个在指定开始值，结束值和增量值的具有均匀间隔的数组。 一般形式： `np.arange(起始值,结束值,增量)` 例： `reshape` 函数用于更改其维度： ``` import numpy as np array1d = np.arange(5) # 1 row and 5 columns print(array1d) array1d = np.arange(0, 12, 2) # 1 row and 6 columns print(array1d) array2d = np.arange(0, 12, 2).reshape(2, 3) # 2 rows 3 columns print(array2d) array3d = np.arange(9).reshape(3, 3) # 3 rows and columns print(array3d) ``` 输出： ``` [0 1 2 3 4] [ 0 2 4 6 8 10] [[ 0 2 4] [ 6 8 10]] [[0 1 2] [3 4 5] [6 7 8]] ``` ------ ### linspace() `linspace()`函数生成一个在指定的起始值和结束值之间指定元素数量，具有均匀间隔值的数组。 一般形式： `np.linspace(起始值,结束值,元素数)` 例： ``` import numpy as np array1d = np.linspace(1, 12, 2) print(array1d) array1d = np.linspace(1, 12, 4) print(array1d) array2d = np.linspace(1, 12, 12).reshape(4, 3) print(array2d) ``` 输出： ``` [ 1. 12.] [ 1. 4.66666667 8.33333333 12. ] [[ 1. 2. 3.] [ 4. 5. 6.] [ 7. 8. 9.] [10. 11. 12.]] ``` ------ ### logspace() `logspace()`函数生成一个在指定的起始值和结束值之间，以对数值间隔的数组。 例： ``` import numpy as np thearray = np.logspace(5, 10, num=10, base=10000000.0, dtype=float) print(thearray) ``` 输出： ``` [1.00000000e+35 7.74263683e+38 5.99484250e+42 4.64158883e+46 3.59381366e+50 2.78255940e+54 2.15443469e+58 1.66810054e+62 1.29154967e+66 1.00000000e+70] ``` ------ ### 0数组 The zeros() function, generates an array with the specified dimensions and data type that is filled with **zeros**. `zeros()`函数生成一个具有指定维度和数据类型的数组，该数组内容全部填充为**0**。 例： ``` import numpy as np array1d = np.zeros(3) print(array1d) array2d = np.zeros((2, 4)) print(array2d) ``` 输出： ``` [0. 0. 0.] [[0. 0. 0. 0.] [0. 0. 0. 0.]] ``` ------ ### 1数组 `ones()`函数生成一个具有指定维度和数据类型的数组，该数组内容全部填充为**1**。 例： ``` import numpy as np array1d = np.ones(3) print(array1d) array2d = np.ones((2, 4)) print(array2d) ``` 输出： ``` [1. 1. 1.] [[1. 1. 1. 1.] [1. 1. 1. 1.]] ``` ------ ### 填充数组 `full()` 函数生成一个具有指定维度和数据类型的数组，该数组内容全部填充为**指定值**。 例： ``` import numpy as np array1d = np.full((3), 2) print(array1d) array2d = np.full((2, 4), 3) print(array2d) ``` 输出： ``` [2 2 2] [[3 3 3 3] [3 3 3 3]] ``` ------ ### Eye数组 `eye()`函数返回一个数组，除了第k个对角线上元素值等于1，其它所有元素值均为0。 例： ``` import numpy as np array1 = np.eye(3, dtype=int) print(array1) array2 = np.eye(5, k=2) print(array2) ``` 输出： ``` [[1 0 0] [0 1 0] [0 0 1]] [[0. 0. 1. 0. 0.] [0. 0. 0. 1. 0.] [0. 0. 0. 0. 1.] [0. 0. 0. 0. 0.] [0. 0. 0. 0. 0.]] ``` ------ ### 随机数数组 `np.random.rand`方法生成一个随机数在0和1之间的数组。 `np.random.randn`方法生成一个随机数的数组，随机数为0或1。 `np.random.randint`方法生成一个数组，其随机数均匀分布在0和给定的整数之间。 例： ``` import numpy as np print(np.random.rand(3, 2)) # Uniformly distributed values. print(np.random.randn(3, 2)) # Normally distributed values. # Uniformly distributed integers in a given range. print(np.random.randint(2, size=10)) print(np.random.randint(5, size=(2, 4))) ``` 输出： ``` [[0.68428242 0.62467648] [0.28595395 0.96066372] [0.63394485 0.94036659]] [[0.29458704 0.84015551] [0.42001253 0.89660667] [0.50442113 0.46681958]] [0 1 1 0 0 0 0 1 0 0] [[3 3 2 3] [2 1 2 0]] ``` ------ ### 对角线数组 `identity()`函数生成主对角线上元素值为**1**的方形数组，而`diag()`函数提取或构造对角线数组。 例： ``` import numpy as np print(np.identity(3)) print(np.diag(np.arange(0, 8, 2))) print(np.diag(np.diag(np.arange(9).reshape((3,3))))) ``` 输出： ``` [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]] [[0 0 0 0] [0 2 0 0] [0 0 4 0] [0 0 0 6]] [[0 0 0] [0 4 0] [0 0 8]] ``` ------ ## NumPy数组的操作 ### 索引 NumPy在创建数组时创建相应的索引。 为了访问数组的单个或多个项，我们需要在方括号中传递索引。 二维数组中的索引由一对值表示，其中第一个值是行的索引，第二个值是列的索引。 例： ``` import numpy as np array1d = np.array([1, 2, 3, 4, 5, 6]) print(array1d[0]) # Get first value print(array1d[-1]) # Get last value print(array1d[3]) # Get 4th value from first print(array1d[-5]) # Get 5th value from last # Get multiple values print(array1d[[0, -1]]) print("-" * 10) array2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) print(array2d) print("-" * 10) print(array2d[0, 0]) # Get first row first col print(array2d[0, 1]) # Get first row second col print(array2d[0, 2]) # Get first row third col print(array2d[0, 1]) # Get first row second col print(array2d[1, 1]) # Get second row second col print(array2d[2, 1]) # Get third row second col ``` 输出： ``` 1 6 4 2 [1 6] ---------- [[1 2 3] [4 5 6] [7 8 9]] ---------- 1 2 3 2 5 8 ``` ------ ### 多维索引 三维数组中的索引基于语法：`array3d [L, M, N] ，其中L是第一个索引，M是行号， N是列号。` 例： ``` import numpy as np array3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]) print(array3d) print(array3d[0, 0, 0]) print(array3d[0, 0, 1]) print(array3d[0, 0, 2]) print(array3d[0, 1, 0]) print(array3d[0, 1, 1]) print(array3d[0, 1, 2]) print(array3d[1, 0, 0]) print(array3d[1, 0, 1]) print(array3d[1, 0, 2]) print(array3d[1, 1, 0]) print(array3d[1, 1, 1]) print(array3d[1, 1, 2]) ``` 输出： ``` [[[ 1 2 3] [ 4 5 6]] [[ 7 8 9] [10 11 12]]] 1 2 3 4 5 6 7 8 9 10 11 12 ``` ------ ### 一维数组切片 切片允许提取数组的部分或选择现有数组的子集以生成新数组。 切片由方括号内的冒号（:)分隔数字序列。 例 ``` import numpy as np array1d = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) print(array1d[4:]) # From index 4 to last index print(array1d[:4]) # From index 0 to 4 index print(array1d[4:7]) # From index 4(included) up to index 7(excluded) print(array1d[:-1]) # Excluded last element print(array1d[:-2]) # Up to second last index(negative index) print(array1d[::-1]) # From last to first in reverse order(negative step) print(array1d[::-2]) # All odd numbers in reversed order print(array1d[-2::-2]) # All even numbers in reversed order print(array1d[::]) # All elements ``` 输出： ``` [4 5 6 7 8 9] [0 1 2 3] [4 5 6] [0 1 2 3 4 5 6 7 8] [0 1 2 3 4 5 6 7] [9 8 7 6 5 4 3 2 1 0] [9 7 5 3 1] [8 6 4 2 0] [0 1 2 3 4 5 6 7 8 9] ``` ------ ### 多维数组切片 对于二维数组，使用相同的语法，但它的行和列是单独定义的。 例 ``` import numpy as np array2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) print("-" * 10) print(array2d[:, 0:2]) # 2nd and 3rd col print("-" * 10) print(array2d[1:3, 0:3]) # 2nd and 3rd row print("-" * 10) print(array2d[-1::-1, -1::-1]) # Reverse an array ``` 输出： ``` ---------- [[1 2] [4 5] [7 8]] ---------- [[4 5 6] [7 8 9]] ---------- [[9 8 7] [6 5 4] [3 2 1]] ``` ------ ## 操作数组的维度和大小 ### 转置和翻转 ndarray中也存在转置函数`transpose`，它可以置换数组的维度。**fliplr（左右翻转）**和**flipud（上下翻转）**函数执行类似于转置的操作，其输出数组的维度与输入相同。`fliplr`在左右方向上翻转矩阵数组。`flipud`在上下方向上翻转矩阵数组。`rot90`在轴指定的平面中将矩阵数组逆时针旋转90度。 例： ``` import numpy as np array2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) print(array2d) print("-" * 10) # Permute the dimensions of an array. arrayT = np.transpose(array2d) print(arrayT) print("-" * 10) # Flip array in the left/right direction. arrayFlr = np.fliplr(array2d) print(arrayFlr) print("-" * 10) # Flip array in the up/down direction. arrayFud = np.flipud(array2d) print(arrayFud) print("-" * 10) # Rotate an array by 90 degrees in the plane specified by axes. arrayRot90 = np.rot90(array2d) print(arrayRot90) ``` 输出： ``` [[1 2 3] [4 5 6] [7 8 9]] ---------- [[1 4 7] [2 5 8] [3 6 9]] ---------- [[3 2 1] [6 5 4] [9 8 7]] ---------- [[7 8 9] [4 5 6] [1 2 3]] ---------- [[3 6 9] [2 5 8] [1 4 7]] ``` ------ ### 拼接和堆叠 NumPy使用堆叠的概念并提供许多功能：垂直堆叠（行式）使用`vstack`，水平堆叠（列式）使用`hstack`，深度堆叠（沿第三轴）使用。`concatenate`函数通过沿给定轴追加数组来创建一个新数组。`append`函数将一个元素追加到数组并创建一个新的数组副本。 例： ``` import numpy as np array1 = np.array([[1, 2, 3], [4, 5, 6]]) array2 = np.array([[7, 8, 9], [10, 11, 12]]) # Stack arrays in sequence horizontally (column wise). arrayH = np.hstack((array1, array2)) print(arrayH) print("-" * 10) # Stack arrays in sequence vertically (row wise). arrayV = np.vstack((array1, array2)) print(arrayV) print("-" * 10) # Stack arrays in sequence depth wise (along third axis). arrayD = np.dstack((array1, array2)) print(arrayD) print("-" * 10) # Appending arrays after each other, along a given axis. arrayC = np.concatenate((array1, array2)) print(arrayC) print("-" * 10) # Append values to the end of an array. arrayA = np.append(array1, array2, axis=0) print(arrayA) print("-" * 10) arrayA = np.append(array1, array2, axis=1) print(arrayA) ``` 输出： ``` [[ 1 2 3 7 8 9] [ 4 5 6 10 11 12]] ---------- [[ 1 2 3] [ 4 5 6] [ 7 8 9] [10 11 12]] ---------- [[[ 1 7] [ 2 8] [ 3 9]] [[ 4 10] [ 5 11] [ 6 12]]] ---------- [[ 1 2 3] [ 4 5 6] [ 7 8 9] [10 11 12]] ---------- [[ 1 2 3] [ 4 5 6] [ 7 8 9] [10 11 12]] ---------- [[ 1 2 3 7 8 9] [ 4 5 6 10 11 12]] ``` ------ ## 代数运算 ### 算术运算 NumPy数组的算术运算是每个元素对应操作的，这意味着运算符仅应用于相应的元素之间。 例： ``` import numpy as np array1 = np.array([[1, 2, 3], [4, 5, 6]]) array2 = np.array([[7, 8, 9], [10, 11, 12]]) print(array1 + array2) print("-" * 20) print(array1 - array2) print("-" * 20) print(array1 * array2) print("-" * 20) print(array2 / array1) print("-" * 40) print(array1 ** array2) print("-" * 40) ``` 输出： ``` [[ 8 10 12] [14 16 18]] -------------------- [[-6 -6 -6] [-6 -6 -6]] -------------------- [[ 7 16 27] [40 55 72]] -------------------- [[7. 4. 3. ] [2.5 2.2 2. ]] ---------------------------------------- [[ 1 256 19683] [ 1048576 48828125 -2118184960]] ---------------------------------------- ``` ------ ### 标量算术运算 标量操作，标量值应用于数组中的每个元素。 例： ``` import numpy as np array1 = np.array([[10, 20, 30], [40, 50, 60]]) print(array1 + 2) print("-" * 20) print(array1 - 5) print("-" * 20) print(array1 * 2) print("-" * 20) print(array1 / 5) print("-" * 20) print(array1 ** 2) print("-" * 20) ``` 输出： ``` [[12 22 32] [42 52 62]] -------------------- [[ 5 15 25] [35 45 55]] -------------------- [[ 20 40 60] [ 80 100 120]] -------------------- [[ 2. 4. 6.] [ 8. 10. 12.]] -------------------- [[ 100 400 900] [1600 2500 3600]] -------------------- ``` ------ ### 初等数学函数 这些数学函数将任意维度的单个数组作为输入，并返回相同维度的新数组。 | 方法 | 描述 | | ---------------------------------------- | ---------------------- | | np.cos(), np.sin(), np.tan() | 三角函数 | | np.arccos(), np.arcsin(), np.arctan() | 反三角函数 | | np.cosh(), np.sinh(), np.tanh() | 双曲三角函数 | | np.arccosh(), np.arcsinh(), np.arctanh() | 反双曲三角函数 | | np.sqrt() | 平方根 | | np.exp() | 指数 | | np.log(), np.log2(), np.log10() | 基数为e，2和10的对数。 | 例： ``` import numpy as np array1 = np.array([[10, 20, 30], [40, 50, 60]]) print(np.sin(array1)) print("-" * 40) print(np.cos(array1)) print("-" * 40) print(np.tan(array1)) print("-" * 40) print(np.sqrt(array1)) print("-" * 40) print(np.exp(array1)) print("-" * 40) print(np.log10(array1)) print("-" * 40) ``` 输出： ``` [[-0.54402111 0.91294525 -0.98803162] [ 0.74511316 -0.26237485 -0.30481062]] ---------------------------------------- [[-0.83907153 0.40808206 0.15425145] [-0.66693806 0.96496603 -0.95241298]] ---------------------------------------- [[ 0.64836083 2.23716094 -6.4053312 ] [-1.11721493 -0.27190061 0.32004039]] ---------------------------------------- [[3.16227766 4.47213595 5.47722558] [6.32455532 7.07106781 7.74596669]] ---------------------------------------- [[2.20264658e+04 4.85165195e+08 1.06864746e+13] [2.35385267e+17 5.18470553e+21 1.14200739e+26]] ---------------------------------------- [[1. 1.30103 1.47712125] [1.60205999 1.69897 1.77815125]] ---------------------------------------- ``` ------ ### 元素数学运算 | 方法 | 描述 | | --------------------------------------------------- | -------------------------------------------------- | | np.add(), np.subtract(), np.multiply(), np.divide() | 数组元素的四则运算 | | np.power() | 第一个数组元素作为底数，求第二个数组中相应元素的幂 | | np.remainder() | 求输入数组中相应元素相除后的余数 | | np.reciprocal() | 求输入数组中相应元素的倒数 | | np.sign(), np.abs() | 返回数字符号（正负号）和绝对值。 | | np.floor(), np.ceil() | 返回向上取整值和向下取整值 | | np.round() | 四舍五入到给定精度的值（默认精度为0位） | 例： ``` import numpy as np array1 = np.array([[10, 20, 30], [40, 50, 60]]) array2 = np.array([[2, 3, 4], [4, 6, 8]]) array3 = np.array([[-2, 3.5, -4], [4.05, -6, 8]]) print(np.add(array1, array2)) print("-" * 40) print(np.power(array1, array2)) print("-" * 40) print(np.remainder((array2), 5)) print("-" * 40) print(np.reciprocal(array3)) print("-" * 40) print(np.sign(array3)) print("-" * 40) print(np.ceil(array3)) print("-" * 40) print(np.round(array3)) print("-" * 40) ``` 输出： ``` [[12 23 34] [44 56 68]] ---------------------------------------- [[ 100 8000 810000] [ 2560000 -1554869184 -1686044672]] ---------------------------------------- [[2 3 4] [4 1 3]] ---------------------------------------- [[-0.5 0.28571429 -0.25 ] [ 0.24691358 -0.16666667 0.125 ]] ---------------------------------------- [[-1. 1. -1.] [ 1. -1. 1.]] ---------------------------------------- [[-2. 4. -4.] [ 5. -6. 8.]] ---------------------------------------- [[-2. 4. -4.] [ 4. -6. 8.]] ---------------------------------------- ``` ------ ### 聚合和统计函数 | 方法 | 描述 | | ------------------------ | -------------------------------------- | | np.mean() | 计算沿指定轴的算术平均值。 | | np.std() | 计算沿指定轴的标准偏差。 | | np.var() | 计算沿指定轴的方差。 | | np.sum() | 给定轴上的数组元素的总和。 | | np.prod() | 返回给定轴上的数组元素的乘积。 | | np.cumsum() | 返回给定轴上元素的累积和。 | | np.cumprod() | 返回给定轴上元素的累积乘积。 | | np.min(), np.max() | 返回沿轴元素的最小值/最大值。 | | np.argmin(), np.argmax() | 返回沿轴元素最小值/最大值的索引。 | | np.all() | 测试沿给定轴的所有数组元素是否为True。 | | np.any() | 测试沿给定轴的任何数组元素是否为True。 | 例： ``` import numpy as np array1 = np.array([[10, 20, 30], [40, 50, 60]]) print("Mean: ", np.mean(array1)) print("Std: ", np.std(array1)) print("Var: ", np.var(array1)) print("Sum: ", np.sum(array1)) print("Prod: ", np.prod(array1)) ``` 输出： ``` Mean: 35.0 Std: 17.07825127659933 Var: 291.6666666666667 Sum: 210 Prod: 720000000 ``` ------ ## 常用的条件和逻辑表达式函数 ### 使用where()更新数组 `where()` 函数用于根据特定条件从数组中选择值。 例： ``` import numpy as np before = np.array([[1, 2, 3], [4, 5, 6]]) # If element is less than 4, mul by 2 else by 3 after = np.where(before < 4, before * 2, before * 3) print(after) ``` 输出： ``` [[ 2 4 6] [12 15 18]] ``` ------ ### 使用select()更新数组 `select()` 函数返回根据条件选中的元素组成的数组。 例： ``` import numpy as np before = np.array([[1, 2, 3], [4, 5, 6]]) # If element is less than 4, mul by 2 else by 3 after = np.select([before < 4, before], [before * 2, before * 3]) print(after) ``` 输出： ``` [[ 2 4 6] [12 15 18]] ``` ------ ### 使用choose()构造数组 从索引数组和一组数组中选择元素构造一个数组。 例： ``` import numpy as np before = np.array([[0, 1, 2], [2, 0, 1], [1, 2, 0]]) choices = [5, 10, 15] after = np.choose(before, choices) print(after) print("-" * 10) before = np.array([[0, 0, 0], [2, 2, 2], [1, 1, 1]]) choice1 = [5, 10, 15] choice2 = [8, 16, 24] choice3 = [9, 18, 27] after = np.choose(before, (choice1, choice2, choice3)) print(after) ``` 输出： ``` [[ 5 10 15] [15 5 10] [10 15 5]] ---------- [[ 5 10 15] [ 9 18 27] [ 8 16 24]] ``` ------ ### 逻辑运算 `logical_or(x1,x2)`函数按元素计算x1 OR x2的真值。`logical_and(x1,x2`)函数按元素计算x1 AND x2的真值。`logical_not(x)`函数按元素计算NOT x的真值。 例： ``` import numpy as np thearray = np.array([[10, 20, 30], [14, 24, 36]]) print(np.logical_or(thearray < 10, thearray > 15)) print("-" * 30) print(np.logical_and(thearray < 10, thearray > 15)) print("-" * 30) print(np.logical_not(thearray < 20)) print("-" * 30) ``` 输出： ``` [[False True True] [False True True]] ------------------------------ [[False False False] [False False False]] ------------------------------ [[False True True] [False True True]] ------------------------------ ``` ------ ## 标准集合运算 标准集合运算包括并集（属于两个输入数组中任意一个数组的元素），交集（同时属于两个输入数组的元素）和差（在数组1中而不在数组2中的元素），对应地由函数 `np.union1d()`，`np.intersect1d()`和`np.setdiff1d()`实现。 例： ``` import numpy as np array1 = np.array([[10, 20, 30], [14, 24, 36]]) array2 = np.array([[20, 40, 50], [24, 34, 46]]) # Find the union of two arrays. print(np.union1d(array1, array2)) # Find the intersection of two arrays. print(np.intersect1d(array1, array2)) # Find the set difference of two arrays. print(np.setdiff1d(array1, array2)) ``` 输出： ``` [10 14 20 24 30 34 36 40 46 50] [20 24] [10 14 30 36] ``` ## 小结 在本教程中，我们了解了**NumPy **库的几个主要方面，并熟悉了**NumPy**的N维数组数据结构和函数范围。我们看到，由于ndarray，我们可以扩展Python的功能，使其成为适合科学计算和数据分析的语言。 我们讨论了用于创建和操作数组的函数，包括用于从数组中提取元素的索引和切片函数。 因此，对于想要进行数据分析的人来说，了解**NumPy **至关重要。 ------ 原文：[numpy tutorial with examples and solutions](https://www.pythonprogramming.in/numpy-tutorial-with-examples-and-solutions.html)