Python数据分析之表示 numpy库 北京理工大学嵩天老师慕课 学习笔记
数据分析之表示
numpy库入门
数据的维度
一维数据:列表和集合类型
[3,4,5]
有序 {1,2,3}
无序
二维数据:列表类型
多维数据:列表类型
[ [3,4,5],
[1,2,3] ]
高维数据:字典类型或 数据表示形式
dict = {
"firstName" : "Tian",
"lastName": "Song"
}
JSON、XML、YAML格式
NumPy的数组对象:ndarray
例:计算 A 2 + B 3 A^2+B^3 A2+B3,其中A,B为一维数组
import numpy as np
def np_sum():
a = np.array([0, 1, 2, 3, 4])
b = np.array([9, 8, 7, 6, 5])
c = a**2+b**3
return c
print(np_sum())
ndarray数组一般要求所有元素类型相同(同质),数组下标从0开始
>>> import numpy as np
>>> a = np.array([[0, 1, 2, 3, 4],[9, 8, 7, 6, 5]])
>>> a
array([[0, 1, 2, 3, 4],
[9, 8, 7, 6, 5]])
>>> print(a)
[[0 1 2 3 4]
[9 8 7 6 5]]
np.array()
生成一个ndarray数组
np.array()
输出成[ ]形式,元素由空格分隔
轴(axis):保存数据的维度;秩(rank):轴的数量
ndarray对象的属性:
.ndim
秩,即轴的数量或维度的数量
.shape
ndarray对象的尺度,对于矩阵,n行m列
.size
ndarray对象元素的个数,相当于.shape
中n*m的值
.dtype
ndarray对象的元素类型
.itemsize
ndarray对象中每个元素的大小,以字节为单位
>>> a = np.array([[0,1,2,3,4],[9,8,7,6,5]])
>>> a.ndim
2
>>> a.shape
(2, 5)
>>> a.size
10
>>> a.dtype
dtype('int32')
>>> a.itemsize
4
ndarray数组的元素类型
数据类型 | 说明 |
---|---|
bool | 布尔类型,True或False |
intc | 与int类型一致,一般为int32或int64 |
intp | 用于索引的整数,int32或int64 |
int8 | 字节长度的整数,取值:[-128,127] |
int16 | 16位长度的整数,取值:[-32768,32767] |
int32 | 32长度的整数,取值:[ − 2 31 , 2 31 − 1 -2^{31},2^{31}-1 −231,231−1] |
int64 | 64长度的整数,取值:[ − 2 63 , 2 63 − 1 -2^{63},2^{63}-1 −263,263−1] |
uint8 | 8位无符号整数,取值:[0,25] |
uint16 | 16位无符号整数,取值:[0,65535] |
uint32 | 32位无符号整数,取值:[ 0 , 2 32 − 1 0,2^{32}-1 0,232−1] |
uint64 | 64位无符号整数,取值:[ 0 , 2 64 − 1 0,2^{64}-1 0,264−1] |
float16 | 16位半精度浮点数:1位符号位,5位指数,10位尾数 |
float32 | 32位半精度浮点数:1位符号位,8位指数,23位尾数 |
float64 | 64位半精度浮点数:1位符号位,11位指数,52位尾数 |
complex64 | 复数类型,实部虚部都是32位浮点数 |
complex128 | 复数类型,实部虚部都是64位浮点数 |
非同质的ndarray对象
创建非同质ndarray元素为对象类型,需规定dtype=object
x = np.array([[0,1,2,3,4],[9,8,7,6]],dtype=object)
ndarray数组的创建和变换
ndarray数组的创建方法
(1)从Python中的列表、元组等类型创建ndarray数组
x=np.array(list/tuple)
x=np.array(list/tuple,dtype=np.float32)
指定每个元素的数据类型
当np.array()
不指定dtype时,numpy将根据数据情况关联一个dtype类型
>>> x = np.array([0,1,2,3]) # 从列表类型创建
>>> print(x)
[0 1 2 3]
>>> x = np.array((4,5,6,7)) # 从元组类型创建
>>> print(x)
[4 5 6 7]
>>> x = np.array([[1,2],[9,8],(0.1,0.2)]) # 从列表和元组混合类型创建,只要包含的数据个数相同
>>> print(x)
[[1. 2. ]
[9. 8. ]
[0.1 0.2]]
(2)使用numpy中函数创建ndarray数组
函数 | 说明 |
---|---|
np.arange(n) | 类似range()函数,返回ndarray类型,元素从0到n-1 |
np.ones(shape) | 根据shape生成一个全1数组,shape是元组类型 |
np.zeros(shape) | 根据shape生成一个全0数组,shape是元组类型 |
np.full(shape,val) | 根据shape生成一个数组,每个元素值都是val |
np.eye(n) | 创建一个正方的 n ∗ n n*n n∗n单位矩阵,对角线为1,其余为0 |
>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.ones((3,6))
array([[1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1.]])
>>> np.zeros((3,6),dtype=np.int32)
array([[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0]])
>>> x = np.ones((2,3,4))
>>> print(x)
[[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]]
>>> x.shape
(2, 3, 4)
.ones
,.zeros
,.eye
生成数组的元素都是浮点数类型
.arange
是整数类型
函数 | 说明 |
---|---|
np.ones_like(a) | 根据数组a的形状生成一个全1数组 |
np.zeros_like(a) | 根据数组a的形状生成一个全0数组 |
np.full_like(a,val) | 根据数组a的形状生成一个数组,每个元素值都是val |
(3)使用numpy中其他函数创建ndarray数组
函数 | 说明 |
---|---|
np.linspace() | 根据起止数据等间距地填充数据,形成数组 |
np.concatenate() | 将两个或多个数组合成一个新的数组 |
>>> a= np.linspace(1,10,4)
>>> a
array([ 1., 4., 7., 10.])
>>> b = np.linspace(1,10,4,endpoint=False) # 10不作为最后一个值
>>> b
array([1. , 3.25, 5.5 , 7.75])
>>> c = np.concatenate((a,b))
>>> c
array([ 1. , 4. , 7. , 10. , 1. , 3.25, 5.5 , 7.75])
nadrray数组的变换
维度变换
方法 | 说明 |
---|---|
.reshape(shape) | 不改变数组元素,返回一个shape形状的数组,原数组不变 |
.resize(shape) | 与.shape()功能一致,但修改原数组 |
.swapaxes(ax1,ax2) | 将数组n个维度中两个维度进行调换 |
.flatten() | 对数组进行降维,返回折叠后的一维数组,原数组不变 |
>>> a = np.ones((2,3,4),dtype=np.int32)
>>> a.reshape((3,8))
array([[1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1]])
>>> a
array([[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]],
[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]]])
>>> a.resize((3,8))
>>> a
array([[1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1]])
>>> a.flatten()
array([1, 1, 1,...,1, 1])
>>> a
array([[1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1]])
>>> b = a.flatten()
>>> b
array([1, 1, 1,...,1, 1])
类型变换
mew_a=a.astype(new_type)
astype()方法一定会创建新的数组(原始数据的拷贝),即使两个类型一致
>>> a = np.ones((2,3,4),dtype=np.int)
>>> a
array([[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]],
[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]]])
>>> b = a.astype(np.float)
>>> b
array([[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]]])
ndarray数组向列表的转换
ls=a.tolist()
>>> a = np.full((2,3,4),25,dtype=np.int32)
>>> a
array([[[25, 25, 25, 25],
[25, 25, 25, 25],
[25, 25, 25, 25]],
[[25, 25, 25, 25],
[25, 25, 25, 25],
[25, 25, 25, 25]]])
>>> a.tolist()
[[[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]], [[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]]]
ndarray数组的操作
索引:获取数组中特定位置元素的过程
切片:获取数组元素子集的过程
一维数组的索引和切片:与python的列表类似
[起始编号:终止编号(不含):步长],3元素冒号分隔
编号0开始从左递增,或-1开始从右递减
>>> a = np.array([9,8,7,6,5])
>>> a[2]
7
>>> a[1:4:2]
array([8, 6])
多维数组的索引
每个维度一个索引值,逗号分隔,从0开始
>>> a = np.arange(24).reshape((2,3,4))
>>> a
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]]])
>>> a[1,2,3]
23
>>> a[0,1,2]
6
>>> a[-1,-2,-3]
17
多维数组的切片
>>> a = np.arange(24).reshape((2,3,4))
>>> a
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]]])
>>> a[:,1,-3] # 选取一个维度用:
array([ 5, 17])
>>> a[:,1:3,:] # 每个维度切片方法与一维数组相同
array([[[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[16, 17, 18, 19],
[20, 21, 22, 23]]])
>>> a[:,:,::2] # 每个维度可以使用步长跳跃切片
array([[[ 0, 2],
[ 4, 6],
[ 8, 10]],
[[12, 14],
[16, 18],
[20, 22]]])
ndarray数组的运算
数组与标量之间的运算作用于数组的每一个元素
实例:计算a与元素平均值的商
>>> a = np.arange(24).reshape((2,3,4))
>>> a
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]]])
>>> a.mean()
11.5
>>> a= a/a.mean()
>>> a
array([[[0. , 0.08695652, 0.17391304, 0.26086957],
[0.34782609, 0.43478261, 0.52173913, 0.60869565],
[0.69565217, 0.7826087 , 0.86956522, 0.95652174]],
[[1.04347826, 1.13043478, 1.2173913 , 1.30434783],
[1.39130435, 1.47826087, 1.56521739, 1.65217391],
[1.73913043, 1.82608696, 1.91304348, 2. ]]])
numpy一元函数
对ndarray中的数据执行元素级别运算的函数
函数 | 说明 |
---|---|
np.abs(x) , np.fabs(x) | 计算数组各元素的绝对值 |
np.sqrt(x) | 计算数组各元素的平方根 |
np.square(x) | 计算数组各元素的平方 |
np.log(x) , np.log10(x) , np.log2(x) | 计算数组各元素的自然对数、10底对数和2底对数 |
np.ceil(x) , np.floor(x) | 计算数组各元素的ceiling值(大于元素的最小整数值) 或 floor值(小于元素的最大整数值) |
np.rint(x) | 计算数组各元素的四舍五入值 |
np.modf(x) | 计算数组各元素的小数和整数部分,以两个独立数组形式返回 |
np.cos(x) , np.cosh(x) , np.sin(x) , np.sinh(x) , np.tan(x) , np.tanh(x) | 计算数组各元素的普通和双曲型三角函数 |
np.exp(x) | 计算数组各元素的指数值 |
np.sign(x) | 计算数组各元素的符号值,1(+), 0, -1(-) |
>>> a = np.arange(24).reshape((2,3,4))
>>> np.square(a)
array([[[ 0, 1, 4, 9],
[ 16, 25, 36, 49],
[ 64, 81, 100, 121]],
[[144, 169, 196, 225],
[256, 289, 324, 361],
[400, 441, 484, 529]]], dtype=int32)
>>> a # 数组没有被真实改变
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]]])
>>> a = np.sqrt(a)
>>> a
array([[[0. , 1. , 1.41421356, 1.73205081],
[2. , 2.23606798, 2.44948974, 2.64575131],
[2.82842712, 3. , 3.16227766, 3.31662479]],
[[3.46410162, 3.60555128, 3.74165739, 3.87298335],
[4. , 4.12310563, 4.24264069, 4.35889894],
[4.47213595, 4.58257569, 4.69041576, 4.79583152]]])
>>> np.modf(a)
(array([[[0. , 0. , 0.41421356, 0.73205081],
[0. , 0.23606798, 0.44948974, 0.64575131],
[0.82842712, 0. , 0.16227766, 0.31662479]],
[[0.46410162, 0.60555128, 0.74165739, 0.87298335],
[0. , 0.12310563, 0.24264069, 0.35889894],
[0.47213595, 0.58257569, 0.69041576, 0.79583152]]]),
array([[[0., 1., 1., 1.],
[2., 2., 2., 2.],
[2., 3., 3., 3.]],
[[3., 3., 3., 3.],
[4., 4., 4., 4.],
[4., 4., 4., 4.]]]))
numpy二元函数
函数 | 说明 |
---|---|
+, -, *, /, ** | 两个数组各元素进行对应运算 |
np.maximum(x,y) , np.fmax() , np.minimum(x,y) , np.fmin() | 元素级的最大值、最小值计算 |
np.mod(x,y) | 元素级的模运算 |
np.copysign(x,y) | 将数组y中元素值的符号赋值给数组x对应元素 |
>, <, >=, <=, ==, != | 算术比较,产生布尔型数据 |
>>> a = np.arange(24).reshape((2,3,4))
>>> b = np.sqrt(a)
>>> a
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]]])
>>> b
array([[[0. , 1. , 1.41421356, 1.73205081],
[2. , 2.23606798, 2.44948974, 2.64575131],
[2.82842712, 3. , 3.16227766, 3.31662479]],
[[3.46410162, 3.60555128, 3.74165739, 3.87298335],
[4. , 4.12310563, 4.24264069, 4.35889894],
[4.47213595, 4.58257569, 4.69041576, 4.79583152]]])
>>> np.maximum(a,b) # 运算结果为浮点数
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.]]])
>>> a>b
array([[[False, False, True, True],
[ True, True, True, True],
[ True, True, True, True]],
[[ True, True, True, True],
[ True, True, True, True],
[ True, True, True, True]]])
numpy数据存取与函数
数据的CSV文件存取
CSV逗号分隔值,常见的文件格式,用来存储批量数据
写入:
np.savetxt(frame,array,fmt='%.18e',delimiter=None)
- frame:文件、字符串或产生器,可以是.gz或.bz2的压缩文件
- array:存入文件的数组
- fmt:写入文件的格式,例如 %d, %.2f, %.18e
- delimiter:分隔字符串,默认为任何空格
a = np.arange(100).reshape(5,20)
np.savetxt('a.csv',a,fmt='%d',delimiter=',')
np.loadtxt(frame,dtype=np.float,delimiter=None,unpack=False)
- frame:文件、字符串或产生器,可以是.gz或.bz2的压缩文件
- dtype:数据类型,可选
- delimiter:分隔字符串,默认是任何空格
- unpack:默认是False,读入的数据写入一个数组;如果是True,读入属性将分别写入不同变量
>>> b = np.loadtxt('a.csv',delimiter=',')
>>> b
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., 36., 37., 38., 39.],
[40., 41., 42., 43., 44., 45., 46., 47., 48., 49., 50., 51., 52.,
53., 54., 55., 56., 57., 58., 59.],
[60., 61., 62., 63., 64., 65., 66., 67., 68., 69., 70., 71., 72.,
73., 74., 75., 76., 77., 78., 79.],
[80., 81., 82., 83., 84., 85., 86., 87., 88., 89., 90., 91., 92.,
93., 94., 95., 96., 97., 98., 99.]])
>>> b=np.loadtxt('a.csv',dtype=np.int,delimiter=',')
>>> b
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,
36, 37, 38, 39],
[40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
56, 57, 58, 59],
[60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
76, 77, 78, 79],
[80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
96, 97, 98, 99]])
CSV只能有效存储一维和二维数组
np.savetxt()
,np.loadtxt()
只能有效存取一维和二维数组
多维数据的存取
a.tofile(frame,sep='',format='%s')
- frame:文件、字符串
- sep:数据分隔字符串,如果是空串,写入文件为二进制
- format:写入数据的格式
存入数据不包含维度信息
a = np.arange(100).reshape(5,10,2)
a.tofile("b.dat",sep=",",format='%d')
np.fromfile(frame,dtype=np.float,count=-1,sep='')
- frame:文件、字符串
- dtype:读取的数据类型
- count:读入元素个数。-1(默认)表示整个文件
- sep:数据分隔字符串,如果是空串,写入文件为二进制
>>> a = np.arange(100).reshape(5,10,2)
>>> a.tofile("b.dat",sep=",",format='%d')
>>> c= np.fromfile("b.dat",dtype=np.int,sep=",")
>>> c
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, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99])
>>> c= np.fromfile("b.dat",dtype=np.int,sep=",").reshape(5,10,2)
>>> c
array([[[ 0, 1],
[ 2, 3],
...
[16, 17],
[18, 19]],
...
[96, 97],
[98, 99]]])
注意
该方法在读取时于要知道存入文件的数组维度和文件类型
numpy的便捷文件存取:
np.save(fname,array)
或np.savez(fname,array)
- fname:文件名,以.npy为扩展名,压缩扩展名为.npz
- array:数组数量
np.load(fname)
- fname:文件名,以.npy为扩展名,压缩扩展名为.npz
>>> a=np.arange(100).reshape(5,10,2)
>>> np.save("a.npy",a)
>>> b = np.load("a.npy")
>>> b
array([[[ 0, 1],
[ 2, 3],
...
[16, 17],
[18, 19]],
...
[96, 97],
[98, 99]]])
numpy的随机数函数
numpy的random子库np.random.*
函数 | 说明 |
---|---|
rand(d0,d1,...,dn) | 根据d0-dn创建随机数数组,浮点数,[0,1),均匀分布 |
randn(d0,d1,...,dn) | 根据d0-dn创建随机数数组,标准正态分布 |
randint(low[,high,shape])) | 根据shape创建随机整数或整数数组,范围是[low,high) |
seed(s) | 随机数种子,s是给定的种子值 |
>>> a = np.random.rand(3,4,5)
>>> a
array([[[0.14382181, 0.40116464, 0.95316951, 0.59516554, 0.5412753 ],
[0.74330551, 0.11714116, 0.70432658, 0.60395914, 0.88522656],
[0.99480544, 0.02828022, 0.98986255, 0.80408683, 0.85556938],
[0.52318958, 0.41265545, 0.95453114, 0.954949 , 0.45072359]],
[[0.8975034 , 0.1190502 , 0.18391151, 0.29274091, 0.09584342],
[0.77419864, 0.86454107, 0.06375058, 0.84610497, 0.9903399 ],
[0.11506808, 0.76579085, 0.71041681, 0.59732553, 0.58226021],
[0.62437956, 0.55395497, 0.8079436 , 0.45841405, 0.09553339]],
[[0.96720271, 0.20833856, 0.51991175, 0.19253304, 0.23248954],
[0.13479736, 0.74396036, 0.60379012, 0.81601586, 0.27316537],
[0.24504229, 0.91785064, 0.94790962, 0.86382857, 0.86162509],
[0.64108086, 0.8403669 , 0.22190639, 0.47940906, 0.60558566]]])
>>> an = np.random.randn(3,4,5)
>>> an
array([[[ 0.12324403, -0.27522593, -1.40427194, 0.71027476,
-1.2064016 ],
[-1.81411973, 1.13196321, -1.50239536, 1.30468353,
-1.75652025],
[-0.7521851 , 0.52314822, 0.10428667, 1.45911077,
0.34249808],
[ 0.47789545, -0.23465799, -0.89852472, 0.01180039,
-0.34879686]],
[[ 0.22374608, 0.39125044, 0.43516147, 0.77711348,
-0.37674005],
[-1.36056322, -0.88144572, -0.37718353, 0.83939591,
0.88144924],
[ 0.01036107, 0.69323783, 0.53411676, -0.66545693,
0.44513866],
[-1.34940089, 1.28929593, 1.9238516 , 0.26764908,
-1.06950077]],
[[-0.38011732, 0.34871198, 0.09995087, 1.13547681,
0.55697704],
[-0.41913241, 0.75671497, 0.55465368, -0.94139144,
0.96120354],
[-0.52069583, -0.49303478, -0.96839163, 0.97729152,
-1.05084446],
[ 0.62842893, -0.81576186, -2.79560964, -1.07479502,
-1.28101222]]])
>>> b=np.random.randint(100,200,(3,4))
>>> b
array([[166, 148, 112, 174],
[137, 118, 169, 105],
[161, 103, 151, 196]])
函数 | 说明 |
---|---|
shuffle(a) | 根据数组a的第1轴进行随排列,改变数组a |
permutation(a) | 根据数组a的第1轴产生一个新的乱序数组,不改变数组a |
choice(a[,size,replace,p]) | 从一维数组a中以概率p抽取元素,形成size形状新数组,replace表示是否可以重用元素,默认为True |
>>> a= np.random.randint(100,200,(3,4))
>>> a
array([[139, 150, 165, 190],
[118, 169, 182, 150],
[148, 128, 176, 167]])
>>> np.random.shuffle(a)
>>> a
array([[148, 128, 176, 167],
[139, 150, 165, 190],
[118, 169, 182, 150]])
>>> a=np.random.randint(100,200,(3,4))
>>> a
array([[171, 182, 132, 199],
[163, 182, 114, 134],
[142, 123, 147, 166]])
>>> np.random.permutation(a)
array([[163, 182, 114, 134],
[171, 182, 132, 199],
[142, 123, 147, 166]])
>>> a # a没有改变
array([[171, 182, 132, 199],
[163, 182, 114, 134],
[142, 123, 147, 166]])
>>> b = np.random.randint(100,200,(8,))
>>> b
array([180, 190, 175, 184, 186, 196, 122, 169])
>>> np.random.choice(b,(3,2))
array([[169, 190],
[190, 180],
[122, 180]])
>>> np.random.choice(b, (3,2),replace=False)
array([[186, 175],
[169, 196],
[184, 180]])
>>> np.random.choice(b,(3,2),p=b/np.sum(b)) # 元素越大,抽取的概率越高
array([[190, 180],
[190, 180],
[169, 122]])
函数 | 说明 |
---|---|
uniform(low,high,size) | 产生具有均匀分布的数组,low起始值,high结束值,size形状 |
normal(loc,scale,size) | 产生具有正态分布的数组,loc均值,scale标准差,size形状 |
possion(lam,size) | 产生具有泊松分布的数组,lam随机事件发生率,size形状 |
>>> u=np.random.uniform(0,10,(3,4))
>>> u
array([[9.94352409, 8.70347241, 9.65385486, 4.44574589],
[3.41977979, 3.68855904, 2.56894504, 9.67607057],
[9.19120304, 6.19575477, 8.81592267, 4.17219459]])
>>> n=np.random.normal(10,5,(3,4))
>>> n
array([[15.28615079, 12.17913066, 19.0283922 , 8.52858733],
[11.41544541, -2.01493306, 10.04386623, 9.6695251 ],
[10.6137511 , 11.20278132, 17.11835936, 7.02603034]])
numpy的统计函数
numpy直接提供的统计类函数np.*
函数 | 说明 |
---|---|
sum(a, axis=None) | 根据给定轴axis计算数组a相关元素之和,axis整数或元组 |
mean(a, axis=None) | 根据给定轴axis计算数组a相关元素的期望,axis整数或元组 |
average(a, axis=None, weights=None) | 根据给定轴axis计算数组a相关元素的加权平均值 |
std(a, axis=None) | 根据给定轴axis计算数组a相关元素的标准差 |
var(a, axis=None) | 根据给定轴axis计算数组a相关元素的方差 |
axis=None
是统计函数的标配参数
>>> import numpy as np
>>> a=np.arange(15).reshape(3,5)
>>> a
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
>>> np.sum(a)
105
# 最外层的维度为0(列),内层的维度为1(行)
>>> np.mean(a,axis=1) # 轴 1为行求平均值
array([ 2., 7., 12.])
>>> np.mean(a,axis=0) # 轴 0为列求平均值
array([5., 6., 7., 8., 9.])
>>> np.average(a,axis=0,weights=[10,5,1]) # 加权平均
array([2.1875, 3.1875, 4.1875, 5.1875, 6.1875])
>>> np.std(a)
4.320493798938574
>>> np.var(a)
18.666666666666668
函数 | 说明 |
---|---|
min(a), max(a) | 计算数组a中元素的最小值、最大值 |
argmin(a), argmax(a) | 计算数组a中元素的最小值、最大值的降一维后下标(先行后列) |
unravel_index(index,shape) | 根据shape将一维下标index转移为多维下标 |
ptp(a) | 计算数组a中元素最小值与最大值的差 |
median(a) | 计算数组a中元素的中位数(中值) |
>>> b = np.arange(15,0,-1).reshape(3,5)
>>> b
array([[15, 14, 13, 12, 11],
[10, 9, 8, 7, 6],
[ 5, 4, 3, 2, 1]])
>>> np.max(b)
15
>>> np.argmax(b) # 扁平化后的下标
0
>>> np.unravel_index(np.argmax(b),b.shape) # 重塑成多维下标
(0, 0)
>>> np.ptp(b)
14
>>> np.median(b)
8.0
numpy的梯度函数
函数 | 说明 |
---|---|
np.gradient(f) | 计算数组f中元素的梯度,当f为多维时,返回每个维度梯度 |
梯度:连续值之间的变化率,即斜率
XY坐标轴连续三个X坐标对应的Y轴值:a,b,c,其中b(存在两侧值)的梯度为:(c-a)/2;a(只有一侧值)的梯度为:(b-a)/1
>>> a=np.random.randint(0,20,5)
>>> a
array([15, 6, 16, 5, 2])
>>> np.gradient(a)
array([-9. , 0.5, -0.5, -7. , -3. ])
>>> b=np.random.randint(0,20,5)
>>> b
array([10, 5, 5, 18, 7])
>>> np.gradient(b)
array([ -5. , -2.5, 6.5, 1. , -11. ])
c=np.random.randint(0,50,(3,5))
c
array([[15, 5, 2, 9, 47],
[28, 10, 3, 31, 10],
[28, 9, 48, 21, 34]])
np.gradient(c)
[array([[ 13. , 5. , 1. , 22. , -37. ], # 最外层维度的梯度(列)
[ 6.5, 2. , 23. , 6. , -6.5],
[ 0. , -1. , 45. , -10. , 24. ]]),
array([[-10. , -6.5, 2. , 22.5, 38. ], # 第二层维度的梯度(行)
[-18. , -12.5, 10.5, 3.5, -21. ],
[-19. , 10. , 6. , -7. , 13. ]])]
图像的手绘效果
图像数组的表示
图像一般使用RGB色彩模式,即每个像素点的颜色由红R、绿G、蓝B组成
RGB三个颜色通道的变化和叠加得到各种颜色,其中
- R 红色,取值范围0-255
- G 绿色,取值范围0-255
- B 蓝色,取值范围0-255
PIL库
PIL,Python Image Library
PIL库是一个具有强大图像处理能力的第三方库
from PIL import Image
Image是PIL库中代表一个图像的类(对象)
图像是一个由像素组成的二维矩阵,每个元素是一个RGB值
图像是一个三维数组,维度分别是高度、宽度和像素RGB值
from PIL import Image
import numpy as np
im = np.array(Image.open("beijing.jpg"))
print(im.shape, im.dtype)
返回:(800, 1200, 3) uint8
图像的变换
读入图像后,获得像素RGB值,修改后保存为新的文件
from PIL import Image
import numpy as np
a = np.array(Image.open("beijing.jpg"))
print(a.shape, a.dtype)
b = [255, 255, 255] - a
im = Image.fromarray(b.astype('uint8'))
im.save("fcity.jpg")
原图:
变换后:
from PIL import Image
import numpy as np
a = np.array(Image.open("fcity.jpg").convert('L')) # convert将彩色图片变换成灰度图片
b = 255 - a # 这里的a为二维数组
im = Image.fromarray(b.astype('uint8'))
im.save("fcity3.jpg")
from PIL import Image
import numpy as np
a = np.array(Image.open("fcity.jpg").convert('L'))
c = (100/255)*a + 150 # 区间变换
im = Image.fromarray(c.astype('uint8'))
im.save("fcity4.jpg")
from PIL import Image
import numpy as np
a = np.array(Image.open("fcity.jpg").convert('L'))
d = 255*(a/255)**2 # 像素平方
im = Image.fromarray(d.astype('uint8'))
im.save("fcity5.jpg")
“图像的手绘效果”实例分析
手绘效果的几个特征:
- 黑白灰色
- 边界线条较重
- 相同或相近色彩趋于白色
- 略有光源效果
利用像素之间的梯度值和模拟深度值对图像进行重构
根据灰度变化来模拟人类视觉的远近程度
from PIL import Image
import numpy as np
a = np.asarray(Image.open('beijing.jpg').convert('L')).astype('float')
depth = 10. # 预设深度值为10,取值范围(0-100)
grad = np.gradient(a) # 取图像灰度的梯度值
grad_x, grad_y = grad # 分别取横纵图像梯度值
grad_x = grad_x*depth/100.
grad_y = grad_y*depth/100. # 根据深度调整x和y方向的梯度值
A = np.sqrt(grad_x**2 + grad_y**2 + 1.) # 构造x和y轴梯度的三维归一化单位体系
uni_x = grad_x/A
uni_y = grad_y/A
uni_z = 1./A
vec_el = np.pi/2.2 # 光源的俯视角度,弧度值
vec_az = np.pi/4. # 光源的方位角度,弧度值
dx = np.cos(vec_el)*np.cos(vec_az) # 光源对x轴的影响
# np.cos(vec_el)为单位光线在地平面上的投影长度
dy = np.cos(vec_el)*np.sin(vec_az) # 光源对y轴的影响
dz = np.sin(vec_el) # 光源对z轴的影响
b = 255*(dx*uni_x + dy*uni_y + dz*uni_z) # 光源归一化
# 梯度与光源相互作用,将梯度转换为灰度
b = b.clip(0, 255) # 为避免数据越界,将生成的灰度值裁剪至0-255区间
im = Image.fromarray(b.astype('uint8')) # 重构图像
im.save('beijingHD.jpg')
手绘效果图: