[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,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列
.sizendarray对象元素的个数，相当于.shape中n*m的值
.dtypendarray对象的元素类型
.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$]
int64	64长度的整数，取值:[$-2^{63},2^{63}-1$]
uint8	8位无符号整数，取值:[0,25]
uint16	16位无符号整数，取值:[0,65535]
uint32	32位无符号整数，取值:[$0,2^{32}-1$]
uint64	64位无符号整数，取值:[$0,2^{64}-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\ast 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')

手绘效果图：