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([])