numpy基础入门笔记

发表于 更新于 分类于 ， Changyan： 本文字数： 5.7k 阅读时长 ≈ 21 分钟

NumPy（Numerical Python）是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure）结构要高效的多（该结构也可以用来表示矩阵），支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

NumPy简介

NumPy是高性能科学计算和数据分析的基础包。它是pandas等其他各种工具的基础

NumPy的主要功能:

  • ndarray，一个多维数组结构，高效且节省空间
  • 无需循环对整组数据进行快速运算的数学函数
  • 线性代数、随机数生成和傅里叶变换功能

安装方法: pip install numpy

引用方式:import numpy as np

为什么要用NumPy?

接下来以两个例子展开

例1: 已知若干家跨国公司的市值 (美元)，将其换算为人民币

1
2
3
4
5
# 假设美元和人民币的汇率为1:7
rate = 7
# 10家公司的市值(100-200之间的随机浮点数)，单位万美元
data = [random.uniform(100, 200) for i in range(10)]
print(data)

输出：

1
[171.96770574456394, 165.19652851118192, 170.14754586353678, 119.9430809003868, 133.97861172504264, 185.59669652773488, 106.10476295851282, 122.60180536636912, 112.58377342379032, 101.58694950879435]

这个换算比较简单，大家很容易想起来实现起来有很多方式：

  1. 使用列表生成式：
1
2
3
# 使用列表生成式换算为人民币
list_results = [i * rate for i in data]
print(list_results)

输出：

1
[1203.7739402119475, 1156.3756995782735, 1191.0328210447574, 839.6015663027076, 937.8502820752985, 1299.1768756941442, 742.7333407095898, 858.2126375645838, 788.0864139665323, 711.1086465615605]
  1. 使用map内置函数：
1
2
3
# 使用内置map函数换算人民币
map_results = list(map(lambda i: i * rate, data))
print(map_results)

输出：

1
[1203.7739402119475, 1156.3756995782735, 1191.0328210447574, 839.6015663027076, 937.8502820752985, 1299.1768756941442, 742.7333407095898, 858.2126375645838, 788.0864139665323, 711.1086465615605]
  1. 使用NumPy：
1
2
3
# 使用NumPy换算人民币
numpy_results = np.array(data)*rate
print(numpy_results)

输出：

1
2
[1203.77394021 1156.37569958 1191.03282104  839.6015663   937.85028208
 1299.17687569  742.73334071  858.21263756  788.08641397  711.10864656]

例2: 已知购物车中每件商品的价格与商品件数，求总金额。

1
2
3
4
5
6
# 存放每件商品价格
price = [random.uniform(10, 20) for i in range(10)]
print('商品单价：', price)
# 存放每件商品的数量
number = [random.randint(1, 10) for i in range(10)]
print('商品数量：', number)

输出：

1
2
商品单价： [14.640278047316102, 14.582306002988826, 12.152869983340928, 19.826851952147102, 19.50138343737435, 10.961565499666381, 11.019103257494821, 12.504565332885052, 13.72086651995783, 19.1802817021777]
商品数量： [3, 6, 3, 9, 2, 9, 10, 5, 2, 6]

  1. 使用列表生成式

    1
    2
    3
    4
    5
    # 计算每件商品的总价
    good = [price[i] * number[i] for i in range(10)]
    print('每件商品总价：', good)
    good_total = sum(good)
    print('所有商品总价：', good_total)

    输出：

    1
    2
    每件商品总价： [43.920834141948305, 87.49383601793295, 36.45860995002278, 178.44166756932393, 39.0027668747487, 98.65408949699743, 110.19103257494821, 62.52282666442526, 27.44173303991566, 115.08169021306621]
    所有商品总价： 799.2090865433294

  2. 使用NumPy

    1
    2
    3
    4
    5
    numpy_price, numpy_number = np.array(price), np.array(number)
    # 计算每件商品的总价
    numpy_good = numpy_price * numpy_number
    print('每件商品总价：', numpy_good)
    print('所有商品总价：', numpy_good.sum())

    输出：

    1
    2
    3
    每件商品总价： [ 43.92083414  87.49383602  36.45860995 178.44166757  39.00276687
      98.6540895  110.19103257  62.52282666  27.44173304 115.08169021]
    所有商品总价： 799.2090865433295

ndarray-多维数组对象

创建ndarray: np.array(array_like)

数组与列表的区别：

  • 数组对象内的元素类型必须相同
  • 数组大小不可修改

ndarray-数据类型

  • 布尔型: bool
  • 整型: int_ int8 int16 int32 int64
  • 无符号整型: uint8 uint16 uint32 uint64
  • 浮点型: float_ float16 float32 float64
  • 复数型: complex_ complex64 complex128

ndarray-常用属性

属性描述
T数组的转置(对高维数组而言)
size数组元素的个数
ndim数组的维数
shape数组的维度大小(元组形式)
dtype数组元素的数据类型

T：多维数组转置示例如下：
$$
\left(\begin{array}{c}1 & 2 & 3\ 4 & 5 & 6\end{array}\right) =>\left(\begin{array}{c}1 & 4\ 2 & 5\ 3 & 6\end{array}\right)
$$

创建ndarray

1
2
3
4
5
In [2]: np.array([2, 4, 6, 7, 8])
Out[2]: array([2, 4, 6, 7, 8])

In [3]: np.array(range(5))
Out[3]: array([0, 1, 2, 3, 4])

dtype

数组类型

1
2
3
4
In [4]: nums = np.array([2, 4, 6, 7, 8])

In [5]: nums.dtype
Out[5]: dtype('int32')

size

数组元素个数

1
2
3
4
In [6]: nums = np.array([2, 4, 6, 7, 8])

In [7]: nums.size
Out[7]: 5

多维数组

1
2
3
4
In [9]: nums = np.array([[1, 2, 3], [4, 5, 6]])

In [10]: nums.size
Out[10]: 6

shape

数组维度大小

1
2
3
4
In [11]: nums = np.array([2, 4, 6, 7, 8])

In [12]: nums.shape
Out[12]: (5,)

多维数组

1
2
3
4
In [13]: nums = np.array([[1, 2, 3], [4, 5, 6]])

In [14]: nums.shape
Out[14]: (2, 3)
1
2
3
4
In [15]: nums = np.array([[[1, 2, 3], [4, 5, 6]], [[5, 6, 7], [8, 9, 0]]])

In [16]: nums.shape
Out[16]: (2, 2, 3)

ndim

数组维数

1
2
3
4
In [20]: nums = np.array([2, 4, 6, 7, 8])

In [21]: nums.ndim
Out[21]: 1

多维数组

1
2
3
4
In [22]: nums = np.array([[1, 2, 3], [4, 5, 6]])

In [23]: nums.ndim
Out[23]: 2
1
2
3
4
In [24]: nums = np.array([[[1, 2, 3], [4, 5, 6]], [[5, 6, 7], [8, 9, 0]]])

In [25]: nums.ndim
Out[25]: 3

T

数组转置

1
2
3
4
5
6
7
8
9
10
11
12
In [27]: nums = np.array([[1, 2, 3], [4, 5, 6]])

In [28]: nums
Out[28]:
array([[1, 2, 3],
       [4, 5, 6]])

In [29]: nums.T
Out[29]:
array([[1, 4],
       [2, 5],
       [3, 6]])

Ones 和 zeros 填充方式

numpy.ones

返回给定形状和类型的新数组，并填充为1。

语法：ones(shape[, dtype, order])

示例：

1
2
3
4
5
6
In [31]: nums = np.ones(5)

In [32]: nums
Out[32]: array([1., 1., 1., 1., 1.])
In [33]: nums.dtype
Out[33]: dtype('float64')

可以看到帮我们生成了长度为5，值为1的一维数组，且每个元素类型为float，也可指定元素类型

1
2
3
4
5
6
7
In [34]: nums = np.ones(5, dtype='int8')

In [35]: nums
Out[35]: array([1, 1, 1, 1, 1])

In [36]: nums.dtype
Out[36]: dtype('int8')

numpy.zeros

返回给定形状和类型的新数组，并用零填充。

语法：zeros(shape[, dtype, order])

示例：

1
2
3
4
In [39]: nums = np.zeros(5)

In [40]: nums
Out[40]: array([0., 0., 0., 0., 0.])

多维数组

1
2
3
4
5
6
7
In [43]: nums = np.zeros((3, 2))

In [44]: nums
Out[44]:
array([[0., 0.],
       [0., 0.],
       [0., 0.]])

numpy.arange

返回给定间隔内的均匀间隔的值。

语法：arange([start,] stop[, step,][, dtype])

类似python中的range

1
2
3
4
5
6
7
8
9
10
11
# 创建1-10为元素的数组
In [45]: np.arange(1, 10)
Out[45]: array([1, 2, 3, 4, 5, 6, 7, 8, 9])

# 创建1-10且步长为2为元素的数组
In [46]: np.arange(1, 10, 2)
Out[46]: array([1, 3, 5, 7, 9])

# 创建1-10且步长为1.5为元素的数组
In [47]: np.arange(1, 10, 1.5)
Out[47]: array([1. , 2.5, 4. , 5.5, 7. , 8.5])

numpy.linspace

返回指定间隔内的等间隔数字。

语法：linspace(start, stop[, num, endpoint, …])

示例:

1
2
3
4
5
6
7
8
9
10
11
# 返回2-5之间的数均匀分为3份为数组元素(默认包头包尾)
In [49]: np.linspace(2, 5, 3)
Out[49]: array([2. , 3.5, 5. ])

# 返回2-5之间的数均匀分为3份为数组元素，明确不包尾
In [50]: np.linspace(2, 5, 3, endpoint=False)
Out[50]: array([2., 3., 4.])

# 返回2-5之间的数均匀分为3份为数组元素，显示步长
In [51]: np.linspace(2, 5, 3, retstep=True)
Out[51]: (array([2. , 3.5, 5. ]), 1.5)

ndarray-批量运算

数组与标量之间的运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
In [52]: a = np.array([2, 3, 5, 6])

In [53]: a
Out[53]: array([2, 3, 5, 6])

In [54]: a+3
Out[54]: array([5, 6, 8, 9])

In [55]: a*3
Out[55]: array([ 6,  9, 15, 18])

In [56]: a**0.5
Out[56]: array([1.41421356, 1.73205081, 2.23606798, 2.44948974])

In [57]: a>5
Out[57]: array([False, False, False,  True])

In [58]: 1//a
Out[58]: array([0, 0, 0, 0], dtype=int32)

同样大小数组之间的运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
In [59]: a = np.array([2, 3, 5, 6])

In [60]: b = np.array([7, 2, 4, 8])

In [61]: a+b
Out[61]: array([ 9,  5,  9, 14])

In [62]: a/b
Out[62]: array([0.28571429, 1.5       , 1.25      , 0.75      ])

In [63]: a**b
Out[63]: array([    128,       9,     625, 1679616])

In [64]: a%b
Out[64]: array([2, 1, 1, 6])

In [65]: a==b
Out[65]: array([False, False, False, False])

In [66]: a>b
Out[66]: array([False,  True,  True, False])

ndarray-索引

一维数组的索引

1
2
3
4
5
6
7
In [2]: data = np.arange(15)

In [3]: data
Out[3]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

In [4]: data[3]
Out[4]: 3

多维数组的索引

列表式写法

python常规列表的元素取值方式

1
2
3
4
5
6
7
8
9
10
In [6]: data = np.arange(15).reshape((3, 5))

In [7]: data
Out[7]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

In [8]: data[1][3]
Out[8]: 8
新式写法
1
2
3
4
5
6
7
8
In [9]: data
Out[9]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

In [10]: data[1, 3]
Out[10]: 8

切片

一维数组切片

与python列表切片用法一样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
In [12]: data
Out[12]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

In [13]: data[1:3]
Out[13]: array([1, 2])

In [14]: data[:3]
Out[14]: array([0, 1, 2])

In [15]: data[5:]
Out[15]: array([ 5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

In [16]: data[::2]
Out[16]: array([ 0,  2,  4,  6,  8, 10, 12, 14])

In [17]: data[-1]
Out[17]: 14

多维数组切片

多维数组只能使用新式写法，先取行后取列，中间用逗号分割

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
26
27
28
29
In [18]: data = np.arange(15).reshape((3, 5))

In [19]: data
Out[19]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

In [20]: data[1:3, 1:3]
Out[20]:
array([[ 6,  7],
       [11, 12]])

In [21]: data[1:3]
Out[21]:
array([[ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

In [22]: data[:,1:3]
Out[22]:
array([[ 1,  2],
       [ 6,  7],
       [11, 12]])

In [23]: data[:,-1]
Out[23]: array([ 4,  9, 14])

In [24]: data[-1,-1]
Out[24]: 14

数组切片与列表切片的差异

我们先以一个例子来说明

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# 数组
In [25]: data = np.arange(15)

In [26]: data
Out[26]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

In [27]: a = np.arange(15)

In [28]: a1=a[:3]

In [29]: a1
Out[29]: array([0, 1, 2])

In [30]: a1[0]=999

In [31]: a1
Out[31]: array([999,   1,   2])

In [32]: a
Out[32]:
array([999,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,
        13,  14])

# 列表
In [33]: b = list(range(15))

In [34]: b
Out[34]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

In [35]: b1=b[:3]

In [37]: b1
Out[37]: [0, 1, 2]

In [38]: b1[0]=20

In [39]: b1
Out[39]: [20, 1, 2]

In [40]: b
Out[40]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

数组切片与列表切片的不同: 数组切片时并不会自动复制 (而是创建一个视图)，在切片数组上的修改会影响原数组。

即：数组切片是浅拷贝，列表切片是深拷贝

copy()方法可以创建数组的深拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
In [56]: a = np.arange(15)

In [57]: a
Out[57]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

In [58]: a1 = a[0:3].copy()

In [59]: a1
Out[59]: array([0, 1, 2])

In [60]: a1[0]=99

In [61]: a1
Out[61]: array([99,  1,  2])

In [62]: a
Out[62]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

布尔型索引

这里我们同样用两个例子来说明布尔型索引的用法

问题:给一个数组，选出数组中所有大于5的数

  • 使用列表生成式或filter都可以很方便的解决

    1
    2
    3
    4
    5
    6
    7
    In [65]: data = [i for i in range(15) if i>5]

    In [66]: data
    Out[66]: [6, 7, 8, 9, 10, 11, 12, 13, 14]

    In [67]: list(filter(lambda i:i>5, range(15)))
    Out[67]: [6, 7, 8, 9, 10, 11, 12, 13, 14]

  • 使用布尔型索引

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    In [68]: data = np.arange(15)

    In [69]: data
    Out[69]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

    In [70]: data>5
    Out[70]:
    array([False, False, False, False, False, False,  True,  True,  True,
            True,  True,  True,  True,  True,  True])

    In [71]: data[data>5]
    Out[71]: array([ 6,  7,  8,  9, 10, 11, 12, 13, 14])

原理:

  • 数组与标量的运算: a>5会对a中的每一个元素进行判断，返回一个布尔数组
  • 布尔型索引: 将同样大小的布尔数组传进索引，会返回一个由所有True对应位置的元分素的数组

问题2:给一个数组，选出数组中所有大于5的偶数

1
2
3
4
5
In [72]: data
Out[72]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

In [73]: data[(data>5) & (data%2==0)]
Out[73]: array([ 6,  8, 10, 12, 14])

问题3:给一个数组，选出数组中所有大于5的数字和所有偶数

1
2
3
4
5
In [74]: data
Out[74]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

In [75]: data[(data>5) | (data%2==0)]
Out[75]: array([ 0,  2,  4,  6,  7,  8,  9, 10, 11, 12, 13, 14])

花式索引

问题1:对于一个数组，选出其第1，3，4，6，7个元素，组成新的二维数组

1
2
3
4
5
6
7
In [77]: data = np.array([random.randint(1, 20) for i in range(10)])

In [78]: data
Out[78]: array([19, 13,  1,  5, 16, 19, 10, 13,  6, 13])

In [79]: data[[1, 3, 4, 6, 7]]
Out[79]: array([13,  5, 16, 10, 13])

问题2:对一个二维数组，选出其第一行和第三行及第一列和第三列，组成新的二维数组

1
2
3
4
5
6
7
8
9
In [81]: data
Out[81]:
array([[ 5, 15, 18, 13,  3],
       [15, 15,  9,  9, 15],
       [10,  9, 10,  7, 17],
       [ 4, 13,  1,  6, 11]])

In [82]: data[[1,3],[1,3]]
Out[82]: array([15,  6])

执行上述代码，发现并不是我们想要的结果，上述结果实际上去给我取的是data[1, 1]和data[3, 3]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
In [84]: data
Out[84]:
array([[ 5, 15, 18, 13,  3],
       [15, 15,  9,  9, 15],
       [10,  9, 10,  7, 17],
       [ 4, 13,  1,  6, 11]])

In [85]: data[1:3, :]
Out[85]:
array([[15, 15,  9,  9, 15],
       [10,  9, 10,  7, 17]])

In [86]: data[1:3, :][:, 1:3]
Out[86]:
array([[15,  9],
       [ 9, 10]])

要想达到我们想要的结果，只能分步做，先去1到3行的所有列，再拿上面的结果去所有行的1到3列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
In [87]: data
Out[87]:
array([[ 5, 15, 18, 13,  3],
       [15, 15,  9,  9, 15],
       [10,  9, 10,  7, 17],
       [ 4, 13,  1,  6, 11]])
# 取第一行所有列
In [88]: data[1, :]
Out[88]: array([15, 15,  9,  9, 15])

# 取所有行第3列
In [89]: data[:, 3]
Out[89]: array([13,  9,  7,  6])

# 取第3行大于7的元素
In [92]: data[3, data[3]>7]
Out[92]: array([13, 11])

浮点数的特殊值

  • nan(Not a Number): 不等于任何浮点数 (nan != nan)
  • inf(infinity): 比任何浮点数都大（無窮大）
  • NumPy中创建特殊值: np.nan和 np.inf
  • 在数据分析中，nan常被用作表示数据缺失值

在Python中，nan是一个特殊的浮点数值，表示“不是一个数字”（Not a Number）。它用于表示缺失或无法表示的数值，例如非数字或未定义的结果。

nan是IEEE浮点异常的一部分，它有一些独特的性质：

  1. 不等于自己：nan != nan 返回True。
  2. 无序：由于NaN没有大小关系，所以不能与任何值（包括自身）进行比较。例如，nan < nan 和 nan > nan 都返回False。
  3. 不是数字：NaN不等于任何数字，包括它自己。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
In [141]: float('5')
Out[141]: 5.0

In [142]: float('5.36')
Out[142]: 5.36

In [143]: float('aaa')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[143], line 1
----> 1 float('aaa')

ValueError: could not convert string to float: 'aaa'

In [144]: float('nan')
Out[144]: nan

In [149]: float('nan') == float('nan')
Out[149]: False

In [150]: float('nan') is float('nan')
Out[150]: False

如上python中数据转换，当我们转换一个nan时，并没有报错，会正正常输出

在Python中，inf是一个特殊的浮点数值，表示无穷大。它用于表示大于任何有限数值的数。

inf是IEEE浮点异常的一部分，它有一些独特的性质：

  1. 大于任何有限数值：inf > x 对于任何有限的实数x都返回True。
  2. 无穷大相加仍为无穷大：inf + inf 返回inf。
  3. 无穷大相减仍为无穷大：inf - inf 返回nan（Not a Number）。
  4. 无穷大乘以任何有限数值仍为无穷大：inf * x 对于任何有限的实数x都返回inf。
  5. 无穷大除以任何有限数值都返回无穷大：inf / x 对于任何有限的实数x都返回inf。

在Python中，可以使用float('inf')来创建无穷大的值。此外，NumPy库也提供了相应的函数和数据结构来处理无穷大的值。例如，可以使用numpy.inf来创建无穷大的值，并使用numpy.isinf()函数来检查一个值是否为无穷大。

当使用NumPy或类似库处理数值数据时，经常会遇到无穷大的值。这些库通常提供了一些方法来处理这些值，例如替换、填充或排除。

什么时候是无穷大呢？举个例子，比如5除以一个特别特别小的数即无限接近于0的数的时候结果就是无穷大的（5/0.0000000000000000000000000000000001）

1
2
In [172]: float('inf')>9999999999999999999999999999999999999999999999999999999
Out[172]: True

NumPy通用函数

通用函数:能同时对数组中所有元素进行运算的函数

常见通用函数:

  • 一元函数: abs，sqrt，exp，log，ceil，floor，round，modf，isnan，isinf
  • 二元函数: add，substract，multiply，divide，power，mod，maximum，mininum,

numpy.abs

按元素计算绝对值。

语法：abs((x, /[, out, where, casting, order, …]))

1
2
3
4
5
6
7
In [93]: data = np.arange(-5, 5)

In [94]: data
Out[94]: array([-5, -4, -3, -2, -1,  0,  1,  2,  3,  4])

In [95]: np.abs(data)
Out[95]: array([5, 4, 3, 2, 1, 0, 1, 2, 3, 4])

numpy.sqrt

返回数组的非负平方根

语法：sqrt(x, /[, out, where, casting, order, …])

1
2
3
4
5
6
7
8
9
In [94]: data
Out[94]: array([-5, -4, -3, -2, -1,  0,  1,  2,  3,  4])

In [96]: np.sqrt(data)
<ipython-input-96-56e57f4a4abd>:1: RuntimeWarning: invalid value encountered in sqrt
  np.sqrt(data)
Out[96]:
array([       nan,        nan,        nan,        nan,        nan,
       0.        , 1.        , 1.41421356, 1.73205081, 2.        ])

上述返回数组中中的nan后面会说

numpy.exp

计算输入数组中所有元素的指数。其中 e = 2.718281… 是自然对数的基数。

语法：exp(x, /[, out, where, casting, order, …])

1
2
3
4
5
6
7
8
In [102]: data
Out[102]: array([-5, -4, -3, -2, -1,  0,  1,  2,  3,  4])

In [103]: np.exp(data)
Out[103]:
array([6.73794700e-03, 1.83156389e-02, 4.97870684e-02, 1.35335283e-01,
       3.67879441e-01, 1.00000000e+00, 2.71828183e+00, 7.38905610e+00,
       2.00855369e+01, 5.45981500e+01])

numpy.log

自然对数

语法：log(x, /[, out, where, casting, order, …])

1
2
3
4
5
6
7
8
9
10
11
In [104]: data
Out[104]: array([-5, -4, -3, -2, -1,  0,  1,  2,  3,  4])

In [105]: np.log(data)
<ipython-input-105-7daca4426ac8>:1: RuntimeWarning: divide by zero encountered in log
  np.log(data)
<ipython-input-105-7daca4426ac8>:1: RuntimeWarning: invalid value encountered in log
  np.log(data)
Out[105]:
array([       nan,        nan,        nan,        nan,        nan,
             -inf, 0.        , 0.69314718, 1.09861229, 1.38629436])

numpy.ceil

返回输入的上限（即向上取整）

语法：ceil(x, /[, out, where, casting, order, …])

1
2
3
4
5
6
In [109]: data
Out[109]: array([-5.5, -4.5, -3.5, -2.5, -1.5, -0.5,  0.5,  1.5,  2.5,  3.5,  4.5])

In [110]: np.ceil(data)
Out[110]: array([-5., -4., -3., -2., -1., -0.,  1.,  2.,  3.,  4.,  5.])

numpy.floor

返回输入的底限（即向下取整）

语法：floor(x, /[, out, where, casting, order, …])

1
2
3
4
5
In [111]: data
Out[111]: array([-5.5, -4.5, -3.5, -2.5, -1.5, -0.5,  0.5,  1.5,  2.5,  3.5,  4.5])

In [112]: np.floor(data)
Out[112]: array([-6., -5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])

numpy.round

将数组舍入到给定的小数位数。

语法：round(a[, decimals, out])

1
2
3
4
5
6
7
8
9
Out[125]:
array([-3.        , -2.68421053, -2.36842105, -2.05263158, -1.73684211,
       -1.42105263, -1.10526316, -0.78947368, -0.47368421, -0.15789474,
        0.15789474,  0.47368421,  0.78947368,  1.10526316,  1.42105263,
        1.73684211,  2.05263158,  2.36842105,  2.68421053,  3.        ])
In [129]: np.round(data)
Out[129]:
array([-3., -3., -2., -2., -2., -1., -1., -1., -0., -0.,  0.,  0.,  1.,
        1.,  1.,  2.,  2.,  2.,  3.,  3.])

numpy.modf

返回数组的分数和整数部分

语法：modf(x[, out1, out2], / [[, out, where, …])

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
26
27
28
29
In [130]: data
Out[130]:
array([-3.        , -2.68421053, -2.36842105, -2.05263158, -1.73684211,
       -1.42105263, -1.10526316, -0.78947368, -0.47368421, -0.15789474,
        0.15789474,  0.47368421,  0.78947368,  1.10526316,  1.42105263,
        1.73684211,  2.05263158,  2.36842105,  2.68421053,  3.        ])

In [131]: np.modf(data)
Out[131]:
(array([-0.        , -0.68421053, -0.36842105, -0.05263158, -0.73684211,
        -0.42105263, -0.10526316, -0.78947368, -0.47368421, -0.15789474,
         0.15789474,  0.47368421,  0.78947368,  0.10526316,  0.42105263,
         0.73684211,  0.05263158,  0.36842105,  0.68421053,  0.        ]),
 array([-3., -2., -2., -2., -1., -1., -1., -0., -0., -0.,  0.,  0.,  0.,
         1.,  1.,  1.,  2.,  2.,  2.,  3.]))

In [132]: a, b = np.modf(data)

In [133]: a
Out[133]:
array([-0.        , -0.68421053, -0.36842105, -0.05263158, -0.73684211,
       -0.42105263, -0.10526316, -0.78947368, -0.47368421, -0.15789474,
        0.15789474,  0.47368421,  0.78947368,  0.10526316,  0.42105263,
        0.73684211,  0.05263158,  0.36842105,  0.68421053,  0.        ])

In [134]: b
Out[134]:
array([-3., -2., -2., -2., -1., -1., -1., -0., -0., -0.,  0.,  0.,  0.,
        1.,  1.,  1.,  2.,  2.,  2.,  3.])

numpy.isnan

对NaN逐个元素进行测试，并将结果作为布尔数组返回。

1
2
3
4
5
6
7
8
9
In [139]: data
Out[139]: array([-5, -4, -3, -2, -1,  0,  1,  2,  3,  4])

In [140]: np.sqrt(data)
<ipython-input-140-56e57f4a4abd>:1: RuntimeWarning: invalid value encountered in sqrt
  np.sqrt(data)
Out[140]:
array([       nan,        nan,        nan,        nan,        nan,
       0.        , 1.        , 1.41421356, 1.73205081, 2.        ])

如上例中，负数没有平方根，即代表这不是一个数字

1
2
3
4
5
6
7
8
9
10
11
12
13
In [161]: data
Out[161]: array([ 1.,  1., nan,  1.])

In [163]: np.isnan(data)
Out[163]: array([False, False,  True, False])

# 获取所有nan
In [164]: data[np.isnan(data)]
Out[164]: array([nan])

# 过滤掉所有nan
In [165]: data[~np.isnan(data)]
Out[165]: array([1., 1., 1.])

numpy.isinf

逐元素测试正无穷大或负无穷大。

语法：isinf(x, /[, out, where, casting, order, …])

1
2
3
4
5
6
7
8
9
10
11
12
In [168]: data = 5/np.array([2, 4, 0, 6])

In [169]: data
Out[169]: array([2.5       , 1.25      ,        inf, 0.83333333])

# 获取所有inf
In [170]: data[np.isinf(data)]
Out[170]: array([inf])

# 过滤掉所有的inf
In [171]: data[~np.isinf(data)]
Out[171]: array([2.5       , 1.25      , 0.83333333])

npmpy.add

按元素添加参数。

语法：add(x1, x2, /[, out, where, casting, order, …])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
In [173]: a = np.array([2, 3, 5, 6])

In [174]: b = np.array([1, 9, 8, 4])

# 两个数组相加
In [175]: np.add(a, b)
Out[175]: array([ 3, 12, 13, 10])

# 一个数组加某个值
In [176]: np.add(a, 100)
Out[176]: array([102, 103, 105, 106])

# 等同于
In [177]: a+100
Out[177]: array([102, 103, 105, 106])

numpy.subtract

逐个元素地减去参数。

语法：subtract(x1, x2, /[, out, where, casting, …])

1
2
3
4
5
6
7
8
9
10
11
In [184]: a
Out[184]: array([2, 3, 5, 6])

In [185]: b
Out[185]: array([1, 9, 8, 4])
# 两个数组相减
In [186]: np.subtract(a, b)
Out[186]: array([ 1, -6, -3,  2])
# 等同于
In [187]: a-b
Out[187]: array([ 1, -6, -3,  2])

numpy.maximum

数组元素的逐元素最大值。

语法：maximum(x1, x2, /[, out, where, casting, …])

1
2
3
4
5
6
7
8
In [188]: a
Out[188]: array([2, 3, 5, 6])

In [189]: b
Out[189]: array([1, 9, 8, 4])
# 获取两个数组中对应位置的最大值组成新的数组
In [190]: np.maximum(a, b)
Out[190]: array([2, 9, 8, 6])

numpy.mininum

数组元素的逐元素最大值。

语法：mininum(x1, x2, /[, out, where, casting, …])

1
2
3
4
5
6
7
8
In [188]: a
Out[188]: array([2, 3, 5, 6])

In [189]: b
Out[189]: array([1, 9, 8, 4])
# 获取两个数组中对应位置的最小值组成新的数组
In [191]: np.minimum(a, b)
Out[191]: array([1, 3, 5, 4])

数学和统计方法

numpy.mean

求平均数

语法：mean(a[, axis, dtype, out, keepdims])

1
2
3
4
5
In [195]: a
Out[195]: array([2, 3, 5, 6])

In [196]: np.mean(a)
Out[196]: 4.0

var

求方差

语法：var(a[, axis, dtype, out, ddof, keepdims])

1
2
3
4
5
In [198]: a
Out[198]: array([2, 3, 5, 6])

In [199]: np.var(a)
Out[199]: 2.5

方差的计算方式我们就以上述数组作为数据源

1
2
3
4
# 先计算出平均值
avg = (2+3+5+6)/4 = 4
# 求标准差
var = ((2-4)**2+(3-4)**2+(5-4)**2+(6-4)**2)/4=2.5

std

求标准差

语法：std(a[, axis, dtype, out, ddof, keepdims])

1
2
3
4
5
In [195]: a
Out[195]: array([2, 3, 5, 6])

In [197]: np.std(a)
Out[197]: 1.5811388300841898

标准差的计算方式其实就是在方差的基础上再开平方根，如上述的方差为2.5，再开平方根即1.5811388300841898

min/max

求最小最大值

语法：min(a[, axis, out, keepdims, initial, where])、max(a[, axis, out, keepdims, initial, where])

1
2
3
4
5
6
7
8
In [200]: a
Out[200]: array([2, 3, 5, 6])

In [201]: np.min(a)
Out[201]: 2

In [202]: np.max(a)
Out[202]: 6

argmin/argmax

求最大最小值的索引

语法：numpy.argmin(a, axis=None, out=None, *, keepdims=<no value>)、numpy.argmax(a, axis=None, out=None, *, keepdims=<no value>)

1
2
3
4
5
6
7
8
In [203]: a
Out[203]: array([2, 3, 5, 6])

In [204]: np.argmin(a)
Out[204]: 0

In [205]: np.argmax(a)
Out[205]: 3

随机数生成

numpy中随机数函数都在np.random子包中

rand

给定形状产生随机数组(0-1之间的数)

1
2
3
4
5
6
7
8
9
In [209]: np.random.rand(10)
Out[209]:
array([0.64494225, 0.39743996, 0.23939766, 0.19598254, 0.75273967,
       0.39717237, 0.71704809, 0.82115764, 0.06821972, 0.67137424])

In [210]: np.random.rand(2, 3)
Out[210]:
array([[0.2875867 , 0.97918918, 0.17240733],
       [0.60603824, 0.97697601, 0.48956452]])

randint

给定形状产生随机整数

1
2
3
4
5
6
7
8
9
10
In [212]: np.random.randint(1, 10)
Out[212]: 2

In [213]: np.random.randint(1, 10, 10)
Out[213]: array([6, 9, 2, 8, 6, 6, 8, 4, 2, 1])

In [214]: np.random.randint(1, 10, (2, 3))
Out[214]:
array([[7, 6, 9],
       [1, 3, 1]])

choice

给定形状产生随机选择

1
2
3
4
5
6
7
8
9
10
11
12
13
In [216]: a
Out[216]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

In [217]: np.random.choice(a)
Out[217]: 13

In [218]: np.random.choice(a, 5)
Out[218]: array([ 1, 11,  2, 12, 13])

In [219]: np.random.choice(a, (2, 3))
Out[219]:
array([[6, 9, 1],
       [6, 6, 6]])

shuffle

与random.shuffle相同，打乱数组

1
2
3
4
5
6
7
In [220]: a
Out[220]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

In [221]: np.random.shuffle(a)

In [222]: a
Out[222]: array([11,  8,  4,  2,  7,  9, 14,  1,  5,  3, 10,  6, 13,  0, 12])

uniform

给定形状产生随机数组

1
2
3
4
5
6
7
8
9
10
In [227]: np.random.uniform(1, 10)
Out[227]: 3.0659406489791405

In [228]: np.random.uniform(1, 10, 3)
Out[228]: array([1.42207316, 6.27902593, 2.31851938])

In [229]: np.random.uniform(1, 10, (2, 3))
Out[229]:
array([[5.96014457, 2.80190332, 8.77041902],
       [6.83106905, 5.75887031, 6.2338454 ]])