Numpy库方法总结

数组的基本信息

import numpy as np

ar = np.array([[1,2,3,4,5,6,7], [1,2,3,4,5,6,7]])
print(ar)          # 输出数组，注意数组的格式：中括号，元素之间没有逗号（和列表区分）
print(ar.ndim)     # 输出数组维度的个数（轴数），或者说“秩”，维度的数量也称rank
print(ar.shape)    # 数组的维度，对于n行m列的数组，shape为（n，m）
print(ar.size)     # 数组的元素总数，对于n行m列的数组，元素总数为n*m
print(ar.dtype)    # 数组中元素的类型，类似type()（注意了，type()是函数，.dtype是方法）
print(ar.itemsize) # 数组中每个元素的字节大小，int32l类型字节为4，float64的字节为8

数组的构造

# 创建数组：arange()，类似range()，在给定间隔内返回均匀间隔的值。
print(np.arange(5.0,12,2))  # 返回5.0-12.0，步长为2
# 创建数组：linspace():返回在间隔[开始，停止]上计算的num个均匀间隔的样本。
ar2 = np.linspace(2.0, 3.0, num=5, endpoint=False)
# 创建数组：zeros()/zeros_like()/ones()/ones_like()
ar2 = np.zeros((2,2), dtype = np.int)
ar4 = np.zeros_like(ar3)
ar7 = np.ones_like(ar3)
# 创建一个正方的N*N的单位矩阵，对角线值为1，其余为0
print(np.eye(5))

ndarray的数据类型

bool 用一个字节存储的布尔类型（True或False）

inti 由所在平台决定其大小的整数（一般为int32或int64）

int8 一个字节大小，-128 至 127

int16 整数，-32768 至 32767

int32 整数，-2 ** 31 至 2 ** 32 -1

int64 整数，-2 ** 63 至 2 ** 63 - 1

uint8 无符号整数，0 至 255

uint16 无符号整数，0 至 65535

uint32 无符号整数，0 至 2 ** 32 - 1

uint64 无符号整数，0 至 2 ** 64 - 1

float16 半精度浮点数：16位，正负号1位，指数5位，精度10位

float32 单精度浮点数：32位，正负号1位，指数8位，精度23位

float64或float 双精度浮点数：64位，正负号1位，指数11位，精度52位

complex64 复数，分别用两个32位浮点数表示实部和虚部

complex128或complex 复数，分别用两个64位浮点数表示实部和虚部

数组形状

# 数组形状：.T/.reshape()/.resize()
# .T方法：转置，一维数组转置后结果不变
ar1 = np.arange(10)
# 改变数组形状，不改变元素个数
ar3 = ar1.reshape(2,5)     # 用法1：直接将已有数组改变形状             
ar4 = np.zeros((4,6)).reshape(3,8)   # 用法2：生成数组后直接改变形状
ar5 = np.reshape(np.arange(12),(3,4))   # 用法3：参数内添加数组，目标形状

# numpy.resize(a, new_shape)：返回具有指定形状的新数组，如有必要可重复填充所需数量的元素。
ar6 = np.resize(np.arange(5),(3,4))
print(ar6)

# 注意了：.T/.reshape()/.resize()都是生成新的数组！！！

数组的复制

# 这里ar1和ar2指向同一个值，所以ar1改变，ar2一起改变
ar1 = np.arange(10)
ar2 = ar1
print(ar2 is ar1)
ar1[2] = 9
# copy方法生成数组及其数据的完整拷贝
ar3 = ar1.copy()
print(ar3 is ar1)
ar1[0] = 9
print(ar1,ar3)
# copy方法生成数组及其数据的完整拷贝

数组类型的改变

# 数组类型转换：.astype()
ar1 = np.arange(10,dtype=float)
# a.astype()：转换数组类型
ar2 = ar1.astype(np.int32)
# 注意：养成好习惯，数组类型用np.int32，而不是直接int32

数组堆叠

# numpy.hstack(tup)：水平（按行顺序）堆叠数组
a = np.arange(5)    # a为一维数组，5个元素
b = np.arange(5,9) # b为一维数组,4个元素
ar1 = np.hstack((a,b))  # 注意:((a,b))，这里形状可以不一样
# numpy.vstack(tup)：垂直（按列顺序）堆叠数组
a = np.array([[1],[2],[3]])   
b = np.array([['a'],['b'],['c'],['d']])   
ar2 = np.vstack((a,b))  # 这里形状可以不一样
# numpy.stack(arrays, axis=0)：沿着新轴连接数组的序列，形状必须一样
a = np.arange(5)    
b = np.arange(5,10)
ar1 = np.stack((a,b),axis = 0)按行
ar2 = np.stack((a,b),axis = 1)按列
# 重点解释axis参数的意思，假设两个数组[1 2 3]和[4 5 6]，shape均为(3,0)
# axis=0：[[1 2 3] [4 5 6]]，shape为(2,3)
# axis=1：[[1 4] [2 5] [3 6]]，shape为(3,2)

数组拆分

# numpy.hsplit(ary, indices_or_sections)：将数组水平（逐列）拆分为多个子数组 → 按列拆分
# 输出结果为列表，列表中元素为数组
ar = np.arange(16).reshape(4,4)
ar1 = np.hsplit(ar,2)
# numpy.hsplit(ary, indices_or_sections)：将数组水平（逐列）拆分为多个子数组 → 按列拆分
# 输出结果为列表，列表中元素为数组
ar2 = np.vsplit(ar,4)
print(ar2,type(ar2))

数组简单运算

# 数组简单运算

ar = np.arange(6).reshape(2,3)
print(ar + 10)   # 加法
print(ar * 2)   # 乘法
print(1 / (ar+1))  # 除法
print(ar ** 0.5)  # 幂
# 与标量的运算

print(ar.mean())  # 求平均值
print(ar.max())  # 求最大值
print(ar.min())  # 求最小值
print(ar.std())  # 求标准差
print(ar.var())  # 求方差
print(ar.sum(), np.sum(ar,axis = 0))  # 求和，np.sum() → axis为0，按列求和；axis为1，按行求和
print(np.sort(np.array([1,4,3,2,5,6])))  # 排序
# 常用函数

数组切片

# 基本索引及切片
# 一维数组索引及切片
print(ar[3:6])
# 二次索引，得到一维数组中的一个值
print(ar[2][1]) 
print(ar[2,2])
# 二维数组切片
print(ar[:2,1:])  # 切片数组中的1,2行、2,3,4列 → 二维数组
# 布尔型索引：以布尔型的矩阵去做筛选
ar = np.arange(12).reshape(3,4)
i = np.array([True,False,True])
print(ar[i,:])
# 索引的赋值
b[7:9] = 200

随机数生成

# numpy.random.rand(d0, d1, ..., dn)：生成一个[0,1)之间的随机浮点数或N维浮点数组 —— 均匀分布
# 生成形状为4的一维数组
b = np.random.rand(4)
# 生成形状为2*3的二维数组，注意这里不是((2,3))
c = np.random.rand(2,3)

#  numpy.random.randn(d0, d1, ..., dn)：生成一个浮点数或N维浮点数组 —— 正态分布
samples1 = np.random.randn(1000)

# numpy.random.randint(low, high=None, size=None, dtype='l')：生成一个整数或N维整数数组
print(np.random.randint(2,6,size=5))
print(np.random.randint(2,6,(2,3)))

数据输入和输出

import os
os.chdir('C:/Users/Hjx/Desktop/')
ar = np.random.rand(5,5)
# 存储数组数据 .npy文件
np.save('arraydata.npy', ar)

# 读取数组数据 .npy文件
ar_load =np.load('arraydata.npy')

# 存储/读取文本文件
ar = np.random.rand(5,5)
np.savetxt('array.txt',ar, delimiter=',')
# np.savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ')：存储为文本txt文件
ar_loadtxt = np.loadtxt('array.txt', delimiter=',')
print(ar_loadtxt)
# 也可以直接 np.loadtxt('C:/Users/Hjx/Desktop/array.txt')

数组重复

# 重复数组的一部分
>>> np.repeat(3, 4)
array([3, 3, 3, 3])
>>> x = np.array([[1,2],[3,4]])
>>> np.repeat(x, 2)
array([1, 1, 2, 2, 3, 3, 4, 4])
>>> np.repeat(x, 3, axis=1)
array([[1, 1, 1, 2, 2, 2],
       [3, 3, 3, 4, 4, 4]])
>>> np.repeat(x, [1, 2], axis=0)
array([[1, 2],
       [3, 4],
       [3, 4]])
# 创建一个有重复模式的数组
>>> np.tile(a, (2, 1, 2))
array([[[0, 1, 2, 0, 1, 2]],
       [[0, 1, 2, 0, 1, 2]]])