python笔记——Numpy库

NumPy数值计算

numpy多维数组

数组创建

1.通过array函数创建ndarray数组

np.array(object, dtype=None)

• object：传入的序列类型数据，若为嵌套序列，则创建多维数组
• dtype：指定数组元素类型，默认值为None，系统将从输入的数据推断数据的类型，可能影响系统速度，最好自行指定。

import numpy as np # 导入numpy库，取别名为np
lst1 = [1,2,3,4,5,6] # 定义一个列表
a1=np.array(lst1) # 创建一维数组
print('a1=',a1) # 打印一维数组 
lst2 = [[1,2,3],[4,5,6]] # 定义一个嵌套列表
a2 = np.array(lst2) # 创建二维数组
print('a2=\n',a2) # 打印二维数组
#运行结果：
#a1= [1 2 3 4 5 6]
#a2=
#[[1 2 3]
#[4 5 6]]

import numpy as np
lst1 = [1,2,3,4,5,6] 
# 基本类型可以加或不加引号，numpy类型需要加引号
a1=np.array(lst1, dtype='int32') # dtype=int
print('a1=',a1)
print(a1.dtype)

astype函数

若想将数组元素转换数据类型，可以使用astype()函数

• astype方法会创建一个新的数组，并不会改变原有数组的数据类型。
• 将浮点数转换为整数时元素的小数部分被截断，而不是四舍五入
• 数值型的字符串可以通过astype方法将其转换为数值类型，但如果字符串中有非数值型字符进行转换就会报错。

import numpy as np
a = np.array([[1,2],[3,4]], dtype=float)
b = a.astype('int') 
print('a=\n', a) # 原数组类型未变
print('b=\n', b) 
#a=
#[[1. 2.]
#[3. 4.]]
#b=
#[[1 2]
#[3 4]]


import numpy as np
a = np.array([['1.2', 2.3], [3, 4]])
# 数组自动根据元素的最高类型更改其他元素类型，使其一致
print("a=\n", a)
b = a.astype(float)
print("b=\n", b)
# 浮点数字符串不能直接转int，先转为float，再转int
c = b.astype(int)
print("c=\n", c)
#a=
#[['1.2' '2.3']
# ['3' '4']]
#b=
#[[1.2 2.3]
#[3. 4. ]]
#c=
#[[1 2]
#[3 4]]

函数创建特殊数组

函数名	功能
ones(shape, dtype, order)	创建全1数组
ones_like(a)	按照a数组的形状和元素类型创建全1数组
zeros(shape, dtype, order)	创建全0数组
zeros_like(a)	按照a数组的形状和元素类型创建全0数组
eye(N,M=None,k,dtype,order)	创建对角线为1的对角矩阵
identity(N,dtype=None)	创建单位矩阵
diag(v,k=0)	以一维数组的形式返回方阵的对角线元素，或将一维数组转换成方阵，两种功能角色转变取决于输入的v

linspace函数

linspace 函数用于创建一个一维数组，数组是一个等差数列构成的，其格式如下：

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

参数	描述
start	序列的起始值（没有默认值，不能省）
stop	序列的终止值
num	要生成的等步长的样本数量，默认为50
endpoint	该值为 True 时，数列中包含stop值，反之不包含，默认是True。
retstep	如果为 True 时，生成的数组中会显示间距，反之不显示。
dtype	ndarray 的数据类型

import numpy as np
a1= np.linspace(1,10,5)
print('a1=', a1)
a2 = np.linspace(1,10, 5, retstep=True) # 返回值包含公差
print('a2=', a2)
#a1= [1. 3.25 5.5 7.75 10.]
#a2= (array([1., 3.25, 5.5 , 7.75, 10. ]), 2.25)

logspace函数

创建开始点为start，结束点为end的，以base为底的幂组成的，num个数的等比数列，其格式如下所示：

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

参数	描述
start	序列的起始值
stop	序列的终止值。如果endpoint为True，该值包含于数列中
num	要生成的等步长的样本数量，默认为50
endpoint	该值为 Ture 时，数列中中包含stop值，反之不包含，默认是True
base	底数
dtype	ndarray 的数据类型

import numpy as np
a1= np.logspace(1, 9, 5)
print('a1=', a1)
a2 = np.logspace(1, 9, 5, base=2)
print('a2=',a2)
#c1= [1.e+01 1.e+03 1.e+05 1.e+07 1.e+09]
#c2= [ 2. 8. 32. 128. 512.]

随机数数组

rand函数

产生一个给定形状的数组，数组中的值服从**[0, 1)之间的均匀分布**，其格式如下：

numpy.random.rand(d0, d1, ..., dn)

• 参数d0, d1, …, dn表示每一维的长度（size），为int型，可选。
• 若没有参数则返回一个符合均匀分布的float型随机数

uniform函数

函数uniform返回一个在区间**[low, high)中均匀分布**的数组，其格式如下：

uniform(low=0.0, high=1.0, size=None)

• 参数low, high是float型，low的默认值为0.0，high的默认值为1.0；
• size指定array的形状，是int型数值（一维数组长度）或int型元组（多维数组形状），不指定该参数则返回一个服从均匀分布的随机数

randn函数

返回一个指定形状的数组，数组中的值服从**标准正态(normal)分布，**格式如下：

numpy.random.randn(d0, d1, ..., dn)

• 参数：d0, d, …, dn指定形状size，int型，可选。
• 如果没有参数，则返回一个服从标准正态分布的float型随机数。

normal函数

生成指定正态分布的概率密度随机数，其格式如下：

numpy.random.normal(loc=0.0, scale=1.0, size=None)

• loc（ 𝜇 ）：float ，此概率分布的均值
• scale（𝛿）：float， 此概率分布的标准差
• size：int or tuple of ints， 输出的shape，默认为None，只输出一个值。

randint函数

函数randint生成一个在区间[low, high)中离散均匀分布的整数数组，格式如下：

numpy.random.randint(low, high=None, size=None, dtype='l')

• low, high：int型，指定抽样区间[low, high)，如果没有写参数high的值，则指定抽样区间为[0,low)。
• size：int型或int型的元组，指定形状
• dypte：可选参数，指定整数数据类型，比如int、int64(i8)等
• 返回值：如果指定了size，则返回一个int型的ndarray对象，否则返回一个服从该分布的int型随机数。

permutation函数

随机排列一个序列，或者数组

numpy.random.permutation(x)

• 如果x是整数，则随机排列np.arange(x)
• 如果x是一维数组或序列，对其复制之后再打乱其元素
• 如果x是多维数组，则沿最小维索引随机排列数组

shuffle函数

对numpy的数组进行原地重新随机排序，如果是多维数组，沿最小维进行随机排序，返回值为None

numpy.random.shuffle(x)

shuffle与permutation都是对原来的数组进行重新洗牌（即随机打乱原来的元素顺序）。

区别在于shuffle直接在原来的数组上进行操作，改变原来数组的顺序，无返回值；

而permutation不直接在原来的数组上进行操作，而是返回一个新的打乱顺序的数组，并不改变原来的数组。

此外，shuffle不能传入int参数。

数组对象属性

属性	描述
ndim	数组维度
shape	数组形状
size	数组元素个数
dtype	数组元素的数据类型
itemsize	数组中每个元素所占字节数
nbytes	存储整个数组元素所需字节，nbytes=itemsize*size
T	数组的转置
flat	返回一个numpy.flatiter对象，可以使用flat的迭代器来遍历数组

数组操作

修改数组形状

reshape函数

函数reshape 在不改变数据的条件下修改形状，其格式如下：

numpy.reshape(arr, newshape, order='C') # 全局函数
array.reshape(newshape,order='C') # 成员函数

参数	描述
array	要修改形状的数组
newshape	新形状参数，为整数或者整数元组，新的形状应当兼容原有形状
order	‘C’ 按行， 'F’按列

flatten函数

将高维度数组展平，返回一个一维的数组，其格式如下：

array. flatten(order='C')

ravel函数

函数ravel 展平数组元素，返回的是数组视图，其函数格式如下所示：

numpy.ravel(a, order='C')
array.ravel(order='C')

与flatten()的不同：

1. 使用ravel()创建的新数组实际上是对父数组的引用（即“视图”）。这意味着对新数组的任何更改也将影响父数组。因为ravel不创建拷贝，所以它的内存效率很高
2. ravel函数有成员函数和全局函数两种形式，flatten只有成员函数形式。

翻转数组

函数	描述
transpose	对换数组的维度
swapaxes	对换数组的两个轴

numpy.transpose函数

交换数组的维度索引值（轴序号），格式如下所示：

numpy.transpose(arr, axes)
narray.transpose(axes)

参数说明如下所示：

• arr：要操作的数组。
• axes：整数序列，对应维度序号。若是2维，则可省略该参数，直接交换行列，即转置

numpy.swapaxes函数

numpy.swapaxes函数用于交换数组的两个轴，格式如下所示：

numpy.swapaxes(arr, axis1, axis2)
narray.swapaxes(axis1, axis2)

swapaxes实际上也是针对轴索引进行变化，区别就在于transpose可以一次传入多个参数，对若干轴进行交换，而swapaxes只能两两置换，且swapaxes(i,j)和swapaxes(j,i)没有区别

连接数组

函数	描述
concatenate	沿轴连接数组或序列
stack	沿着新轴堆叠一系列数组
hstack	水平堆叠序列中的数组（列方向）
vstack	竖直堆叠序列中的数组（行方向）

numpy.concatenate

numpy.concatenate函数用于沿指定轴连接形状兼容、维度相同的两个或多个数组，格式如下所示。

numpy.concatenate((a1, a2, ...), axis=0)

参数:

• (a1, a2, …)：形状兼容的数组组成的元组
• axis：沿着它连接数组的轴序号，默认为 0

numpy.hstack

• 在水平方向上堆叠两个或多个形状兼容的数组形成新的数组
• 机器学习数据集准备过程中，可以用于将数据列与标签列在水平方向上合并，从而得到带标签的数据集

import numpy as np
a = np.array([['姓名'] ,['年龄'], ['籍贯']]) 
b = np.array([['张三','李四','王五'], [18,19,16], ['长沙','上海','南京']])
c = np.hstack((a,b)) # 等同于np.concatenate((a,b),1)
print('c=\n', c)
#输出：
#a=
#[['姓名']
#['年龄']
#['籍贯']]
#b=
#[['张三' '李四' '王五']
#['18' '19' '16']
#['长沙' '上海' '南京']]
#c=
#[['姓名' '张三' '李四' '王五']
#['年龄' '18' '19' '16']
#['籍贯' '长沙' '上海' '南京']]

numpy.vstack

• 在垂直方向上堆叠两个或多个形状兼容的数组形成新的数组
• 机器学习数据集准备过程中，可以用于将标题行以及从多个数据文件中加载的数据行在垂直方向上合并，从而将所有数据集整合为一个数据集。

import numpy as np
a = np.array(['姓名', '年龄', '籍贯']) 
b = np.array([['张三',18,'长沙'],['李四',19,'上海'],['王五',16,'南京']]) 
c = np.vstack((a,b)) # 一维a数组可以与二维b数组vstack 
# np.concatenate((a,b),0)出错，需要将a改为[['姓名','年龄','籍贯']]
print("c=\n", c)
#a=
#['姓名' '年龄' '籍贯']
#b=
#[['张三' '18' '长沙']
#['李四' '19' '上海']
#['王五' '16' '南京']]
#c=
#[['姓名' '年龄' '籍贯']
#['张三' '18' '长沙']
#['李四' '19' '上海']
#['王五' '16' '南京']]

numpy.stack

numpy.stack(arrays, axis=0)

将一系列数组沿一个新轴合并。其中axis指定了新轴在所得数组维度中的索引值。如果axis=0，将沿第一个维度，如果axis=-1将沿最后一个维度

参数：

• arrays: 指一系列数组（打包成元组），且每个数组需具有相同形状。
• axis: 整型，非必须。输入数组在所得数组中的堆叠方向

返回：

• 堆叠后的新数组，且堆叠后的数组比输入的数组多一个维度。

分割数组

函数	描述
split	将一个数组分割为多个子数组
hsplit	将一个数组水平分割为多个子数组（按列）
vsplit	将一个数组垂直分割为多个子数组（按行）

numpy.split

分割数组函数如表所示

numpy.split函数沿特定的轴将数组分割为子数组，返回值增加一维：

numpy.split(array, indices_or_sections, axis)

参数：

• array：被分割的数组
• indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置
• axis：沿着哪个维度进行切分，默认为0

numpy.hsplit

numpy.hsplit函数用于水平均分数组，不能均分则出错。

numpy.hsplit(array, indices_or_sections)

numpy.vsplit

numpy.vsplit沿着垂直轴均分数组，不能均分则出错

numpy.hsplit(array, indices_or_sections)

数组元素的添加和删除

函数	描述
resize	返回指定形状的新数组
append	将值添加到数组末尾
insert	沿指定轴将值插入到指定下标之前
delete	删掉某个轴的子数组，并返回删除后的新数组

numpy.resize

按照shape的形状拓展arr，不够的依次按原数组单个元素排列顺序补全，返回指定大小的新数组。

numpy.resize(arr, shape) # 全局函数，返回新形状数组，不修改原数组arr
arr.resize(shape) # 成员函数，原地修改arr形状，返回值为None

• arr：要修改大小的数组
• shape：新形状(数组或序列）

注：numpy.resize可以多退少补数据，array.reshape必须和原数组数据量一样

numpy.append

• numpy.append函数在数组的末尾添加值，输入数组的形状必须与原数组匹配，否则出错。

• append 格式：

  numpy.append(arr, values, axis=None)
  

  • arr：输入数组
  • values：要向arr添加的值，需要和arr形状（除了要添加的轴）和维度相同
  • axis：默认为 None
    • axis为None时，是横向加成，返回一维数组
    • axis为0时，数据是加在下边（列数要相同）
    • axis为1时，数组是加在右边（行数要相同）

numpy.insert

numpy.insert函数在给定索引之前，沿给定轴在输入数组中插入值

numpy.insert(arr, index, values, axis=None)

• arr：输入数组
• index：在其之前插入值的索引，可以是序列数据（如元组、列表），实现在多个索引之前插入数据
• values：要插入的数据，可以是序列数据，但其形状必须与原数组匹配
• axis：沿着它插入的轴，如果未提供，则输入数组会被展开

numpy.delete

numpy.delete函数返回从输入数组中删除指定子数组的新数组。 与insert()函数的情况一样，如果未提供轴参数，则输入数组将展开。

numpy.delete(arr, obj, axis)

• arr：输入数组
• obj：可取值为slice（前闭后开）、 int 、int类型的array、int类型的序列等，指示要沿指定轴删除的子数组的索引
• axis未指定：arr会先按行展开，然后按照obj删除，返回一个行矩阵
• axis = 0：按行删除
• axis = 1：按列删除

数组运算

广播

• Numpy中的基本运算（加、减、乘、除、求余等等）都是元素级别的，但是这仅仅局限于两个数组的形状相同的前提下。
• 广播是指NumPy在算术运算期间处理不同形状的数组的能力。如果两个数组的维数不相同，numpy将会自动触发广播机制较小的数组会被广播到较大数组的大小，以便使它们的形状可兼容

numpy全局算术函数

函数	描述
isnan	返回布尔数组标识哪些元素是 NaN （不是一个数）
isfinite isinf	判断元素是有限的数 判断元素是否无限大

函数	描述
add(+)	数组对应元素相加
substract(-)	数组对应元素相减
multiply(*)	点积，矩阵对应位置相乘，必要时使用广播规则
divide(/)	除法
mod(%)	模运算（求余）
power	用第二个数组作为指数，计算第一个数组中的元素的幂

集合运算

unique：唯一值

np.unique方法用于找出数组中的唯一值，并返回已排序的结果，格式如下：

numpy.unique(arr, return_index, return_inverse, return_counts)

• arr：输入数组，如果不是一维数组则会展开成一维数组
• return_index：若为true，返回新数组元素在旧数组中的位置（下标），并以列表形式存储
• return_inverse：若为true，返回旧数组元素在新数组中的位置（下标），并以列表形式储
• return_counts：若为true，返回去重数组中的元素在原数组中的出现次数

in1d：是否包含

函数返回一个与ar1长度相同的布尔数组（若数组是多维数组，则被展平再判断）。若ar1的元素在ar2中有，该数组元素为True，否则为False

numpy.in1d(ar1, ar2, assume_unique=False, invert=False)

• assume_unique ：bool, 可选。如果为True，则假定输入数组都是唯一的，这可以加快计算速度。 默认值为False
• invert ：bool, 可选。如果为True，则返回的数组中的值将被反转，即，在ar1中的一个元素位于ar2中时为False，否则为True。 默认值为False

统计运算

NumPy库支持对整个数组或按指定轴向的数据进行统计计算。统计函数有axis参数，用于计算指定轴方向的统计值，axis默认值为None，此时把数组当成一维数组

排序

numpy.sort()

函数sort()返回输入数组的排序副本，格式如下：

numpy.sort(a, axis, kind, order)

• a 要排序的数组
• axis：选择按照哪一个坐标轴进行排序，如果设定为None值，就会先对被排序数组进行扁平化，再进行排序。如果不进行值的而设定，那么默认值为-1，即沿着最后一个坐标轴进行排序
• kind 默认为‘quicksort’(快速排序)，可设置为’mergesort’归并排序，‘heapsort’堆排序。
• order：如果数组包含字段，则表示要排序的字段

numpy.argsort()

返回数组值从小到大的索引值

numpy.argsort(a, axis=-1, kind='quicksort', order=None)

参数：

• a为要排序的数组
• axis：按哪一维进行排序，默认-1，the last axis
• kind：排序算法的选择，有quicksort，mergesort，heapsort

搜索

numpy.where()

where()有两种形式

np.where(condition)

参数只有条件condition，输出满足条件元素的坐标（索引）。这里的坐标以tuple的形式给出，通常原数组有多少维，输出的tuple中就包含几个数组，分别对应符合条件元素的各维坐标

np.where(condition, x, y)

满足条件condition输出x，不满足输出y

numpy.extract(condition, arr)

与where函数相似，但extract函数是返回满足条件的元素，而不是元素索引

numpy.nonzero()

返回输入数组中非零元素的索引。

线性代数

函数	描述
dot	两个数组的点积
vdot	两个向量的点积
det	数组的行列式
solve	求解线性矩阵方程
inv	计算矩阵的乘法逆矩阵

numpy.dot()

• 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积之和
• 对于二维数组，计算的是两个数组的矩阵乘积
• 二维数组和一维数组的点积，则将一维数组转置后计算矩阵乘积，最后结果还原成向量

numpy.dot(a, b, out=None) 或 a.dot(b,out=None)

参数说明：

• a : ndarray 数组
• b : ndarray 数组
• out : ndarray, 可选，用来保存dot()的计算结果，必须与乘积结果的维度、长度、类型一致

numpy.vdot()

• 函数vdot是两个向量的点积（对应元素乘积之和）

• 如果第一个参数是复数，则将第一个参数的复共轭用于点积的计算

numpy.linalg.det()

• 计算矩阵的行列式

numpyp.linalg.solve()

• 求解线性方程组

numpy.linalg.inv()

• 计算方阵的乘法逆矩阵（A*B=I）

  注意：如果矩阵是奇异的或者非方阵，使用inv函数求逆矩阵，会出现错误

补充：numpy.linalg.pinv()

• 如果A不是方阵或者不可逆，求其伪逆矩阵

numpy.linalg.eigvals()和numpy.linalg.eig()

• 计算特征值时，我们可以用numpy.linalg程序包提供的eigvals()函数eig()函数，其中函数eigvals返回矩阵的特征向量，eig函数返回一个元组，其元素为特征值和特征向量（列向量）

数组的存取

np.savetxt

• Numpy中通过np.savetxt方法对数组进行存储

• numpy.savetxt(fname, X, fmt='%.18e', delimiter=' ')
  

参数：

• fname：文件名或者文件句柄
• X：将要被写入文件的一维或者二维数组
• fmt：格式字符串，缺省时为 %.18e
• delimiter：分隔符，缺省时为空格

np.loadtxt

• Numpy中通过np.loadtxt方法对存储数组文件进行读取，并将其加载到一个数组中

• numpy.loadtxt(fname, dtype=np.float, delimiter=None)
  

  参数：

  • fname：文件名
  • dtype：文件中读入的数据以说明类型返回，默认为np.float类型
  • delimiter：分隔符，缺省时为空

附件1

math库

常数

常数	描述
pi	圆周率
e	自然对数
inf	正无穷大，-inf为负无穷大
nan	Not a Number float(‘inf’) - float(‘inf’)

函数

数学函数	描述
fabs(x)	返回x的绝对值
fmod(x,y)	x%y
fsum([x,y,……])	所有浮点数之和
gcd(a,b)	a和b的最大公约数,a和b为整数
trunc(x)	x的整数部分
modf(x)	x的小数和整数部分
ceil(x)	向上取整
floor(x)	向下取整
factorial(a)	a的阶乘 a!
log(x[,base])	x的以base为底的对数，base默认为e

函数	描述
pow(x,y)	x的y次幂
exp(x)	e的x次幂
sqrt(x)	x的平方根
log(x[,base])	x以base为底的对数
log2(x)	x以2为底的对数
log10(x)	x以10为底的对数
degrees(x)	x为弧度制，返回对应的角度值
radians(x)	x为角度值，返回对应的弧度值
hypot(x,y)	(x,y)到(0,0的距离)

函数	描述
sin(x)	sinx
cos(x)	cosx
tan(x)	tanx
asin(x)	arcsinx
acos(x)	arccosx
atan(x)	arctanx

random库

from random import randint

函数	描述
random()	返回[0.0,1.0)中的一个随机浮点数
uniform(m,n)	生成一个[m,n]之间的随机浮点数
randint(start,end)	返回一个[start,end]区间的随机整数
random.randrange([start,]stop[,step])	返回[start,end)里的一个随机整数，可指定步长
choice(s)	从一个列表、元组或字符串中随机选取一个元素返回
sample(pop,k)	从pop类型中随机选取k个元素，以列表类型返回
shuffle(s)	将序列类型中的元素随机排列，返回打乱后的序列
seed(n)	用整数n重置随机数生成器(设置相同的n，产生的随机数相同)。缺省则利用系统当时的时间重置随机数生成器