Numpy
什么是Numpy？
NumPy是Python中科学计算的基础软件包。 它是一个提供多了维数组对象，多种派生对象（如：掩码数组、矩阵）以及用于快速操作数组的函数及API， 它包括数学、逻辑、数组形状变换、排序、选择、I/O 、离散傅立叶变换、基本线性代数、基本统计运算、随机模拟等等。
NumPy中的核心是ndarray对象。ndarray对象是具有相同类型和大小（通常是固定大小）项目的多维容器。可以对其进行索引、切片、形状变换等操作。
关于axis
根据官方的说法，1表示横轴，方向从左到右；0表示纵轴，方向从上到下，即axis=1为横向，axis=0为纵向。
有时候理解为行和列会很容易使用的，但实际不是表示行列
数组
数组内元素的类型需要相同
创建数组大小固定
创建数组
In [1]：
import numpy as np
a = np.array( # 创建一个1x3的一维数组
[1,2,3]
)
aOut[1]：
array([1, 2, 3])In [2]：
type(a) # 数据类型Out[2]：
numpy.ndarray # 数组类型为ndarrayndarray对象的属性
ndarray.shape
数组的形状。返回一个元组表示各个维度中数组的大小。
In [3]：
a.shape # 每行元素的个数Out[3]：
(3,)In [11]：
b = np.array( # 创建一个2x3的二维数组
[
[1,2,3],
[4,5,6]
]
)
bOut[11]：
array([[1, 2, 3],
[4, 5, 6]])In [13]：
b.shape # 数组形状即几行几列Out[13]：
(2, 3)ndarray.ndim
数组的轴（维度）的个数即几行。维度的数量被称为rank。
In [4]：
a.ndim # 1行，维度即几行Out[4]：
1ndarray.size
数组中元素的总数。等于shape各个元素的乘积。
In [5]：
a.size # 数组中元素的总个数Out[5]：
3ndarray.dtype
一个描述数组中元素类型的对象。
In [6]：
a.dtype # 数组中元素的类型Out[6]：
dtype('int32')ndarray.itemsize
数组中每个元素的字节大小。
In [7]：
a.itemsize # 数组中每个元素的字节大小Out[7]：
4ndarray.real
数组的实部
In [8]：
g = np.array(
[1+2j,2+3j]
)
g.dtypeOut[8]：
dtype('complex128')In [9]：
g.realOut[9]：
array([1., 2.])ndarray.imag
数组的虚部
In [10]：
g.imagOut[10]：
array([2., 3.])ndarray的创建方法
nd.array()
In [1]：
import numpy as np
np.array( # 创建一个1x3的一维数组
[1,2,3]Out[1]：
array([1, 2, 3])np.asarray()
array()和asarray()都可以将结构数据转化为ndarray，但是主要区别就是当数据源是ndarray时，array仍然会copy出一个副本，占用新的内存，但asarray不会。
In [14]：
np.asarray([1,2])Out[14]：
array([1, 2])In [15]：
np.asarray(np.array([1,2,3]))Out[15]：
array([1, 2, 3])np.zeros(shape, dtype=float)
创建一个全为0的数组（ndarray对象）
shape：形状，即创建几行几列的数组
dtype：数组内值得数据类型
In [16]：
np.zeros(5,dtype=int)Out[16]：
array([0, 0, 0, 0, 0])In [17]：
np.zeros((5,))Out[17]：
array([0., 0., 0., 0., 0.])In [18]：
np.zeros((5,5))Out[18]：
array([[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]])np.zeros_like()
传入一个数组作为参数，根据该数组的形状和dtype创建一个全0的ndaray对象
In [19]：
np.zeros_like(
[
[1.2,1.3,2],
[1.2,1.3,2]
]
)Out[19]：
array([[0., 0., 0.],
[0., 0., 0.]])np.empty((shape, dtype=float)
类似于np.zeros(),但只分配内存但是不填充任何值
shape：形状，即创建几行几列的数组
dtype：数组内值得数据类型
In [20]：
np.empty(5)Out[20]：
array([0., 0., 0., 0., 0.])np.empty_like()
同上
略
np.full(shape, fill_value, dtype=None,)
根据指定形状传建一个数组（ndarray对象），并用fill_value的值进行填充
shape：指定ndarray数组的大小、
fill_vallue：填充值，即数组内值全为fill_valule
In [21]：
np.full((3,2),fill_value=5)Out[21]：
array([[5, 5],
[5, 5],
[5, 5]])np.full_like()
同上
略
np.eye()
传入一个整数N，创建一个N * N的单位矩阵
In [22]：
np.eye(5) # 创建一个5x5的单位矩阵(identity matrix)Out[22]：
array([[1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 0., 0., 1.]])np.identity()
传入一个整数N，创建一个N * N的单位矩阵，类似于np.eye()
In [23]：
np.identity(5)Out[23]：
array([[1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 0., 0., 1.]])np.random
随机抽样创建数组
rand：产生指定形状的均匀分布的样本值
randn：返回一个或一组样本，具有标准正态分布
randint：从给定的上下限范围内选取随机整数
binomial：产生二项分布的样本值
normal：产生正态（高斯）分布的样本值
beta：生Beta分布的样本值
chisquare：产生卡方分布的样本值
gamma：产生Gamma分布的样本值
uniform：产生在指定范围中均匀分布的样本值
shuffle：一个序列就地随机排列
In [24]：
np.random.rand(3,2)Out[24]：
array([[0.87739699, 0.62405667],
[0.05264142, 0.21515255],
[0.34419254, 0.79204327]])In [25]：
np.random.randn(3,2)Out[25]：
array([[-0.71596008, -0.73378479],
[-0.99908948, 0.70328556],
[-0.55219447, 0.02029755]])np.arange(start,stop,step,dtype)
创建一位数组，从start~stop（不包括stop）范围内选取值，步长为step，默认为1
In [26]：
np.arange(5)Out[26]：
array([0, 1, 2, 3, 4])In [27]：
np.arange(5,5)Out[27]：
array([], dtype=int32)In [28]：
np.arange(1,5,2)Out[28]：
array([1, 3])np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
返回一个在指定范围内(start~stop，但不包括stop)指定大小num（默认为50）的一位数组
In [29]：
np.linspace(1,5)Out[29]：
array([1. , 1.08163265, 1.16326531, 1.24489796, 1.32653061,
1.40816327, 1.48979592, 1.57142857, 1.65306122, 1.73469388,
1.81632653, 1.89795918, 1.97959184, 2.06122449, 2.14285714,
2.2244898 , 2.30612245, 2.3877551 , 2.46938776, 2.55102041,
2.63265306, 2.71428571, 2.79591837, 2.87755102, 2.95918367,
3.04081633, 3.12244898, 3.20408163, 3.28571429, 3.36734694,
3.44897959, 3.53061224, 3.6122449 , 3.69387755, 3.7755102 ,
3.85714286, 3.93877551, 4.02040816, 4.10204082, 4.18367347,
4.26530612, 4.34693878, 4.42857143, 4.51020408, 4.59183673,
4.67346939, 4.75510204, 4.83673469, 4.91836735, 5. ])In [30]：
np.linspace(1,5,2)Out[30]：
array([1., 5.])np.fromfunction(function, shape, **kwargs)
通过对每个执行函数来构造一个数组
function：执行函数
shape：数组大小
In [31]:
def mime(a,b):
return b
np.fromfunction(mime,(3,3))Out[31]:
array([[0., 1., 2.],
[0., 1., 2.],
[0., 1., 2.]])In [32]:
def mime(a,b):
return a
np.fromfunction(mime,(3,3))Out[32]:
array([[0., 0., 0.],
[1., 1., 1.],
[2., 2., 2.]])In [33]:
def add(a,b):
return a+b
np.fromfunction(add,(3,3))Out[33]:
array([[0., 1., 2.],
[1., 2., 3.],
[2., 3., 4.]])In [34]:
def dot(a,b):
return a*b
np.fromfunction(dot,(3,3))Out[34]:
array([[0., 0., 0.],
[0., 1., 2.],
[0., 2., 4.]])数据类型
所有的数据类型如下表所示：
int8、uint8
i1、u1
有符号和无符号的8位（1个字节）整形
int16、uint16
i2、u2
有符号和无符号的16位（2个字节）整形
int32、uint32
i4、u4
有符号和无符号的32位（4个字节）整形
int64、uint64
i8、u8
有符号和无符号的64位（8个字节）整形
float16
f2
半精度浮点数
float32
f4或f
标准的单精度浮点数
float64
f8或d
标准的双精度浮点数
float128
f16或g
扩展精度浮点数
bool
?
存储布尔类型（存储为一个字节）
object
O
Python对象类型
string_
S
固定长度的字符串类型（每个字符1个字节）
unicode_
U
固定长度的unicode类型（字节数由平台决定）
complex64、complex128、complex256
c8、c16、c32
分别用两个32位、64位或128位浮点数表示的复数
注意：int_为int32的简写，float_为float64的简写，complex_为complex128的简写
In [1]:
a = np.array([1,2,3])
a.dtypeOut[1]:
dtype('int32')数组运算
In [1]:
import numpy as npIn [2]:
a = np.array([
[1,2,3],
[4,5,6],
])
aOut[2]:
array([[1, 2, 3],
[4, 5, 6]])数组与标量的算术运算
In [3]:
a * 2Out[3]:
array([[ 2, 4, 6],
[ 8, 10, 12]])加法
In [5]:
a+aOut[5]:
array([[ 2, 4, 6],
[ 8, 10, 12]])减法
In [6]:
a-a # np.subtract(a,a)Out[6]:
array([[0, 0, 0],
[0, 0, 0]])除法
In [7]:
a/a # np.divide(a,a)Out[7]:
array([[1., 1., 1.],
[1., 1., 1.]])In [8]:
星乘（*）与点乘（.）
In [8]:
a = np.array([
[1,2,3],
[1,2,3]
])
b = np.array([
[1,1,1],
[1,1,1]
])In [9]:
a*b # np.multiply(a,b)Out[9]:
array([[1, 2, 3],
[1, 2, 3]])In [10]:
np.dot(a,b)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-10-3339b236d1c5> in <module>
----> 1 np.dot(a,b)
<__array_function__ internals> in dot(*args, **kwargs)
ValueError: shapes (2,3) and (2,3) not aligned: 3 (dim 1) != 2 (dim 0)In [11]:
a = np.array([
[1,2,],
[1,2,]
])
b = np.array([
[1,1,],
[1,1,]
])In [12]:
np.dot(a,b)Out[12]:
array([[3, 3],
[3, 3]])In [13]:
a.dot(b)Out[13]:
array([[3, 3],
[3, 3]])拷贝
完全不拷贝：两个变量公用一个数组，引用的地址都是同一个
In [14]:
a = np.arange(10)
b = aOut[14]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])In [15]:
aOut[15]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])In [16]:
bOut[16]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])In [17]:
b[0] = 100
bOut[17]:
array([100, 1, 2, 3, 4, 5, 6, 7, 8, 9])In [18]:
aOut[18]:
array([100, 1, 2, 3, 4, 5, 6, 7, 8, 9])浅拷贝：与上有区别，一个数组值会变化会反映在另一个数组上，但是形状不变化
In [21]:
a = np.arange(10)
b = a.view()In [22]:
aOut[22]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])In [23]:
bOut[23]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])In [24]:
b[0] = 500In [25]:
aOut[25]:
array([500, 1, 2, 3, 4, 5, 6, 7, 8, 9])In [26]:
bOut[26]:
array([500, 1, 2, 3, 4, 5, 6, 7, 8, 9])In [30]:
b.shape = (10,1)
bOut[30]:
array([[500],
[ 1],
[ 2],
[ 3],
[ 4],
[ 5],
[ 6],
[ 7],
[ 8],
[ 9]])In [31]:
aOut[31]:
array([500, 1, 2, 3, 4, 5, 6, 7, 8, 9])深拷贝：创建原数组的副本，副本的任何变化都不会反映在原数组上
In [32]:
a = np.arange(10)
b = a.copy()In [33]:
b[0] = 500In [34]:
aOut[34]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])In [35]:
bOut[35]:
array([500, 1, 2, 3, 4, 5, 6, 7, 8, 9])索引与切片
In [36]:
a = np.arange(36).reshape(6,6)
aOut[36]:
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23],
[24, 25, 26, 27, 28, 29],
[30, 31, 32, 33, 34, 35]])取第2,3,4行的数据，注意索引从0开始
In [37]:
a[[1,2,3]]Out[37]:
array([[ 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23]])取（2,4），（3,5），（4,6）的值
In [39]:
a[[1,2,3],[3,4,5]]Out[39]:
array([ 9, 16, 23])取第2,3,4行后，再取第4,5,6列的值
In [42]:
a[[1,2,3]][:,[3,4,5]]Out[42]:
array([[ 9, 10, 11],
[15, 16, 17],
[21, 22, 23]])统计方法 ☆☆☆
In [1]:
import numpy as npIn [2]:
a = np.array([
[np.NaN,2,3,4],
[2,np.NaN,4,5],
[3,4,np.NaN,6]
])In [3]:
aOut[3]:
array([[nan, 2., 3., 4.],
[ 2., nan, 4., 5.],
[ 3., 4., nan, 6.]])amin(a[, axis, out, keepdims]
返回数组的最小值或沿轴的最小值
见下
amax(a[, axis, out, keepdims])
返回数组的最大值或沿轴的最大值
In [4]:
np.amax(a,axis=0) # axis=0表示列Out[4]:
array([nan, nan, nan, 6.])In [5]:
np.amax(a,axis=1) # axis=1表示行Out[5]:
array([nan, nan, nan])In [6]:
np.amax(a) # 整个数组Out[6]:
nannanmin(a[, axis, out, keepdims])
返回数组的最小值或沿轴的最小值，忽略任何NAN
见下
nanmax(a[, axis, out, keepdims])
返回数组的最大值或沿轴方向的最大值，忽略任何NAN
In [7]:
np.nanmin(a)Out[7]:
2.0In [8]:
np.nanmax(a)Out[8]:
6.0median(a[, axis, out, overwrite_input, keepdims])
沿指定轴计算中值
略
#### nanmedian(a[, axis, out, overwrite_input, …])
在忽略NAS的情况下，沿指定的轴计算中值
In [9]:
np.nanmedian(a)Out[9]:
4.0average(a[, axis, weights, returned])
计算沿指定轴的加权平均
见下
mean(a[, axis, dtype, out, keepdims])
沿指定的轴计算算术平均值
见下
nanmean(a[, axis, dtype, out, keepdims])
计算沿指定轴的算术平均值，忽略NAN
In [11]:
b = a.copy()
bOut[11]:
array([[nan, 2., 3., 4.],
[ 2., nan, 4., 5.],
[ 3., 4., nan, 6.]])In [12]:
b[np.isnan(b)]=np.nanmean(b) # 筛选出所有nan值然后用均值进行替换
bOut[12]:
array([[3.66666667, 2. , 3. , 4. ],
[2. , 3.66666667, 4. , 5. ],
[3. , 4. , 3.66666667, 6. ]])std(a[, axis, dtype, out, ddof, keepdims])
计算沿指定轴的标准偏差即标准差
见下
nanstd(a[, axis, dtype, out, ddof, keepdims])
计算指定轴上的标准偏差，而忽略NAN
In [14]:
np.nanstd(a)Out[14]:
1.247219128924647var(a[, axis, dtype, out, ddof, keepdims])
计算沿指定轴的方差
见下
nanvar(a[, axis, dtype, out, ddof, keepdims])
计算指定轴上的方差，同时忽略NAN
In [15]:
np.nanvar(a)Out[15]:
1.5555555555555556形状变换
重塑
ndarray.reshape(shape, order='C')
ndarray.resize()
注意：reshape 函数返回修改后的新对象，而 ndarray.resize 方法修改数组本身
重塑的各个维度上整数的乘积必须等于arr.size
如果想让自动计算某个轴上的大小，可以传入-1
扁平化处理
In [1]:
import numpy as np
a = np.array([[1,2,5],[2,3,5],[3,4,5],[2,3,6]])
aOut[1]:
array([[1, 2, 5],
[2, 3, 5],
[3, 4, 5],
[2, 3, 6]])In [2]:
a.flatten()Out[2]:
array([1, 2, 5, 2, 3, 5, 3, 4, 5, 2, 3, 6])In [3]:
b = a.ravel() # flatten()与ravel()都是讲数组变成一维数组，但是flatten会重新创建一个新的对 # 象，ravel()只是返回一个视图，如果修改了其中的值，原数组也会被修改In [4]:
b[0] = 100
aOut[4]:
array([[100, 2, 5],
[ 2, 3, 5],
[ 3, 4, 5],
[ 2, 3, 6]])数组合并
concatenate
沿着一条轴连接一组（多个）数组。除了与axis对应的轴之外，其它轴必须有相同的形状。
In [1]:
import numpy as np
a = np.array([
[1,2,3],
[4,5,6]
])
b = np.array([
[5,6,7],
[8,9,10]
])In [2]:
np.concatenate((a,b),axis=0) # 垂直拼接Out[2]:
array([[ 1, 2, 3],
[ 4, 5, 6],
[ 5, 6, 7],
[ 8, 9, 10]])In [3]:
np.concatenate((a,b),axis=1) # 将两个二维数组分别转化为一维数组后，在垂直拼接Out[3]:
array([[ 1, 2, 3, 5, 6, 7],
[ 4, 5, 6, 8, 9, 10]])vstack&row_stack
以追加行的方式对数组进行连接（沿轴0）即垂直方向
In [4]:
np.vstack((a,b))Out[4]:
array([[ 1, 2, 3],
[ 4, 5, 6],
[ 5, 6, 7],
[ 8, 9, 10]])In [5]:
np.row_stack((a,b))Out[5]:
array([[ 1, 2, 3],
[ 4, 5, 6],
[ 5, 6, 7],
[ 8, 9, 10]])hstack
以追加列的方式对数组进行连接（沿轴1）即水平方向
In [6]:
np.hstack((a,b))Out[6]:
array([[ 1, 2, 3, 5, 6, 7],
[ 4, 5, 6, 8, 9, 10]])column_stack
类似于hstack，但是会先将一维数组转换为二维列向量
In [7]:
np.column_stack((a,b))Out[7]:
array([[ 1, 2, 3, 5, 6, 7],
[ 4, 5, 6, 8, 9, 10]])dstack
以面向“深度”的方式对数组进行叠加
In [8]:
np.dstack((a,b))Out[8]:
array([[[ 1, 5],
[ 2, 6],
[ 3, 7]],
[[ 4, 8],
[ 5, 9],
[ 6, 10]]])数组拆分
split
沿指定轴在指定的位置拆分数组
In [9]:
c = np.arange(36).reshape(6,-1)
cOut[9]:
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23],
[24, 25, 26, 27, 28, 29],
[30, 31, 32, 33, 34, 35]])In [10]:
np.split(c,2,axis=0) # 从第二行开始进行拆分，axis=0代表行方向Out[10]:
[array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17]]),
array([[18, 19, 20, 21, 22, 23],
[24, 25, 26, 27, 28, 29],
[30, 31, 32, 33, 34, 35]])]In [11]:
np.split(c,2,axis=1) # 从第二列开始进行拆分，axis=1代表列方向Out[11]:
[array([[ 0, 1, 2],
[ 6, 7, 8],
[12, 13, 14],
[18, 19, 20],
[24, 25, 26],
[30, 31, 32]]),
array([[ 3, 4, 5],
[ 9, 10, 11],
[15, 16, 17],
[21, 22, 23],
[27, 28, 29],
[33, 34, 35]])]In [12]:
np.split(c,[2,3,4],axis=0) # 第二项参数可以为列表，分别从第二行，第三行，第四行，进行拆分Out[12]:
[array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]]),
array([[12, 13, 14, 15, 16, 17]]),
array([[18, 19, 20, 21, 22, 23]]),
array([[24, 25, 26, 27, 28, 29],
[30, 31, 32, 33, 34, 35]])]hsplit、vsplit、dsplit
split的便捷化函数，分别沿轴0、轴1、轴2进行拆分
重复数组
repeat
对数组中的元素进行复制
In [13]:
d = np.arange(5)
dOut[13]:
array([0, 1, 2, 3, 4])In [14]:
np.repeat(d,3) # 所有元素都重复3次Out[14]:
array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])In [15]:
np.repeat(d,[1,1,2,5,6]) # 指定每个元素进行重复的次数，列表中的值代表数组中的该位置的元素进行重复的次数Out[15]:
array([0, 1, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4])注意在多维数组中，不指定axis轴方向，会扁平化
tile
对整个数组进行复制
In [16]:
np.tile(d,2) # 水平复制Out[16]:
array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4])In [17]:
f = np.arange(9).reshape(3,-10)
fOut[17]:
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])In [18]:
np.tile(f,2) # 水平复制Out[18]:
array([[0, 1, 2, 0, 1, 2],
[3, 4, 5, 3, 4, 5],
[6, 7, 8, 6, 7, 8]])In [19]:
np.tile(f,(1,2))# 将f数组，变成一个1x2的f构成Out[19]:
array([[0, 1, 2, 0, 1, 2],
[3, 4, 5, 3, 4, 5],
[6, 7, 8, 6, 7, 8]])In [20]:
np.tile(f,(2,3)) # 将f数组，变成一个2x3的f构成Out[20]:
array([[0, 1, 2, 0, 1, 2, 0, 1, 2],
[3, 4, 5, 3, 4, 5, 3, 4, 5],
[6, 7, 8, 6, 7, 8, 6, 7, 8],
[0, 1, 2, 0, 1, 2, 0, 1, 2],
[3, 4, 5, 3, 4, 5, 3, 4, 5],
[6, 7, 8, 6, 7, 8, 6, 7, 8]])转置
ndarray数组对象.T即可得到ndarray对象的转置
In [21]:
h = np.arange(25).reshape(5,-1) # 等价于reshape(5,5)
hOut[21]:
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24]])In [23]:
h.T # 转置Out[23]:
array([[ 0, 5, 10, 15, 20],
[ 1, 6, 11, 16, 21],
[ 2, 7, 12, 17, 22],
[ 3, 8, 13, 18, 23],
[ 4, 9, 14, 19, 24]])In [24]:
h.transpose() # 转置Out[24]:
array([[ 0, 5, 10, 15, 20],
[ 1, 6, 11, 16, 21],
[ 2, 7, 12, 17, 22],
[ 3, 8, 13, 18, 23],
[ 4, 9, 14, 19, 24]])通用函数☆☆☆
一元ufunc
abs、fabs
计算整数、浮点数或复数的绝对值。对于非复数值，可以使用更快的fabs
sqrt
计算各元素的平方根。相当于arr ** 0.5
square
计算各元素的平方。相当于arr ** 2
exp
计算各元素的指数。相当于e的x次方
log、log10、log2、log1p
分别对应自然对数（底数为e）、底数为10的log、底数为2的log、log(1 + p)
sign
计算各元素的正负号：1（正数）、0（零）、-1（负数）
ceil
计算各元素的ceiling值，即大于等于该值的最小整数
floor
计算各元素的floor值。即小于等于该值的最大整数
rint
将各元素值四舍五入到最接近的整数，保留dtype
modf
将数组的小数和整数部分以两个独立数组的形式返回
isnan
返回一个表示“哪些值是NaN”的布尔型数组
isfinite、isinf
分别返回一个表示“哪些元素是有穷的（非inf，非NaN）”或“哪些元素是无穷的”的布尔型数组
cos、cosh、sin、sinh、tan、tanh
普通型和双曲型三角函数
arccos、arccosh、arcsin、arcsinh、arctan、arctanh
反三角函数
logical_not
计算个元素的not x的真值。相当于-arr
二元ufunc
add
将数组中对应的元素相加
subtract
从第一个数组中减去第二个数组中的元素
multiply
将数组元素相乘
divide、floor_divide
除法或向下取整除法（丢弃余数）
power
对第一个数组中的元素A，根据第二个数组中的相应元素B，计算A的B次方
maximum、fmax
元素级的最大值计算。fmax将忽略NaN
minimum、fmin
元素级的最小值计算。fmin将忽略NaN
mod
元素级别的求模计算（除法的余数）
copysign
将第二个数组中的值得符号复制给第一个数组中的值
greater、greater_equal、less、less_equal、equal、not_equal、
执行元素级的比较运算，最终产生布尔数组。相当于中缀运算符号>、>=、<、<=、==、!=
logical_and、logical_or、logical_xor
执行元素级的真值逻辑运算。相当于中缀运算符&、| 、^
In [24]:
a = np.random.randn(5)
b = np.random.randn(5)In [25]:
aOut[25]:
array([-0.09068035, -0.187416 , 0.94935988, 2.43188324, -1.71809499])In [26]:
bOut[26]:
array([-0.55215555, 0.49648021, 1.45710124, -1.47626841, -1.38574365])In [27]:
np.abs(a)Out[27]:
array([0.09068035, 0.187416 , 0.94935988, 2.43188324, 1.71809499])In [28]:
np.rint(a)Out[28]:
array([-0., -0., 1., 2., -2.])In [29]:
np.subtract(a,b)Out[29]:
array([ 0.4614752 , -0.68389622, -0.50774136, 3.90815164, -0.33235134])搜索和计数☆☆☆
搜索
argmax(a[, axis, out])
返回沿轴的最大值的索引即最大值所在位置的下标
In [1]:
import numpy as np
a = np.arange(36).reshape(6,-1)
aOut[1]:
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23],
[24, 25, 26, 27, 28, 29],
[30, 31, 32, 33, 34, 35]])In [2]:
np.argmax(a) # 整个数组其中最大值的下标，以flatten扁平化后的下标进行返回Out[2]:
35In [3]:
np.argmax(a,axis=0) # 每行最大值的下标Out[3]:
array([5, 5, 5, 5, 5, 5], dtype=int64)In [4]:
np.argmax(a,axis=1 # 每列最大值的下标Out[4]:
array([5, 5, 5, 5, 5, 5], dtype=int64)nanargmax(a[, axis])
返回指定轴上最大值的索引，忽略NAN
略
argmin(a[, axis, out])
返回沿轴的最小值的索引即最小值所在位置的下标
In [5]:
np.argmin(a)Out[5]:
0##### nanargmin(a[, axis])
返回指定轴上的最小值的索引，忽略NAN
##### argwhere(a)
返回按元素分组的非零数组元素的索引。
In [8]:
np.argwhere(a>28) # 帅选出条件符合的值得下标即(i,j)Out[8]:
array([[4, 5],
[5, 0],
[5, 1],
[5, 2],
[5, 3],
[5, 4],
[5, 5]], dtype=int64)##### nonzero(a)
返回非零元素的索引，以两个数组的形式进行返回，第一个数组为行下标，第二个数组为列下标
In [9]:
np.nonzero(a)Out[9]:
(array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5], dtype=int64),
array([1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4,
5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5], dtype=int64))##### flatnonzero(a)
返回a的展平版本中非零的索引
In [10]:
np.flatnonzero(a) # 将数组扁平化后也就是变成一维数组后，返回一维 # 数组的下标Out[10]:
array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
35], dtype=int64)##### where(condition, [x, y])☆
返回元素，可以是x或y，具体取决于条件
In [11]:
np.where(a>30) # 与argwehe方法类似，只是where是分别用两个数组， # 进行存储符合条件的值得行下标以及列下标Out[11]:
(array([5, 5, 5, 5, 5], dtype=int64), array([1, 2, 3, 4, 5], dtype=int64))In [12]:
b = np.array([
1,2,3,4
])
c = np.array([
'a','b','c','d'
])
condtion = np.array([
True,False,True,False
])
np.where(condtion,b,c) # 根据condition条件将c中符合的数据替换掉b中相应位置的数据Out[12]:
array(['1', 'b', '3', 'd'], dtype='<U11')In [13]:
np.where(a>10,0,a) # 将大于10的值全部替换为0Out[13]:
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 0],
[ 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0]])##### searchsorted(a, v[, side, sorter])
查找应插入元素以维护顺序的索引
In [14]:
d = np.array([8,15,3,12,5])
f = np.array([3,5,8,12,15])In [15]:
np.searchsorted(f,7) # 默认先往左插，插入7后，值7的下标位置Out[15]:
2In [16]:
np.searchsorted(f,7,side='right') # 往右插，插入7后，值7的下标位置Out[16]:
2In [17]:
np.searchsorted(f,8)Out[17]:
2In [18]:
np.searchsorted(f,8,side='right')Out[18]:
3##### extract(condition, arr)
返回满足某些条件的数组元素
#### 计数
##### count_nonzero(a[, axis])
计算数组a中的非零值的数量
In [20]:
np.count_nonzero([[1,2,3,4,5,0],[0,0,0,0,0,1]]) # 统计数组中非0数量Out[20]:
6In [21]:
np.count_nonzero([[1,2,3,4,5,0],[0,0,0,0,0,1]],axis=0) # 统计沿垂直方向的非0数量Out[21]:
array([1, 1, 1, 1, 1, 1], dtype=int64)In [22]:
np.count_nonzero([[1,2,3,4,5,0],[0,0,0,0,0,1]],axis=1) # 统计沿水平方向的非0数量Out[22]:
array([5, 1], dtype=int64)线性代数
diag(v, k=0)
以一维数组的形式返回方阵的对角线（或非对角线）元素，或将一数组转换为方阵（非对角线元素为0）
In [24]:
np.diag(g) # 以一维数组形式返回对角元素Out[24]:
array([ 0, 6, 12, 18, 24])In [25]:
np.diag(g,1)# 返回从下标i=1开始打得对角元素Out[25]:
array([ 1, 7, 13, 19])In [26]:
np.diag(np.array([ # 若为一维数组，则返回一个二维数组，对角元素为一维数组相对应的值，其余为0
1,2,3
]))Out[26]:
array([[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])##### dot(a, b[, out])
两个数组的点积
In [27]:
a = np.array([
[1,2,],[4,5]
])
b = np.array([
[5,2,],[6,9]
])
np.dot(a,b) # 返回矩阵乘积Out[27]:
array([[17, 20],
[50, 53]])##### trace(a[, offset, axis1, axis2, dtype, out])
计算对角线元素的和
In [28]:
np.trace(a) # 对角元素和Out[28]:
6##### linalg.det(a)
计算矩阵行列式
In [29]:
np.linalg.det(b)# 5*9-2*6=45-12=33 # 计算行列式Out[29]:
33.0In [30]:
np.linalg.det(a) # 1*5-2*4=5-8=-3Out[30]:
-2.9999999999999996##### linalg.inv(a)
计算方阵的逆
In [31]:
np.linalg.inv(a) # 计算a矩阵的逆矩阵Out[31]:
array([[-1.66666667, 0.66666667],
[ 1.33333333, -0.33333333]])计算均方误差MSE
用numpy进行表示
分别设置相应的预测值以及真实值
In[1]:
import numpy as np
predictions = np.array([1,1,1]).T
labels =np.array([1,2,3]).T
errors = 1/np.size(predictions)*np.sum(np.square(predictions-labels))
errorsOut[1]:
1.6666666666666665注意进行计算时，需要知道矩阵的状态，才能保证按照公式计算无误
最后更新于
这有帮助吗？