Python NumPy 实例教程 [译]

# 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)

```

输出：

```

[[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]

----------

[[1 2 3]

[4 5 6]

[7 8 9]]

----------

```

------

### 多维索引

三维数组中的索引基于语法：`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]]]

```

------

### 一维数组切片

切片允许提取数组的部分或选择现有数组的子集以生成新数组。切片由方括号内的冒号（:)分隔数字序列。

例

```

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)

最后编辑于：2019.03.27 15:34:31

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 194,242评论 5赞 459
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 81,769评论 2赞 371
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 141,484评论 0赞 319
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 52,133评论 1赞 263
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 61,007评论 4赞 355
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 46,080评论 1赞 272
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 36,496评论 3赞 381
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 35,190评论 0赞 253
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 39,464评论 1赞 290
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 34,549评论 2赞 309
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 36,330评论 1赞 326
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 32,205评论 3赞 312
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 37,567评论 3赞 298
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 28,889评论 0赞 17
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,160评论 1赞 250
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 41,475评论 2赞 341
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 40,650评论 2赞 335

Python NumPy 实例教程 [译]

推荐阅读更多精彩内容