Numpy速查

数据读取和保存

# np.save，np.load
np.save('path.npy', np_data)   # 数组以未压缩的原始二进制格式保存在扩展名为npy的文件中
np_data = np.load('path.npy')

# np.savetxt 和 np.loadtxt 只能读写 1 维和 2 维的数组
np.savetxt("filename.txt",a)   # 将数组写入以某种分隔符隔开的文本文件中，默认是逗号
b =  numpy.loadtxt("filename.txt", delimiter=',')   # 指定某种分隔符，将文本文件读入到数组中

# np.savez()可以保存任意多个N维数组,保存后的本地文件为npz格式
np.savez()
# 1.用*args方式，比如np.savez('data',d1,d2,d3),它将会以以arr_0,arr_1,arr_2来表示d1,d2,d3的名字，用于访问数据时用。
# 2.用**kwds方式，比如np.savez('data',d1=d1,d2=d2,d3=d3)，即指定了数组名，用于访问数据时用。
np_data = np.load(file)
# 参考：python：保存N维数组(ndarray)到本地文件_一从际发的博客-CSDN博客_python保存ndarray

# tofile 将数组以二进制的格式写进文件
a.tofile("filename.bin")
b = np.fromfile("filename.bin",dtype = **)
# tofile函数只能将数组保存为二进制文件，文件后缀名没有固定要求。
# 这种保存方法对数据读取有要求，np.fromfile 需要手动指定读出来的数据的的dtype，如果指定的格式与保存时的不一致，则读出来的就是错误的数据。
# tofile函数不能保存当前数据的行列信息，因此使用 np.fromfile 读出来的数据是一维数组，需要利用reshape指定行列信息。

数据生成

# 创建新数组
np.empty(shape, dtype = float, order = 'C')                  # 生成未初始化shape形状的数组，数组元素为随机值
ny.zeros(shape, dtype = float, order = 'C')                  # 生成全0的shape形状的数组，dtype指定类型时尽量使用np.int这种方式
np.ones(shape, dtype = None, order = 'C')                    # 生成全1的shape形状的数组，dtype默认类型为 float

# 从已有数据创建数组
np.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)  # 可以将序列数据转换成arr类型，序列可以是list、dict、set、Series、DataFrame等；ndmin用来指定返回的数组最小维度
np.asarray(a, dtype = None, order = None)                    # a 任意形式的输入参数，比如列表、列表的元组、元组、元组的元组、元组的列表
np.fromiter(iterable, dtype, count = -1)                     # 从任何可迭代对象构建一个ndarray对象

# 从数值范围创建数组
np.arange(start, stop, step, dtype)                          # 将给定范围内的等间隔值创建为数组
np.linspace(start, stop, num, endpoint, retstep, dtype)      # num：将start和stop之间的数据平均分成的数量；endpoint是否包含stop值

# 随机数创建数组
np.random.seed(n)                                            # 设置随机数种子，n 可以是任意数字，对以下所有方法适用
np.random.random(size=None)                                  # 以给定的形状创建一个数组,数据在 [0,1) 之间均匀随机分布；没有参数时，返回一个值；参数为一个数值时，返回一维数组；参数为一个元组时，返回指定维度数组
np.random.rand(d0,d1,...,dn)                                 # 以给定的形状创建一个数组,数据在 [0,1) 之间均匀随机分布；没有参数时，返回一个值；参数为一个数值时，返回一维数组；参数为多个数值时，返回指定维度数组
np.random.uniform(low=0.0, high=1.0, size=None)              # 以给定的形状创建一个数组,数据在 [low,high) 之间均匀随机分布；若high=None，则取值区间变为[0,low)，size为关键字参数，不指定size时，返回一个数值；size=0时，返回空数组；size=n时，返回长度为n的一维数组；size=(d0,d1,...dn)时，返回多维数组
np.random.randint(low, high=None, size=None)                 # 以给定的形状创建一个数组,数据在 [low,high) 之间均匀随机分布；若high=None，则取值区间变为[0,low)，size为关键字参数
np.random.randn(2,3)                                         # 以给定的形状创建一个数组,数据服从均值为 0，标准差为 1 的 标准正态分布；
np.random.normal(loc=0.0, scale=1.0, size=None)              # 以给定的形状创建一个数组,数据服从均值为loc，标准差为scale的 正态分布；size为关键字参数，不指定size时，返回一个数值；size=0时，返回空数组；size=n时，返回长度为n的一维数组；size=(d0,d1,...dn)时，返回多维数组
np.random.choice(a, size=None, replace=True, p=None)         # 从给定的一维数组中生成随机数, a为一维数组类似数据或整数；size为返回数组维度；p为权重
np.random.shuffle(x)                                         # 打乱数组，无返回值，在原数组上进行；多维数组默认是在axis=1上打乱，但实际无axis参数
np.random.permutation(x)                                     # 打乱数组，有返回值；
np.random.permutation(10)                                    # 打乱 range(10) 数组返回

# DataFrame/Series转换成数组
pd.values                                                    # Series、DataFrame两种类型的数据可以使用该方法转换成arr

数据访问

# 基本切片
a[slice(2,7,2)]                                              # 索引区间为[2,7)，步长为2 的索引方式
a[2:7:2]                                                     # 索引区间为[2,7)，步长为2 的索引方式
a[...,1]
a[:,1]


# 高级索引
# 1、将整数数组索引————数组的形状决定了输出的形状
x = np.arange(32).reshape((8,4))
x[[1,5,7,2]]                                                 # 取1，5，7，2行，所有列；顺序有先后
x[:,[0,3,1,2]]                                               # 取所有行，0，3，1，2列；顺序有先后
x[[-1,-5,-7,-2]]                                             # 取-1，-5，-7，-2行，所有列；顺序有先后
x[:,[0,-3,-1,-2]]                                            # 取所有行，0，-3，-1，-2列；顺序有先后
x[[[1,5,7,2],[0,3,1,2]]]                                     # 写法错误，会报错
x[[1,5,7,2],[0,3,1,2]]                                       # 取(1,0),(5,3),(7,1),(2,2)位置处的元素，输出一维
x[[[1,5],[7,2]],[[0,3],[1,2]]]                               # 取(1,0),(5,3),(7,1),(2,2)位置处的元素，输出二维
x[np.ix_([1,5,7,2],[0,3,1,2])]                               # 取1，5，7，2行，0，3，1，2列

# 2、布尔索引————返回布尔值为Ture的值
x[x > 5]
a[~np.isnan(a)]

# 3、np.where，按条件访问数据
np.where(condition, x, y)                                    # 满足 condition 条件返回 x，否则返回 y
np.where(condition)                                          # 满足 condition 条件返回相应元素的坐标

# 4、np.select，按条件操作数据
np.select(condlist, choicelist, default=0)
# condlist：操作数据所依据的条件； choiselist：根据condlist条件所需要执行的操作； default：不满足条件所执行的操作
# 前两个参数必须写成“列表”的形式：
# 例子：np.select([a<6, np.logical_and(a>10, a<16), a>20], [a+10, a**2, a*10], default=100)
参见：Python学习笔记：numpy选择符合条件数据

数据属性

a.shape
a.shape = (3,2)
a.reshape(3,2)

a.ndim

数据操作

np.ravel(arr, order)                                         # 返回展开的一维数组；order：'C'：按行展开，'F'：按列展开，'A'：原顺序，'k'：元素在内存中的出现顺序。
np.transpose(arr, axes)                                      # 翻转给定数组的维度
arr.T                                                        # 转置数组
np.expand_dims(arr, axis)                                    # 在指定位置扩展数据维度，从外向内数
np.squeeze(arr, axis)                                        # 在指定位置减少数据维度，从外向内数
np.around(a,decimals)                                        # decimals 要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置
arr.nonzero()                                                # 返回数组/矩阵中非空元素的目录，如果是多维数组或矩阵，怎返回的行索引和列索引是分开在不同的array中的
np.percentile(a, 90)                                         # 计算一个多维数组的任意百分比分位数
np.percentile(a, [0, 25, 50, 75, 100])                       # 计算一个多维数组的任意百分比分位数

arr[:, np.newaxis()]                                         # 为arr增加一个维度

# 无穷数和空值处理
np.nan                                                       # 生成nan
np.inf                                                       # 生成inf
np.isinf()                                                   # 显示哪些元素为正或负无穷大；若存在，返回Ture
df[np.isinf(df)] = 999                                       # 
np.isposinf()                                                # 显示哪些元素为正无穷大；若存在，返回Ture
np.isneginf()                                                # 显示哪些元素为负无穷大；若存在，返回Ture
np.isnan()                                                   # 显示哪些元素不是数字；若存在，返回Ture
np.isfinite()                                                # 显示哪些元素是有限的（正无穷大和负无穷大中的一个）；若存在，返回False
df[~np.isfinite(df)] = 999                                   # 要使用取反

vfunc = np.vectorize(lambda x: 1 if x>=0.5 else 0)
vfunc(a)

# 数据合并
a = [[0, 1, 2],[3, 4, 5],[6, 7, 8]]
b = [[1, 2, 3],[4, 5, 6],[7, 8, 9]]

对于0/0 的类型，得到的结果是Nan
对于1/0 的类型，得到的结果是Inf（注意还有-inf）

数据合并

import numpy as np

# 二维数据
a = [[0, 1, 2],
     [3, 4, 5],
     [6, 7, 8]]
b = [[1, 2, 3],
     [4, 5, 6],
     [7, 8, 9]]

# 一维数据
c = [0, 1, 2]
d = [1, 2, 3]

np.append(a,b)
np.concatenate()    # 比较常用
np.stack()
np.hstack()
np.vstack()
np.dstack()


np.append(a,b)
"""array([0, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 9])"""
np.append(c,d)
"""array([0, 1, 2, 1, 2, 3])"""


np.concatenate((a,b),axis=1)         # 横向拼接，要求行数相同
""" 
array([[0, 1, 2, 1, 2, 3],
       [3, 4, 5, 4, 5, 6],
       [6, 7, 8, 7, 8, 9]])
""" 
np.concatenate((a,b),axis=0)         # 纵向拼接，要求列数相同
""" 
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8],
       [1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
""" 
np.concatenate((c,d))                # 一维array拼接，没有维度要求，与append效果相同
"""array([0, 1, 2, 1, 2, 3])"""


np.stack((a,b))                      # 前后连接，升维，要求两个array形状必须相同
""" 
array([[[0, 1, 2],
        [3, 4, 5],
        [6, 7, 8]],
       [[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]]])
""" 
np.stack((c,d))                      # 前后连接，升维，要求两个array形状必须相同
""" 
array([[0, 1, 2],
       [1, 2, 3]])
""" 


np.hstack((a,b))                      # 横向拼接，要求行数相同，效果与concatenate(,axis=1)相同
""" 
array([[0, 1, 2, 1, 2, 3],
    [3, 4, 5, 4, 5, 6],
    [6, 7, 8, 7, 8, 9]])
""" 
np.hstack((c,d))
"""array([0, 1, 2, 1, 2, 3])"""


np.vstack((a,b))                      # 纵向拼接，要求列数相同，效果与concatenate(,axis=0)相同
""" 
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8],
       [1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
""" 
np.vstack((c,d))
""" 
array([[0, 1, 2],
       [1, 2, 3]])
""" 


np.dstack((a,b))                      # 竖向拼接，要求形状必须相同
""" 
array([[[0, 1],
       [1, 2],
       [2, 3]],
       [[3, 4],
       [4, 5],
       [5, 6]],
       [[6, 7],
       [7, 8],
       [8, 9]]])
""" 
np.dstack((c,d))
""" 
array([[[0, 1],
        [1, 2],
        [2, 3]]])
"""

数据运算

np.sin(a)  
np.cos(a)  
np.tan(a)

np.add(a,b)  
np.subtract(a,b)  
np.multiply(a,b)
   # 一个 array 可以直接和形状相同的列表用*相乘（返回相同形状的对应元素相乘之后的列表），但是列表和列表之间不行 
np.divide(a,b)

np.reciprocal()                                               # 倒数；对于绝对值大于 1 的整数元素，结果始终为 0， 对于整数 0，则发出溢出警告。
np.power()                                                    # 幂次；此函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。
np..mod()                                                     # 余数；返回两个数组对应位置的余数

np.amin(a, axis)                                              # 返回沿轴的最小值
np.amax(a, axis)                                              # 返回沿轴的最大值
np.argmax(a, axis)                                            # 返回沿轴的最大值的索引
np.argmin(a, axis)                                            # 返回沿轴的最小值的索引
np.nonzero()                                                  # 返回非零值的索引


numpy.percentile(a, q, axis)                                  # q 要计算的百分位数，在 0 ~ 100 之间
np.ptp(a, axis)                                               # 返回沿轴的值的范围
np.median(a, axis)                                            # 返回沿轴的中位数
np.mean(a, axis)                                              # 返回沿轴的算术平均值，沿轴的元素的总和除以元素的数量
np.average(a, weights=wts, returned=True)                     # 如果 returned 参数设为 true，则返回权重的和
np.std(a)                                                     # 方差
np.var(a)                                                     # 标准差

矩阵操作

np.triu(m，k)                                                  # 获取矩阵上三角，m是矩阵，k是对角线的起始位置，k的默认值为0；其他没有取到的位置用0填充
np.tril(m，k)                                                  # 获取矩阵下三角，参数同上

np.dot()                                                      # 两个数组的点积
np.vdot()                                                     # 两个向量的点积
np.inner()                                                    # 两个数组的内积
np.matmul()                                                   # 两个数组的矩阵积
np.determinant()                                              # 数组的行列式
np.solve()                                                    # 求解线性矩阵方程
np.linalg.inv()                                               # 寻找矩阵的乘法逆矩阵

np.ravel(x)                                                   # 寻找矩阵的乘法逆矩阵
x.ravel()

x.flatten()