Python数据分析与展示

基础知识

Ipython

Ipython是一个功能强大的交互式shell，适合进行交互式数据可视化和GUI相关应用

想要汉化可以参考这个github上的汉化链接

?：变量名后跟?如：a?来获取变量相关的类型、值以及相关的描述信息。对于函数增加?能够获得函数的源代码

%run+python文件命令：用于执行py文件，同时会生成一个新的空的命名空间（即，该程序内部需要包含足够的import变量）

其他相关的魔术命令：

常用命令	说明
%magic	显示所有魔术命令
%hist	IPython命令的输入历史
%pdb	异常发生后自动进入调试器
%reset	删除当前命名空间中的全部变量或名称
%who	显示lpython当前命名空间中已经定义的变量
%time statement	给出代码的执行时间，statement表示一段代码
%timeit statement	多次执行代码，计算综合平均执行时间

官方文档

NumPy库

NumPy是一个开源的 Python科学计算基础库。

• 一个强大的N维数组对象 ndarray
• 广播功能函数
• 整合C/C++/Fortran代码的工具
• 线性代数、傅里叶变换、随机数生成等功能

NumPy是 SciPy、 Pandas等数据处理或科学计算库的基础。

引入：import numpy as np

基本知识

数据的维度

维度：一组数据的组织形式

一维数据：一维数据由对等关系的有序或无序数据构成，采用线性方式组织。如：列表、数组（和列表一样，均表示一组数据的有序结构，与列表的区别如下）、集合等概念（对应python中的列表（有序）和集合（无序））

• 列表：列表项的数据类型可以不同
• 数组：数据类型必须相同

二维数据：二维数据由多个—维数据构成，是一维数据的组合式。如：表格（对应python中的列表）

多维数据：多维数据由一维或二维数据在新维度上扩展形成。（对应python中的多维列表）

高维数据：高维数据仅利用最基本的二元关系展示数据间的复杂结构（可以理解为由键值对将数据组织起来形成的数据方式）。如：json（对应python中的字典或数据表示格式（JSON、XML、YAML））

数组对象：ndarray

ndarray是一个多维数组对象，由两部分构成：

• 实际的数据
• 描逃这些数据的元数据（数据维度、数据类型等）

ndarray数组一般要求所有元素类型相同（同质），数组下标从0开始。

ndarray在程序中的别名是：array

# 生成一个 ndarray数组
a = np.array([[0,1,2,3,4],[9,8,7,6,5]])

基本概念：

• 轴（axis）：保存数据的维度
• 秩（rank）：轴的数量（即有多少个维度）

基本属性：

属性	说明
.ndim	秩，即轴的数量或维度的数量
.shape	ndarray对象的尺度，对于矩阵，n行m列
.size	ndarray对象元素的个数，相当于.shape中n*m的值
.dtype	ndarray对象的元素类型
.itemsize	ndarray对象中每个元素的大小，以字节为单位

元素类型：

数据类型	说明
bool	布尔类型，True或False
intc	与C语言中的int类型一致，一般是int32或int64
intp	用于索引的整数，与C语言中ssize_t一致，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，255]
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元素为对象类型。非同质 ndarray对象无法有效发挥 NumPy优势，尽量避免使用。（当元素的类型并不相同或每一个元素的维度数据并不相同的时候，会将每个元素认为一个对象，将该对象认为同质的数据类型）

#同质
>>> a = np.array([[0,1,2,3,4],[9,8,7,6,5]])
>>> a.shape
(2, 5)
>>> a.dtype
dtype('int32')
>>> a
array([[0, 1, 2, 3, 4],
       [9, 8, 7, 6, 5]])
>>> a.itemsize
4
>>> a.size
10
#非同质
>>> a = np.array([[0,1,2,3,4],[9,8,7,6]])
>>> a.shape
(2,)
>>> a.dtype
dtype('O')
>>> a
array([list([0, 1, 2, 3, 4]), list([9, 8, 7, 6])], dtype=object)
>>> a.itemsize
8
>>> a.size
2

创建和变换

创建方法：

• 从 Python中的列表、元组等类型创建 ndarray数组。

  x = np.array(list/tuple)
  x = np.array(list/tuple, dtype=np.float32)#指定类型

  • 当np. array()不指定 dtype时， NumPy将根据数据情况关联一个 dtype类型
  • 只要元组和列表包含的数据个数和类型相同，就可以混合使用

• 使用 NumPy中函数创建 ndarray数组，如：arange, ones, zeros等。

  函数	说明
  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，类型为val的类型
  np.eye(n)	创建一个 正方的n*n单位矩阵，对角线为1，其余为0，浮点数类型
  np.ones_like(a)	根据数组a的形状生成一个全1数组
  np.zeros_like(a)	根据数组a的形状生成一个全0数组
  np.full_like(a,val)	根据数组a的形状生成一个数组，每个元素值都是val
  np.linspace()	根据起止数据等间距地填充数据，形成数组，浮点数类型
  np.coucatenate()	将两个或多个数组合井成一个新的数组

  例子：

  >>> np.array(10)
  array(10)
  >>> 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]])
  >>> np.eye(5)
  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.ones((2,3,4))
  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.]]])
  >>> x = np.ones((2,3,4))
  >>> x.shape
  (2, 3, 4)
  
  >>> np.linspace(1,10,4) #起始1 末尾10 4个元素
  array([ 1.,  4.,  7., 10.])
  >>> np.linspace(1,10,4,endpoint=False) #最后一个元素10是否为4个元素中的一个
  array([1.  , 3.25, 5.5 , 7.75])
  >>> a = np.linspace(1,10,4)
  >>> b = np.linspace(1,10,4,endpoint=False)
  >>> np.concatenate((a,b))
  array([ 1.  ,  4.  ,  7.  , 10.  ,  1.  ,  3.25,  5.5 ,  7.75])

• 从字节流（ raw bytes）中创建 ndarray数组。

• 从文件中读取特定格式，创建 ndarray数组。

变换：

维度变换

方法	说明
.reshape(shape)	不改变数组元素,返回一个 shape形状的数组,原数组不变
.resize(shape)	与.reshape()功能一致,但修改返回的数组时会改变原数组
.swapaxes(ax1,ax2)	将数组n个维度中两个维度进行调换
.flatten()	对数组进行降维,返回折叠后的一维数组,原数组不变

类型变换

方法	说明
.astype(new_type)	改变数据中元素的类型,原数组不变
.tolist()	将ndarray数组转化为list

数组的操作

索引：获取数组中特定位置元素的过程

切片：获取数组元素子集的过程

一维数组的索引和切片：与 Python的列表类似

>>> a = np.array([9,8,7,6,5])
>>> a[2]
7
>>> a[1:4:2] #[1,4)号元素，不包含4，步长为2
array([8, 6])

多维数组的索引和切片：

# 索引
>>> 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[:,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]]])

数组的运算

数组与标量（一个数据）之间的运算等价于数组中的每一个元素都与这个标量进行运算

例子：

>>> 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.mean()
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.        ]]])

相关函数（均为对数组中的各个元素进行操作，且均为新生成的数组，不改变原始数组）：

一元函数

函数	说明
np.abs(x)、np.fabs(x)	计算数组各元素的绝对值
np.sqrt()	计算数组各元素的平方根
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(-)

二元函数

函数	说明
+、-、*、/、**	两个数组各元素进行对应运算
np.maximum(x,y)、np.fmax()、np. minimum(x,y)、np.fmin()	元素级的最大值/最小值计算
np.mod(x,y)	元素级的模运算
np. copysign(x,y)	将数组y中各元素值的符号赋值给数组x对应元素
>、<、>=、<=、==、!=	算术比较,产生布尔型数组

数据存取与函数

CSV文件存取

CSV（ Comma-Separated value，逗号分隔值）是—种常见的文件格式，用来存储批量数据。（CSV文件只能用来保存一维二维数组）

将数据写入csv文件：

np.savetxt(frame, array, fmt='%.18e', delimeter=None)

• frame：文件、字符串或产生器，可以是.gz或.bz2的压缩文件。
• array：存入文件的数组。
• fmt：写人文件的格式，例如：%d、%.2f、%.18e。
• delimiter：分割字符串，默认是空格（csv文件中是逗号,）

读取csv文件中的数据：

np.loadtxt(frame, dtype=np.float, delimeter=None, unpack=False)

• frame：文件、字符串或产生器，可以是.gz或.bz2的压缩文件。
• dtype：数据类型，可选。
• delimiter：分割字符串，默认是空格（csv文件中是逗号,）
• unpack：如果True，读入属性将分别写入不同变量

多维数据的存取

存储：

a.tofile(frame, sep='', format='%s')

• frame：文件、字符串
• sep：数据分割字符串，如果是空串，写入文件为二进制。
• format：写人数据的格式

注意：将数组写入文件后，其中的维度信息会丢失，可以利用reshape方法：np.fromfile().reshape()在读取的时候还原维度信息，但是需要之前数组的维度信息

读取：

a.fromfile(frame, dtype=float, count=-1, sep='')

• frame：文件、字符串
• dtype：读取的数据类型。
• count：读入元素个数，-1表示读入整个文件。
• sep：数据分割字符串，如果是空串，写入文件为二进制。

例子：

>>> a = np.arange(100).reshape(5, 10, 2)
>>> a.tofile("b.dat", format='%d')
>>> c = np.fromfile("b.dat", dtype=np.int).reshape(5, 10, 2)

注意：该方法需要读取时知道存入文件时数组的维度和元素类型，a.tofile()和 np.fromfile()需要配合使用。为解决上述维度丢失的情况，可以通过元数据文件来存储额外信息

Numpy便捷文件存储

该方法可以解决上述方法的维度丢失情况

存储：

np.save(fname, array)
np.savez(fname, array)

• frame：文件名，以.npy为扩展名，压缩扩展名为.npz
  • save方法存为.npy文件，savez方法存为压缩文件.npz
• array：数组变量

读取：

a.load(fname)

• frame：文件名，以.npy为扩展名，压缩扩展名为.npz

随机数函数

python中提供random库可以使用随机数，但是只能生成一般的随机数，Numpy中提供random字库提供numpy中的随机数，基本格式为np.random.*，*为random库中提供的函数，具体有：

函数	说明
rand(d0,d1,…,dn)	根据d0-dn（视为shape信息）创建随机数数组，浮点数，[0,1)， 均匀分布
randn(d0,d1,…,dn)	根据d0-dn（即视为shape信息）创建随机数数组，标准正态分布
randint(low[,high,shape])	根据shape创建随机整数或整数数组，范围是[low, high)
seed(s)	随机数种子，s是给定的种子值
shuffle(a)	根据数组a的第1轴（最外层维度的元素）进行随排列，会改变数组a
permutation(a)	根据数组a的第1轴（最外层维度的元素）产生一个新的乱序数组，不改变数组a
choice(a[,size, replace,p])	从一维数组a中以概率p抽取元素，形成size形状新数组，replace表示是否可以重用元素，默认为 False
uniform(low,high,size)	产生具有均匀分布的数组，low起始值，high结束值，size形状
normal(locc, scale,size)	产生具有正态分布的数组，loc均值，scale标准差，size形状
poisson(lam,size)	产生具有泊松分布的数组，lam随机事件发生率，size形状

例子：

>>> a = np.random.randint(100, 200, (3,4))
>>> a
array([[121, 114, 100, 112],
       [155, 183, 137, 177],
       [131, 189, 158, 101]])
>>> np.random.shuffle(a)
>>> a
array([[155, 183, 137, 177],
       [121, 114, 100, 112],
       [131, 189, 158, 101]])
>>> np.random.shuffle(a)
>>> a
array([[131, 189, 158, 101],
       [155, 183, 137, 177],
       [121, 114, 100, 112]])

统计函数

基本格式为np.*，*为random库中提供的函数，具体有：

函数	说明
sum(a, axis=None)	根据给定轴axis计算数组a相关元素之和，axis整数或元组
mean(a, axis=None)	根据给定轴axis计算数组a相关元素的期望，axis整数或元组
average(a,axis=None, weights=None)	根据给定轴axis计算数组a相关元素的加权平均值，weights为每个元素的权重
std(a, axis=None)	根据给定轴axis计算数组a相关元素的标准差
var(a, axis=None)	根据给定轴axis计算数组a相关元素的方差
min(a) max(a)	计算数组a中元素的最小值、最大值
argmin(a) argmax(a)	计算数组a中元素最小值、最大值的降一维后下标
unravel_index(index, shape)	根据shape将一维下标index转换成多维下标
ptp(a)	计算数组a中元素最大值与最小值的差
median(a)	计算数组a中元素的中位数(中值)

• axis=None即所有轴

例子1：

>>> 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
>>> np.mean(a, axis=1)
array([ 2.,  7., 12.])
>>> np.mean(a, axis=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])# 4.1875=(2*10+7*5+1*12)/(10+5+1)

例子2：

>>> 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.argmax(b) # 扁平化后的下标
0
>>> np.unravel_index(np.argmax(b), b.shape) # 重塑成多维下标
(0, 0)
>>> np.ptp(b)
14

梯度函数

梯度：连续值之间的变化率，即斜率。具体来说，XY坐标轴连续三个X坐标对应的Y轴值：a,b,c，其中，b的梯度是：(c-a)/2

numpy中梯度函数只有一个：

np.gradient(f)

• 计算数组f中元素的梯度，当f为多维时，返回每个维度梯度

例子：

#一维数组
>>> a = np.random.randint(0, 20, (5))
>>> a
array([ 6, 11, 18,  2,  6])
>>> np.gradient(a)
#第二个返回值6=(18-6)/2 最后一个返回值4=(6-2)/1
array([ 5. ,  6. , -4.5, -6. ,  4. ])

#二维数组
>>> a = np.random.randint(0, 50, (3, 5))
>>> a
array([[42,  5,  0, 21, 16],
       [ 7, 40, 17, 31, 18],
       [41, 22,  1,  2, 14]])
>>> np.gradient(a)
#二维数组中的任何一个元素的梯度存在两个方向
[array([[-35. ,  35. ,  17. ,  10. ,   2. ],# 最外层维度的梯度
       [ -0.5,   8.5,   0.5,  -9.5,  -1. ],
       [ 34. , -18. , -16. , -29. ,  -4. ]]),
 array([[-37. , -21. ,   8. ,   8. ,  -5. ],# 最第二层维度的梯度
       [ 33. ,   5. ,  -4.5,   0.5, -13. ],
       [-19. , -20. , -10. ,   6.5,  12. ]])]

• 若一个n维数组，经过gradient求梯度后会生成n个数组，每个数组代表原始的n维数组中一个元素在第n维度的梯度值

图像手绘效果

from PIL import Image
import numpy as np

a = np.asarray(Image.open('D:/pycodes/beijing.jpg').convert('L')).astype('float')

depth = 10 # (0-100)
grad = np.gradient(a) # 取图像灰度的梯度值
grad_x, grad_y = grad # 分别取横纵图像梯度值
grad_x = grad_x*depth/100.
grad_y = grad_y*depth/100.
A = np.sqrt(grad_x**2 + grad_y**2 + 1.)
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轴的影响
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)

im = Image.fromarray(b.astype("uint8")) # 重构图像
im.save('D:/pycodes/beijingHD.jpg')

Matplotlib库

Matplotlib是Python优秀的数据可视化第三方库，由各种可视化类构成，内部结构复杂。

matplotlib.pyplot是绘制各类可视化图形的命令子库，相当于快捷方式。所以基本上只会对该子库进行操作

引入：import matplotlib.pyplot as plt

基本知识

plot函数

基本绘图函数

plt.plot(x, y, format_string, **kwargs)

• x：X轴数据，列表或数组，可选。

• y：Y轴数据，列表或数组。

• format_string：控制曲线的格式字符串，可选。由颜色字符、风格字符和标记字符组成

  • 常用颜色字符：

    颜色字符	说明	颜色字符	说明
    ‘b’	蓝色	‘m’	洋红色 magenta
    ‘g’	绿色	‘y’	黄色
    ‘r’	红色	‘k’	黑色
    ‘c’	青绿色 cyan	‘w’	白色
    ‘#008000’	RGB某颜色	‘0.8’	灰度值字符串

  • 风格字符：

    风格字符	说明
    ‘-’	实线
    ‘–’	破折线
    ‘-.’	点划线
    ‘:’	虚线
    ‘’（空）或者’ '（空格）	无线条

  • 常用标记字符：

    标记字符	说明	标记字符	说明	标记字符	说明
    ‘.’	点标记	‘1’	下花三角标记	‘h’	竖六边形标记
    ‘,’	像素标记（极小点）	‘2’	上花三角标记	‘H’	横六边形标记
    ‘o’	实心圈标记	‘3’	左花三角标记	‘+’	十字标记
    ‘v’	倒三角标记	‘4’	右花三角标记	‘x’	x标记
    ‘^’	上三角标记	‘s’	实心方角标记	‘D’	菱形标记
    ‘>’	右三角标记	‘p’	实心五角标记	‘d’	瘦菱形标记
    ‘<’	左三角标记	‘*’	星形标记	‘|’	垂直线标记

• kwargs：第二组或更多（x,y,format_string）

  • 当绘制多条曲线时，各条曲线的不能省略
  • color：控制颜色， color=‘green’
  • linestyle：线条风格， linestyle=‘dashed’
  • marker：标记风格， marker=‘o’
  • markerfacecolor：标记颜色， markerfacecolor=‘blue’
  • markersize：标记尺寸， markersize=20

中文显示

pyplot默认不支持中文显示，可以通过以下两种方式设置：

一、使用rcParams属性改变pyplot全局字体

import matplotlib.pyplot as plt
import matplotlib

matplotlib.rcParams['font.family']='SimHei' # 'SimHei'黑体，只需要支持中文即可
plt.plot([3, 1, 4, 5, 2])
plt.ylabel("纵轴（值）")
plt.savefig('test', dpi=600) # 保存图像
plt.show()

• rcParams常用属性说明：

  属性	说明
  ‘font.family’	用于显示字体的名字
  ‘font.style’	字体风格，正常’normal’或斜体’italic’
  ‘font.size’	字体大小，整数字号或者’large’、‘x-small’

• 常用中文字体：

  • ‘SimHei’：中文黑体
  • ‘Kaiti’：中文楷体
  • ‘LiSu’：中文隶书
  • ‘FangSong’：中文仿宋
  • ‘YouYuan’：中文幼圆
  • ‘STSong’：华文宋体

二、在有中文输出的地方,增加一个属性: fontproperties

import matplotlib.pyplot as plt
import numpy as np

a = np.arange(0.0, 5.0, 0.02)
plt.xlabel('横轴，时间', fontproperties='SimHei', fontsize=20)
plt.ylabel('纵轴，振幅', fontproperties='SimHei', fontsize=20)
plt.plot(a, np.cos(2*np.pi*a), 'r--')
plt.savefig('test', dpi=600) # 保存图像
plt.show()

文本显示

常用函数：

函数	说明
plt.xlabel()	对X轴增加文本标签
plt.ylabel()	对Y轴增加文本标签
plt.title()	对图形整体增加文本标签，放于整个图像的正上方
plt.text()	在任意位置增加文本
plt.annotate()	在图形中增加带箭头的注解

其中annotate函数有：

plt.annotate(s, xy=arrow_crd, xytext=text_crd, arrowprops=dict)

• s：带注解字符串
• xy：箭头所在位置
• xytext：文本显示位置
• arrowprops：字典类型，包含箭头显示的一些属性

例子：

import matplotlib.pyplot as plt
import numpy as np

a = np.arange(0.0, 5.0, 0.02)
plt.plot(a, np.cos(2*np.pi*a), 'r--')

plt.xlabel('横轴，时间', fontproperties='SimHei', fontsize=15, color='green')
plt.ylabel('纵轴，振幅', fontproperties='SimHei', fontsize=15)
plt.title(r'正弦波实例 $y=cos(2\pi x)$', fontproperties='SimHei', fontsize=25) # $$中为latex语法
plt.text(2, 1, r'$\mu=100$', fontsize=15) # 在(2,1)处显示文本
plt.annotate(r'$\mu=100$', xy=(2,1), xytext=(3,1.5), arrowprops=dict(facecolor='black', shrink=0.1, width=2)) # 箭头在(2,1)，文本在(3,1.5)，黑色箭头，箭头宽度为2，从箭头的起始到结束，按照0.1的比例将箭头缩进

plt.axis([-1, 6, -2, 2]) # 横轴由-1到6，纵轴由-2到2
plt.grid(True) # 加入网格
plt.show()

子绘图区域

如果在一个绘图区域中，希望分成几个子绘图区域来绘制图像，可以通过使用subplot函数：

plt.subplot(nrows, ncols, plot_number)

• 该函数将绘图区域划分成了横纵数量为nrows，纵轴数量为ncols的子区域
• plot_number为在划分后的区域中，当前选中的那块区域（区域编号为从左到右，从上倒下，从1开始）
• 中间点逗号可以省略

对于绘制较为复杂的子区域（不能由行列来划分，有些子区域占据多行或多列），需要通过以下函数来进行操作：

plt.subplot2grid(GridSpec, CurSpec, colspan=l, rowspan=l)

理念：设定网格,选中网格,确定选中行列区域数量,编号从0开始.

例子：

绘制以下区域图形：

#ax1：
plt.subplot2grid((3,3), (0,0), colspan=3) # 将总区域划分成3*3的大小，选定(0,0)这个区域，并且列延伸colspan=3个单位（即选定长度加上旁边的长度）
#ax2：
plt.subplot2grid((3,3), (1,0), colspan=2) # 将总区域划分成3*3的大小，选定(1,0)这个区域，并且列延伸colspan=2个单位（即选定长度加上旁边的一个长度）
#ax3：
plt.subplot2grid((3,3), (1,2), rowspan=2) # 将总区域划分成3*3的大小，选定(1,2)这个区域，并且行延伸rowspan=2个单位（即选定长度加上旁边的长度）
#ax4：
plt.subplot2grid((3,3), (2,0)) # 将总区域划分成3*3的大小，选定(2,0)这个区域
#ax5：
plt.subplot2grid((3,3), (2,1)) # 将总区域划分成3*3的大小，选定(2,1)这个区域

通过GridSpec类能够简化上述流程：

import matplotlib.gridspec as gridspec

gs = gridspec.GridSpec(3,3) # 在该区域中划分为3*3的网格

ax1 = plt.subplot(gs[0, :]) # 横向第0列，纵向所有列
ax2 = plt.subplot(gs[1, :-1])
ax3 = plt.subplot(gs[1:, -1])
ax4 = plt.subplot(gs[2, 0])
ax5 = plt.subplot(gs[2, 1])

基础绘图函数

函数	说明
plt.plot(x.y,fmt,…)	绘制一个坐标图(直角/极坐标)
plt.boxplot(data,notch,position)	绘制一个箱形图
plt.bar(left,height,width,bottom)	绘制一个条形图
plt.barh(width,bottom,left,height)	绘制一个横向条形图
plt.polar(theta,r)	绘制极坐标图
plt.pie(data, explode)	绘制饼图
plt.psd(x,NFFT=256,pad_to,Fs)	绘制功率谱密度图
plt.specgram(x,NFFT=256,pad_to,F)	绘制谱图
plt.cohere(x,y,NFFT=256,Fs)	绘制X-Y的相关性函数
plt.scatter(x,y)	绘制散点图,其中,x和y长度相同
plt.step(x,y,where)	绘制步阶图
plt.hist(x,bins,normed)	绘制直方图
plt.contour(X,Y,Z,N)	绘制等值图
plt.vlines()	绘制垂直图
plt.stem(x,y,linefmt,markerfmt)	绘制柴火图
plt.plot_date()	绘制数据日期

Pandas库

Pandas是Python第三方库,提供高性能易用数据类型和分析工具，引用如下：

import pandas as pd

Pandas基于NumPy实现,常与 NumPy和Matplotlib一同使用

Pandas主要提供两个数据类型：Series（一维），DataFrame（二维）

Series类型

Series类型由一组数据及与之相关的数据索引组成。其索引由pandas自动构建或由用户自定义生成：

• 自动构建：

  >>> import pandas as pd
  >>> a = pd.Series([9,8,7,6])
  >>> a
  0    9 # 左侧为pandas自动追加的索引，右侧为数据
  1    8
  2    7
  3    6
  dtype: int64 # NumPy中的数据类型

• 用户自定义索引：

  >>> import pandas as pd
  >>> b = pd.Series([9,8,7,6], index=['a','b','c','d']) # 若为第二个参数，index=可以省略
  >>> b
  a    9
  b    8
  c    7
  d    6
  dtype: int64

Series类型可以由以下类型创建：

• Python列表

• 标量值

  >>> import pandas as pd
  >>> s = pd.Series(25, index=['a','b','c']) # 此时index=不能省略
  >>> s
  a    25
  b    25
  c    25
  dtype: int64

• Python字典

  >>> import pandas as pd
  >>> d = pd.Series({'a':9,'b':8,'c':7})
  >>> d
  a    9
  b    8
  c    7
  dtype: int64
  >>> e = pd.Series({'a':9,'b':8,'c':7}, index=['c','a','b','d']) # index从字典中进行选择操作
  >>> e
  c    7.0
  a    9.0
  b    8.0
  d    NaN
  dtype: float64

• ndarray

  >>> import pandas as pd
  >>> import numpy as np
  >>> n = pd.Series(np.arange(5))
  >>> n
  0    0
  1    1
  2    2
  3    3
  4    4
  dtype: int32
  >>> m = pd.Series(np.arange(5),index=np.arange(9,4,-1))
  >>> m
  9    0
  8    1
  7    2
  6    3
  5    4
  dtype: int32

• 其他函数（range()等函数）

基本操作

Series类型包括index和values两部分（Series类型的操作类似ndarray类型、Python字典类型），可以通过.index和.values分别获得索引和数据

>>> import pandas as pd
>>> b = pd.Series([9,8,7,6], index=['a','b','c','d'])
>>> b.index
Index(['a', 'b', 'c', 'd'], dtype='object')
>>> b.values
array([9, 8, 7, 6], dtype=int64) # numpy中的array类型

获得索引值和值的操作：

>>> b['b'] # 自定义索引
8
>>> b[1] # 自动索引
8
>>> b[['c','d',0]] # 报错
>>> b[['c','d','a']] # 两套索引并存，但不能混用
c    7
d    6
a    9
dtype: int64

Series类型的操作类似ndarray类型：

• 索引方法相同，采用[]

• NumPy中运算和操作可用于Series类型

• 可以通过自定义索引的列表进行切片

• 可以通过自动索引进行切片，如果存在自定义索引， 则一同被切片

  >>> b[1] # 索引出来的是值
  8
  >>> b[:3] # 切片出来的任是Series
  a    9
  b    8
  c    7
  dtype: int64
  >>> b[b>b.median()] # b.median()=7.5
  a    9
  b    8
  dtype: int64
  >>> np.exp(b)
  a    8103.083928
  b    2980.957987
  c    1096.633158
  d     403.428793
  dtype: float64

  • 对Series类型的切片及相关运算都会返回Series类型
  • 如果只选择Series类型中的一个值，此时返回的是一个值

Series类型的操作类似Python字典类型

• 通过自定义索引访问

• 保留字in操作（只判断自定义索引）

  >>> 'c' in b # 判断'c'是否为自定义索引
  True
  >>> 0 in b
  False

• 使用.get()方法

  >>> b.get('f',100) # 从b中提取索引'f'对应的值，不存在则返回100，否则返回'f'对应的值
  100

对齐操作：Series类型在运算中会自动对齐不同索引的数据（Series+Series时，索引值相同的值进行计算，不同的值不进行计算）

>>> import pandas as pd
>>> a = pd.Series([1,2,3], index=['c','d','e'])
>>> b = pd.Series([9,8,7,6], index=['a','b','c','d'])
>>> a+b
a    NaN
b    NaN
c    8.0
d    8.0
e    NaN
dtype: float64

Series对象和索引都可以有一个名字，存储在属性.name中

>>> import pandas as pd
>>> b = pd.Series([9,8,7,6], index=['a','b','c','d'])
>>> b.name
>>> b.name='Series对象'
>>> b.index.name='索引列'
>>> b
索引列
a    9
b    8
c    7
d    6
Name: Series对象, dtype: int64

Series对象可以随时修改并即刻生效

Dataframe类型

Dataframe类型由共用相同索引的一组列组成（表格），是二维带“标签”数组：

• 是一个表格型的数据类型，每列值类型可以不同或相同
• 既有行索引（index）、也有列索引（column）
  • axis=0（0轴）为行，即index
  • axis=1（1轴）为列，即column
• 常用于表达二维数据，但可以表达多维数据

创建方式

• 二维 ndarray对象

  >>> import pandas as pd
  >>> import numpy as np
  >>> pd.DataFrame(np.arange(10).reshape(2,5)) # 10个元素 2*5的大小
     0  1  2  3  4 #← 自动列索引
  0  0  1  2  3  4
  1  5  6  7  8  9
  #↑ 自动行索引

• 一维 ndarray、列表、字典、元组或 Series构成的字典

  • Series构成的字典：

    >>> dt = {'one':pd.Series([1,2,3], index=['a','b','c']),
    ... 'two':pd.Series([9,8,7,6], index=['a','b','c','d'])}
    >>> pd.DataFrame(dt)
       one  two
    a  1.0    9
    b  2.0    8
    c  3.0    7
    d  NaN    6

    可通过index指定行索引，columns指定列索引：

    >>> pd.DataFrame(dt, index=['b','c','d'], columns=['two','three'])
       two three
    b    8   NaN
    c    7   NaN
    d    6   NaN

  • 列表类型的字典：

    >>> dl = {'one':[1,2,3,4], 'two':[9,8,7,6]}
    >>> pd.DataFrame(dl, index=['a','b','c','d'])
       one  two
    a    1    9
    b    2    8
    c    3    7
    d    4    6

• Series类型

• 其他的 Dataframe类型

可以通过.index、.columns和.values分别获得行索引、列索引和表中的数据

>>> dl = {'one':[1,2,3,4], 'two':[9,8,7,6]}
>>> d = pd.DataFrame(dl, index=['a','b','c','d'])
>>> d.index # 获得行索引
Index(['a', 'b', 'c', 'd'], dtype='object')
>>> d.columns # 获得列索引
Index(['one', 'two'], dtype='object')
>>> d.values # 获得表中的数据
array([[1, 9],
       [2, 8],
       [3, 7],
       [4, 6]], dtype=int64)

获得Dataframe中的元素：

>>> d['one'] # 列索引标记 获得一列数据（Series类型）
a    1
b    2
c    3
d    4
Name: one, dtype: int64
>>> d.iloc[1] # 查找第二行（Series类型）
one    2
two    8
Name: b, dtype: int64
>>> d['one']['b'] # 精确查找
2

• 在pandas的1.0.0版本开始，移除了Series.ix和DataFrame.ix方法，用loc方法或者iloc方法进行替换。loc、iloc使用

数据类型操作

Index对象

Series和 Dataframe的索引是Index类型，Index对象是不可修改类型，其常用方法如下：

方法	说明
.append(idx)	连接另一个Index对象，产生新的Index对象
.diff(idx)	计算差集，产生新的Index对象
.intersection(idx)	计算交集
.union(idx)	计算并集
.delete(loc)	删除loc位置处的元素
.insert(loc,e)	在loc位置增加一个元素e

重新索引（增加或重排）

.reindex(index=None, columnS=None,...)能够改变或重排 Series和 Dataframe索引

• index, columns：新的行列自定义索引
• fill_value：重新索引中，用于填充缺失位置的值
• method：填充方法，ffill当前值向前填充，bfill向后填充
• limit：最大填充量
• copy：默认True，生成新的对象， False时，新旧相等不复制

>>> dt = {'one':pd.Series([1,2,3], index=['a','b','c']),
... 'two':pd.Series([9,8,7,6], index=['a','b','c','d'])}
>>> d= pd.DataFrame(dt)
>>> d
   one  two
a  1.0    9
b  2.0    8
c  3.0    7
d  NaN    6
>>> d.reindex(index=['d','c','b','a']) # 重排行
   one  two
d  NaN    6
c  3.0    7
b  2.0    8
a  1.0    9
>>> d.reindex(columns=['two','one']) # 重排列
   two  one
a    9  1.0
b    8  2.0
c    7  3.0
d    6  NaN
>>> newc = d.columns.insert(2, 'three') # 列中新增一列
>>> d.reindex(columns=newc, fill_value=200)
   one  two  three
a  1.0    9    200
b  2.0    8    200
c  3.0    7    200
d  NaN    6    200

删除

.drop()能够删除 Series和 DataFrame指定行或列索引，会生成新的DataFrame对象

• 默认axis=0，即默认对行进行操作。如需对列操作，需指定axis=1

>>> import pandas as pd
>>> a = pd.Series([9,8,7,6], index=['a','b','c','d'])
>>> a
a    9
b    8
c    7
d    6
dtype: int64
>>> a.drop(['b','c'])
a    9
d    6
dtype: int64

数学类型运算

算术运算

• 算术运算根据行列索引，补齐后运算，运算默认产生浮点数

• 补齐时缺项填充NaN（空值）

• 二维和一维、一维和零维间为广播运算

  • 广播运算：两个数组进行运算，一个是Series数组（即一维数组），另一个是DataFrame数组（多维数组）：

    >>> a = pd.DataFrame(np.arange(20).reshape(4,5))
    >>> a
        0   1   2   3   4
    0   0   1   2   3   4
    1   5   6   7   8   9
    2  10  11  12  13  14
    3  15  16  17  18  19
    >>> b = pd.Series(np.arange(4))
    >>> b
    0    0
    1    1
    2    2
    3    3
    dtype: int32
    >>> b-10
    0   -10
    1    -9
    2    -8
    3    -7
    dtype: int32
    >>> a-b
          0     1     2     3   4
    0   0.0   0.0   0.0   0.0 NaN
    1   5.0   5.0   5.0   5.0 NaN
    2  10.0  10.0  10.0  10.0 NaN
    3  15.0  15.0  15.0  15.0 NaN

    • 一维和零维的运算：一维上每个值加上零维的数据

    • 不同维度间为广播运算，一维Series默认在轴1参与运算

      • 一维数组看成是一行，分别与多维数组的每一行进行运算

    • 可以通过axis=0指定到0轴上，即列上：

      >>> a.sub(b,axis=0)
          0   1   2   3   4
      0   0   1   2   3   4
      1   4   5   6   7   8
      2   8   9  10  11  12
      3  12  13  14  15  16

• 采用±*/符号进行的二元运算产生新的对象

  • .add(d,**argws)：类型间加法运算，可选参数
    • fill_value：用于填充缺失位置的值
  • .sub(d,**argws)：类型间减法运算，可选参数
  • .mul(d,**argws)：类型间乘法运算，可选参数
  • .div(d,**argws)：类型间除法运算，可选参数

  >>> a = pd.DataFrame(np.arange(12).reshape(3,4))
  >>> a
     0  1   2   3
  0  0  1   2   3
  1  4  5   6   7
  2  8  9  10  11
  >>> b = pd.DataFrame(np.arange(20).reshape(4,5))
  >>> b
      0   1   2   3   4
  0   0   1   2   3   4
  1   5   6   7   8   9
  2  10  11  12  13  14
  3  15  16  17  18  19
  >>> a+b
        0     1     2     3   4
  0   0.0   2.0   4.0   6.0 NaN
  1   9.0  11.0  13.0  15.0 NaN
  2  18.0  20.0  22.0  24.0 NaN
  3   NaN   NaN   NaN   NaN NaN
  >>> a.mul(b,fill_value=0)
        0     1      2      3    4
  0   0.0   1.0    4.0    9.0  0.0
  1  20.0  30.0   42.0   56.0  0.0
  2  80.0  99.0  120.0  143.0  0.0
  3   0.0   0.0    0.0    0.0  0.0

比较运算

• 比较运算只能比较相同索引的元素，不进行补齐

• 二维和一维、—维和零维间为广播运算

• 用>、<、>=、<=、==、!=等符号进行的二元运算产生布尔对象

  >>> a = pd.DataFrame(np.arange(12).reshape(3,4))
  >>> a
     0  1   2   3
  0  0  1   2   3
  1  4  5   6   7
  2  8  9  10  11
  >>> b = pd.DataFrame(np.arange(12,0,-1).reshape(3,4))
  >>> b
      0   1   2  3
  0  12  11  10  9
  1   8   7   6  5
  2   4   3   2  1
  >>> a>b
         0      1      2      3
  0  False  False  False  False
  1  False  False  False   True
  2   True   True   True   True
  >>> a==b
         0      1      2      3
  0  False  False  False  False
  1  False  False   True  False
  2  False  False  False  False

排序

.sort_index(axis=0, ascending=True)方法在指定轴上根据索引进行排序，默认升序

• axis：排序的轴，默认0轴，即行
• ascending：是否递增排序，默认True

>>> b = pd.DataFrame(np.arange(20).reshape(4,5), index=['c','a','b','d'])
>>> b
    0   1   2   3   4
c   0   1   2   3   4
a   5   6   7   8   9
b  10  11  12  13  14
d  15  16  17  18  19
>>> b.sort_index()
    0   1   2   3   4
a   5   6   7   8   9
b  10  11  12  13  14
c   0   1   2   3   4
d  15  16  17  18  19
>>> b.sort_index(ascending=False)
    0   1   2   3   4
d  15  16  17  18  19
c   0   1   2   3   4
b  10  11  12  13  14
a   5   6   7   8   9

.sort_values()方法在指定轴上根据数值进行排序，默认升序

• Series.sort_values(axis=0, ascending=True)
  • axis：排序的轴，默认0轴，即行
  • ascending：是否递增排序，默认True
• DataFrame.sort_values(by, axis=0, ascending=True)
  • by：axis轴上的某个索引或索引列表

>>> b = pd.DataFrame(np.arange(20).reshape(4,5), index=['c','a','d','b'])
>>> b
    0   1   2   3   4
c   0   1   2   3   4
a   5   6   7   8   9
d  10  11  12  13  14
b  15  16  17  18  19
>>> b.sort_values(2,ascending=False) # 第三列 降序排序
    0   1   2   3   4
b  15  16  17  18  19
d  10  11  12  13  14
a   5   6   7   8   9
c   0   1   2   3   4
>>> b.sort_values('a',axis=1,ascending=False) # 'a'这一行 降序排序
    4   3   2   1   0
c   4   3   2   1   0
a   9   8   7   6   5
d  14  13  12  11  10
b  19  18  17  16  15

• NaN统一放到排序未尾（无论ascending为何值）

基本统计分析

适用于 Series和 DataFrame类型：

方法	说明
.sum()	计算数据的总和,按0轴计算,下同
.count()	非NaN值的数量
.mean() .median()	计算数据的算术平均值、算术中位数
.var() .std()	计算数据的方差、标准差
.min() .max()	计算数据的最小值、最大值

适用于 Series类型：

方法	说明
.argmin() .argmax()	计算数据最大值、最小值所在位置的索引位置(自动索引)
.idxmin() .idxmax()	计算数据最大值、最小值所在位置的索引(自定义索引)

统计汇总（适用于 Series和 DataFrame类型）：

方法	说明
.describe()	针对0轴(各列)的统计汇总

对于Series类型：

>>> a = pd.Series([9,8,7,6], index=['a','b','c','d'])
>>> a
a    9
b    8
c    7
d    6
dtype: int64
>>> a.describe()
count    4.000000
mean     7.500000
std      1.290994
min      6.000000
25%      6.750000
50%      7.500000
75%      8.250000
max      9.000000
dtype: float64
>>> type(a.describe()) # 类型，任是Series类型
<class 'pandas.core.series.Series'>
>>> a.describe()['max']
9.0

对于DataFrame类型：

>>> b = pd.DataFrame(np.arange(20).reshape(4,5), index=['c','a','d','b'])
>>> b
    0   1   2   3   4
c   0   1   2   3   4
a   5   6   7   8   9
d  10  11  12  13  14
b  15  16  17  18  19
>>> b.describe()
               0          1          2          3          4
count   4.000000   4.000000   4.000000   4.000000   4.000000
mean    7.500000   8.500000   9.500000  10.500000  11.500000
std     6.454972   6.454972   6.454972   6.454972   6.454972
min     0.000000   1.000000   2.000000   3.000000   4.000000
25%     3.750000   4.750000   5.750000   6.750000   7.750000
50%     7.500000   8.500000   9.500000  10.500000  11.500000
75%    11.250000  12.250000  13.250000  14.250000  15.250000
max    15.000000  16.000000  17.000000  18.000000  19.000000
>>> type(b.describe()) # 类型，任是Series类型
<class 'pandas.core.series.Series'>
>>> b.describe().iloc[7] # 获取最后一行内容（Series类型）
0    15.0
1    16.0
2    17.0
3    18.0
4    19.0
Name: max, dtype: float64
>>> b.describe()[2] # 获取第三列内容（Series类型）
count     4.000000
mean      9.500000
std       6.454972
min       2.000000
25%       5.750000
50%       9.500000
75%      13.250000
max      17.000000
Name: 2, dtype: float64

累计统计信息

适用于 Series和 DataFrame类型：

方法	说明
.cumsum()	依次给出前1、2、…、n个数的和
.cumprod()	依次给出前1、2、…、n个数的积
.cummax()	依次给出前1、2、…、n个数的最大值
.cummin()	依次给出前1、2、…、n个数的最小值

• 默认为列，如需改为行，需添加参数axis=1

例子：

>>> b = pd.DataFrame(np.arange(20).reshape(4,5), index=['c','a','d','b'])
>>> b
    0   1   2   3   4
c   0   1   2   3   4
a   5   6   7   8   9
d  10  11  12  13  14
b  15  16  17  18  19
>>> b.cumsum()
    0   1   2   3   4
c   0   1   2   3   4
a   5   7   9  11  13
d  15  18  21  24  27
b  30  34  38  42  46

适用 Series和 DataFrame类型，滚动计算（窗囗计算）：

方法	说明
.rolling(w).sum()	依次计算相邻w个元素的和
.rolling(w).mean()	依次计算相邻w个元素的算术平均值
.rolling(w).var()	依次计算相邻w个元素的方差
.rolling(w).std()	依次计算相邻w个元素的标准差
.rolling(w).min() .max()	依次计算相邻w个元素的最小值和最大值

例子：

>>> b = pd.DataFrame(np.arange(20).reshape(4,5), index=['c','a','d','b'])
>>> b
    0   1   2   3   4
c   0   1   2   3   4
a   5   6   7   8   9
d  10  11  12  13  14
b  15  16  17  18  19
>>> b.rolling(2).sum() # 列方向上，每两个单位求一次和
      0     1     2     3     4
c   NaN   NaN   NaN   NaN   NaN
a   5.0   7.0   9.0  11.0  13.0
d  15.0  17.0  19.0  21.0  23.0
b  25.0  27.0  29.0  31.0  33.0
>>> b.rolling(3).sum()
      0     1     2     3     4
c   NaN   NaN   NaN   NaN   NaN
a   NaN   NaN   NaN   NaN   NaN
d  15.0  18.0  21.0  24.0  27.0
b  30.0  33.0  36.0  39.0  42.0

相关分析

适用 Series和 DataFrame类型：

方法	说明
.cov()	计算协方差矩阵
.corr()	计算相关系数矩阵，Pearson、 Spearman、 Kendall等系数

>>> hprice = pd.Series([3.04,22.93,12.75,22.6,12.33],index=['2008','2009','2010','2011','2012'])
>>> m2 = pd.Series([8.18,18.38,9.13,7.82,6.69],index=['2008','2009','2010','2011','2012'])
>>> hprice.corr(m2)
0.5239439145220387