【数据分析（一）】初探 Numpy

前言

Numpy是Python的常用开源数值计算扩展库，用于高效存储和处理大型矩阵。本文主要介绍Numpy的数组array的操作及其相关函数的使用。

以下对Numpy库函数的介绍中，已传入的参数为默认值，并且无返回值的函数不会以赋值形式演示。

1. 一维 array 的生成

array(p_object, dtype)：引用一个列表或元组，生成类型为dtype的一维数组
arange(start, stop, step)：生成相当于array(range(start, stop, step))的整数序列
linspace(start, stop, num=50, endpoint=True, retstep=False, dtype='float64')：生成长度为num，类型为dtype，在[start, stop]上的等差序列；endpoint表示区间右端是否封闭，retstep=True时则返回一个元组(array, step)，即等差数列和步长
empty(shape, dtype='float64')：生成长度为shape，类型为dtype，元素的值全为空值的一维数组
zeros(shape, dtype='float64')：生成长度为shape，类型为dtype，元素的值全为0的一维数组
ones(shape, dtype='float64')：生成*长度为shape，类型为dtype，元素的值**全为1的一维数组
fill(value)：将value转换为原数组的数据类型后，把原数组的元素的值全部填充为value
random.rand(d)：在区间[0, 1)生成随机浮点数，返回长度为d的一维数组
random.randn(d)：生成服从正态分布的随机浮点数，返回长度为d的一维数组
random.randint(low, high, size, dtype='int')：在区间[low, high)生成类型为dtype的随机数，返回长度为size的一维数组

python">import numpy as np# 引用创建
l = [1, 2, 3, 4]
a = np.array(l, dtype='float')  # [1. 2. 3. 4.]# 整数序列
a = np.arange(1, 10, 2)         # [1 3 5 7 9]# 等差数列
a = np.linspace(1, 10, 4)       # [ 1.  4.  7. 10.]# 全0填充 
a = np.zeros(3, dtype='bool')   # [False False False]# 全1填充
a = np.ones(4, dtype='int')     # [1 1 1 1]# 任意值填充
a.fill(2.5)                     # [2 2 2 2]# 随机浮点数
a = np.random.rand(3)           # [0.39581995 0.13435102 0.31592101]# 随机正态分布值
a = np.random.randn(3)          # [ 1.62916156  0.44159883 -1.85375949]# 随机数
a = np.random.randint(1, 3, 5)  # [1 1 2 1 1]

2. 一维 array 的基本操作

2.1. 查看属性

python">import numpy as np
a = np.array([1, 2, 3, 4])# 查看类型：即元素的数据类型
print(a.dtype)              # int32# 查看维度
print(a.ndim)               # 1# 查看长度：即元素数目
print(a.size)               # 4# 查看尺寸：返回一个元组，值为对应维度的元素数目
print(a.shape)              # (4,)# 类型转换
# a = np.array(a, dtype='float64')
a = a.astype('float64')     # [1. 2. 3. 4.]

2.2. 花式索引

python">import numpy as np
a = np.arange(1, 20, 2)
'''[ 1  3  5  7  9 11 13 15 17 19]'''# 索引列表：获取对应索引的元素
print(a[[2, 2, -3, 6, -1]])
'''[ 5  5 15 13 19]'''# 布尔数组：和numpy数组长度相等，获取布尔值为True的对应位置上的元素
print(a[np.array([1, 1, 0, 1, 0, 1, 1, 0, 1, 0], dtype='bool')])
'''[ 1  3  7 11 13 17]'''

2.3. 条件筛查

python">import numpy as np
a = np.arange(1, 20, 2)
'''[ 1  3  5  7  9 11 13 15 17 19]'''# 对数组中的所有元素做条件判断，并在对应位置返回布尔值
print(a > 10)
'''[False False False False False  True  True  True  True  True]'''# 以元组形式，返回所有符合条件的元素的索引
print(np.where(a > 10))
'''(array([5, 6, 7, 8, 9], dtype=int64),)'''# 返回所有符合条件的元素的数组
print(a[a > 10])
print(a[np.where(a > 10)])
'''[11 13 15 17 19]'''

2.4. 数据统计

python">import numpy as np
a = np.array([-5, -2, 3, 1, 4])'''排列'''
# 正序排列
b = np.sort(a)      # [-5 -2  1  3  4]# 排列后的元素在原数组中的索引
b = np.argsort(a)   # [0 1 3 2 4]'''运算'''
# 应用于所有元素
b = a+1             # [-4 -1  4  2  5]# 应用于对应元素
b = b*a             # [20  2 12  2 20]# 绝对值
abs = np.abs(a)     # [5 2 3 1 4]# 指数
exp = np.exp(a)     # [6.73794700e-03 1.35335283e-01 2.00855369e+01 2.71828183e+00 5.45981500e+01]'''统计'''
# 求和
# s = a.sum()
s = np.sum(a)       # 1# 最小值
# m = a.min()
m = np.min(a)       # -5# 最大值
# M = a.max()
M = np.max(a)       # 4# 均值
# avg = a.mean()
avg = np.mean(a)    # 0.2# 中值
#
mid = np.median(a)  # 1.0# 累计和(前缀和)
cs = np.cumsum(a)   # [-5 -7 -4 -3  1]# 标准差
# std = a.std()
std = np.std(a)     # 3.3105890714493698

3. n 维 array 的生成

array(p_object, dtype)：引用一个由 n个相同长度的列表或元组构成的元组，生成类型为dtype的n维数组
empty((*dn), dtype='float64')：生成尺寸为(d0, d1, ..., dn)，类型为dtype，元素的值全为空值的n维数组
zeros((*dn), dtype='float64')：生成尺寸为(d0, d1, ..., dn)，类型为dtype，元素的值全为0的n维数组
ones((*dn), dtype='float64')：生成尺寸为(d0, d1, ..., dn)，类型为dtype，元素的值全为1的n维数组
fill(value)：将value转换为原数组的数据类型后，把原数组的元素的值全部填充为value
random.rand(*dn)：在区间[0, 1)生成随机浮点数，返回尺寸为(d0, d1, ..., dn)的n维数组
random.randn(*dn)：生成服从正态分布的随机浮点数，返回尺寸为(d0, d1, ..., dn)的n维数组
random.randint(low, high, (*dn), dtype='int')：在区间[low, high)生成类型为dtype的随机数，返回尺寸为(d0, d1, ..., dn)的n维数组

python">import numpy as np# 引用创建
a = np.array(([1, 2, 3, 4], (5, 6, 7, 8)))
'''
[[1 2 3 4][5 6 7 8]]
'''# 全0填充
a = np.zeros((2, 4))
'''
[[0. 0. 0. 0.][0. 0. 0. 0.]]
'''# 全1填充
a = np.ones((2, 4))
'''
[[1. 1. 1. 1.][1. 1. 1. 1.]]
'''# 任意值填充
a.fill(False)
'''
[[0. 0. 0. 0.][0. 0. 0. 0.]]
'''# 随机浮点数
a = np.random.rand(2, 2)
'''
[[0.11188812 0.83587679][0.98262527 0.79479766]]
'''# 随机正态分布值
a = np.random.randn(2, 2)
'''
[[-0.79453966 -1.5958028 ][ 0.89898492 -0.9779685 ]]
'''# 随机数
a = np.random.randint(1, 10, (2, 4))
'''
[[9 7 3 9][3 7 4 8]]
'''

4. n 维 array 的基本操作

以二维数组为例。

4.1. 查看属性

python">import numpy as np
a = np.array(([1, 2, 3, 4], (5, 6, 7, 8)))
'''
[[1 2 3 4][5 6 7 8]]
'''# 查看类型
print(a.dtype)              # int32# 查看维度
print(a.ndim)               # 2# 查看数目
print(a.size)               # 8# 查看尺寸
print(a.shape)              # (2, 4)# 对数组所有元素进行运算
a = a+1
'''
[[2 3 4 5][6 7 8 9]]
'''# 两个数组的对应元素进行运算
a = a*(a-1)
'''
[[ 2  6 12 20][30 42 56 72]]
'''

4.2. 查询和切片

python">import numpy as np
a = np.array(([1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]))
'''
[[ 1  2  3  4][ 5  6  7  8][ 9 10 11 12][13 14 15 16]]
'''
print(a)
# 单元查询：对于a[x, y]，x是行索引，y是列索引
print(a[1, 0])              # 5# 单行查询
print(a[1])                 # [5 6 7 8]# 单列查询
print(a[:, 1])              # [ 2  6 10 14]# 连续区域切片
print(a[1:3, 1:3])
'''
[[ 6  7][10 11]]
'''# 离散区域切片
print(a[1::2, 1::2])
'''
[[ 6  8][14 16]]
'''# 不完全索引：只给出行索引范围时，默认对整行切片
print(a[:3])
'''
[[ 1  2  3  4][ 5  6  7  8][ 9 10 11 12]]
'''

与列表不同的是，Numpy数组的切片是对原数组的引用，即它们共同指向一处内存空间，这意味元素的修改会同时作用到数组和它的切片上。可以用copy()方法进行拷贝，申请新的内存。

python">import numpy as npa = np.array([1, 2, 3, 4])
b = a[1: 3]
b[0] = '0'
print(a)    # [1 0 3 4]a = [1, 2, 3, 4]
b = a[1: 3]
b[0] = '0'
print(a)    # [1, 2, 3, 4]

4.3. 花式索引

花式索引是对原数组的拷贝而非引用。

python">import numpy as np
a = np.array(([1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]))
'''
[[ 1  2  3  4][ 5  6  7  8][ 9 10 11 12][13 14 15 16]]
'''# 索引列表
print(a[[0, 1, 2, 3], [0, 1, 2, 3]])
'''[ 1  6 11 16]'''# 布尔数组：需要指定列
mask = np.array([0, 1, 0, 1], dtype='bool')
print(a[mask])
'''
[[ 5  6  7  8][13 14 15 16]]
'''
print(a[mask, 1])   # [ 6 14]
print(a[1, mask])   # [6 8]# 配合切片使用花式索引
print(a[1: 3, [0, 3]])
'''
[[ 5  8][ 9 12]]
'''
'''

4.4. 矩阵

python">import numpy as np
x = np.array([1, 3, 2, 4, 6, 9])
y = np.array([13, 25, 37, 42, 54, 69])# 相关系数矩阵
cov = np.cov(x, y)
'''
[[  8.56666667  55.        ][ 55.         400.8       ]]
'''# 变形
x = x.reshape(2, 3)
'''
[[1 3 2][4 6 9]]
'''
y.shape = (2, 3)
print(y)                # 原矩阵发生改变
'''
[[13 25 37][42 54 69]]
'''# 转置
# x_T = x.T
x_T = x.transpose()     # 原矩阵不发生改变
'''
[[1 4][3 6][2 9]]
'''# 连接
'''沿行方向，即第一维（默认）'''
# z = np.vstack((x, y))
z = np.concatenate((x, y), axis=0)
'''
[[ 1  3  2][ 4  6  9][13 25 37][42 54 69]]
''''''沿列方向，即第二维'''
# z = np.hstack((x, y))
z = np.concatenate((x, y), axis=1)
'''
[[ 1  3  2 13 25 37][ 4  6  9 42 54 69]]
''''''沿垂直方向，即第三维'''
z = np.array((x, y))
print(z)
'''
[[[ 1  3  2][ 4  6  9]][[13 25 37][42 54 69]]]
'''
z = np.dstack((x, y))
'''
[[[ 1 13][ 3 25][ 2 37]][[ 4 42][ 6 54][ 9 69]]]
'''