python3 numpy模块
什么是numpy？
一个在Python中做科学计算的基础库，重在数值计算，也是大部分PYTHON科学计算库的基础库，多用于在大型、多维数组上执行数值运算
创建数组（矩阵）
import numpy as np
# 创建数组方式一
t1 = np.array([1, 2, 3])
# [1 2 3]
print(t1)
# 创建数组方式二
t2 = np.array(range(10))
# 数据类型为：numpy.ndarray
print(type(t2))
# 创建数组方式三
t3 = np.arange(4, 10, 2)
# 存放的是数据类型为：int32
print(t3.dtype)
常见的数据类型
| 类型 | 代码类型 | 说明 |
|---|---|---|
| int8、unit8 | i1、u1 | 有符号和无符号的8位（1个字节）整型 |
| int16、unit16 | i2、u2 | 有符号和无符号的16位（2个字节）整型 |
| int32、unit32 | i4、u4 | 有符号和无符号的32位（4个字节）整型 |
| int64、unit64 | i8、u8 | 有符号和无符号的64位（8个字节）整型 |
| float16 | f2 | 半精度浮点数 |
| float32 | f4或f | 标准的单精度浮点数，与C的float兼容 |
| float64 | f8或d | 标准的双精度浮点数，与C的double和Python的float对象兼容 |
| float128 | f16或g | 扩展精度浮点数 |
| complex64、complex128、complex256 | c8、c16、c32 | 复数 |
| bool | ? | 存储True和False的布尔类型 |
数据类型操作
import numpy as np
# 指定创建数组的数据类型
t1 = np.array(range(1, 4), dtype='float64')
# float64
print(t1.dtype)
# 修改数组的数据类型，方式一
t2 = t1.astype(np.int8)
# int8
print(t2.dtype)
# 修改数组的数据类型，方式二
t3 = t1.astype('i2')
# int16
print(t3.dtype)
t4 = np.array([0.0485436, 0.26320629, 0.69646413])
# 修改浮点型的小数的位数
t5 = np.round(t4, 2)
# [0.05 0.26 0.7 ]
print(t5)
数组的形状
import numpy as np
t1 = np.arange(12)
# 通过shape属性查看数组形状
# (12,)
print(t1.shape)
t2 = np.array([[1, 2, 3], [4, 5, 6]])
# (2,3)
print(t2.shape)
t3 = np.array([[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10], [11, 12]]])
# (2,2,3)
print(t3.shape)
# 通过reshape方法修改数组形状
t5 = t1.reshape(3, 4)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
print(t5)
# 通过flatten方法将多维数组转换为一维数组
t6 = t5.flatten()
# [ 0 1 2 3 4 5 6 7 8 9 10 11]
print(t6)
数组和数的计算
'''
在运算过程中，加减乘除的值都被广播到所有的元素上面
'''
import numpy as np
a = np.array([[3, 4, 5, 6, 7, 8], [4, 5, 6, 7, 8, 9]])
b = 2
# 数组与数的加减法
c = a+b
# [[ 5 6 7 8 9 10]
# [ 6 7 8 9 10 11]]
print(c)
# 数组与数的乘除法
c = a*b
# [[ 6 8 10 12 14 16]
# [ 8 10 12 14 16 18]]
print(c)
数组与数组的计算1
import numpy as np
a = np.array([[3, 4, 5, 6, 7, 8], [4, 5, 6, 7, 8, 9]])
b = np.array([[21, 22, 23, 24, 25, 26], [27, 28, 29, 30, 31, 32]])
# 数组与数组的加减法
c = a+b
# [[24 26 28 30 32 34]
# [31 33 35 37 39 41]]
print(c)
# 数组与数组的乘除法
c = a*b
# [[ 63 88 115 144 175 208]
# [108 140 174 210 248 288]]
print(c)
数组与数组的计算2
import numpy as np
a = np.array([[3, 4, 5, 6, 7, 8], [4, 5, 6, 7, 8, 9]])
b = np.array([1, 2, 3, 4, 5, 6])
# 数组与数组的加减法
# [[ 4 6 8 10 12 14]
# [ 5 7 9 11 13 15]]
c = a+b
print(c)
# 数组与数组的乘除法
c = a*b
# [[ 3 8 15 24 35 48]
# [ 4 10 18 28 40 54]]
print(c)
数组与数组的计算3
import numpy as np
a = np.array([[3, 4, 5, 6, 7, 8], [4, 5, 6, 7, 8, 9]])
b = [[1], [2]]
# 数组与数组的加减法
c = a+b
# [[ 4 5 6 7 8 9]
# [ 6 7 8 9 10 11]]
print(c)
# 数组与数组的乘除法
c = a*b
# [[ 3 4 5 6 7 8]
# [ 8 10 12 14 16 18]]
print(c)
轴
在numpy中可以理解为方向,使用0,1,2...数字表示,对于一个一维数组,只有一个0轴,对于2维数组(shape(2,2)),有0轴和1轴,对于三维数组(shape(2,2, 3)),有0,1,2轴
有了轴的概念之后,我们计算会更加方便,比如计算一个2维数组的平均值,必须指定是计算哪个方向上面的数字的平均值
读取数据
import numpy as np
us_file_path = './youtube_video_data/US_video_data_numbers.csv'
uk_file_path = './youtube_video_data/GB_video_data_numbers.csv'
t1 = np.loadtxt(us_file_path, delimiter=',', dtype='int')
t2 = np.loadtxt(uk_file_path, delimiter=',', dtype='int')
| 参数 | 说明 |
|---|---|
| frame | 文件、字符串或产生器，可以是.gz或bz2压缩文件 |
| dtype | 数据类型，可选，CSV的字符串以什么类型读入数组，默认np.float |
| delimiter | 分隔字符串，默认是任何空格，改为逗号 |
| skiprows | 跳过前x行，一般跳过第一行表头 |
| usecols | 读取指定的列，索引，元组类型 |
| unpack | 如果为True，读入属性将分别写入不同数组变量，False读入数据只写入一个数组变量，默认为False |
转置
转置是一种变换,对于numpy中的数组来说,就是在对角线方向交换数据,目的也是为了更方便的去处理数据
import numpy as np
t = np.array([[0, 1, 2, 3, 4, 5],
[6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17]])
# 方式一
t1 = t.transpose()
# [[ 0 6 12]
# [ 1 7 13]
# [ 2 8 14]
# [ 3 9 15]
# [ 4 10 16]
# [ 5 11 17]]
print(t1)
# 方式二
# 交换轴
t1 = t.swapaxes(1, 0)
# 方式三
t1 = t.T
索引和切片
import numpy as np
t = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]])
# 取一行
t1 = t[1]
# [5 6 7 8]
print(t1)
# 取连续的多行
t2 = t[1:3]
# [[ 5 6 7 8]
# [ 9 10 11 12]]
print(t2)
# 取不连续多行
t3 = t[[0, 1, 3]]
# [[ 1 2 3 4]
# [ 5 6 7 8]
# [13 14 15 16]]
print(t3)
# 取一列
t4 = t[:, 0]
# [ 1 5 9 13]
print(t4)
# 取连续的多列
t5 = t[:, 1:3]
# [[ 2 3]
# [ 6 7]
# [10 11]
# [14 15]]
print(t5)
# 取不连续的多列
t6 = t[:, [0, 2, 3]]
# [[ 1 3 4]
# [ 5 7 8]
# [ 9 11 12]
# [13 15 16]]
print(t6)
# 取偶数行
t7 = t[1::2]
# [[ 5 6 7 8]
# [13 14 15 16]]
print(t7)
# 取奇数列
t8 = t[:, ::2]
# [[ 1 3]
# [ 5 7]
# [ 9 11]
# [13 15]]
print(t8)
# 取多个不相邻的点
# 选取(1,0),(3,2)两个点
t9 = t[[1, 3], [0, 2]]
# [ 5 15]
print(t9)
数值的修改1
import numpy as np
t = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]])
# 将第二行和第三行替换为0
t[:, 1:3] = 0
# [[ 1 0 0 4]
# [ 5 0 0 8]
# [ 9 0 0 12]
# [13 0 0 16]]
print(t)
数值修改2
import numpy as np
t = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]])
# 将t中小于10的数字替换成0
t[t < 10] = False
# [[0 0 0 0]
# [0 0 0 0]
# [0 10 11 12]
# [13 14 15 16]]
print(t)
数值修改3
import numpy as np
t = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]])
# 将t中小于10的数替换成0，其余的替换成1
t1 = np.where(t < 10, 0, 1)
# [[0 0 0 0]
# [0 0 0 0]
# [0 1 1 1]
# [1 1 1 1]]
print(t1)
clip（裁剪）
import numpy as np
t = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]])
# 将t中小于5的数替换成5，将t中大于10的数替换成10
t1 = t.clip(5, 10)
print(t1)
nan和inf
nan(NAN,Nan):not a number表示不是一个数字
inf(-inf,inf):infinity,inf表示正无穷，-inf表示负无穷
nan和inf属于float类型
两个nan不相等
通过方法isnan来判断是否为nan
nan和任何数字计算都是nan
import numpy as np
t = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]])
# 先把t转换成float类型
t = t.astype(float)
# 将(4,4)点的值替换成nan
t[3, 3] = np.nan
# [[ 1. 2. 3. 4.]
# [ 5. 6. 7. 8.]
# [ 9. 10. 11. 12.]
# [13. 14. 15. nan]]
print(t)
常用的统计方法
| 作用 | 公式 |
|---|---|
| 求和 | t.sum(axis=None) |
| 均值 | t.mean(a,axis=None) |
| 中值 | np.median(t,axis=None) |
| 最大值 | t.max(axis=None) |
| 最小值 | t.min(axis=None) |
| 极值（即最大值和最小值之差） | np.ptp(t,axis=None) |
| 标准差（一组数据平均值分散程度的一种度量。一个较大的标准差，代表大部分数值和其平均值之间差异较大） | t.std(axis=None) |
import numpy as np
t = np.array([[0, 2, 3, 4],
[0, 6, 7, 8],
[0, 10, 11, np.nan],
[0, 14, 15, np.nan]])
# 统计t中不为0的个数
num = np.count_nonzero(t)
print(num)
# 统计t中nan的个数
# np.nan != np.nan
num = np.count_nonzero(t != t)
print(num)
# 统计t中nan的个数
num = np.count_nonzero(np.isnan(t))
print(num)
# 将t中的nan替换为0
t[np.isnan(t)] = 0
print(t)
t = np.array([[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11]])
# 计算t中所有数字的和
t_sum = np.sum(t)
# 66
print(t_sum)
# 计算0轴上所有数字的和
# axis参数指定计算那个轴上的数字
t_sum = np.sum(t, axis=0)
# [12 15 18 21]
print(t_sum)
缺失值填充均值
import numpy as np
def fill_ndarray(t1):
# 遍历每一列
for i in range(t1.shape[1]):
# 每一列的数据
temp_col = t1[:, i]
# nan的数量
nan_num = np.count_nonzero(temp_col != temp_col)
if nan_num != 0:
# 取一列中非nan的数据
temp_not_nan_col = temp_col[temp_col == temp_col]
# 将原数据为nan的位置替换为该列的平均值
temp_col[np.isnan(temp_col)] = temp_not_nan_col.mean()
return t1
if __name__ == "__main__":
t1 = np.arange(12).reshape(3, 4).astype('float')
t1[1, 2:] = np.nan
t2 = fill_ndarray(t1)
print(t2)
数据的拼接
import numpy as np
t1 = np.array([[1, 2, 3, 4, 5],
[6, 7, 8, 9, 10]])
t2 = np.array([[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20]])
# 水平拼接
t3 = np.hstack((t1, t2))
# [[ 1 2 3 4 5 11 12 13 14 15]
# [ 6 7 8 9 10 16 17 18 19 20]]
print(t3)
# 竖直拼接
t4 = np.vstack((t1, t2))
# [[ 1 2 3 4 5]
# [ 6 7 8 9 10]
# [11 12 13 14 15]
# [16 17 18 19 20]]
print(t4)
数组的行列交换
import numpy as np
t = np.arange(12, 24).reshape(3, 4)
# [[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]
print(t)
# 行交换
# 第二行和第三行交换
t[[1, 2], :] = t[[2, 1], :]
# [[12 13 14 15]
# [20 21 22 23]
# [16 17 18 19]]
print(t)
# 列交换
# 第一列和第三列交换
t[:, [0, 2]] = t[:, [2, 0]]
# [[14 13 12 15]
# [22 21 20 23]
# [18 17 16 19]]
print(t)
更多好用的方法
| 方法 | 描述 |
|---|---|
| np.argmax(t,axis=None) | 获取最大值的位置 |
| np.argmin(t,axis=None) | 获取最小值的位置 |
| np.zeros((m,n)) | 创建一个m行n列全为0的数组 |
| np.ones((m,n)) | 创建一个m行n列全为1的数组 |
| np.eye(m) | 创建一个对角线为1的m行m列的正方形数组（方阵） |
随机数
均匀分布：在相同的大小范围内出现的概率是等可能的。
正态分布：呈钟型，两头低，中间高，左右对称。
均匀分布
正态分布
| 方法 | 描述 |
|---|---|
| np.random.rand(d0,d1,...dn) | 创建一个d0dn维度的均匀分布的随机数组，浮点数，范围01 |
| np.random.randn(d0,d1,...dn) | 创建一个d0~dn维度的标准正态分布随机数，浮点数，平均数0，标准差1 |
| np.random.randint(low,high,(shape)) | 给定上下限范围选取随机整数，范围是low~high，形状是shape |
| np.random.uniform(low,high,(size)) | 产生具有均匀分布的数组，low起始值，high结束值，size形状 |
| np.random.normal(loc,scale,(size)) | 从指定正态分布中随机抽取样本，分布中心是loc（概率分布的均值），标准差是scale，形状是size |
| np.random.seed(s) | 随机种子，s是给定的种子值，因为计算机产生的是伪随机数，所以通过设定相同的随机数种子，可以每次生成相同的随机数 |