参考文献

numpy

  • 在 NumPy里有两个重要的对象：
    • ndarray(N-dimensional array object)解决了多维数组问题
    • ufunc(universal function object)则是解决对数组进行处理的函数
  • NumPy的数组类被调用ndarray.它也被别名所知 array.请注意,numpy.array这与标准Python库类不同array.array,后者只处理一维数组并提供较少的功能.ndarray对象更重要的属性是：
    • ndarray.ndim - 数组的轴(维度)的个数.在Python世界中,维度的数量被称为rank.
    • ndarray.shape - 数组的维度.这是一个整数的元组,表示每个维度中数组的大小.对于有n行和m列的矩阵,shape 将是 (n,m).因此,shape 元组的长度就是rank或维度的个数 ndim.
    • ndarray.size - 数组元素的总数.这等于 shape 的元素的乘积.
    • ndarray.dtype - 一个描述数组中元素类型的对象.可以使用标准的Python类型创建或指定dtype.另外NumPy提供它自己的类型.例如numpy.int32、numpy.int16和numpy.float64.
    • ndarray.itemsize - 数组中每个元素的字节大小.例如,元素为 float64 类型的数组的 itemsize 为8(=64/8),而 complex32 类型的数组的 itemsize 为4(=32/8).它等于 ndarray.dtype.itemsize .
    • ndarray.data - 该缓冲区包含数组的实际元素.通常,我们不需要使用此属性,因为我们将使用索引访问数组中的元素.

创建数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import numpy as np

a = np.array([1, 2, 3])
b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
b[1, 1] = 10
# 通过函数 shape 属性获得数组的大小
print(a.shape)
print(b.shape)
# 通过 dtype 获得元素的属性
print(a.dtype)
print(b)

# output
(3,)
(3, 3)
int64
[[ 1  2  3]
 [ 4 10  6]
 [ 7  8  9]]

  • 一个常见的错误，就是调用array的时候传入多个数字参数，而不是提供单个数字的列表类型作为参数。

    1
    2
    >>> a = np.array(1,2,3,4)    # WRONG
    >>> a = np.array([1,2,3,4])  # RIGHT

算术运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import numpy as np

x1 = np.arange(1, 11, 2)
x2 = np.linspace(1, 9, 5)
# 加
print(np.add(x1, x2))
# 减
print(np.subtract(x1, x2))
# 乘
print(np.multiply(x1, x2))
# 除
print(np.divide(x1, x2))
# 求n次方
print(np.power(x1, x2))
# 取余数
print(np.remainder(x1, x2))

统计函数

计数组 / 矩阵中的最大值函数amax(),最小值函数amin()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import numpy as np

a = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])
print(np.amin(a))
# axis = 0 代表跨行,按列进行运算
print(np.amin(a, axis=0))
# axis =1  代表跨列,按行进行运算
print(np.amin(a, axis=1))
print(np.amax(a))
# axis = 0 代表跨行,按列进行运算
print(np.amax(a, axis=0))
# axis =1  代表跨列,按行进行运算
print(np.amax(a, axis=1))

# output
1
[1 2 3]
[1 4 7]
9
[7 8 9]
[3 6 9]
统计最大值与最小值之差ptp()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import numpy as np

a = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])
              
print(np.ptp(a))
# axis = 0 代表跨行,按列进行运算
print(np.ptp(a, axis=0))
# axis =1  代表跨列,按行进行运算
print(np.ptp(a, axis=1))

# output
8
[6 6 6]
[2 2 2]
统计数组的百分位数percentile()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import numpy as np

a = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

print(np.percentile(a, 50))
print(np.percentile(a, 50, axis=0))
print(np.percentile(a, 50, axis=1))

# output
5.0
[4. 5. 6.]
[2. 5. 8.]
  • percentile() 代表着第 p 个百分位数,这里 p 的取值范围是 0-100,如果 p=0,那么就是求最小值,如果 p=50 就是求平均值,如果 p=100 就是求最大值
统计数组中的中位数median()、平均数mean()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import numpy as np

a = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])
              
# 求中位数
print(np.median(a))
print(np.median(a, axis=0))
print(np.median(a, axis=1))

# 求平均数
print(np.mean(a))
print(np.mean(a, axis=0))
print(np.mean(a, axis=1))

# output
5.0
[4. 5. 6.]
[2. 5. 8.]
5.0
[4. 5. 6.]
[2. 5. 8.]
统计数组中的加权平均值average()
1
2
3
4
5
6
7
8
9
10
import numpy as np

a = np.array([1, 2, 3, 4])
wts = np.array([1, 2, 3, 4])
print(np.average(a))
print(np.average(a, weights=wts))

# output 
2.5
3.0
统计数组中的标准差 std()、方差 var()
1
2
3
4
5
6
7
8
9
import numpy as np

a = np.array([1, 2, 3, 4])
print(np.std(a))
print(np.var(a))

# output
1.118033988749895
1.25
  • 方差的计算是指每个数值与平均值之差的平方求和的平均值,即 mean((x - x.mean())** 2).
  • 标准差是方差的算术平方根.在数学意义上,代表的是一组数据离平均值的分散程度.
排序
  • sort(a, axis=-1, kind=‘quicksort’, order=None),默认情况下使用的是快速排序；在 kind 里,可以指定 quicksort、mergesort、heapsort分别表示快速排序、合并排序、堆排序.同样 axis 默认是 -1,即沿着数组的最后一个轴进行排序,也可以取不同的 axis 轴,或者 axis=None 代表采用扁平化的方式作为一个向量进行排序.另外order 字段,对于结构化的数组可以指定按照某个字段进行排序.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np
a = np.array([[4, 3, 2],
              [2, 4, 1]])
print(np.sort(a))
print(np.sort(a, axis=None))
# 按列排序 第一行第一列和第二行第一列进行比较  第一行第二列和第二行第二列比较 ...
print(np.sort(a, axis=0))
print(np.sort(a, axis=1))

# output 
[[2 3 4]
 [1 2 4]]

[1 2 2 3 4 4]

[[2 3 1]
 [4 4 2]]

[[2 3 4]
 [1 2 4]]