ifuun

目錄

• • 0.1 先導條件：
  • 0.2 前言：matplotlib字型安裝
• 1 畫布(figure)：
  • 1.1 基本演示：
  • 1.2 多張畫布：
  • 1.3 一張畫布多個子圖：
    • 1.3.1 基本方法：
    • 1.3.2 進階方法：
      • 1.3.2.1 方法一：
      • 1.3.2.2 方法二：
• 2 軸/子圖(axes):
  • 2.1 基本演示：
  • 2.2 新增軸子圖：
    • 2.2.1 基本方法：
    • 2.2.2 快捷方法：
  • 2.3 共享軸子圖：
  • 2.4 圖中圖：
• 3 最基本的連線函式：
  • 3.1 基本演示：
  • 3.2 常見函式演示：
• 4 坐標軸：
  • 4.1 設定坐標軸名稱：（label）
  • 4.2 設定坐標軸上下限：
  • 4.3 自定義刻度：
    • 4.3.1自定義分格數量：
    • 4.3.2 自定義刻度label：
    • 4.3.3隱藏坐標軸刻度：
  • 4.4 邊界操作：
  • 4.5 分片：（可能也就我這麼叫...）
  • 4.6 雙Y軸：（次坐標軸）
• 5 圖例(legend)：
• 6 標註(annotation)：
• 7 坐標軸能見度：
• 8 散點圖(Scatter)：
  • 8.1 基本演示：
    • 8.1.1 也可以畫基本圖形：
  • 8.2 散點圖連線：
• 9 柱狀圖(Bar)：
  • 9.1基本演示：
    • 9.1.1 正常的柱狀圖是向上的：
    • 9.1.2 我們也可以讓它向下：
  • 9.2 其他形式：
    • 9.2.1 並行柱狀圖：
    • 9.2.2 堆疊柱狀圖：
    • 9.2.3 柱狀圖上顯示數值：
    • 9.2.4 水平柱狀圖：
• 10 直方圖(hist)：
  • 10.1 基本演示：
  • 10.2 各種引數演示：
  • 10.3 在直方圖上繪製折線：
  • 10.4 一些基本分布的頻率分布直方圖的演示：
• 11 餅狀圖(pie)：
  • 11.1 基本演示：
  • 11.2 各種引數演示：
• 12 等高線圖(contour/contourf)：
  • 12.1 基本演示：
    • 12.1.1 contour:
    • 12.1.2 contourf:
  • 12.2 contour高階演示：
  • 12.3 contourf高階演示：
• 13 影象(image)：
  • 13.1 基本用法：
  • 13.2 DIY:
    • 13.2.1 最簡單的照貓畫虎以及cmap演示：
    • 13.2.2 連續的影象：
• 14 3D影象(axes3d)：
  • 14.1 3D散點圖：
  • 14.2 3D曲線圖：
  • 14.3 3D柱狀圖：
  • 14.4 3D線框圖：
  • 14.5 3D曲面圖：
• 15 影片(animation)：
  • 15.1 FuncAnimation:
  • 15.2 ArtistAnimation:
• 16 地圖(basemap)：

0.1 先導條件：

import numpy as np
import matplotlib.pyplot as plt

0.2 前言：matplotlib字型安裝

方便matplotlib顯示中文，不需要的可以無視,參考：

https://blog.csdn.net/u014465934/article/details/80377470

1 畫布(figure)：

plt.figure(

    figsize=None, #Figure的大小，單位是英寸              

    dpi=None,    #解析度（每英寸的點數）                  

    facecolor=None, #修飾的顏色                      

    edgecolor=None, #邊界顏色                      

    linewidth=0.0, #線條寬度  
    
    figtext:         # 文字
    
    frameon=None, #布林值，是否繪製框架(Frame)                   

    subplotpars=None, #子圖的引數                            

    tight_layout=None, #取值布林或者字典，預設自動佈局，False 使用 subplotpars引數，True就使用tight_layout，如果是字典，則包含如下欄位：pad, w_pad, h_pad, 與 rect                    

    constrained_layout=None #True就使用constrained_layout，會自動調整plot的位置。        

)

1.1 基本演示：

plt.figure(figsize=(9, 9),  # 大小
           dpi=80,  # 解析度
           facecolor='r',  # 修飾顏色
           edgecolor='g',  # 邊框顏色
           linewidth=10,  # 線條寬度
           )
plt.show()

1.2 多張畫布：

plt.figure(figsize=(5, 3))
# 在第一張畫布上做你想做的
plt.figure(figsize=(10, 6))
# 在第二張畫布上做你想做的
plt.show()

1.3 一張畫布多個子圖：

1.3.1 基本方法：

fig = plt.figure(figsize=(10, 8))

plt.subplot(221)  # 分解成2×2=4個子圖，這裡是第一個
plt.title("子圖1")
plt.subplot(222)
plt.title("子圖2")

# 另一種方式：
fig.add_subplot(223)
plt.title("子圖3")
fig.add_subplot(224)
plt.title("子圖4")

plt.show()

我們還可以設計出這樣的排版：

plt.figure(figsize=(15, 7))
plt.subplot(211)  # 分兩行，第一行衹有一塊
plt.subplot(234)  # 第二行分三塊，但是因為第一行的一塊相當於第二行三塊的位置，所以，第二行要從4開始
plt.subplot(235)
plt.subplot(236)
plt.show()

1.3.2 進階方法：

1.3.2.1 方法一：

plt.figure(figsize=(10, 10))
ax1 = plt.subplot2grid((3, 3),  # 總體效果：三行三列（9×9）
                       (0, 0),  # 從原點開始（0行0列）
                       colspan=3,  # 第一塊寬3個格子
                       rowspan=1,  # 高1個格子
                       )
ax1.set(title=("第一塊"))
# 如法炮製
ax2 = plt.subplot2grid((3, 3), (1, 0), colspan=2, rowspan=1)
ax2.set(title=("第二塊"))
ax3 = plt.subplot2grid((3, 3), (1, 2), colspan=1, rowspan=2)
ax3.set(title=("第三塊"))
ax4 = plt.subplot2grid((3, 3), (2, 0), colspan=1, rowspan=1)
ax4.set(title=("第四塊"))
ax5 = plt.subplot2grid((3, 3), (2, 1), colspan=1, rowspan=1)
ax5.set(title=("第五塊"))
plt.show()

1.3.2.2 方法二：

import matplotlib.gridspec as gridspec

plt.figure(figsize=(10, 10))
gs = gridspec.GridSpec(3, 3)  # 三行三列
ax1 = plt.subplot(gs[0, :])  # 第一塊占第一（0）行全部
ax1.set(title=("第一塊"))
ax2 = plt.subplot(gs[1, :2])  # 第二塊占第二（1）行前兩個
ax2.set(title=("第二塊"))
ax3 = plt.subplot(gs[1:, 2])  # 第三塊占第二（1）行，最後一列兩個
ax3.set(title=("第三塊"))
ax4 = plt.subplot(gs[-1, 0])  # 第四塊占最後一行第一個
ax4.set(title=("第四塊"))
ax5 = plt.subplot(gs[-1, -2])  # 第五塊占最後一行倒數第二個（-2），因為倒數第一個（-1）被第三塊拿走了
ax5.set(title=("第五塊"))
plt.show()

2 軸/子圖(axes):

也可以理解為真正的作圖區域

雖然一般作圖都會有自適應的預設軸，但是這種只適用於簡單的、快速的作圖，如果想要精細作圖的話，還是需要axes的

2.1 基本演示：

fig = plt.figure()
ax = fig.add_subplot(111)
ax.set(xlim=[0.5, 4.5], ylim=[-2, 8],
       title='An Example Axes', ylabel='Y', xlabel='X')
plt.show()

2.2 新增軸子圖：

2.2.1 基本方法：

fig = plt.figure()
ax1 = fig.add_subplot(331)
ax2 = fig.add_subplot(335)
ax3 = fig.add_subplot(339)

這種方法一個一個新增是不是太麻煩了，而且看上去也很蠢…

2.2.2 快捷方法：

一句話就夠了

fig, axes = plt.subplots(nrows=3, ncols=3, figsize=(10, 10))

如果你想要對其中的某個圖進行操作

fig, axes = plt.subplots(nrows=3, ncols=3, figsize=(10, 10))
axes[2, 1].set(title="我要操作你")
axes[1, 2].plot([1, 2, 3, 4], [5, 6, 1, 2])
axes[2, 2].scatter([9, 0, 3, 4], [5, 1, 5, 2])
plt.show()

是不是很方便

2.3 共享軸子圖：

fig, ax = plt.subplots(3, 3, sharex=True, sharey=True)
# 舉例
ax[1, 2].plot([_ for _ in range(4)], [_ for _ in range(4)])
ax[2, 1].scatter([1, 2, 3, 4], [1, 2, 3, 4])
ax[0, 0].set(title="000")

plt.tight_layout()  # 自動佈局
plt.show()

2.4 圖中圖：

fig = plt.figure()
x = [1, 2, 3, 4, 5, 6, 7]
y = [7, 6, 5, 4, 3, 2, 1]
# 第一張大子圖
ax1 = fig.add_axes([0.1,  # left 距離畫布左邊10%
                    0.1,  # bottom 距離畫布下面10%
                    0.8,  # width 寬度占畫布寬度的80%
                    0.8,  # height 高度占畫布的80%
                    ]
                   )
# 在第一張大子圖上作畫
ax1.plot([_ for _ in range(10)], [_ for _ in range(10, 0, -1)], 'r')
ax1.set_xlabel("X1")
ax1.set_ylabel("Y1")
ax1.set_title("子圖1")

# 其他如法炮製
ax2 = fig.add_axes([0.2,  0.2, 0.25, 0.25])
ax2.plot([_ for _ in range(10, 0, -1)], [_ for _ in range(10)], 'g')
ax2.set_xlabel("X2")
ax2.set_ylabel("Y2")
ax2.set_title("子圖2")

# 另一種方法
plt.axes([0.6,  0.6, 0.25, 0.25])
plt.plot([_ for _ in range(10, 0, -1)], [_ for _ in range(10)], 'b')
plt.xlabel("X3")
plt.xlabel("Y3")
plt.title("子圖3")
plt.show()

3 最基本的連線函式：

plt.plot(x, y, 『xxx』, label=, linewidth=)

引數1：位置引數，點的橫坐標，可迭代物件

引數2：位置引數，點的縱坐標，可迭代物件

引數3：位置引數，點和線的樣式，字串

引數 4：label 關鍵字引數，設定圖例，需要呼叫 plt 或子圖的 legend 方法

引數 5：linewidth 關鍵字引數，設定線的粗細

一般呼叫形式：

plot([x], y, [fmt], data=None, **kwargs) # 單條線

plot([x], y, [fmt], [x2], y2, [fmt2], …, **kwargs) # 多條線

可選引數[fmt] 是一個字串來定義圖的基本屬性如：顏色（color），點型（marker），線型（linestyle），

具體形式 fmt = 『[color][marker][line]』

fmt接收的是每個屬性的單個字母縮寫，例如：

plot(x, y, 『bo-』) # 藍色圓點實線

若屬性用的是全名則不能用fmt引數來組合賦值，應該用關鍵字引數對單個屬性賦值如：

plot(x,y2,color=『green』, marker=『o』, linestyle=『dashed』, linewidth=1, markersize=6)

plot(x,y3,color=』#900302』,marker=』+』,linestyle=』-』)

常見顏色引數：

=============    ===============================
character        color
=============    ===============================
``'b'``          blue 藍
``'g'``          green 綠
``'r'``          red 紅
``'c'``          cyan 藍綠
``'m'``          magenta 洋紅
``'y'``          yellow 黃
``'k'``          black 黑
``'w'``          white 白
=============    ===============================

常見點型引數：

=============    ===============================
character        description
=============    ===============================
``'.'``          point marker
``','``          pixel marker
``'o'``          circle marker
``'v'``          triangle_down marker
``'^'``          triangle_up marker
``'<'``          triangle_left marker
``'>'``          triangle_right marker
``'1'``          tri_down marker
``'2'``          tri_up marker
``'3'``          tri_left marker
``'4'``          tri_right marker
``'s'``          square marker
``'p'``          pentagon marker
``'*'``          star marker
``'h'``          hexagon1 marker
``'H'``          hexagon2 marker
``'+'``          plus marker
``'x'``          x marker
``'D'``          diamond marker
``'d'``          thin_diamond marker
``'|'``          vline marker
``'_'``          hline marker
=============    ===============================

常見線型引數：

=============    ===============================
character        description
=============    ===============================
``'-'``          solid line style 實線
``'--'``         dashed line style 虛線
``'-.'``         dash-dot line style 點畫線
``':'``          dotted line style 點線
=============    ===============================

3.1 基本演示：

plt.plot([1, 2, 3, 4],
         [9, 1, 7, 3], 'm*-.')
plt.plot([9, 1, 7, 3],
         [1, 2, 3, 4], 'g^--')
plt.show()

3.2 常見函式演示：

plt.figure(figsize=(10, 8), dpi=80)

plt.subplot(221)
x = np.linspace(-5, 5, 70)
plt.plot(x, x**2, 'r-.+')
plt.title("二次函式")

plt.subplot(222)
x = np.linspace(-5, 5, 70)
plt.plot(x, x**3, 'g--.')
plt.title("三次函式")

plt.subplot(223)
x = np.linspace(-5, 5, 70)
plt.plot(x, 3**x, 'b-*')
plt.title("指數函式")

plt.subplot(224)
x = np.linspace(1, 1000, 70)
plt.plot(x, [np.log2(_) for _ in list(x)], 'm--v')
plt.title("對數函式")

plt.show()

4 坐標軸：

4.1 設定坐標軸名稱：（label）

plt.xlabel("I'm X")
plt.ylabel("I'm Y")
plt.show()
# 注意，這裡x、y不設限的話預設0~1

4.2 設定坐標軸上下限：

注意，與其他範例對比一下，這裡的原點時緊緊貼合的

plt.xlim(0, 10000)
plt.ylim(0, 100)
plt.show()

4.3 自定義刻度：

4.3.1自定義分格數量：

xticks = np.linspace(-90, 100, 9)
plt.xticks(xticks)
yticks = np.linspace(90, 300, 9)
plt.yticks(yticks)
plt.show()

4.3.2 自定義刻度label：

支援lateX語法

plt.xticks([40, 60, 80, 100],
           ['label1', 'label2', '刻度3', '刻度4'])
plt.yticks([60, 80, 90, 100],
           ['$lambda$', r'$eta$', '$gamma$', '$\alpha$'])
# 注意，a、 等關鍵字，既可以用兩個反斜線將其轉義，(像 alpha)
#                       也可以在前面加個 r 正則轉義   (像 beta )
plt.show()

4.3.3隱藏坐標軸刻度：

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

4.4 邊界操作：

ax = plt.gca()
ax.spines['right'].set_color('none')  # 設定右邊框為透明，（隱藏右邊框）
ax.spines['top'].set_color('red')  # 設定上邊框為紅色
plt.show()

4.5 分片：（可能也就我這麼叫…）

注意到沒，上面的所有範例中，無論xy的範圍是多少，顯示出來衹有一塊（類似第一象限）

但這有時不是我們想要的效果

有時我們想這樣：

plt.xlim(-100, 100)
plt.ylim(-100, 100)
ax = plt.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')  # 刻度位置
ax.yaxis.set_ticks_position('left')
ax.spines['bottom'].set_position(('data', 0))  # x的某一點對應y的某一點（此處為原點）
ax.spines['left'].set_position(('data', 0))  # y的某一點對應x的某一點（此處為原點）
plt.show()

或者這樣：

plt.xlim(-100, 100)
plt.ylim(-100, 100)
ax = plt.gca()
ax.spines['left'].set_color('none')
ax.spines['bottom'].set_color('none')
ax.xaxis.set_ticks_position('top')
ax.yaxis.set_ticks_position('right')
ax.spines['top'].set_position(('data', 100))
ax.spines['right'].set_position(('data', 100))
plt.show()

4.6 雙Y軸：（次坐標軸）

fig, ax1 = plt.subplots()
x = np.linspace(1, 100, 1000)
ax2 = ax1.twinx()
ax1.plot(x, 1/x, 'r')
ax1.set_xlabel("X",color='black')
ax1.set_ylabel("反比例函式用軸",color='r')

ax2.plot(x, np.log2(x), 'g')
ax2.set_ylabel("對數函式用軸",color='g')

plt.show()

5 圖例(legend)：

plt.legend(

    loc:圖例位置，預設'best'，可取(『best』, 『upper right』, 『upper left』, 『lower left』, 『lower right』, 『right』, 『center left』, 『center , right』, 『lower center』, 『upper center』, 『center』) ；(若是使用了bbox_to_anchor，則這項就無效了)
    
    fontsize： 字型大小
    
    frameon： 是否顯示圖例邊框
    
    ncol： 圖例的列的數量，一般為1
    
    title: 為圖例新增標題
    
    shadow: 為圖例邊框新增陰影
    
    markerfirst: True表示圖例標籤在控制代碼右側，false反之
    
    markerscale： 圖例標記為原圖示記中的多少倍大小
    
    numpoints: 表示圖例中的控制代碼上的標記點的個數，一般設為1
    
    fancybox: 是否將圖例框的邊角設為圓形
    
    framealpha: 控制圖例框的透明度
    
    borderpad: 圖例框內邊距
    
    labelspacing: 圖例中條目之間的距離
    
    handlelength: 圖例控制代碼的長度
    
    bbox_to_anchor: (橫向看右，縱向看下),如果要自定義圖例位置或者將圖例畫在坐標外邊，用它，例如bbox_to_anchor=(1.4,0.8)，這個一般配合著ax.get_position()，set_position([box.x0, box.y0, box.width*0.8 , box.height])
    
   )

plt.xlim(-100, 100)
plt.ylim(-100, 100)
x = np.linspace(-100, 100, 100)
plt.plot(x, x, 'r', label="y = x")
plt.plot(x, -x, 'b', label="y = -x")
plt.legend(loc="center", title="title")
plt.show()

6 標註(annotation)：

plt.annptation(

s 為註解文字內容

xy 為被註解的坐標點

xytext 為註解文字的坐標位置

xycoords 引數如下:

    figure points：圖左下角的點
    figure pixels：圖左下角的畫素
    figure fraction：圖的左下部分
    axes points：坐標軸左下角的點
    axes pixels：坐標軸左下角的畫素
    axes fraction：左下軸的分數
    data：使用被註解物件的坐標系統(預設)
    polar(theta,r)：if not native 『data』 coordinates t

weight 設定字型線型 {『ultralight』, 『light』, 『normal』, 『regular』, 『book』, 『medium』, 『roman』, 『semibold』, 『demibold』, 『demi』, 『bold』, 『heavy』, 『extra bold』, 『black』}

color 設定字型顏色
    {『b』, 『g』, 『r』, 『c』, 『m』, 『y』, 『k』, 『w』}
    『black』,'red』等
    [0,1]之間的浮點型資料
    RGB或者RGBA, 如: (0.1, 0.2, 0.5)、(0.1, 0.2, 0.5, 0.3)等

arrowprops  #箭頭引數,引數型別為字典dict

    width：箭頭的寬度(以點為單位)
    headwidth：箭頭底部以點為單位的寬度
    headlength：箭頭的長度(以點為單位)
    shrink：總長度的一部分，從兩端「收縮」
    facecolor：箭頭顏色

bbox給標題增加外框 ，常用引數如下：

    boxstyle：方框外形
    facecolor：(簡寫fc)背景顏色
    edgecolor：(簡寫ec)邊框線條顏色
    edgewidth：邊框線條大小

)

plt.xlim(-100, 100)
plt.ylim(-100, 100)
x = np.linspace(-100, 100, 100)
plt.plot(x, x)
plt.scatter(0, 0, color='r')
plt.annotate("原點在這裡",  # 標記文字
             xy=(0, 0),  # 初始位置
             xytext=(+30, -30),  # 移動（右30，下30）
             arrowprops=dict(arrowstyle='->',  # 箭頭
                             connectionstyle='arc3,rad=.2'  # 設定樣式，角度弧度
                             )
             )
plt.show()

7 坐標軸能見度：

有時線條太粗或坐標軸刻度太密的話會被線條遮擋，所以…

plt.xlim(-10, 10)
plt.ylim(-10, 10)
plt.plot(x, x, linewidth=40,
         zorder=0
         # zorder設定線條、坐標軸刻度、坐標軸出現順序
         # zorder=0 or 1,線條在最下方
         # zorder=2,線條在坐標軸下方刻度上方
         # zorder≥3，線條在最上方
         )
ax = plt.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
ax.spines['bottom'].set_position(('data', 0))
ax.spines['left'].set_position(('data', 0))
for label in ax.get_xticklabels()+ax.get_yticklabels():
    label.set_bbox(dict(facecolor='white',  # 背景色為白色
                        edgecolor='none',  # 不顯示邊框
                        alpha=0.7)  # 透明度
                   )

plt.show()

8 散點圖(Scatter)：

plt.scatter(

x，y：array_like，shape（n，）
    輸入資料

s：標量或array_like，shape（n，），可選
    大小以點數^2。預設是rcParams ['lines.markersize'] ** 2。

c：顏色，順序或顏色順序，可選，預設：'b'
    c可以是單個顏色格式的字串，也可以是一系列顏色
    規範的長度為N，或一系列N數值
    使用透過kwargs指定的cmap和norm對映到顏色
    （見下文）。請注意，c不應該是單個數值RGB或
    RGBA序列，因為這與陣列無法區分
    值將被彩色對映。 c可以是一個二維陣列，其中的
    行是RGB或RGBA，但是，包括單個的情況
    行為所有點指定相同的顏色。

marker：matplotlib.markers.MarkerStyle，可選，預設值：'o'
    請參閱matplotlib.markers以取得有關不同的更多訊息
    標記分散支援的樣式。 marker可以是
    該類的例項或特定文字的簡寫
    標記。

cmap：matplotlib.colors.Colormap，可選，預設：無
    一個matplotlib.colors.Colormap例項或註冊名稱。
    cmap僅在c是浮點陣列時使用。如果沒有，
    預設為rcimage.cmap。

norm：matplotlib.colors.Normalize，可選，預設：無
    matplotlib.colors.Normalize例項用於縮放
    亮度資料為0,1。norm衹有在c是一個陣列時才被使用
    彩車。如果'None'，則使用預設值：func：normalize。

vmin，vmax：標量，可選，預設值：無
    vmin和vmax與norm結合使用來標準化
    亮度資料。如果其中任何一個都是'無'，那麼最小和最大的
    使用顏色陣列。請注意，如果你透過一個「規範」例項，你的
    vmin和vmax的設定將被忽略。

alpha：標量，可選，預設值：無
    alpha混合值，介於0（透明）和1（不透明）之間，

linewidths：標量或array_like，可選，預設值：無
    如果無，則預設為（lines.linewidth，）。

verts：（x，y）的序列，可選
    如果`marker`為None，這些頂點將用於
    構建標記。標記的中心位於
    在（0,0）為標準化單位。整體標記重新調整
    由s完成。

 edgecolors ：顏色或顏色順序，可選，預設值：無
    如果無，則預設為'face'

    如果'face'，邊緣顏色將永遠是相同的
    臉色。

    如果它是'none'，補丁邊界不會
    被畫下來。

    對於未填充的標記，「edgecolors」kwarg
    被忽視並被迫在內部「面對」。

)

8.1 基本演示：

plt.figure(figsize=(17, 5))
plt.xlim(0, 1000)
plt.ylim(0, 1000)
marks = ['o', '*', '^', '+', 'x', 's', '.',
         'd', 'v', '<', '>', 'p', 'h']  # 基本點型
colors = ['r', 'g', 'b', 'y', 'm', 'c', 'w', 'k']  # 基本顏色
for i in range(300):  # 隨機選擇顏色、大小、形狀、透明度
    x = np.random.randint(500)
    y = np.random.randint(1000)
    plt.scatter(x, y, c=np.random.choice(colors), s=np.random.randint(20, 100),
                marker=np.random.choice(marks), alpha=np.random.random())
x = np.random.randint(500, 1000, size=200)
y = np.random.randint(1000, size=200)
plt.scatter(x, y, c=np.arctan2(y, x))  # 反正切色系
plt.xticks(())
plt.yticks(())  # 隱藏刻度
plt.show()

8.1.1 也可以畫基本圖形：

x = np.linspace(1, 20, 100)
plt.scatter(x, np.cos(x))
plt.scatter(x, np.sin(x))
plt.show()

8.2 散點圖連線：

plt.xlim(0, 100)
plt.ylim(0, 100)
lists = []
for i in range(50):
    slist = []
    x = np.random.randint(100)
    y = np.random.randint(100)
    plt.scatter(x, y, c='b')
    slist.append(x)
    slist.append(y)
    lists.append(slist)
for i in range(10):  # 取前10對點連線
    a1, a2 = lists[i]
    b1, b2 = lists[i+1]
    plt.plot([a1, b1], [a2, b2])
plt.show()

一個更加成熟的散點圖連線範例：

Python分治法解決凸包問題並用matplotlib實現視覺化

9 柱狀圖(Bar)：

plt.bar(

    left        每個柱x軸左邊界
    
    bottom      每個柱y軸下邊界
    
    height      柱高度(Y軸方向) 
    
    width       柱寬度(X軸方向)
    
    以上引數可以設定為數值或者list
    但要保證如果為list, len(list)要一致
    繪製的方形為:
        X: left   --- left+width
        Y: bottom --- bottom+height
    回傳值:
        matplotlib.patches.Rectangle

    柱狀圖使用bottom擴展即可化為甘特圖 Gantt Chart

    color       Bar顏色
    
    edgecolor   Bar邊界線顏色
    
    linewidth(lw)   Bar邊界線寬度  
    
    align       可選['left'(default) | 'center']
                決定整個bar圖分布
                預設left表示預設從左邊界開始繪製,center會將圖繪製在中間位置

    xerr        x方向error bar
    
    yerr        y方向error bar
    
    ecolor      error bar顏色
    
    capsize     error bar橫線寬度(default 3)

)

9.1基本演示：

9.1.1 正常的柱狀圖是向上的：

plt.bar(range(1, 17), range(1, 17), alpha=0.5, width=0.7,
        color='yellow', edgecolor='red',  linewidth=1)
plt.show()

9.1.2 我們也可以讓它向下：

ax = plt.gca()
ax.xaxis.set_ticks_position('top')
plt.bar(range(1, 17), [-_ for _ in range(17, 1, -1)], alpha=0.5, width=0.7,
        color='yellow', edgecolor='red',  linewidth=1)
plt.show()

9.2 其他形式：

9.2.1 並行柱狀圖：

bar_width = 0.4
plt.bar(np.arange(16)-bar_width/2, range(1, 17), width=bar_width)
plt.bar(np.arange(16)+bar_width/2, range(17, 1, -1),   width=bar_width)
plt.show()

9.2.2 堆疊柱狀圖：

plt.bar(range(1, 16), range(1, 16))
plt.bar(range(1, 16), range(16, 1, -1), bottom=range(1, 16))

plt.show()

9.2.3 柱狀圖上顯示數值：

items = plt.bar(range(1, 17), range(1, 17))


def add_labels(items):
    for item in items:
        height = item.get_height()
        plt.text(x=item.get_x()+item.get_width()/5, y=height*1.01, s=height)
        item.set_edge_color = "none"


add_labels(items)
plt.show()

9.2.4 水平柱狀圖：

plt.barh(range(1, 16), range(1, 16))
plt.show()

10 直方圖(hist)：

直方圖與柱狀圖外觀表現很相似，用來展現連續型資料分布特徵的統計圖形（柱狀圖主要展現離散型資料分布）

plt.hist(

    x: 資料集，最終的直方圖將對資料集進行統計
    
    bins: 統計的區間分布
    
    range: tuple, 顯示的區間
    
    width:  寬度
    
    rwidth:  寬度（最大為1）
    
    density: bool，預設為false，顯示的是頻數統計結果，為True則顯示頻率統計結果，這裡需要注意，頻率統計結果=區間數目/(總數*區間寬度)，和normed效果一致，官方推薦使用density
    
    histtype: 可選{'bar', 'barstacked', 'step', 'stepfilled'}之一，預設為bar，推薦使用預設配置，step使用的是梯狀，stepfilled則會對梯狀內部進行填充，效果與bar類似
    
    align: 可選{'left', 'mid', 'right'}之一，預設為'mid'，控制柱狀圖的水平分布，left或者right，會有部分空白區域，推薦使用預設
    
    log: bool，預設False,即y坐標軸是否選擇指數刻度
    
    stacked: bool，預設為False，是否為堆積狀圖

)

10.1 基本演示：

# 直方圖會進行統計各個區間的數值
plt.hist(x=np.random.randint(0, 100, 100),  # 生成 0~100 之間的100個資料,即資料集
         bins=np.arange(0, 101, 10),  # 設定連續的邊界值，即直方圖的分布區間[0,10],[10,20]...
         )
plt.show()

10.2 各種引數演示：

plt.hist(x=np.random.randint(0, 100, 100),
         bins=np.arange(0, 101, 10),
         alpha=0.5,  # 透明度
         density=True,  # 頻率
         color='green',  # 顏色
         width=8  # 寬度    <=>   rwidth=0.8
         )
plt.show()

10.3 在直方圖上繪製折線：

bins = np.arange(0, 101, 10)
width = 8
s1 = plt.hist(x=np.random.randint(0, 100, 100),
              bins=bins,
              alpha=0.5,  # 透明度
              density=True,  # 頻率
              color='green',  # 顏色
              width=width
              )
plt.plot(bins[1:]-width/2, s1[0])
plt.show()

10.4 一些基本分布的頻率分布直方圖的演示：

def normal(mu, sigma, color):
    plt.hist(np.random.normal(mu, sigma, 1000), alpha=0.6, color=color,
             density=True, label='$mu = {},sigma = {}$'.format(mu, sigma))


def binomial(n, p, color):
    plt.hist(np.random.binomial(n, p, 1000), color=color,
             density=True, alpha=0.6, label="n = {},p = {}".format(n, p))


def poisson(lam, color):
    plt.hist(np.random.poisson(lam, 1000), color=color,
             label="$lambda = {}$".format(lam), alpha=0.6, density=True)


def beta(alpha, beta_, color):
    plt.hist(np.random.beta(alpha, beta_, 1000), color=color,
             label="$\alpha = {},\beta $ = {}".format(alpha, beta_), alpha=0.6, density=True)


plt.figure(figsize=(20, 12), dpi=80)

plt.subplot(221)
normal(4, 0.8, 'r')
normal(-3, 0.5, 'g')
normal(0, 1, 'b')
plt.legend()
plt.title("正態分布")

plt.subplot(222)
poisson(200, 'r')
poisson(400, 'g')
poisson(600, 'b')
plt.legend()
plt.title("伯努利分布")

plt.subplot(223)
poisson(200, 'r')
poisson(400, 'g')
poisson(600, 'b')
plt.legend()
plt.title("泊松分布")

plt.subplot(224)
beta(1, 3, 'r')
beta(10, 30, 'g')
beta(20, 20, 'b')
plt.legend()
plt.title("貝塔分布")

plt.show()

11 餅狀圖(pie)：

plt.pie(

    x :(每一塊)的比例，如果sum(x) > 1會使用sum(x)歸一化；
    
    labels  :(每一塊)餅圖外側顯示的說明文字；
    
    explode :(每一塊)離開中心距離；
    
    startangle :起始繪製角度,預設圖是從x軸正方向逆時針畫起,如設定=90則從y軸正方向畫起；
    
    shadow  :在餅圖下面畫一個陰影。預設值：False，即不畫陰影；
    
    labeldistance :label標記的繪製位置,相對於半徑的比例，預設值為1.1, 如<1則繪製在餅圖內側；
    
    autopct :控制餅圖內百分比設定,可以使用format字串或者format function
            '%1.1f'指小數點前後位數(沒有用空白補齊)；
            
    pctdistance :類似於labeldistance,指定autopct的位置刻度,預設值為0.6；
    
    radius  :控制餅圖半徑，預設值為1；
    
    counterclock ：指定指標方向；布林值，可選引數，預設為：True，即逆時針。將值改為False即可改為順時針。
    
    wedgeprops ：字典型別，可選引數，預設值：None。引數字典傳遞給wedge物件用來畫一個餅圖。例如：wedgeprops={'linewidth':3}設定wedge線寬為3。
    
    textprops ：設定標籤（labels）和比例文字的格式；字典型別，可選引數，預設值為：None。傳遞給text物件的字典引數。
    
    center ：浮點型別的串列，可選引數，預設值：(0,0)。圖示中心位置。
    
    frame ：布林型別，可選引數，預設值：False。如果是true，繪製帶有表的軸框架。
    
    rotatelabels ：布林型別，可選引數，預設為：False。如果為True，旋轉每個label到指定的角度。

)

11.1 基本演示：

plt.pie([2, 5, 12, 70, 2, 9])
plt.show()

11.2 各種引數演示：

plt.pie(x=[_ for _ in range(1, 21)],
        explode=[_*0.05 for _ in [_ for _ in range(1, 21)]],  # 挨個突出
        startangle=100,  # 起始角度
        shadow=True,  # 陰影
        labels=[_ for _ in range(1, 21)],
        autopct='%1.1f%%',  # 顯示比例
        )
plt.show()

12 等高線圖(contour/contourf)：

contour和contourf都是畫三維等高線圖的，不同點在於contourf會對等高線間的區域進行填充

plt.contour([X, Y,] Z, [levels], ** kwargs)

plt.contourf([X, Y,] Z, [levels], ** kwargs)

X，Y ： array-like，可選值Z的坐標。

X和Y必須都是2-D，且形狀與Z相同，或者它們必須都是1-d，這樣len（X）== M是Z中的列數，len（Y）== N是Z中的行數。

Z ： array-like（N，M）

繪製輪廓的高度值。

levels： int或類似陣列，可選

確定輪廓線/區域的數量和位置。

如果int ?，使用?資料間隔; 即繪製n + 1個等高線。水平高度自動選擇。

如果是陣列，則在指定的級別繪製輪廓線。值必須按遞增順序排列。

12.1 基本演示：

12.1.1 contour:

x = np.array([1, 2, 3])
y = np.array([1, 2, 3])
z = np.array([[-3, -2, -1], [0, 0, 0], [1, -1, 1]])
plt.contour(x, y, z)
plt.show()

12.1.2 contourf:

plt.contourf(x, y, z)
plt.show()

12.2 contour高階演示：

參考：https://blog.csdn.net/qq_42505705/article/details/88771942

delta = 0.025
x = np.arange(-3.0, 3.0, delta)
y = np.arange(-3.0, 3.0, delta)
X, Y = np.meshgrid(x, y)
Z1 = np.exp(-X**2 - Y**2)
Z2 = np.exp(-(X - 1)**2 - (Y - 1)**2)
Z = (Z1 - Z2) * 2
fig, ax = plt.subplots()
CS = ax.contour(X, Y, Z)
ax.clabel(CS, inline=1, fontsize=10)
plt.xticks(())
plt.yticks(())
plt.show()

12.3 contourf高階演示：

參考：https://www.bilibili.com/video/av16378354?p=12

def f(x, y):
    # the height function
    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.contourf(X, Y, f(X, Y), 8, alpha=.75, cmap=plt.cm.hot)
C = plt.contour(X, Y, f(X, Y), 8, colors='black')
plt.clabel(C, inline=True, fontsize=10)
plt.xticks(())
plt.yticks(())
plt.show()

13 影象(image)：

plt.imshow(

    X, # 儲存影象，可以是浮點型陣列、unit8陣列以及PIL影象，如果其為陣列，則需滿足一下形狀：  
        (1) M*N   此時陣列必須為浮點型，其中值為該坐標的灰度；  
        (2) M*N*3  RGB（浮點型或者unit8型別）  
        (3) M*N*4  RGBA（浮點型或者unit8型別）

    
    cmap=None, # 用於設定熱圖的Colormap
            hot 從黑平滑過度到紅、橙色和黃色的背景色，然後到白色。 
            cool 包含青綠色和品紅色的陰影色。從青綠色平滑變化到品紅色。  
            gray 回傳線性灰度色圖。   
            bone 具有較高的藍色成分的灰度色圖。該色圖用於對灰度圖新增電子的檢視表。  
            white 全白的單色色圖。   
            spring 包含品紅和黃的陰影顏色。    
            summer 包含綠和黃的陰影顏色。   
            autumn 從紅色平滑變化到橙色，然後到黃色。  
            winter 包含藍和綠的陰影色。
    
    norm=None,    # 預設"None"，可設為 Normalize
                「Normalize（標準化）」，將2-D的X浮點值轉化到[0, 1]區間，再作為cmap的輸入值；
                 如果norm是"None"，則使用預設功能：normilize（標準化）
                 如果norm是例如"NoNorm"，X必須是直接指向camp的搜尋表的整數陣列
    
    aspect=None,    # 控制軸的縱橫比。該引數可能使影象失真，即畫素不是方形的。
                『equal』：確保寬高比為1,畫素將為正方形。
                   （除非畫素大小明確地在資料中變為非正方形,坐標使用 extent ）。
                『auto』: 更改影象寬高比以匹配軸的寬高比。通常，這將導致非方形畫素。
    
    interpolation=None,  #預設"None"，可用字串型別命令設定
                    可設定的字串命令為：
                    'none'，'nearest'，'bilinear'，'bicubic'，
                    『spline16', 'spline36', 'hanning', 'hamming',
                    'hermite'， 'kaiser'，'quadric'，'catrom'，
                    'gaussian'，'bessel'，'mitchell'， 'sinc'，'lanczos'
    
    alpha=None,    # 透明度
    
    vmin=None,
    
    vmax=None, 
    
    origin=None, 
    
    extent=None, 
    
    shape=None,
    
    filternorm=1,
    
    filterrad=4.0,
    
    imlim=None,
    
    resample=None,
    
    url=None,
    
    hold=None,
    
    data=None,
    
    **kwargs

)

13.1 基本用法：

import matplotlib.image as mpimg

# 開啟一張圖像
img= mpimg.imread('C:\Users\1696589321\Desktop\cat.jpg')
imgplot=plt.imshow(img)

接下來我們print一下這張圖像試試看;

print(img)

[[[141 123  99]
  [152 136 113]
  [148 133 112]
  ...
  [173 165 152]
  [176 168 155]
  [177 169 156]]

 [[167 149 125]
  [150 134 109]
  [126 111  88]
  ...
  [175 167 154]
  [176 168 155]
  [175 167 154]]

 [[162 142 117]
  [123 105  81]
  [ 90  74  51]
  ...
  [170 162 149]
  [170 162 149]
  [168 160 147]]

 ...

 [[181  98  48]
  [181  98  48]
  [181  98  48]
  ...
  [190 174 148]
  [191 175 149]
  [191 175 149]]

 [[181  98  48]
  [181  98  48]
  [181  98  48]
  ...
  [190 174 148]
  [191 175 149]
  [191 175 149]]

 [[181  98  48]
  [181  98  48]
  [181  98  48]
  ...
  [190 174 148]
  [191 175 149]
  [191 175 149]]]

可以看到這是一個多維陣列，這就是它的工作原理，每一個數值都代表一個畫素點，這樣我們就可以DIY自己的圖像了

（PS:雖然說是DIY，但是真的不能叫圖像哈哈…真正的圖像，就算畫質比較差的，畫素點也成千上萬了，而且每個值都代表不同的顏色…所以我們在這裡就僅僅隨便搞搞… ：）

13.2 DIY:

13.2.1 最簡單的照貓畫虎以及cmap演示：

X = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]).reshape(3, 3)

fig = plt.figure()

ax = fig.add_subplot(231)
im = ax.imshow(X, cmap=plt.cm.hot, origin='urpper')  # c熱
plt.colorbar(im, cax=None, ax=None,
             shrink=0.5  # 右邊的Bar的比例
             )
plt.xticks(())
plt.yticks(())

ax = fig.add_subplot(232)
im = ax.imshow(X, cmap=plt.cm.cool, origin='urpper')  # 冷
plt.colorbar(im, cax=None, ax=None, shrink=0.5)
plt.xticks(())
plt.yticks(())

ax = fig.add_subplot(233)
im = ax.imshow(X, cmap=plt.cm.spring, origin='urpper')  # 春
plt.colorbar(im, cax=None, ax=None, shrink=0.5)
plt.xticks(())
plt.yticks(())

ax = fig.add_subplot(234)
im = ax.imshow(X, cmap=plt.cm.summer, origin='urpper')  # 夏
plt.colorbar(im, cax=None, ax=None, shrink=0.5)
plt.xticks(())
plt.yticks(())

ax = fig.add_subplot(235)
im = ax.imshow(X, cmap=plt.cm.autumn, origin='urpper')  # 秋
plt.colorbar(im, cax=None, ax=None, shrink=0.5)
plt.xticks(())
plt.yticks(())

ax = fig.add_subplot(236)
im = ax.imshow(X, cmap=plt.cm.winter, origin='urpper')  # 冬
plt.colorbar(im, cax=None, ax=None, shrink=0.5)

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

13.2.2 連續的影象：

points = np.arange(0, 10, 0.01)
xs, ys = np.meshgrid(points, points)

fig = plt.figure()

ax = fig.add_subplot(121)
ax.imshow(np.sqrt(xs**2 + ys**2), cmap=plt.cm.cool)
plt.xticks(())
plt.yticks(())

points = np.arange(-10, 0, 0.01)
xs, ys = np.meshgrid(points, points)
ax = fig.add_subplot(122)
ax.imshow(np.sqrt(xs**2 + ys**2), cmap=plt.cm.hot)
plt.xticks(())
plt.yticks(())

plt.show()

14 3D影象(axes3d)：

前提：from mpl_toolkits.mplot3d import Axes3D

14.1 3D散點圖：

from mpl_toolkits.mplot3d.axes3d import Axes3D
x = np.random.randint(0, 100, size=100)
y = np.random.randint(0, 100, size=100)
z = np.random.randint(-100, 0, size=100)
fig = plt.figure(figsize=(6, 4))
ax = Axes3D(fig)
ax.scatter3D(x, y, z, s=100, c=np.arctan2(y, z))
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
plt.show()

14.2 3D曲線圖：

x = np.linspace(0, 20, 200)
y = np.sin(x)
z = np.cos(x)
fig = plt.figure(figsize=(8, 6))
ax = Axes3D(fig)
ax.plot(x, y, z, color='m')
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
plt.show()

14.3 3D柱狀圖：

x = np.array([2001, 2003, 2005, 2007, 2009])
y = np.arange(1, 13)
fig = plt.figure(figsize=(8, 6))
ax = Axes3D(fig)
for year in x:
    z = np.random.randint(10, 50, size=12)
    ax.bar(y, z, zs=year, zdir='x', color=np.random.rand(12, 3))
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
plt.show()

14.4 3D線框圖：

from mpl_toolkits.mplot3d import axes3d
fig = plt.figure()
ax = Axes3D(fig)
X, Y, Z = axes3d.get_test_data(0.03)
ax.plot_wireframe(X, Y, Z,
                  rstride=10,  # rstride（row）指定行的跨度
                  cstride=10,  # cstride(column)指定列的跨度
                  color='m'
                  )
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
plt.show()

14.5 3D曲面圖：

3D曲面圖可以幫我們理解一些抽象的三維數學函式

fig = plt.figure(figsize=(12, 8))
ax = Axes3D(fig)
delta = 0.125
x = np.arange(-3.0, 3.0, delta)
y = np.arange(-2.0, 2.0, delta)
X, Y = np.meshgrid(x, y)
Z = X**2+Y**2
ax.plot_surface(X, Y, Z,
                rstride=1,
                cstride=1,
                cmap=plt.get_cmap('rainbow')  # 設定顏色對映
                )
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
plt.title("$y=x^2+y^2$")
plt.show()

fig = plt.figure(figsize=(12, 8))
ax = Axes3D(fig)
delta = 0.125
x = np.arange(-3.0, 3.0, delta)
y = np.arange(-2.0, 2.0, delta)
X, Y = np.meshgrid(x, y)
Z = np.sqrt(X**2+Y**2)
ax.plot_surface(X, Y, Z,
                rstride=1,
                cstride=1,
                cmap=plt.get_cmap('rainbow')
                )
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
plt.title("$y=sqrt{x^2+y^2}$")
plt.show()

fig = plt.figure(figsize=(12, 8))
ax = Axes3D(fig)
delta = 0.125
x = np.arange(-3.0, 3.0, delta)
y = np.arange(-2.0, 2.0, delta)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2+Y**2))
ax.plot_surface(X, Y, Z,
                rstride=1,
                cstride=1,
                cmap=plt.get_cmap('rainbow')
                )
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
plt.title("$y=sin(x^2+y^2)$")
plt.show()

fig = plt.figure(figsize=(12, 8))
ax = Axes3D(fig)
delta = 0.125
x = np.arange(-3.0, 3.0, delta)
y = np.arange(-2.0, 2.0, delta)
X, Y = np.meshgrid(x, y)
Z = np.cos(np.sqrt(X**2+Y**2))
ax.plot_surface(X, Y, Z,
                rstride=1,
                cstride=1,
                cmap=plt.get_cmap('rainbow')
                )
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
plt.title("$y=cos(x^2+y^2)$")
plt.show()

fig = plt.figure(figsize=(12, 8))
ax = Axes3D(fig)
delta = 0.125
x = np.arange(-3.0, 3.0, delta)
y = np.arange(-2.0, 2.0, delta)
X, Y = np.meshgrid(x, y)
Z = np.tan(np.sqrt(X**2+Y**2))
ax.plot_surface(X, Y, Z,
                rstride=1,
                cstride=1,
                cmap=plt.get_cmap('rainbow')
                )
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
plt.title("$y=tan(x^2+y^2)$")
plt.show()

15 影片(animation)：

前提：from matplotlib import animation

FuncAnimationnc： Makes an animation by repeatedly calling a function fun.

            (透過反覆呼叫函式來實現一個影片)

ArtistAnimation： Animation using a fixed set of Artist objects.

            (使用一組固定的Artist物件進行影片處理。)

15.1 FuncAnimation:

animation.FuncAnimation(

    fig,     # 影片所在的圖
    
    func,    # 影片函式，第一個引數是下一幀的值， 其他引數由fargs傳遞
    
    frames=None,      # 影片幀數
    
    init_func=None,    # 初始化函式，用於清空圖形，如果不設定，則使用func中第一幀影象
    
    fargs=None,         # 一個字典型別的資料，會作為func函式的引數
    
    save_count=None,     # 緩衝的影片幀數量
    
    *, 
    cache_frame_data=True, 
    **kwargs
       |- interval：間隔時間； 單位milliseconds毫秒1/1000
       |- repeat：是否重複播放；
       |- 其他引數參考檔案。

)

from matplotlib import animation

fig, ax = plt.subplots()
x = np.arange(0, 2*np.pi, 0.01)
line, = ax.plot(x, np.sin(x))


def funcs(i):
    line.set_ydata(np.sin(x+i/10))
    return line,


def inits():
    line.set_ydata(np.sin(x))
    return line,


ani = animation.FuncAnimation(fig=fig, func=funcs, frames=100, interval=20)
plt.show()
ani.save('FuncAnamiation.gif', writer='pillow', fps=10)  # 儲存到本地

一個更加成熟並完美應用的範例：

利用matplotlib畫出凸包問題分治遞迴策略實現過程動態圖

15.2 ArtistAnimation:

animation.ArtistAnimation(

      fig, # 用來展示figure，用plt.figure()生成
      
      ims,           # list格式，每一個元素是一個完全由artists 類組成的collection ，代表一幀，並且只在這一幀顯示（過了這一幀會被擦除）
      
      interval=200,  # 更新頻率，以ms計
      
      repeat_delay=None,   # 每顯示一次影片後間隔多長時間重複
      
      repeat = True,     # 是否重複影片 
      
      blit=False      # # 選擇更新所有點，還是僅更新產生變化的點。應選擇True，但mac使用者請選擇False，否則無法顯示

)

a = np.random.rand(10, 10)

fig, ax = plt.subplots()
container = []

for i in range(a.shape[1]):
    line, = ax.plot(a[:, i])
    title = ax.text(0.5, 1.05, "Title {}".format(i),
                    size=plt.rcParams["axes.titlesize"],
                    ha="center", transform=ax.transAxes)
    container.append([line, title])

ani = animation.ArtistAnimation(fig, container, interval=200, blit=False)
ani.save('ArtistAnamiation.gif', writer='pillow', fps=10)  # 儲存到本地
plt.show()

16 地圖(basemap)：

這個太多了，也不是入門看的，如果想玩的話，就去這裡看：

https://basemaptutorial.readthedocs.io/en/latest/

說實話是因為我沒用過…
（我畫地圖都是用的pyecharts??,例如這篇：
pyecharts-Map3D實現新冠肺炎疫情全國資料立體視覺化）

文章轉自：https://www.defcode01.com/cs104855560/