Sklearn环境搭建与经常使用包

开发环境搭建

直接安装Anaconda

IPython

IPython是公认的现代科学计算中最重要的Python工具之一。它是一个增强版的Python交互命令行工具，有如下几个明显的特色：

1. 能够在IPython环境下直接执行Shell指令

2. 能够直接绘图操做的Web GUI环境

3. 更强大的交互功能，包括内省、Tab键自动完成、魔术命令

基础

命令行输入ipython，便可启动交互环境

按Tab键，会自动显示命名空间下的全部开头函数，自动完成

Ctrl + A：移动光标到开头

Ctrl + E：移动光标到结尾

Ctrl + U：删除光标以前的全部字符

Ctrl + K：删除光标以后的全部字符，包含当前字符

Ctrl + L：清屏

Ctrl + P：向后搜索匹配的指令

Ctrl + N：向前搜索匹配的指令

Ctrl + C：终端当前脚本的执行

能够直接在函数或变量后面加上问号？来查询文档

在类或变量、函数后面添加两个问号??，能够查看源码，结合星号 * 和问号 ?，还能够查询命名空间里的全部函数和对象。

魔术命令

%run hello.py 能够直接运行hello.py文件。

%timeit np.dot(a,a) 能够快速评估代码执行效率。

%who 或 %whos命令查看当前环境下的变量列表

%quickref 显示IPython的快速参考文档

%magic 显示全部的魔术命令及其详细文档

%reset 删除当前环境下的全部变量和导入的模块

%logstart 开始记录IPython里的全部输入的命令，默认保存在当前工做目录的ipython_log.py中

%logstop 中止记录，并关闭log文件

须要说明的是，魔术命令后面加上问号 ? 能够直接显示魔术命令的文档。来查看%reset魔术命令的文档

IPython与shell交互的能力，可让咱们不离开IPython环境便可完成不少与操做系统相关的功能。最简单的方法就是在命令前加上叹号！既能够直接运行shell命令。

例如：!ifconfig | grep "inet "

当使用 %automagic on 启用自动魔术命令功能后，能够省略百分号%的输入便可直接运行魔术命令

IPython图形界面

除了控制台环境外，IPython另一个强大的功能就是图形环境。与控制台环境相比，它有两个显著的特色：

1. 方便编写多行代码

2. 能够直接把数据可视化，显示在当前页面下

安装Jupyter

pip install jupyter

jupyter notebook

安装完Jupyter后，直接在命令行输入ipython notebook，启动网页版的图形编程界面。会在命令行启动一个轻量级的Web服务器，同时用默认浏览器打开当前目录所在的页面，在这个页面下能够直接打开某个notebook或者建立一个新的notebook。一个notebook是以.ipynb做为后缀名的、基于json格式的文本文件。

咱们能够建立一个notebook，而且画一个正弦曲线 jupyter notebook inline.ipynb

# 设置 inline 方式，直接把图片画在页面上
%matplotlib inline
# 导入必要的库
import numpy as np
import matplotlib.pyplot as plt
# 在[0,2*PI] 之间取100个点
x = np.linspace(0,2*np.pi,num=100)
# 计算这100个点的正弦值，并保存到变量y中
y = np.sin(x)
plt.plot(x,y)

几乎全部的IPython控制台的技巧均可以在IPython notebook里使用。一个比较大的区别是，IPython notebook使用cell做为一个代码单元。控制台里，写完代码直接按Enter键便可运行，而在IPython notebook里须要单击“运行”按钮或用快捷键Ctrl+ Enter才能运行。

notebook有两种模式，一个是编辑模式，能够修改代码。一个是命令模式，输入的按键做为命令。使用Ctrl + M快捷键在模式之间切换。

Numpy简介

Numpy是Python科学计算的基础库，主要提供了高性能的N维数组实现及计算能力，还提供了和其余语言如C/C++集成的能力，此外还实现了一些基础的数学算法，如线性代数相关、傅里叶变换及随机数生成等。

API：https://docs.scipy.org/doc/numpy/genindex.html

参考：https://docs.scipy.org/doc/numpy/reference/index.html

指南：https://docs.scipy.org/doc/numpy/user/index.html

Numpy数组

能够直接用Python列表来建立数组

Numpy核心是ndarry对象，封装了数据类型的操做。因此使用np.array建立的数组能够直接相乘。

import numpy as np

a = np.array([1, 2, 3, 4])
print(a)  # [1 2 3 4]

b = np.array([[1, 2], [3, 4], [5, 6]])
print(b)  # [[1 2] [3 4]]
print(b.ndim)  # 查看维度：2
print(b.shape)  # 查看行、列 (3,2)
print(b.dtype)  # 查看类型 int32

c = np.arange(10)  # 建立连续数组
print(c)  # [0 1 2 3 4 5 6 7 8 9]
d = np.linspace(0, 2, 11)  # 将[0,2]切分红11等分以后的数组
print(d)  # [0.  0.2 0.4 0.6 0.8 1.  1.2 1.4 1.6 1.8 2. ]
print(np.ones((3, 3)))  # 建立3行3列的1数组
np.zeros((3, 6))  # 建立3行3列的0数组
np.eye(4)  # 建立4行4列的对角线数组
np.random.randn(6, 3)  # 建立6行3列的随机数组
np.random.rand(10) # 建立一个给定维度的数组，并用统一分布的随机样本[0,1]填充它
np.random_integers(1,5,(6,3)) # 建立6行3列的随机整数数组
np.random.normal(0,1,100) # 从正态分布中抽取随机样本

c[3]  # 能够经过索引查找
c[:3]  # 切片也能够
c[2:8:2]  # 表示起始、结束、步长
c[2:: 2]  # 能够省略结束为止
c[:: 3]  # 开始结束都省略

a = np.arange(0, 51, 10).reshape(6, 1) + np.arange(6)  # 建立0-51且步长为10的连续数组，6行6列的二维数组
a[0, 0]  # 访问0行0列
a[:3, 3:]  # 访问前三行的后三列
a[2, :]  # 访问第2行
a[:, 3]  # 访问第三列向量
a[:, ::2]  # 访问全部行的步长为2的列
a[::2, ::3]  # 访问步长为2的行的步长为3的列
a % 2 == 0  # 判断每个数组与2取余是否等于0，返回True/False
a[a % 2 == 0]  # 每一个数与2取余等于0，并输出

正态分布：也称常态分布、高斯分布。是一个很是重要的几率分布。观测数据很是大的时候，具备独立分布的独立随机变量的观测样本平均值是收敛于正态分布的。几率密度函数为

μ是分布的均值，或者叫指望值；σ是标准差。σ的平方是方差

Numpy老是试图自动把结果转换为行向量，

Numpy数组是共享内存的，若是须要独立保存，要显示备份。可使用np.may_share_memory()函数来判断两个数组是否共享内存

若是须要显示备份：a[2:6].copy()

使用埃拉托斯特尼筛法来打印[0,100]之间的全部质数（除了1和它自身外，不能被其余天然数整除的数）。从第一个质数2开始，数据里全部能被2整除的数字都不是质数，即从2开始，以2为步长，每通过的数字能被2整除，标识为非质数。接着，从下一个质数3开始，重复上述过程

import numpy as np

a = np.arange(1, 101)
n_max = int(np.sqrt(len(a)))  # 返回平方根
is_prime = np.ones(len(a), dtype=bool)
is_prime[0] = False
for i in range(2, n_max):
    if i in a[is_prime]:
        is_prime[(i * 2 - 1):: i] = False  # 省略截止，步长为2
print(a[is_prime])

Numpy运算

最简单的数值计算是数组和标量进行计算，计算过程是直接把数组里的元素和标量逐个进行计算

a = np.arange(6)
print(a * 3)

使用Numpy的优势是运行速度会比较快。

另外一种是数组和数组的运算，若是数组的维度相同，那么在组里对应位置进行逐个元素的数学运算

a = np.random.random_integers(1, 5, (5, 4))
b = np.random.randn(5, 4)
print(a + b, a * b)

矩阵乘积应该使用np.dot()函数

a = np.random.random_integers(1, 5, (5, 4))
b = np.random.randn(4, 1)
print(np.dot(a, b))

若是数组的维度不一样，Numpy会视图使用广播机制来匹配，若是能匹配上，就进行运算。若是不知足广播条件，则报错

符合广播的条件是两个数组必须有一个维度能够扩展，而后在这个维度上进行复制，最终复制出两个相同维度的数组，再进行运算。

import numpy as np

a = np.random.random_integers(1, 9, (5, 4))
b = np.arange(4)
print(a + b)  # 符合广播条件
# 会将b转换为5行4列的向量，其中每一行的内容一致，则至关于同维度相加

数组还能够直接比较，返回一个同维度的布尔数组。针对布尔数组，可使用all()/any()函数来返回布尔数组的标量值

a = np.array([1, 2, 3, 4])
b = np.array([4, 2, 3, 1])
print(a == b)  # [False  True  True False]
print(a > b)  # [False False False  True]
print((a == b).all())  # False
print((a == b).any())  # True

Numpy还提供了一些数组运算的内置函数：

np.cos(a) 计算余弦

np.exp(a) 计算全部元素的指数

np.sqrt(a) 计算平方根

还提供了一些基本的统计功能

a.sum() 汇总

a.mean() 平均值

a.std() 标准误差

a.min()

a.max()

a.argmin() 返回轴上最小值

a.argmax() 返回轴上最大值

针对二维数组或者更高维度的数组，能够根据行或列来计算

b.sum()

b.sum(axis=0)

b.sum(axis=1)

b.sum(axis=1).sum()

b.min(axis=1)

其中axis参数表示坐标轴，0表示按行计算，1表示按列计算。

注意：按列计算后，计算结果Numpy会默认转换为行向量。

随机漫步算法

两我的用一个均匀的硬币来赌博，硬币抛出正面和反面的几率各占一半。硬币抛出正面时甲方输给乙方一块钱，反面时乙方输给甲方一块钱。这种赌博规则下，随着抛硬币次数的增长，输赢的总金额呈现怎么样的分布。

首先让足够多的人两两组成一组参与这个游戏，而后抛出足够多的硬币，就能够统计算出输赢的平均金额。

当使用Numpy实现时，生成多个由-1和1构成的足够长的随机数组，用来表明每次硬币抛出正面和反面的事件。这个二维数组中，每行表示一组参与赌博的人抛出正面和反面的事件序列，而后按行计算这个数组的累加和就是这每组输赢的金额

实际计算时，先求出每组输赢金额的平方，再求平均值。最后把平方根的值用绿色的点画在二维坐标上，同时画出的红色曲线来对比两组曲线的重合状况

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

n_person = 2000
n_times = 500

t = np.arange(n_times)
steps = 2 * np.random.random_integers(0, 1, (n_person, n_times)) - 1

amount = np.cumsum(steps, axis=1)
sd_amount = amount ** 2
mean_sd_amount = sd_amount.mean(axis=0)

plt.figure(figsize=(20, 12), dpi=144)
plt.xlabel(r"$t$", fontsize=24)
plt.tick_params(labelsize=20)
plt.ylabel(r"$\sqrt{\langle (\delta x)^2 \rangle}$", fontsize=24)
plt.plot(t, np.sqrt(mean_sd_amount), 'g.', t, np.sqrt(t), 'r-');

使用np.reshape() 进行数组维度变换，而np.ravel() 则正好相反，会把多维数组变成一维向量

a= np.arange(12)
b = a.reshape(4,3)
# [[ 0  1  2]
#  [ 3  4  5]
#  [ 6  7  8]
#  [ 9 10 11]]
b.ravel()

添加维度使用np.newaxis

a = np.arange(4)
print(a.shape)  # (4,)
b = a[:, np.newaxis]
print(b.shape)  # (4, 1)
c = a[np.newaxis, :]
print(c.shape) # (1, 4)

np.sort(a,axis=1) 按行独立排序

a.sort(axis=0) 按列独立排序，并直接把结果给a

Numpy高级功能包括多项式求解以及多项式拟合的功能。np.polyfit() 函数能够用多项式对数据进行拟合。咱们生成20个在平方根曲线周围引入随机噪声点，用3阶多项式来拟合这些点。

import matplotlib.pyplot as plt
import numpy as np

n_dots = 20
n_order = 3

x = np.linspace(0, 1, n_dots)  # [0,1]之间建立20个点
y = np.sqrt(x) + 0.2 * np.random.rand(n_dots)
p = np.poly1d(np.polyfit(x, y, n_order))  # 用3阶多项式拟合
print(p.coeffs)

# 画出拟合出来的多项式所表达的曲线以及原始的点
t = np.linspace(0, 1, 200)
plt.plot(x, y, 'ro', t, p(t), '-');

使用Numpy求圆周率π的值。使用的算法是蒙特卡罗方法（Monte Carlo method）其主要思想是，在一个正方形内，用正方形的边长画出一个1/4圆的扇形，假设圆的半径为r，则正方形的面积为r²，圆的面积为1/4π r²，它们的面积之比是π/4

咱们在正方形内随机产生足够多的点，计算落在扇形区域内的点的个数与总的点个数的比值。当产生的随机点足够多时，这个比值和面积比值应该是一致的。这样就能够算出π的值。判断一个点是否落在扇形区域的方法是计算这个点到圆心的距离。当距离小于半径时，说明这个点落在扇形内。

import numpy as np

# 假设圆的半径为1，圆心在原点
n_dots = 10000000
x = np.random.random(n_dots)
y = np.random.random(n_dots)
# 随机产生一百万个点
distance = np.sqrt(x ** 2 + y ** 2)
# 计算每一个点到圆心的距离
in_circle = distance[distance < 1]
# 全部落在扇形内的点
pi = 4 * float(len(in_circle)) / n_dots
# 计算出PI的值
print(pi)

Numpy数组做为文本文件，能够直接保存到文件系统里，也能够从文件系统里读取出数据

a = np.arange(15).reshape(3, 5)
np.savetxt('a.txt', a)  # 序列化为文本
b = np.loadtxt('a.txt')  # 文本反序列化
print(b)

也能够直接保存为Numpy特有的二进制格式

np.save('a.npy', a)  # 序列化为文本
b = np.load('a.npy')  # 文本反序列化

Pandas简介

Pandas是一个强大的时间序列数据处理工具包，为了分析财经数据，如今已经普遍应用在Python数据分析领域中。

文档：http://pandas.pydata.org/pandas-docs/stable/

Pandas最基础的数据结构是Series，用它来表达一行数据，能够理解为一维的数组。好比建立一个包含6个数据的一维数组

s = pd.Series([4, 2, 5])
# 0    4
# 1    2
# 2    5
# dtype: int64

另外一个关键的数据结构为DataFrame，表示是二维数组。下面的代码建立一个DataFrame对象

df = pd.DataFrame(np.random.rand(6, 4), columns=list('ABCD'))
#           A         B         C         D
# 0  0.584111  0.186057  0.204064  0.519430
# 1  0.645679  0.405943  0.032989  0.897339
# 2  0.898421  0.757804  0.948457  0.145658
# 3  0.502044  0.925613  0.599234  0.220672
# 4  0.432294  0.039789  0.577377  0.954598
# 5  0.274313  0.443114  0.416644  0.604243

DataFrame里的数据实际是Numpy的array对象来保存的，读者能够输入df.values来查看原始数据。DataFrame对象的每一行和列都是一个Series对象。可使用行索引来访问一个行数，能够用列名称来索引一列数据

df.iloc[0]  行索引

df.A  列索引

df.shape 查看维度

df.head(3) 访问前三行

df.tail(3） 访问后三行

df.index　　访问数据的行索引

df.columns　　访问数据的列索引

df.describe()　　计算简单的数据统计信息（能够计算出个数、平均值、标准差、最小值、最大值）

df.sort_index(axis=1,ascending=False) 能够进行列名称倒序

df.sort_values(by='B')　　对B列数值进行排序

df[3:5] 　 索引范围访问

df[['A','B','C']]  　　选择3列数据

df.loc[3,'A']　　选择3行的A列

df.iloc[3,0]　　经过数组索引来访问

df.iloc[2:5,0:2] 　　经过索引

df[df.c > 0]　　插入布尔值

df["D"] = ["A","B"]　　添加一列

df.groupby("D").sum() 　　分组

Pandas提供了时间序列处理能力，能够建立以时间序列为索引的数据集

import numpy as np
import pandas as pd

n_items = 366
ts = pd.Series(np.random.rand(n_items), index=pd.date_range('20000101', periods=n_items))
print(ts.shape) # (366,)
print(ts.head(5))
# 2000-01-01    0.523365
# 2000-01-02    0.127577
# 2000-01-03    0.914436
# 2000-01-04    0.474645
# 2000-01-05    0.098926
# Freq: D, dtype: float64
# 按照月份聚合
print(ts.resample("1m").sum())
# 2000-01-31    14.488162
# 2000-02-29    16.219371
# 2000-03-31    14.601253

数据可视化 

% matplotlib inline
# 导入必要的库
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

n_items = 366
ts = pd.Series(np.random.rand(n_items), index=pd.date_range('20000101', periods=n_items))
plt.figure(figsize=(10,6),dpi=144)
cs = ts.cumsum()
cs.plot()

文件读写

import numpy as np
import pandas as pd

n_items = 366
ts = pd.Series(np.random.rand(n_items), index=pd.date_range('20000101', periods=n_items))
ts.to_csv('data.csv') # 写入
df = pd.read_csv('data.csv', index_col=0) # 读取
print(df.shape)
print(df.head(5))

Matplotlib

Matplotlib是Python数据可视化工具包，

示例：https://matplotlib.org/tutorials/index.html

API：https://matplotlib.org/contents.html

若是要在IPython控制台使用，可使用ipython--matplotlib来启动

若是要在IPython notebook使用，须要开始位置插入

% matplotlib inline

而且进入包

from matplotlitb import pyplot as plt

在机器学习领域中，常常须要把数据可视化，以便观察数据的模式。对算法性能评估时，也须要把模型相关的数据可视化，才能观察出须要改进的地方。

图形样式

默认样式的坐标轴上画出正弦和余弦

% matplotlib inline
from matplotlib import pyplot as plt
import numpy as np

x = np.linspace(-np.pi, np.pi, 200)
C, S = np.cos(x), np.sin(x)
plt.plot(x, C)  # 余弦
plt.plot(x, S)  # 正弦
plt.show()

正弦值是在直角三角形中，对边的长比上斜边的长的值。sinA=∠A的对边/斜边=a/c

余弦值是在直角三角形中，邻边比三角形的斜边的值，cosA=b/c，也可写为cosa=AC/AB

画出来的图形以下

接着能够经过修改默认样式，来变成右边的正余弦曲线

% matplotlib inline
from matplotlib import pyplot as plt
import numpy as np

X = np.linspace(-np.pi, np.pi, 200, endpoint=True)
C, S = np.cos(X), np.sin(X)

# 画出余弦/正弦
plt.plot(X, C, color="blue", linewidth=2.0, linestyle="-")
plt.plot(X, S, color="red", linewidth=2.0, linestyle="-")

# 设置坐标轴的长度
plt.xlim(X.min() * 1.1, X.max() * 1.1)
plt.ylim(C.min() * 1.1, C.max() * 1.1)

# 从新设置坐标轴的刻度、X轴自定义标签
plt.xticks((-np.pi, -np.pi/2, np.pi/2, np.pi),
           (r'$-\pi$', r'$-\pi/2$', r'$+\pi/2$', r'$+\pi$'))
plt.yticks([-1, -0.5, 0, 0.5, 1])

# 左侧图片的4个方向坐标改成两个方向的交叉坐标
# 方法经过设置颜色为透明色，把上方和右侧的坐标线隐藏
# 移动左侧和下方的坐标边线到原点（0，0）的位置
ax = plt.gca()  # 获取当前坐标轴
ax.spines['right'].set_color('none')  # 隐藏右侧坐标轴
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')  # 设置刻度显示到下方
ax.spines['bottom'].set_position(('data', 0))  # 设置下方坐标轴的位置
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data', 0))  # 设置左侧坐标轴位置

# 在余弦去线上标识出这个点，同时用虚线画出对应的X轴坐标
# 在坐标轴上标示相应的点
t = 2 * np.pi / 3
# 画出 cos(t) 所在的点在 X 轴上的位置，即画出 (t, 0) -> (t, cos(t)) 线段，使用虚线
plt.plot([t, t], [0, np.cos(t)], color='blue', linewidth=1.5, linestyle="--")
# 画出标示的坐标点，即在 (t, cos(t)) 处画一个大小为 50 的蓝色点
plt.scatter([t, ], [np.cos(t), ], 50, color='blue')
# 画出标示点的值，即 cos(t) 的值
plt.annotate(r'$cos(\frac{2\pi}{3})=-\frac{1}{2}$',
             xy=(t, np.cos(t)), xycoords='data',
             xytext=(-90, -50), textcoords='offset points', fontsize=16,
             arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))

# 画出 sin(t) 所在的点在 X 轴上的位置，即画出 (t, 0) -> (t, sin(t)) 线段，使用虚线
plt.plot([t, t], [0, np.sin(t)], color='red', linewidth=1.5, linestyle="--")
# 画出标示的坐标点，即在 (t, sin(t)) 处画一个大小为 50 的红色点
plt.scatter([t, ], [np.sin(t), ], 50, color='red')
# 画出标示点的值，即 sin(t) 的值
plt.annotate(r'$sin(\frac{2\pi}{3})=\frac{\sqrt{3}}{2}$',
             xy=(t, np.sin(t)), xycoords='data',
             xytext=(+10, +30), textcoords='offset points', fontsize=16,
             arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))
# plt.annotate函数的功能时在图片上画出标示文本

# 定制坐标轴上的刻度标签字体，在刻度标签上添加一个半透明的背景
for label in ax.get_xticklabels() + ax.get_yticklabels():
    label.set_fontsize(16)
    label.set_bbox(dict(facecolor='white', edgecolor='None', alpha=0.65))


plt.show()

图形对象

在Matplotlib里，一个图形是指图片的所有可视区域，可使用plt.figure来建立。在一个图形里，能够包含多个子图，可使用plt.subplot() 来建立子图。子图按照网络形状排列显示在图形里，能够在每一个子图上单独做画。。坐标轴和子图相似，惟一不一样的是，坐标轴能够在图形上任意摆放，而不须要按照网络排列，这样显示起来更灵活，可使用plt.axes()来建立坐标轴

当使用默认配置做画时，Matplotlib调用plt.gac()函数来获取当前的坐标轴，并在当前坐标轴上做画。plt.gac()函数调用plt.gcf函数来获取当前图形对象，若是当前不存在图形对象会调用plt.figure()函数建立要一个图形对象

plt.figure函数有几个经常使用的参数

num：图形对象的标识符，能够是数字或字符串。

figsize：以英寸为单位的图形大小，是一个元组

dpi：指定图形的质量，每英寸多少个点

下面的代码建立了两个图形，一个是sin，而且把正弦曲线画在这个图形上。而后建立了一个名称是cos的图形，而且把余弦曲线画在这个图形上。接着切换到以前建立的sin图形上，把余弦图片画在这个图形上

from matplotlib import pyplot as plt
import numpy as np

X = np.linspace(-np.pi, np.pi, 200, endpoint=True)
C, S = np.cos(X), np.sin(X)

plt.figure(num='sin', figsize=(16, 4))
plt.plot(X, S)
plt.figure(num='cos', figsize=(16, 4))
plt.plot(X, C)
plt.figure(num='sin')
plt.plot(X, C)
print(plt.figure(num='sin').number)
print(plt.figure(num='cos').number)

不一样的图形能够单独保存为一个图片文件，但子图是指一个图形里分红几个区域，在不一样的区域里单独做画，全部的子图最终都保存在一个文件里。plt.subplot()函数的关键参数是一个包含三个元素的元组，分别表明子图的行、列以及当前激活的子图序号。好比plt.subplot(2,2,1)表示把图标对象分红两行两列，激活的一个子图来做画

from matplotlib import pyplot as plt

plt.figure(figsize=(18, 4))
plt.subplot(2, 2, 1)
plt.xticks(())
plt.yticks(())
plt.text(0.5, 0.5, 'subplot(2,2,1)', ha='center', va='center', size=20, alpha=.5)

plt.subplot(2, 2, 2)
plt.xticks(())
plt.yticks(())
plt.text(0.5, 0.5, 'subplot(2,2,2)', ha='center', va='center', size=20, alpha=.5)

plt.tight_layout()
plt.show()

更复杂的子图布局，可使用gridspec来实现，优势是能够指定某个子图横跨多个列或多个行

from matplotlib import pyplot as plt
import matplotlib.gridspec as gridspec

plt.figure(figsize=(18, 4))
G = gridspec.GridSpec(3, 3)

axes_1 = plt.subplot(G[0, :])  # 占用第一行
plt.xticks(())
plt.yticks(())
plt.text(.5, .5, 'Axes 1', ha='center', va='center', size=24, alpha=.5)

axes_2 = plt.subplot(G[1:, 0])  # 占用第二行开始以后的全部行，第一列
plt.xticks(())
plt.yticks(())
plt.text(0.5, 0.5, 'Axes 2', ha='center', va='center', size=24, alpha=.5)

axes_3 = plt.subplot(G[1:, -1])  # 占用第二行开始以后的全部行，最后一列
plt.xticks(())
plt.yticks(())
plt.text(0.5, 0.5, 'Axes 3', ha='center', va='center', size=24, alpha=.5)

axes_4 = plt.subplot(G[1, -2])  # 占用第二行，倒数第二列
plt.xticks(())
plt.yticks(())
plt.text(0.5, 0.5, 'Axes 4', ha='center', va='center', size=24, alpha=.5)

axes_5 = plt.subplot(G[-1, -2])  # 占用倒数第一行，倒数第二列
plt.xticks(())
plt.yticks(())
plt.text(0.5, 0.5, 'Axes 5', ha='center', va='center', size=24, alpha=.5)

plt.tight_layout()
plt.show()

使用坐标轴plt.axes()来建立，能够给矩形进行定位 plt.axes([.1,.1,.8,.8])

画图操做

绘制一个点分布图，须要使用plt.scatter()函数。np.arctan2(Y,X) 计算随机点的反正切，这个值做为随机点的颜色。

import numpy as np
from matplotlib import pyplot as plt

n = 1024  # 定义点数量
X = np.random.normal(0, 1, n)
Y = np.random.normal(0, 1, n)
T = np.arctan2(Y, X)

plt.figure(figsize=(18, 4))
plt.subplot(1, 2, 1)
plt.scatter(X, Y, s=75, c=T, alpha=.5)

plt.xlim(-1.5, 1.5)
plt.xticks(())
plt.ylim(-1.5, 1.5)
plt.yticks(())

使用plt.fill_between()函数，能够画出正弦曲线。并在直线和曲线之间填充指定的颜色

import numpy as np
from matplotlib import pyplot as plt

n = 256
X = np.linspace(-np.pi, np.pi, n, endpoint=True)
Y = np.sin(2*X)

plt.figure(figsize=(10, 3))
plt.subplot(1, 2, 2)
plt.plot(X, Y+1, color="blue", alpha=1.00)
plt.fill_between(X, 1, Y+1, color="blue", alpha=.25)

plt.plot(X, Y-1, color="blue", alpha=1.00)
plt.fill_between(X, -1, Y-1, (Y-1) > -1, color="blue", alpha=.25)
plt.fill_between(X, -1, Y-1, (Y-1) < -1, color="red", alpha=.25)

plt.xlim(-np.pi, np.pi)
plt.xticks(())
plt.ylim(-2.5, 2.5)
plt.yticks(())

使用plt.bar()函数能够画出柱状图。生成24个随机值，调用两次plt.bar() 分别画在上下两侧。在调用plt.text()函数把数值画在对应的柱状图上。

import numpy as np
from matplotlib import pyplot as plt

n = 12
X = np.arange(n)
Y1 = (1-X/float(n)) * np.random.uniform(0.5, 1.0, n)
Y2 = (1-X/float(n)) * np.random.uniform(0.5, 1.0, n)

plt.figure(figsize=(15, 3))
plt.subplot(1, 2, 1)
plt.bar(X, +Y1, facecolor="#9999ff", edgecolor="white")
plt.bar(X, -Y2, facecolor="#ff9999", edgecolor="white")

for x, y in zip(X, Y1):
    plt.text(x+0.4, y+0.05, '%.2f' % y, ha='center', va='bottom')

for x, y in zip(X, Y2):
    plt.text(x+0.4, -y-0.05, '%.2f' % y, ha='center', va='top')

plt.xlim(-.5, n)
plt.xticks(())
plt.ylim(-1.25, 1.25)
plt.yticks(())

使用plt.contourf() 函数填充等高线，命名参数cmap表示颜色映射风格。plt.contour()函数画出等高线。plt.clable()画出等高线上的数字

import numpy as np
from matplotlib import pyplot as plt

def f(x, y):
    return (1 - x / 2 + x ** 5 + y ** 3) * np.exp(-x ** 2, -y ** 2)


n = 256
x = np.linspace(-3, 3, n)
y = np.linspace(-3, 3, n)
X, Y = np.meshgrid(x, y)

plt.figure(figsize=(30, 10))
plt.subplot(1, 2, 2)

plt.contourf(X, Y, f(X, Y), 8, alpha=.75, cmap=plt.cm.hot)
c = plt.contour(X, Y, f(X, Y), 8, colors="black", linewidth=.5)
plt.clabel(c, inline=1, fontsize=10)

plt.xticks(())
plt.yticks(())

使用plt.imshow()函数把数组当成图片画出来

import numpy as np
from matplotlib import pyplot as plt

def f(x, y):
    return (1 - x / 2 + x ** 5 + y ** 3) * np.exp(-x ** 2, -y ** 2)

plt.subplot(1, 2, 1)
n = 10
x = np.linspace(-3, 3, 4 * n)
y = np.linspace(-3, 3, 3 * n)
X, Y = np.meshgrid(x, y)
plt.imshow(f(X, Y), cmap="hot", origin="low")
plt.colorbar(shrink=.83)

plt.xticks(())
plt.yticks(())

使用plt.pie()函数画出饼图

import numpy as np
from matplotlib import pyplot as plt

plt.subplot(1, 2, 2)
n = 20
Z = np.ones(n)
Z[-1] *= 2

plt.pie(Z, explode=Z*.05, colors=['%f' % (i/float(n)) for i in range(n)])
plt.axis('equal')
plt.xticks(())
plt.yticks()

使用坐标轴set_major_locator()和set_minor_locator()把坐标刻度设置成MultipleLocator央视。而后使用grid()函数在刻度刻画线段。这样就生成了网格

from matplotlib import pyplot as plt

ax = plt.subplot(1,2,1)
ax.set_xlim(0,4)
ax.set_ylim(0,3)
ax.xaxis.set_major_locator(plt.MultipleLocator(1.0))
ax.xaxis.set_major_locator(plt.MultipleLocator(0.1))
ax.yaxis.set_major_locator(plt.MultipleLocator(1.0))
ax.yaxis.set_major_locator(plt.MultipleLocator(0.1))
ax.grid(which="major",axis="x",linewidth=0.75,linestyle="-",color="0.75")
ax.grid(which="minor",axis="x",linewidth=0.25,linestyle="-",color="0.75")
ax.grid(which="major",axis="y",linewidth=0.75,linestyle="-",color="0.75")
ax.grid(which="minor",axis="y",linewidth=0.25,linestyle="-",color="0.75")
ax.set_xticklabels([])
ax.set_yticklabels([])

使用plt.bar()和bar.set_facecolor()来填充不一样的颜色，能够作出极坐标图

import numpy as np
from matplotlib import pyplot as plt

ax = plt.subplot(1, 2, 2, polar=True)
N = 20
theta = np.arange(0.0, 2*np.pi, 2*np.pi/N)
radii = 10 * np.random.rand(N)
width = np.pi / 4 * np.random.rand(N)
bars = plt.bar(theta, radii, width=width, bottom=0.0)

for r, bar in zip(radii, bars):
    bar.set_facecolor(plt.cm.jet(r/10.))
    bar.set_alpha(0.5)

ax.set_xticklabels([])
ax.set_yticklabels([])