# 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
<U1
<U5
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)) # <class 'list'>
array1 = np.array(thelist)
print(type(array1)) # <class 'numpy.ndarray'>
thetuple = ((1, 2, 3))
print(type(thetuple)) # <class 'tuple'>
array2 = np.array(thetuple)
print(type(array2)) # <class 'numpy.ndarray'>
array3 = np.array([thetuple, thelist, array1])
print(array3)
```
输出：
```
<class 'list'>
<class 'numpy.ndarray'>
<class 'tuple'>
<class 'numpy.ndarray'>
[[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)
网友评论