【Pandas】数据分析工具Pandas的基本操作和可视化工具Matplotlib

比眉伴天荒 2023-07-04 15:48 15阅读 0赞

## 1、Pandas简介 ##

pandas是python的一个数据分析包，最初由AQR Capital Management于2008年4月开发，并于2009年底开源出来，目前由专注于Python数据包开发的PyData开发team继续开发和维护，属于PyData项目的一部分。Pandas最初被作为金融数据分析工具而开发出来，因此，pandas为时间序列分析提供了很好的支持。  
Pandas的名称来自于面板数据（panel data）和python数据分析（data analysis）。panel data是经济学中关于多维数据集的一个术语，在Pandas中也提供了panel的数据类型。  
官网：http://pandas.pydata.org/  
参考文档：http://pandas.pydata.org/pandas-docs/stable/

## 2、Pandas安装 ##

Python的Anaconda发行版，已经安装好了pandas库，因此无需另外安装。  
使用Anaconda界面安装：打开Anaconda Navigator，选择开发环境，从Not installed下找到pandas相关的库，勾选安装。  
Anaconda安装命令： `conda install pandas`  
PyPi安装命令： `pip install pandas`

## 3、Pandas数据结构 ##

（1）Pandas引入约定

from pandas import Series, DataFrame
    import pandas as pd

（2）Series  
Series是一种类似于一维数组的对象，它是由一组数据（各种Numpy数据类型）以及一组与之相关的数据标签（即索引）组成。仅由一组数据即可产生简单的Series。  
1）通过一维数组创建Series

>> import numpy as np
    >> import pandas as pd
    >> from pandas import Series, DataFrame
    
    >> arr = np.array([1, 2, 3, 4])
    >> series01 = Series(arr)
    >> series01
    0	1
    1	2
    2	3
    3	4
    dtype: int32
    >> series01.index
    RangeIndex(start=0, stop=4, step=1)
    >> series01.values
    array([1, 2, 3, 4])
    >> series01.dtype
    dtype('int32')
    
    >> series02 = Series([34.5, 56.78, 45.67])										# 通过数组创建时，如果没有为数据指定索引，则会自动创建一个从0到N-1（N为数据的长度）的整数型索引
    >> series02
    0	34.50
    1	56.78
    2	45.67
    dtype: float64
    >> series02.index = ['product1', 'product2', 'product3']						# 默认索引可通过赋值方式进行修改
    >> series02
    product1	34.50
    product2	56.78
    product3	45.67
    dtype: float64
    
    >> series03 = Series([98, 56, 88, 45], index=['语文', '数学', '英语', '体育'])		# 通过数组创建Series时，可以通过index参数传入一个明确的标签索引
    >> series03
    语文	98
    数学	56
    英语	88
    体育	45
    dtype: int64
    >> series03.index
    Index([u'语文', u'数学', u'英语', u'体育'], dtype='object')
    >> series03.values
    array([98, 56, 88, 45], dtype=int64)

2）通过字典的方式创建Series  
Series可以被看成是一个定长的有序字典，是索引值到数据值的一个映射，因此可以直接通过字典来创建Series。

>> a_dict = {'20071001':6798.98, '20071002':34556.89, '20071003':3748758.88}
    >> series04 = Series(a_dict)		# 通过字典创建Series时，字典中的key组成Series的索引，字典中的value组成Series中的values
    >> series04.index
    Index([u'20071001', u'20071002', u'20071003'], dtype='object')
    >> series04
    20071001	6798.98
    20071002	34556.89
    20071003	3748758.88

3）Series应用Numpy数组运算  
通过索引取值：

>> series04['20071001']
    6798.9799999999996
    >> series04[0]
    6798.9799999999996

Numpy中的数组运算，在Series中都保留使用，并且Series进行数组运算时，索引与值之间的映射关系不会改变。

>> series04
    20071001	6798.98
    20071002	34556.89
    20071003	3748758.88
    dtype: float64
    >> series04[series04>10000]
    20071002	34556.89
    20071003	3748758.88
    dtype: float64
    >> series04 / 100
    20071001	67.9898
    20071002	345.5689
    20071003	37487.5888
    dtype: float64
    >> series01 = Series([1, 2, 3, 4])
    >> np.exp(series01)
    0	2.718282
    1	7.389056
    2	20.085537
    3	54.598150
    dtype: float64

4）Series缺失值检测

>> scores = Series({"Tom":89, "John":88, "Merry":96, "Max":65})
    >> scores
    John	88
    Max		65
    Merry	96
    Tom		89
    dtype: int64
    >> new_index = ['Tom', 'Max', 'Joe', 'John', 'Merry']
    >> scores = Series(scores, index=new_index)
    >> scores
    Tom		89.0
    Max		65.0
    Joe		NaN				# NaN（not a number）在pandas中用于表示一个缺失或者NA值
    John	88.0
    Merry	96.0
    dtype: float64

pandas中的isnull和notnull函数可用于Series缺失值检测，isnull和notnull都返回一个布尔类型的Series。

>> pd.isnull(scores)
    Tom		False
    Max		False
    Joe		True
    John	False
    Merry	False
    dtype: bool
    >> pd.notnull(scores)
    Tom		True
    Max		True
    Joe		False
    John	True
    Merry	True
    dtype: bool
    >> scores[pd.isnull(scores)]		# 过滤出为缺失值的项
    Joe		NaN
    dtype: float64
    >> scores[pd.notnull(scores)]		# 过滤出不是缺失值的项
    Tom		89.0
    Max		65.0
    John	88.0
    Merry	96.0
    dtype: float64

5）Series自动对齐  
不同Series之间进行算术运算，会自动对齐不同索引的数据。

product_num = Series([23, 45, 67, 89], index=['p3', 'p1', 'p2', 'p5'])
    product_price_table = Series([9.98, 2.34, 4.56, 5.67, 8.78], index=['p1', 'p2', 'p3', 'p4', 'p5'])
    product_sum = product_num * product_price_table
    product_sum
    p1		449.10
    p2		156.78
    p3		104.88
    p4		NaN
    p5		781.42
    dtype: float64

6）Series及其索引的name属性  
Series对象本身及其索引都有一个name属性，可赋值设置。

>> product_num.name = 'ProductNums'
    >> product_num.index.name = 'ProductType'
    >> product_num
    ProductType
    p3		23
    p1		45
    p2		67
    p5		89
    Name: ProductNums, dtype: int64

（3）DataFrame  
DataFrame是一个表格型的数据结构，含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等），DataFrame既有行索引也有列索引，可以被看做是由Series组成的字典。  
1）通过二维数组创建DataFrame

>> df01 = DataFrame([['Tom', 'Merry', 'John'], [76, 98, 100]])
    >> df01
    		0		1			2
    0		Tom		Merry		John
    1		76		98			100
    >> df02 = DataFrame([['Tom', 76], ['Merry', 98], ['John', 100]])
    >> df02
    		0		1
    0		Tom		76
    1		Merry	98
    2		John	100
    >> arr = np.array([['Tom', 76], ['Merry', 98], ['John', 100]])
    >> df03 = DataFrame(arr, columns=['name', 'score'])
    >> df03
    		name	score
    0		Tom		76
    1		Merry	98
    2		John	100
    >> df04 = DataFrame(arr, index=['one', 'two', 'three'], columns=['name', 'score'])		# 自定义行索引index，自定义列索引columns
    >> df04
    		name	score
    one		Tom		76
    two		Merry	98
    three	John	100

2）通过字典的方式创建DataFrame

>> data = {"apart":['1001', '1002', '1003', '1001'], "profits":[567.87, 987.87, 873, 498.87], "year":[2001, 2001, 2001, 2000]}
    >> df = DataFrame(data)
    >> df
    		apart		profits		year
    0		1001		567.87		2001
    1		1002		987.87		2001
    2		1003		873.00		2001
    3		1001		498.87		2000
    >> df.index
    RangeIndex(start=0, stop=4, step=1)
    >> df.columns
    Index([u'apart', u'profits', u'year'], dtype='object')
    >> df.values
    array([['1001', 567.87, 2001L], 
    	   ['1002', 987.87, 2001L], 
    	   ['1003', 873.0, 2001L], 
    	   ['1001', 498.87, 2000L]], dtype=object)
    >> data = {"apart":['1001', '1002', '1003', '1001'], "profits":[567.87, 987.87, 873, 498.87], "year":[2001, 2001, 2001, 2000]}
    >> df = DataFrame(data, index=['one', 'two', 'three', 'four'])
    >> df
    		apart		profits		year
    one		1001		567.87		2001
    two		1002		987.87		2001
    three	1003		873.00		2001
    four	1001		498.87		2000
    >> df.index
    Index([u'one', u'two', u'three', u'four'], dtype='object')

（4）索引对象  
不管是Series对象还是DataFrame对象，都有索引对象。索引对象负责管理轴标签和其他元数据（比如轴名称等）。通过索引可以从Series、DataFrame中取值或对某个位置的值重新赋值。Series或者DataFrame自动化对齐功能就是通过索引进行的。  
1）通过索引从Series中取值

>> series02 = Series([34.56, 23.34, 45.66, 98.08], index=['2001', '2002', '2003', '2004'])
    >> series02
    2001	34.56
    2002	23.34
    2003	45.66
    2004	98.08
    dtype: float64
    >> series02['2003']
    45.659999999999997
    >> series02['2002':'2004']		# 包含右边界，这与Python基础中的列表等不一样
    2002	23.34
    2003	45.66
    2004	98.08
    dtype: float64
    >> series02['2001':]
    2001	34.56
    2002	23.34
    2003	45.66
    2004	98.08
    dtype: float64
    >> series02[:'2003']
    2001	34.56
    2002	23.34
    2003	45.66
    dtype: float64
    >> series02['2001'] = 35.65
    >> series02
    2001	35.65
    2002	23.34
    2003	45.66
    2004	98.08
    dtype: float64
    >> series02[:'2002'] = [23.45, 56.78]
    >> series02
    2001	23.45
    2002	56.78
    2003	45.66
    2004	98.08
    dtype: float64

2）通过索引从DataFrame中取值  
可以直接通过列索引获取指定列的数据，要通过行索引获取指定行数据需要ix方法。

>> df
    		apart	profits		year
    0		1001	567.87		2001
    1		1002	987.87		2001
    2		1003	873.00		2001
    3		1001	498.87		2000
    >> df['year']
    0		2001
    1		2001
    2		2001
    3		2000
    Name: year, dtype: int64
    >> df.ix[0]
    apart			1001
    profits			567.87
    year			2001
    Name: 0, dtype: object
    >> df = DataFrame(data)
    >> df
    		apart	profits		year
    0		1001	567.87		2001
    1		1002	987.87		2001
    2		1003	873.00		2001
    3		1001	498.87		2000
    >> df['pdn'] = np.NaN
    >> df
    		apart	profits		year	pdn
    0		1001	567.87		2001	NaN
    1		1002	987.87		2001	NaN
    2		1003	873.00		2001	NaN
    3		1001	498.87		2000	NaN

## 4、Pandas基本功能 ##

（1）汇总和计算描述统计  
1）常用的数学和统计方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th align="left">  说明 </th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>count</td> 
   <td align="left">非NA值的数量</td> 
  </tr> 
  <tr> 
   <td>describe</td> 
   <td align="left">针对Series或各DataFrame列计算多个统计量</td> 
  </tr> 
  <tr> 
   <td>min/max</td> 
   <td align="left">计算最小值、最大值</td> 
  </tr> 
  <tr> 
   <td>argmin、argmax</td> 
   <td align="left">计算能够获取到最小值和最大值的索引位置（整数）</td> 
  </tr> 
  <tr> 
   <td>idxmin、idxmax</td> 
   <td align="left">计算能够获取到最小值和最大值的索引值</td> 
  </tr> 
  <tr> 
   <td>quantile</td> 
   <td align="left">计算样本的分位数（0到1）</td> 
  </tr> 
  <tr> 
   <td>sum</td> 
   <td align="left">值的总和</td> 
  </tr> 
  <tr> 
   <td>mean</td> 
   <td align="left">值的平均数</td> 
  </tr> 
  <tr> 
   <td>median</td> 
   <td align="left">值的算术中位数（50%分位数）</td> 
  </tr> 
  <tr> 
   <td>mad</td> 
   <td align="left">根据平均值计算平均绝对离差</td> 
  </tr> 
  <tr> 
   <td>var</td> 
   <td align="left">样本数值的方差</td> 
  </tr> 
  <tr> 
   <td>std</td> 
   <td align="left">样本值的标准差</td> 
  </tr> 
  <tr> 
   <td>cumsum</td> 
   <td align="left">样本值的累计和</td> 
  </tr> 
  <tr> 
   <td>cummin、cummax</td> 
   <td align="left">样本值的累计最小值、最大值</td> 
  </tr> 
  <tr> 
   <td>cumprod</td> 
   <td align="left">样本值的累计积</td> 
  </tr> 
  <tr> 
   <td>Pct_change</td> 
   <td align="left">计算百分数变化</td> 
  </tr> 
 </tbody> 
</table>

>> data = {'a': [0, 2, 4, 6, 8, 10, 12, 14], 'b': [1, 3, 5, 7, 9, 11, 13, 15]}
    >> df = DataFrame(data)
    >> df.describe()
    		a			b
    count	8.00000		8.00000
    mean	7.00000		8.00000
    std		4.89898		4.89898
    min		0.00000		1.00000
    25%		3.50000		4.50000
    50%		7.00000		8.00000
    75%		10.50000	11.50000
    max		14.00000	15.00000
    >> frame
    		d	a	b	c
    three	0	1	2	3
    one		4	5	6	7
    >> frame.count()			# 对于DataFrame，这些统计方法，默认是计算各列上的数据
    d	2
    a	2
    b	2
    c	2
    dtype: int64
    >> frame.count(axis=1)		# 如果要应用于各行数据，则增加参数axis=1
    three	4
    one		4
    dtype: int64

2）相关系数与协方差

>> df = DataFrame({"GDP": [12, 23, 34, 45, 56], "air_temperature": [23, 25, 26, 27, 30]}, index=['2001', '2002', '2003', '2004', '2005'])
    >> df
    		GDP		air_temperature
    2001	12		23
    2002	23		25
    2003	34		26
    2004	45		27
    2005	56		30
    >> df.corr()
    					GDP			air_temperature
    GDP					1.000000	0.977356
    air_temperature		0.977356	1.000000
    >> df.cov()
    					GDP			air_temperature
    GDP					302.5		44.0
    air_temperature		44.0		6.7
    >> df['GDP'].corr(df['air_temperature'])
    0.97735555485044179
    >> df['GDP'].cov(df['air_temperature'])
    44.0
    >> series = Series([13, 13.3, 13.5, 13.6, 13.7], index=['2001', '2002', '2003', '2004', '2005'])
    >> series
    2001	13.0
    2002	13.3
    2003	13.5
    2004	13.6
    2005	13.7
    dtype: float64
    >> df.corrwith(series)
    GDP					0.968665
    air_temperature		0.932808
    dtype: float64

3）唯一值、值计数以及成员资格  
unique方法用于获取Series唯一值数组。value\_counts方法用于计算一个Series中各值出现的频率。isin方法用于判断矢量化集合的成员资格，可用于选取Series中或者DataFrame中列数据的子集。

>> ser = Series(['a', 'b', 'c', 'a', 'a', 'b', 'c'])
    >> ser
    0	a
    1	b
    2	c
    3	a
    4	a
    5	b
    6	c
    dtype: object
    >> ser.unique()
    array(['a', 'b', 'c'], dtype=object)
    >> df = DataFrame({'orderId': ['1001', '1002', '1003', '1004'], 'orderAmt': [345.67, 34.23, 456.77, 334.55], 'memberId': ['a1001', 'b1002', 'a1001', 'a1001']})
    >> df
    	memberId	orderAmt	orderId
    0	a1001		345.67		1001
    1	b1002		34.23		1002
    2	a1001		456.77		1003
    3	a1001		334.55		1004
    >> df['memberId'].unique()
    array(['a1001', 'b1002'], dtype=object)
    >> ser
    0	a
    1	b
    2	c
    3	a
    4	a
    5	b
    6	c
    dtype: object
    >> ser.value_counts()			# 默认情况下会按值出现频率降序排列
    a	3
    b	2
    c	2
    dtype: int64
    >> ser.value_counts(ascending=False)
    a	3
    b	2
    c	2
    dtype: int64
    >> mask = ser.isin(['b', 'c'])
    >> mask
    0	False
    1	True
    2	True
    3	False
    4	False
    5	True
    6	True
    dtype: bool
    >> ser[mask]					# 选出值为'b'、'c'的项
    1	b
    2	c
    5	b
    6	c

（2）处理缺失数据  
1）缺失值NaN处理方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th align="left">  说明 </th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>dropna</td> 
   <td align="left">根据标签的值中是否存在缺失数据对轴标签进行过滤（删除），可通过阈值调节对缺失值的容忍度</td> 
  </tr> 
  <tr> 
   <td>fillna</td> 
   <td align="left">用指定值或插值方法（如ffill或bfill）填充缺失数据</td> 
  </tr> 
  <tr> 
   <td>isnull</td> 
   <td align="left">返回一个含有布尔值的对象，这些布尔值表示哪些值是缺失值NA</td> 
  </tr> 
  <tr> 
   <td>notnull</td> 
   <td align="left">Isnull的否定式</td> 
  </tr> 
 </tbody> 
</table>

2）缺失值检测

>> df = DataFrame([['Tom', np.nan, 456.67, 'M'], ['Merry', 34, 4567.34, np.NaN], ['John', 23, np.NaN, 'M'], ['Joe', 18, 342.45, 'F']], columns=['name', 'age', 'salary', 'gender'])
    >> df
    	name	age		salary	gender
    0	Tom		NaN		456.67	M
    1	Merry	34.0	4567.34	NaN
    2	John	23.0	NaN		M
    3	Joe		18.0	342.45	F
    >> df.isnull()
    	name	age		salary	gender
    0	False	True	False	False
    1	False	False	False	True
    2	False	False	True	False
    3	False	False	False	False
    >> df.notnull()
    	name	age		salary	gender
    0	True	False	True	True
    1	True	True	True	False
    2	True	True	False	True
    3	True	True	True	True

3）过滤缺失数据

>> series = Series([1, 2, 3, 4, np.NaN, 5])
    >> series.dropna()
    0	1.0
    1	2.0
    2	3.0
    3	4.0
    5	5.0
    dtype: float64
    >> data = DataFrame([[1., 3.4, 4.], [np.nan, np.nan, np.nan], [np.nan, 4.5, 6.7]])
    >> data
    	0		1		2
    0	1.0		3.4		4.0
    1	NaN		NaN		NaN
    2	NaN		4.5		6.7
    >> data.dropna()						# 默认丢弃只要含有缺失值的行
    	0		1		2
    0	1.0		3.4		4.0
    >> data.dropna(how='all')				# 丢弃全部为缺失值的行
    	0		1		2
    0	1.0		3.4		4.0
    2	NaN		4.5		6.7
    >> data[4] = np.nan
    >> data
    	0		1		2		4
    0	1.0		3.4		4.0		NaN
    1	NaN		NaN		NaN		NaN
    2	NaN		4.5		6.7		NaN
    >> data.dropna(axis=1, how='all')		# 丢弃全部为缺失值的列
    	0		1		2
    0	1.0		3.4		4.0
    1	NaN		NaN		NaN
    2	NaN		4.5		6.7

4）填充缺失数据

>> df = DataFrame(np.random.randn(7, 3))
    >> df.ix[:4, 1] = np.nan
    >> df.ix[:2, 2] = np.nan
    >> df
    	0			1			2
    0	1.101286	NaN			NaN
    1	1.071460	NaN			NaN
    2	0.058237	NaN			NaN
    3	-1.629676	NaN			-0.556655
    4	-1.036194	NaN			-0.063239
    5	0.686838	0.666562	1.252273
    6	0.852754	-1.035739	0.102285
    >> df.fillna(0)
    	0			1			2
    0	1.101286	0.000000	0.000000
    1	1.071460	0.000000	0.000000
    2	0.058237	0.000000	0.000000
    3	-1.629676	0.000000	-0.556655
    4	-1.036194	0.000000	-0.063239
    5	0.686838	0.666562	1.252273
    6	0.852754	-1.035739	0.102285
    >> df.fillna({1: 0.5, 2: -1, 3: -2})
    	0			1			2
    0	1.101286	0.500000	-1.000000
    1	1.071460	0.500000	-1.000000
    2	0.058237	0.500000	-1.000000
    3	-1.629676	0.500000	-0.556655
    4	-1.036194	0.500000	-0.063239
    5	0.686838	0.666562	1.252273
    6	0.852754	-1.035739	0.102285

（3）层次化索引  
在某个方向上拥有多个（两个及两个以上）索引级别。通过层次化索引，pandas能够以低维度形式处理高维度数据。通过层次化索引，可以按层级统计数据。  
1）Series层次化索引

>> data = Series([988.44, 95859, 3949.44, 32445.44, 234.45], index=[['2001', '2001', '2001', '2002', '2002'], ['苹果', '香蕉', '西瓜', '苹果', '西瓜']])
    >> data
    2001	苹果	988.44
    		香蕉	95859.00
    		西瓜	3949.44
    2002	苹果	32445.44
    		西瓜	234.45
    dtype: float64
    >> data.index.names = ['年份', '水果类别']
    >> data
    年份	水果类别
    2001	苹果	988.44
    		香蕉	95859.00
    		西瓜	3949.44
    2002	苹果	32445.44
    		西瓜	234.45
    dtype: float64

2）DataFrame层次化索引

>> df = DataFrame({'year': [2001, 2001, 2002, 2002, 2003], 'fruit': ['apple', 'banana', 'apple', 'banana', 'apple'], 'production': [2345, 3423, 4556, 4455, 534], 'profits': [2334.44, 44556.55, 6677.88, 77856.778, 3345.55]})
    >> df
    	fruit	production	profits		year
    0	apple	2345		2334.440	2001
    1	banana	3423		44556.550	2001
    2	apple	4556		6677.880	2002
    3	banana	4455		77856.778	2002
    4	apple	534			3345.550	2003
    >> df.set_index(['year', 'fruit'])
    year	fruit		production	profits
    2001	apple		2345		2334.440
    		banana		3423		44556.550
    2002	apple		4556		6677.880
    		banana		4455		77856.778
    2003	apple		534			3345.550
    >> new_df = df.set_index(['year', 'fruit'])
    >> new_df.index
    MultiIndex(levels=[[2001, 2002, 2003], [u'apple', u'banana']],
    		   labels=[[0, 0, 1, 1, 2], [0, 1, 0, 1, 0]],
    		   names=[u'year', u'fruit'])

3）按层级统计数据

>> new_df.index
    MultiIndex(levels=[[2001, 2002, 2003], [u'apple', u'banana']],
    		   labels=[[0, 0, 1, 1, 2], [0, 1, 0, 1, 0]],
    		   names=[u'year', u'fruit'])
    >> new_df.sum(level='year')
    year	production	profits
    2001	5768		46890.990
    2002	9011		84534.658
    2003	534			3345.550
    >> new_df.sum(level='fruit')
    fruit	production	profits
    apple	7435		12357.870
    banana	7878		122413.328

## 5、Matplotlib ##

（1）Matplotlib简介  
Matplotlib是python最著名的绘图库，它提供了一整套和matlab相似的命令API，十分适合交互式地进行制图。而且也可以方便地将它作为绘图控件，嵌入GUI应用程序中。  
官网地址：http://matplotlib.org/。  
学习方式，从官网examples入手学习：http://matplotlib.org/examples/index.html。  
http://matplotlib.org/gallery.html有各种图示案例。  
（2）Figure和Subplot  
matplotlib的图像都位于Figure对象中，Figure对象下创建一个或多个subplot对象（即axes）用于绘制图表。

import matplotlib.pyplot as plt
    import numpy as np
    
    # 设置中文和 '-' 负号
    from pylab import mpl
    mpl.rcParams['font.sans-serif'] = ['FangSong']
    mpl.rcParams['axes.unicode_minus'] = False
    
    # 获得Figure对象
    fig = plt.figure(figsize=(8, 6))
    # 在Figure对象上创建axes对象
    ax1 = fig.add_subplot(2, 2, 1)
    ax2 = fig.add_subplot(2, 2, 2)
    ax3 = fig.add_subplot(2, 2, 3)
    # 在当前axes上绘制曲线图（ax3）
    plt.plot(np.random.randn(50).cumsum(), 'k--')
    # 在ax1上绘制柱状图
    ax1.hist(np.random.randn(300), bins=20, color='k', alpha=0.3)
    # 在ax2上绘制散点图
    ax2.scatter(np.arange(30), np.arange(30) + 3 * np.random.randn(30))
    plt.show()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70][]

import matplotlib.pyplot as plt
    import numpy as np
    
    # 设置中文和 '-' 负号
    from pylab import mpl
    mpl.rcParams['font.sans-serif'] = ['FangSong']
    mpl.rcParams['axes.unicode_minus'] = False
    
    fig, axes = plt.subplots(2, 2, sharex=True, sharey=True)
    print axes
    
    for i in range(2):
    	for j in range(2):
    		axes[i, j].hist(np.random.randn(500), bins=10, color='k', alpha=0.5)
    
    plt.subplots_adjust(wspace=0, hspace=0)
    plt.show()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 1][]  
（3）Matplotlib绘制曲线图

import numpy as np
    import matplotlib.pyplot as plt
    x = np.linspace(0, 10, 100)
    y = np.sin(x)
    z = np.cos(x ** 2)
    plt.figure(figsize=(8, 4))				# 创建一个绘图对象，并且指定宽8英寸，高4英寸
    # label：给所绘制的曲线一个名字，此名字在图示（legend）中显示
    # 只要在字符串前后添加"$"符号，matplotlib就会使用其内嵌的latex引擎绘制数学公式
    # color指定曲线颜色，linewidth指定曲线宽度，"b--"指定曲线的颜色和线型
    plt.plot(x, y, label="$sin(x)$", color="red", linewidth=2)
    plt.plot(x, z, "b--", label="$cos(x^2)$")
    plt.xlabel("Time(s)")					# 设置x轴标题
    plt.ylabel("Volt")						# 设置y轴标题
    plt.title("PyPlot First Example")		# 设置图表标题
    plt.ylim(-1.2, 1.2)						# 设置x轴范围
    plt.legend()							# 显示图示说明
    plt.grid(True)							# 显示虚线框
    plt.show()								# 展示图表

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 2][]  
（4）Matplotlib绘制散点图

import matplotlib.pyplot as plt
    plt.axis([0, 5, 0, 20])
    plt.title('My First Chart', fontsize=20, fontname='Times New Roman')
    plt.xlabel('Counting', color='gray')
    plt.ylabel('Square values', color='gray')
    plt.text(1, 1.5, 'First')
    plt.text(2, 4.5, 'Second')
    plt.text(3, 9.5, 'Third')
    plt.text(4, 16.5, 'Fourth')
    plt.text(1, 11.5, r'$y=x^2$', fontsize=20, bbox={'facecolor': 'yellow', 'alpha': 0.2})
    plt.grid(True)
    plt.plot([1, 2, 3, 4], [1, 4, 9, 16], 'ro')
    plt.plot([1, 2, 3, 4], [0.8, 3.5, 8, 15], 'g^')
    plt.plot([1, 2, 3, 4], [0.5, 2.5, 5.4, 12], 'b*')
    plt.legend(['First series', 'Second series', 'Third series'], loc=2)
    plt.savefig('my_chart.png')
    plt.show()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 3][]  
（5）颜色、标记和线型  
通过help(plt.plot)查看文档。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 4][]  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 5][]

import matplotlib.pyplot as plt
    import numpy as np
    from pylab import mpl
    mpl.rcParams['font.sans-serif'] = ['FangSong']
    mpl.rcParams['axes.unicode_minus'] = False
    x = np.arange(-5, 5)
    y = np.sin(np.arange(-5, 5))
    plt.axis([-5, 5, -5, 5])
    plt.plot(x, y, color='g', linestyle='dashed', marker='o')
    plt.text(-3, -3, '$y=sin(x)$', fontsize=20, bbox={'facecolor': 'yellow', 'alpha': 0.2})
    plt.show()

（6）刻度、标签和图例

*  xlim、ylim控制图表的范围
 *  xticks、yticks控制图表刻度位置
 *  xtickslabels,yticklabels控制图表刻度标签

（7）将图表保存到文件

*  plt.savefig(文件名称)

（8）Matplotlib输出中文  
修改matplotlib安装目录（Lib/site-packages/ matplotlib ）下mpl-data子目录的matplotlibrc文件，去掉font.family和font.sans-serif的注释，并且在font.sans-serif添加FangSong中文字体。  
![20200214172118196.png][]  
或者在代码中添加下面这个函数并调用该函数：

def set_ch():
    	from pylab import mpl
    	mpl.rcParams['font.sans-serif'] = ['FangSong']
    	mpl.rcParams['axes.unicode_minus'] = False
    
    set_ch()

import numpy as np
    months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
    mean_sales = [343.56, 566.99, 309.81, 456.78, 989, 345.98, 235.67, 934, 119.09, 245.6, 213.98, 156.77]
    np_months = np.array([i+1 for i, _ in enumerate(months)])
    np_mean_sales = np.array(mean_sales)
    plt.figure(figsize=(15, 8))
    plt.bar(np_months, np_mean_sales, width=1, facecolor='yellowgreen', edgecolor='white')
    plt.xlim(0.5, 13)
    plt.xlabel(u"月份")
    plt.ylabel(u"月均销售额")
    for x, y in zip(np_months, np_mean_sales):
    	plt.text(x, y, y, ha="center", va="bottom")
    plt.show()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 6][]  
（9）用LaTex编写数学表达式  
参考：http://matplotlib.org/users/mathtext.html

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200214161920638.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200214162516476.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200214164231999.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200214170614935.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200214170954398.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200214171006372.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70
[20200214172118196.png]: https://img-blog.csdnimg.cn/20200214172118196.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200214173443996.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvbmd4aWZhY2FpX2JlbGlldmU=,size_16,color_FFFFFF,t_70