Numpy
什么是Numpy？
NumPy是Python中科学计算的基础软件包。 它是一个提供多了维数组对象，多种派生对象（如：掩码数组、矩阵）以及用于快速操作数组的函数及API， 它包括数学、逻辑、数组形状变换、排序、选择、I/O 、离散傅立叶变换、基本线性代数、基本统计运算、随机模拟等等。
NumPy中的核心是ndarray对象。ndarray对象是具有相同类型和大小（通常是固定大小）项目的多维容器。可以对其进行索引、切片、形状变换等操作。
关于axis
根据官方的说法，1表示横轴，方向从左到右；0表示纵轴，方向从上到下，即axis=1为横向，axis=0为纵向。
有时候理解为行和列会很容易使用的，但实际不是表示行列
数组
- 数组内元素的类型需要相同
- 创建数组大小固定
创建数组
In [1]：
import numpy as npa = np.array( # 创建一个1x3的一维数组[1,2,3]
)
aOut[1]：
array([1, 2, 3])
In [2]：
type(a) # 数据类型Out[2]：
numpy.ndarray # 数组类型为ndarray
ndarray对象的属性
ndarray.shape
数组的形状。返回一个元组表示各个维度中数组的大小。
In [3]：
a.shape # 每行元素的个数
Out[3]：
(3,)
In [11]：
b = np.array( # 创建一个2x3的二维数组[[1,2,3],[4,5,6]]
)
b
Out[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]：
1
ndarray.size
数组中元素的总数。等于shape各个元素的乘积。
In [5]：
a.size # 数组中元素的总个数
Out[5]：
3
ndarray.dtype
一个描述数组中元素类型的对象。
In [6]：
a.dtype # 数组中元素的类型
Out[6]：
dtype('int32')
ndarray.itemsize
数组中每个元素的字节大小。
In [7]：
a.itemsize # 数组中每个元素的字节大小
Out[7]：
4
ndarray.real
数组的实部
In [8]：
g = np.array([1+2j,2+3j]
)
g.dtype
Out[8]：
dtype('complex128')
In [9]：
g.real
Out[9]：
array([1., 2.])
ndarray.imag
数组的虚部
In [10]：
g.imag
Out[10]：
array([2., 3.])
ndarray的创建方法
nd.array()
In [1]：
import numpy as npnp.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.dtype
Out[1]:
dtype('int32')
数组运算
In [1]:
import numpy as np
In [2]:
a = np.array([[1,2,3],[4,5,6],
])
a
Out[2]:
array([[1, 2, 3],[4, 5, 6]])
数组与标量的算术运算
In [3]:
a * 2
Out[3]:
array([[ 2, 4, 6],[ 8, 10, 12]])
加法
In [5]:
a+a
Out[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 = a
Out[14]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [15]:
a
Out[15]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [16]:
b
Out[16]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [17]:
b[0] = 100
b
Out[17]:
array([100, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [18]:
a
Out[18]:
array([100, 1, 2, 3, 4, 5, 6, 7, 8, 9])
- 浅拷贝：与上有区别，一个数组值会变化会反映在另一个数组上，但是形状不变化
In [21]:
a = np.arange(10)
b = a.view()
In [22]:
a
Out[22]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [23]:
b
Out[23]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [24]:
b[0] = 500
In [25]:
a
Out[25]:
array([500, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [26]:
b
Out[26]:
array([500, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [30]:
b.shape = (10,1)
b
Out[30]:
array([[500],[ 1],[ 2],[ 3],[ 4],[ 5],[ 6],[ 7],[ 8],[ 9]])
In [31]:
a
Out[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] = 500
In [34]:
a
Out[34]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [35]:
b
Out[35]:
array([500, 1, 2, 3, 4, 5, 6, 7, 8, 9])
索引与切片
In [36]:
a = np.arange(36).reshape(6,6)
a
Out[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 np
In [2]:
a = np.array([[np.NaN,2,3,4],[2,np.NaN,4,5],[3,4,np.NaN,6]
])
In [3]:
a
Out[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]:
nan
nanmin(a[, axis, out, keepdims])
返回数组的最小值或沿轴的最小值，忽略任何NAN
见下
nanmax(a[, axis, out, keepdims])
返回数组的最大值或沿轴方向的最大值，忽略任何NAN
In [7]:
np.nanmin(a)
Out[7]:
2.0
In [8]:
np.nanmax(a)
Out[8]:
6.0
median(a[, axis, out, overwrite_input, keepdims])
沿指定轴计算中值
略
#### nanmedian(a[, axis, out, overwrite_input, …])
在忽略NAS的情况下，沿指定的轴计算中值
In [9]:
np.nanmedian(a)
Out[9]:
4.0
average(a[, axis, weights, returned])
计算沿指定轴的加权平均
见下
mean(a[, axis, dtype, out, keepdims])
沿指定的轴计算算术平均值
见下
nanmean(a[, axis, dtype, out, keepdims])
计算沿指定轴的算术平均值，忽略NAN
In [11]:
b = a.copy()
b
Out[11]:
array([[nan, 2., 3., 4.],[ 2., nan, 4., 5.],[ 3., 4., nan, 6.]])
In [12]:
b[np.isnan(b)]=np.nanmean(b) # 筛选出所有nan值然后用均值进行替换
b
Out[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.247219128924647
var(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 npa = np.array([[1,2,5],[2,3,5],[3,4,5],[2,3,6]])
a
Out[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
a
Out[4]:
array([[100, 2, 5],[ 2, 3, 5],[ 3, 4, 5],[ 2, 3, 6]])
数组合并
concatenate
沿着一条轴连接一组（多个）数组。除了与axis对应的轴之外，其它轴必须有相同的形状。
In [1]:
import numpy as npa = 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)
c
Out[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)
d
Out[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)
f
Out[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)
h
Out[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]:
a
Out[25]:
array([-0.09068035, -0.187416 , 0.94935988, 2.43188324, -1.71809499])
In [26]:
b
Out[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 npa = np.arange(36).reshape(6,-1)
a
Out[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]:
35
In [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的值全部替换为0
Out[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]:
2
In [16]:
np.searchsorted(f,7,side='right') # 往右插，插入7后，值7的下标位置
Out[16]:
2
In [17]:
np.searchsorted(f,8)
Out[17]:
2
In [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]:
6
In [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([ # 若为一维数组，则返回一个二维数组，对角元素为一维数组相对应的值，其余为01,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.0
In [30]:
np.linalg.det(a) # 1*5-2*4=5-8=-3
Out[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 nppredictions = np.array([1,1,1]).T
labels =np.array([1,2,3]).Terrors = 1/np.size(predictions)*np.sum(np.square(predictions-labels))
errors
Out[1]:
1.6666666666666665
注意进行计算时，需要知道矩阵的状态，才能保证按照公式计算无误