Plotly 快速指南

---

---

Plotly - 簡介

Plotly 是一家位於蒙特利爾的科技計算公司，致力於開發資料分析和視覺化工具，例如Dash 和 Chart Studio。它還開發了針對 Python、R、MATLAB、Javascript 和其他計算機程式語言的開源繪圖應用程式程式設計介面 (API) 庫。

Plotly 的一些重要功能如下：

• 它生成互動式圖表。

• 圖表以 JavaScript 物件表示法(JSON 資料格式)儲存，因此可以使用其他程式語言（例如 R、Julia、MATLAB 等）的指令碼讀取它們。

• 圖表可以匯出為各種光柵和向量影像格式。

Plotly - 環境設定

本章重點介紹如何在 Python 中藉助 Plotly 進行環境設定。

安裝 Python 包

始終建議使用 Python 的虛擬環境功能來安裝新包。以下命令在指定的資料夾中建立一個虛擬環境。

python -m myenv

要啟用已建立的虛擬環境，請執行bin子資料夾中的activate指令碼，如下所示。

source bin/activate

現在，我們可以使用 pip 實用程式安裝 Plotly 的 Python 包，如下所示。

pip install plotly

您可能還想安裝Jupyter Notebook應用程式，這是一個基於 Web 的Ipython直譯器介面。

pip install jupyter notebook

首先，您需要在網站 https://plot.ly 上建立一個帳戶。您可以使用此處提到的連結 https://plot.ly/api_signup 註冊，然後成功登入。

接下來，從儀表板的設定頁面獲取 API 金鑰。

使用您的使用者名稱和 API 金鑰在Python 直譯器會話中設定憑據。

import plotly
plotly.tools.set_credentials_file(username='test', 
api_key='********************')

在您的主目錄下，.plotly子資料夾中會建立一個名為credentials的特殊檔案。它類似於以下內容：

{
   "username": "test",
   "api_key": "********************",
   "proxy_username": "",
   "proxy_password": "",
   "stream_ids": []
}

為了生成圖表，我們需要從 Plotly 包匯入以下模組：

import plotly.plotly as py
import plotly.graph_objs as go

plotly.plotly 模組包含有助於我們與 Plotly 伺服器通訊的函式。plotly.graph_objs 模組中的函式生成圖形物件。

Plotly - 線上和離線繪圖

本章介紹線上和離線繪圖的設定。讓我們首先研究線上繪圖的設定。

線上繪圖設定

線上圖表的資料和圖表儲存在您的plot.ly 帳戶中。線上圖表透過兩種方法生成，這兩種方法都會為圖表建立一個唯一的URL並將其儲存在您的 Plotly 帳戶中。

• py.plot() - 返回唯一的 URL 並可選地開啟 URL。

• py.iplot() - 在Jupyter Notebook中工作時，在 Notebook 中顯示圖表。

我們現在將顯示弧度角與其正弦值的簡單圖表。首先，使用 numpy 庫中的arange()函式獲取 0 到 2π 之間的角度的 ndarray 物件。此 ndarray 物件用作圖表中x 軸的值。透過以下語句獲得 x 中角度的對應正弦值，這些值必須顯示在y 軸上：

import numpy as np
import math #needed for definition of pi
xpoints = np.arange(0, math.pi*2, 0.05)
ypoints = np.sin(xpoints)

接下來，使用graph_objs 模組中的Scatter()函式建立一個散點跡。

trace0 = go.Scatter(
   x = xpoints,
   y = ypoints
)
data = [trace0]

使用上述列表物件作為plot()函式的引數。

py.plot(data, filename = 'Sine wave', auto_open=True)

將以下指令碼另存為plotly1.py

import plotly
plotly.tools.set_credentials_file(username='lathkar', api_key='********************')
import plotly.plotly as py
import plotly.graph_objs as go
import numpy as np
import math #needed for definition of pi

xpoints = np.arange(0, math.pi*2, 0.05)
ypoints = np.sin(xpoints)
trace0 = go.Scatter(
   x = xpoints, y = ypoints
)
data = [trace0]
py.plot(data, filename = 'Sine wave', auto_open=True)

從命令列執行上述指令碼。生成的圖表將顯示在瀏覽器中指定的 URL 上，如下所示。

$ python plotly1.py
High five! You successfully sent some data to your account on plotly. 
View your plot in your browser at https://plot.ly/~lathkar/0

在顯示的圖表上方，您會找到選項卡“圖表”、“資料”、“Python”和“Rand Forking 歷史記錄”。

當前，已選擇“圖表”選項卡。“資料”選項卡顯示一個包含 x 和y資料點的網格。“Python 和 R”選項卡中，您可以檢視對應於當前圖表的 Python、R、JSON、Matlab 等程式碼。以下快照顯示了上面生成的圖表的 Python 程式碼：

離線繪圖設定

Plotly 允許您離線生成圖表並將它們儲存在本地機器上。plotly.offline.plot()函式建立一個獨立的 HTML 檔案，該檔案儲存在本地並在您的網路瀏覽器中開啟。

在Jupyter Notebook中離線工作時，使用plotly.offline.iplot()在 Notebook 中顯示圖表。

注意 - 離線繪圖需要 Plotly 1.9.4+ 版本。

更改指令碼中的plot()函式語句並執行。一個名為temp-plot.html的 HTML 檔案將建立在本地並在網路瀏覽器中開啟。

plotly.offline.plot(
   { "data": data,"layout": go.Layout(title = "hello world")}, auto_open = True)

Plotly - 在 Jupyter Notebook 中內聯繪圖

在本章中，我們將學習如何在 Jupyter Notebook 中進行內聯繪圖。

為了在 Notebook 中顯示圖表，您需要啟動 Plotly 的 Notebook 模式，如下所示：

from plotly.offline import init_notebook_mode
init_notebook_mode(connected = True)

保持其餘指令碼不變，然後按Shift+Enter執行 Notebook 單元格。圖表將離線顯示在 Notebook 本身中。

import plotly
plotly.tools.set_credentials_file(username = 'lathkar', api_key = '************')
from plotly.offline import iplot, init_notebook_mode
init_notebook_mode(connected = True)

import plotly
import plotly.graph_objs as go
import numpy as np
import math #needed for definition of pi

xpoints = np.arange(0, math.pi*2, 0.05)
ypoints = np.sin(xpoints)
trace0 = go.Scatter(
   x = xpoints, y = ypoints
)
data = [trace0]
plotly.offline.iplot({ "data": data,"layout": go.Layout(title="Sine wave")})

Jupyter Notebook 輸出將如下所示：

圖表輸出在右上角顯示一個工具欄。它包含以下按鈕：下載為png、放大和縮小、框選和套索、選擇和懸停。

Plotly - 包結構

Plotly Python 包具有三個主要模組，如下所示：

• plotly.plotly
• plotly.graph_objs
• plotly.tools

plotly.plotly 模組包含需要 Plotly 伺服器響應的函式。此模組中的函式是您的本地機器和 Plotly 之間的介面。

plotly.graph_objs 模組是最重要的模組，它包含構成您看到的圖表的物件的全部類定義。定義了以下圖形物件：

• Figure（圖形），
• Data（資料），
• Layout（佈局），
• 不同的圖形軌跡，如散點圖、箱線圖、直方圖等。

所有圖形物件都是字典和列表狀物件，用於生成和/或修改 Plotly 圖表的每個功能。

plotly.tools 模組包含許多有用的函式，可以促進和增強 Plotly 體驗。此模組中定義了用於子圖生成、將 Plotly 圖表嵌入IPython Notebook、儲存和檢索您的憑據的函式。

圖表由 Figure 物件表示，該物件表示在plotly.graph_objs 模組中定義的 Figure 類。它的建構函式需要以下引數：

import plotly.graph_objs as go
fig = go.Figure(data, layout, frames)

data引數是 Python 中的列表物件。它是您想要繪製的所有軌跡的列表。軌跡只是我們賦予要繪製的資料集合的名稱。軌跡物件根據您希望資料在繪圖表面上的顯示方式命名。

Plotly 提供了許多軌跡物件，例如散點圖、條形圖、餅圖、熱力圖等，每個物件都是由graph_objs函式中的相應函式返回的。例如：go.scatter()返回散點軌跡。

import numpy as np
import math #needed for definition of pi

xpoints=np.arange(0, math.pi*2, 0.05)
ypoints=np.sin(xpoints)

trace0 = go.Scatter(
   x = xpoints, y = ypoints
)
data = [trace0]

layout引數定義圖表的顯示方式以及與資料無關的圖表功能。因此，我們將能夠更改標題、座標軸標題、註釋、圖例、間距、字型，甚至在圖表頂部繪製形狀。

layout = go.Layout(title = "Sine wave", xaxis = {'title':'angle'}, yaxis = {'title':'sine'})

圖表可以具有圖表標題以及座標軸標題。它還可以具有註釋以指示其他描述。

最後，由go.Figure()函式建立了一個Figure 物件。它是一個類似字典的物件，包含資料物件和佈局物件。最終繪製圖形物件。

py.iplot(fig)

Plotly - 匯出為靜態影像

離線圖表的輸出可以匯出為各種光柵和向量影像格式。為此，我們需要安裝兩個依賴項——orca和psutil。

Orca

Orca 代表開源報表建立應用程式。它是一個 Electron 應用程式，可以從命令列生成 Plotly 圖表、Dash 應用程式和儀表板的影像和報表。Orca 是 Plotly 影像伺服器的支柱。

psutil

psutil（Python 系統和程序實用程式）是一個跨平臺庫，用於在 Python 中檢索有關正在執行的程序和系統利用率的資訊。它實現了許多由UNIX命令列工具（例如：ps、top、netstat、ifconfig、who等）提供的功能。psutil 支援所有主要作業系統，例如 Linux、Windows 和 MacOs。

安裝 Orca 和 psutil

如果您使用的是 Anaconda Python 發行版，則可以使用conda 包管理器非常輕鬆地安裝 orca 和 psutil，如下所示：

conda install -c plotly plotly-orca psutil

由於 orca 在 PyPi 儲存庫中不可用。您可以改用npm 實用程式來安裝它。

npm install -g electron@1.8.4 orca

使用 pip 安裝 psutil

pip install psutil

如果您無法使用 npm 或 conda，也可以從以下網站下載 orca 的預構建二進位制檔案 https://github.com/plotly/orca/releases。

要將 Figure 物件匯出為 png、jpg 或 WebP 格式，首先，匯入plotly.io模組

import plotly.io as pio

現在，我們可以按如下方式呼叫write_image()函式：

pio.write_image(fig, ‘sinewave.png’)
pio.write_image(fig, ‘sinewave.jpeg’)
pio.write_image(fig,’sinewave.webp)

orca工具還支援將plotly匯出為svg、pdf和eps格式。

Pio.write_image(fig, ‘sinewave.svg’)
pio.write_image(fig, ‘sinewave.pdf’)

在Jupyter notebook中，由pio.to_image()函式獲得的影像物件可以按如下方式內聯顯示：

Plotly - 圖例

預設情況下，包含多個軌跡的Plotly圖表會自動顯示圖例。如果只有一個軌跡，則不會自動顯示。要顯示，請將Layout物件的showlegend引數設定為True。

layout = go.Layoyt(showlegend = True)

圖例的預設標籤是軌跡物件的名稱。要顯式設定圖例標籤，請設定軌跡的name屬性。

在下面的例子中，繪製了兩個帶有name屬性的散點軌跡。

import numpy as np
import math #needed for definition of pi

xpoints = np.arange(0, math.pi*2, 0.05)
y1 = np.sin(xpoints)
y2 = np.cos(xpoints)
trace0 = go.Scatter(
   x = xpoints,
   y = y1,
   name='Sine'
)
trace1 = go.Scatter(
   x = xpoints,
   y = y2,
   name = 'cos'
)
data = [trace0, trace1]
layout = go.Layout(title = "Sine and cos", xaxis = {'title':'angle'}, yaxis = {'title':'value'})
fig = go.Figure(data = data, layout = layout)
iplot(fig)

圖表如下所示：

Plotly - 格式化座標軸和刻度

您可以透過指定線寬和顏色來配置每個座標軸的外觀。也可以定義網格寬度和網格顏色。讓我們在本節中詳細瞭解一下。

帶有座標軸和刻度的圖表

在Layout物件的屬性中，將showticklabels設定為true將啟用刻度。tickfont屬性是一個字典物件，指定字型名稱、大小、顏色等。tickmode屬性可以有兩個可能的值——linear和array。如果是linear，則起始刻度的位置由tick0確定，刻度之間的步長由dtick屬性確定。

如果將tickmode設定為array，則必須提供值列表和標籤作為tickval和ticktext屬性。

Layout物件還具有Exponentformat屬性，將其設定為'e'將導致刻度值以科學計數法顯示。你還需要將showexponent屬性設定為'all'。

現在，我們格式化上面例子中的Layout物件，透過指定線、網格和標題字型屬性以及刻度模式、值和字型來配置x和y軸。

layout = go.Layout(
   title = "Sine and cos",
   xaxis = dict(
      title = 'angle',
      showgrid = True,
      zeroline = True,
      showline = True,
      showticklabels = True,
      gridwidth = 1
   ),
   yaxis = dict(
      showgrid = True,
      zeroline = True,
      showline = True,
      gridcolor = '#bdbdbd',
      gridwidth = 2,
      zerolinecolor = '#969696',
      zerolinewidth = 2,
      linecolor = '#636363',
      linewidth = 2,
      title = 'VALUE',
      titlefont = dict(
         family = 'Arial, sans-serif',
         size = 18,
         color = 'lightgrey'
      ),
      showticklabels = True,
      tickangle = 45,
      tickfont = dict(
      family = 'Old Standard TT, serif',
      size = 14,
      color = 'black'
      ),
      tickmode = 'linear',
      tick0 = 0.0,
      dtick = 0.25
   )
)

具有多個座標軸的圖表

有時在一個圖形中使用雙x或y軸非常有用；例如，當繪製具有不同單位的曲線時。Matplotlib使用twinx和twiny函式支援此功能。在下面的示例中，該圖具有雙y軸，一個顯示exp(x)，另一個顯示log(x)

x = np.arange(1,11)
y1 = np.exp(x)
y2 = np.log(x)
trace1 = go.Scatter(
   x = x,
   y = y1,
   name = 'exp'
)
trace2 = go.Scatter(
   x = x,
   y = y2,
   name = 'log',
   yaxis = 'y2'
)
data = [trace1, trace2]
layout = go.Layout(
   title = 'Double Y Axis Example',
   yaxis = dict(
      title = 'exp',zeroline=True,
      showline = True
   ),
   yaxis2 = dict(
      title = 'log',
      zeroline = True,
      showline = True,
      overlaying = 'y',
      side = 'right'
   )
)
fig = go.Figure(data=data, layout=layout)
iplot(fig)

這裡，附加的y軸配置為yaxis2，出現在右側，標題為'log'。生成的圖表如下：

Plotly - 子圖和內嵌圖

在這裡，我們將瞭解Plotly中子圖和內嵌圖的概念。

製作子圖

有時並排比較資料的不同檢視很有幫助。這支援子圖的概念。它在plotly.tools模組中提供make_subplots()函式。該函式返回一個Figure物件。

以下語句在一行中建立兩個子圖。

fig = tools.make_subplots(rows = 1, cols = 2)

現在，我們可以將兩個不同的軌跡（上面示例中的exp和log軌跡）新增到圖形中。

fig.append_trace(trace1, 1, 1)
fig.append_trace(trace2, 1, 2)

圖形的佈局透過使用update()方法進一步配置，指定標題、寬度、高度等。

fig['layout'].update(height = 600, width = 800s, title = 'subplots')

這是完整的指令碼：

from plotly import tools
import plotly.plotly as py
import plotly.graph_objs as go
from plotly.offline import iplot, init_notebook_mode
init_notebook_mode(connected = True)
import numpy as np
x = np.arange(1,11)
y1 = np.exp(x)
y2 = np.log(x)
trace1 = go.Scatter(
   x = x,
   y = y1,
   name = 'exp'
)
trace2 = go.Scatter(
   x = x,
   y = y2,
   name = 'log'
)
fig = tools.make_subplots(rows = 1, cols = 2)
fig.append_trace(trace1, 1, 1)
fig.append_trace(trace2, 1, 2)
fig['layout'].update(height = 600, width = 800, title = 'subplot')
iplot(fig)

這是你的繪圖網格的格式：[ (1,1) x1,y1 ] [ (1,2) x2,y2 ]

內嵌圖

要將子圖顯示為內嵌圖，我們需要配置其軌跡物件。首先將內嵌軌跡的xaxis和yaxis屬性分別設定為'x2'和'y2'。以下語句將'log'軌跡放入內嵌圖中。

trace2 = go.Scatter(
   x = x,
   y = y2,
   xaxis = 'x2',
   yaxis = 'y2',
   name = 'log'
)

其次，配置Layout物件，其中內嵌圖的x軸和y軸的位置由domain屬性定義，該屬性指定其相對於主軸的位置。

xaxis2=dict(
   domain = [0.1, 0.5],
   anchor = 'y2'
),
yaxis2 = dict(
   domain = [0.5, 0.9],
   anchor = 'x2'
)

下面給出了顯示內嵌log軌跡和主軸exp軌跡的完整指令碼：

trace1 = go.Scatter(
   x = x,
   y = y1,
   name = 'exp'
)
trace2 = go.Scatter(
   x = x,
   y = y2,
   xaxis = 'x2',
   yaxis = 'y2',
   name = 'log'
)
data = [trace1, trace2]
layout = go.Layout(
   yaxis = dict(showline = True),
   xaxis2 = dict(
      domain = [0.1, 0.5],
      anchor = 'y2'
   ),
   yaxis2 = dict(
      showline = True,
      domain = [0.5, 0.9],
      anchor = 'x2'
   )
)
fig = go.Figure(data=data, layout=layout)
iplot(fig)

輸出如下所示：

Plotly - 條形圖和餅圖

在本章中，我們將學習如何藉助Plotly製作條形圖和餅圖。讓我們從瞭解條形圖開始。

條形圖

條形圖用矩形條表示分類資料，其高度或長度與它們所代表的值成比例。條形圖可以垂直或水平顯示。它有助於顯示離散類別之間的比較。圖表的其中一個軸顯示要比較的特定類別，另一個軸表示測得的值。

下面的例子繪製了一個簡單的條形圖，關於不同課程的學生人數。go.Bar()函式返回一個條形軌跡，其x座標設定為科目列表，y座標設定為學生人數。

import plotly.graph_objs as go
langs = ['C', 'C++', 'Java', 'Python', 'PHP']
students = [23,17,35,29,12]
data = [go.Bar(
   x = langs,
   y = students
)]
fig = go.Figure(data=data)
iplot(fig)

輸出將如下所示：

要顯示分組條形圖，Layout物件的barmode屬性必須設定為group。在下面的程式碼中，表示每一年學生人數的多個軌跡針對科目繪製，並顯示為分組條形圖。

branches = ['CSE', 'Mech', 'Electronics']
fy = [23,17,35]
sy = [20, 23, 30]
ty = [30,20,15]
trace1 = go.Bar(
   x = branches,
   y = fy,
   name = 'FY'
)
trace2 = go.Bar(
   x = branches,
   y = sy,
   name = 'SY'
)
trace3 = go.Bar(
   x = branches,
   y = ty,
   name = 'TY'
)
data = [trace1, trace2, trace3]
layout = go.Layout(barmode = 'group')
fig = go.Figure(data = data, layout = layout)
iplot(fig)

其輸出如下所示：

barmode屬性決定了圖上相同位置座標的條形圖如何顯示。定義的值為“stack”（條形圖一個疊加在一個上面），“relative”（條形圖一個疊加在一個上面，負值在軸下方，正值在軸上方），“group”（條形圖並排繪製）。

將barmode屬性更改為“stack”，繪製的圖形如下所示：

餅圖

餅圖只顯示一個數據系列。餅圖顯示一個數據系列中專案（稱為扇區）的大小，與專案的總和成比例。資料點顯示為整體餅圖的百分比。

graph_objs模組中的pie()函式 – go.Pie()，返回一個餅圖軌跡。兩個必需的引數是labels和values。讓我們繪製一個簡單的餅圖，顯示語言課程與學生人數，如以下示例所示。

import plotly
plotly.tools.set_credentials_file(
   username = 'lathkar', api_key = 'U7vgRe1hqmRp4ZNf4PTN'
)
from plotly.offline import iplot, init_notebook_mode
init_notebook_mode(connected = True)
import plotly.graph_objs as go
langs = ['C', 'C++', 'Java', 'Python', 'PHP']
students = [23,17,35,29,12]
trace = go.Pie(labels = langs, values = students)
data = [trace]
fig = go.Figure(data = data)
iplot(fig)

Jupyter notebook中顯示以下輸出：

環形圖是一箇中心有一個圓孔的餅圖，使其看起來像一個甜甜圈。在下面的示例中，兩個環形圖以1X2網格佈局顯示。“label”佈局對於兩個餅圖軌跡都是相同的，每個子圖的行和列目標由domain屬性決定。

為此，我們使用2019年議會選舉中按政黨劃分的席位和得票率資料。在Jupyter notebook單元格中輸入以下程式碼：

parties = ['BJP', 'CONGRESS', 'DMK', 'TMC', 'YSRC', 'SS', 'JDU','BJD', 'BSP','OTH']
seats = [303,52,23,22,22,18,16,12,10, 65]
percent = [37.36, 19.49, 2.26, 4.07, 2.53, 2.10, 1.46, 1.66, 3.63, 25.44]
import plotly.graph_objs as go
data1 = {
   "values": seats,
   "labels": parties,
   "domain": {"column": 0},
   "name": "seats",
   "hoverinfo":"label+percent+name",
   "hole": .4,
   "type": "pie"
}
data2 = {
   "values": percent,
   "labels": parties,
   "domain": {"column": 1},
   "name": "vote share",
   "hoverinfo":"label+percent+name",
   "hole": .4,
   "type": "pie"
}
data = [data1,data2]
layout = go.Layout(
   {
      "title":"Parliamentary Election 2019",
      "grid": {"rows": 1, "columns": 2},
      "annotations": [
         {
            "font": {
               "size": 20
            },
            "showarrow": False,
            "text": "seats",
            "x": 0.20,
            "y": 0.5
         },
         {
            "font": {
               "size": 20
            },
            "showarrow": False,
            "text": "votes",
            "x": 0.8,
            "y": 0.5
         }
      ]
   }
)
fig = go.Figure(data = data, layout = layout)
iplot(fig)

其輸出如下所示：

散點圖、Scattergl圖和氣泡圖

本章重點介紹散點圖、Scattergl圖和氣泡圖的細節。首先，讓我們學習散點圖。

散點圖

散點圖用於在水平軸和垂直軸上繪製資料點，以顯示一個變數如何影響另一個變數。資料表中的每一行都由一個標記表示，其位置取決於在X和Y軸上設定的列中的值。

graph_objs模組的scatter()方法(go.Scatter)生成一個散點軌跡。這裡，mode屬性決定資料點的外觀。mode的預設值為lines，顯示連線資料點的連續線。如果設定為markers，則只顯示由小實心圓表示的資料點。當mode賦值為'lines+markers'時，圓和線都會顯示。

在下面的例子中，繪製了笛卡爾座標系中三組隨機生成的點的散點軌跡。下面解釋了每個用不同mode屬性顯示的軌跡。

import numpy as np
N = 100
x_vals = np.linspace(0, 1, N)
y1 = np.random.randn(N) + 5
y2 = np.random.randn(N)
y3 = np.random.randn(N) - 5
trace0 = go.Scatter(
   x = x_vals,
   y = y1,
   mode = 'markers',
   name = 'markers'
)
trace1 = go.Scatter(
   x = x_vals,
   y = y2,
   mode = 'lines+markers',
   name = 'line+markers'
)
trace2 = go.Scatter(
   x = x_vals,
   y = y3,
   mode = 'lines',
   name = 'line'
)
data = [trace0, trace1, trace2]
fig = go.Figure(data = data)
iplot(fig)

Jupyter notebook單元格的輸出如下所示：

Scattergl圖

WebGL（Web圖形庫）是一個JavaScript API，用於在任何相容的Web瀏覽器中渲染互動式2D和3D圖形，無需使用外掛。WebGL與其他Web標準完全整合，允許使用圖形處理單元（GPU）加速影像處理。

在Plotly中，您可以使用Scattergl()代替Scatter()來實現WebGL，以提高速度、改進互動性和繪製更多資料的能力。go.scattergl()函式在涉及大量資料點時效能更好。

import numpy as np
N = 100000
x = np.random.randn(N)
y = np.random.randn(N)
   trace0 = go.Scattergl(
   x = x, y = y, mode = 'markers'
)
data = [trace0]
layout = go.Layout(title = "scattergl plot ")
fig = go.Figure(data = data, layout = layout)
iplot(fig)

輸出如下所示：

氣泡圖

氣泡圖顯示資料的三個維度。每個實體及其三個相關的維度資料都繪製為一個圓盤（氣泡），透過圓盤的xy位置表示其中的兩個維度，透過其大小表示第三個維度。氣泡的大小由第三個資料系列中的值決定。

氣泡圖是散點圖的一種變體，其中資料點被氣泡取代。如果你的資料有三個維度，如下所示，建立氣泡圖將是一個不錯的選擇。

氣泡圖是用go.Scatter()軌跡生成的。上面兩個資料系列作為x和y屬性給出。第三個維度由標記顯示，其大小表示第三個資料系列。在上述情況下，我們使用產品和銷量作為x和y屬性，使用市場份額作為標記大小。

在Jupyter notebook中輸入以下程式碼。

company = ['A','B','C']
products = [13,6,23]
sale = [2354,5423,4251]
share = [23,47,30]
fig = go.Figure(data = [go.Scatter(
   x = products, y = sale,
   text = [
      'company:'+c+' share:'+str(s)+'%' 
      for c in company for s in share if company.index(c)==share.index(s)
   ],
   mode = 'markers',
   marker_size = share, marker_color = ['blue','red','yellow'])
])
iplot(fig)

輸出將如下所示：

Plotly - 點圖和表格

在這裡，我們將學習Plotly中的點圖和表格函式。首先，讓我們從點圖開始。

點圖

點圖在一個非常簡單的尺度上顯示點。它只適用於少量資料，因為大量點會使其看起來非常雜亂。點圖也稱為Cleveland點圖。它們顯示兩個（或多個）點之間或兩個（或多個）條件之間的變化。

點圖類似於水平條形圖。但是，它們可能不太混亂，並且可以更容易地比較條件。該圖繪製了一個mode屬性設定為markers的散點軌跡。

下面的例子顯示了印度獨立後每次人口普查中記錄的男性和女性識字率的比較。圖表中的兩條軌跡分別代表1951年到2011年每次人口普查中男性和女性的識字率。

from plotly.offline import iplot, init_notebook_mode
init_notebook_mode(connected = True)
census = [1951,1961,1971,1981,1991,2001, 2011]
x1 = [8.86, 15.35, 21.97, 29.76, 39.29, 53.67, 64.63]
x2 = [27.15, 40.40, 45.96, 56.38,64.13, 75.26, 80.88]
traceA = go.Scatter(
   x = x1,
   y = census,
   marker = dict(color = "crimson", size = 12),
   mode = "markers",
   name = "Women"
)
traceB = go.Scatter(
x = x2,
y = census,
marker = dict(color = "gold", size = 12),
mode = "markers",
name = "Men")
data = [traceA, traceB]
layout = go.Layout(
   title = "Trend in Literacy rate in Post independent India",
   xaxis_title = "percentage",
   yaxis_title = "census"
)
fig = go.Figure(data = data, layout = layout)
iplot(fig)

輸出將如下所示：

Plotly中的表格

Plotly的Table物件由go.Table()函式返回。Table軌跡是一個圖形物件，用於在一個行和列網格中檢視詳細資訊。Table使用列主序，即網格表示為列向量的向量。

go.Table()函式的兩個重要引數是header，它是表的首行，以及cells，它構成其餘的行。這兩個引數都是字典物件。headers的values屬性是列標題列表，以及列表的列表，每個列表對應一行。

進一步的樣式定製透過linecolor、fill_color、font和其他屬性完成。

下面的程式碼顯示了最近結束的2019年板球世界盃迴圈賽階段的積分榜。

trace = go.Table(
   header = dict(
      values = ['Teams','Mat','Won','Lost','Tied','NR','Pts','NRR'],
      line_color = 'gray',
      fill_color = 'lightskyblue',
      align = 'left'
   ),
   cells = dict(
      values = 
      [
         [
            'India',
            'Australia',
            'England',
            'New Zealand',
            'Pakistan',
            'Sri Lanka',
            'South Africa',
            'Bangladesh',
            'West Indies',
            'Afghanistan'
         ],
         [9,9,9,9,9,9,9,9,9,9],
         [7,7,6,5,5,3,3,3,2,0],
         [1,2,3,3,3,4,5,5,6,9],
         [0,0,0,0,0,0,0,0,0,0],
         [1,0,0,1,1,2,1,1,1,0],
         [15,14,12,11,11,8,7,7,5,0],
         [0.809,0.868,1.152,0.175,-0.43,-0.919,-0.03,-0.41,-0.225,-1.322]
      ],
      line_color='gray',
      fill_color='lightcyan',
      align='left'
   )
)
data = [trace]
fig = go.Figure(data = data)
iplot(fig)

輸出如下所示：

表格資料也可以從 Pandas 資料框填充。讓我們建立一個逗號分隔的檔案（points-table.csv）如下所示：

Teams,Matches,Won,Lost,Tie,NR,Points,NRR
India,9,7,1,0,1,15,0.809
Australia,9,7,2,0,0,14,0.868
England,9,6,3,0,0,12,1.152
New Zealand,9,5,3,0,1,11,0.175
Pakistan,9,5,3,0,1,11,-0.43
Sri Lanka,9,3,4,0,2,8,-0.919
South Africa,9,3,5,0,1,7,-0.03
Bangladesh,9,3,5,0,1,7,-0.41
West Indies,9,2,6,0,1,5,-0.225
Afghanistan,9,0,9,0,0,0,-1.322

我們現在從這個 csv 檔案構建一個數據框物件，並用它來構建表格軌跡，如下所示：

import pandas as pd
df = pd.read_csv('point-table.csv')
trace = go.Table(
   header = dict(values = list(df.columns)),
   cells = dict(
      values = [
         df.Teams, 
         df.Matches, 
         df.Won, 
         df.Lost, 
         df.Tie, 
         df.NR, 
         df.Points, 
         df.NRR
      ]
   )
)
data = [trace]
fig = go.Figure(data = data)
iplot(fig)

Plotly - 直方圖

直方圖由卡爾·皮爾遜引入，它是數值資料分佈的精確表示，是對連續變數機率分佈的估計（CORAL）。它看起來類似於條形圖，但是，條形圖關聯兩個變數，而直方圖只關聯一個變數。

直方圖需要箱（或桶），它將整個值範圍劃分為一系列區間——然後計算有多少值落入每個區間。箱通常指定為變數的連續、不重疊的區間。箱必須相鄰，並且通常大小相等。在箱上豎起一個矩形，其高度與頻率成比例——每個箱中的案例數量。

直方圖軌跡物件由go.Histogram()函式返回。它的自定義是透過各種引數或屬性完成的。一個重要的引數是 x 或 y 設定為列表、numpy 陣列或Pandas 資料框物件，這些物件將在箱中分佈。

預設情況下，Plotly 將資料點分佈在自動大小的箱中。但是，您可以定義自定義箱大小。為此，您需要將 autobins 設定為 false，指定nbins（箱數）、其起始和結束值以及大小。

以下程式碼生成一個簡單的直方圖，顯示班級中學生分數的分佈情況（大小自動調整）：

import numpy as np
x1 = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
data = [go.Histogram(x = x1)]
fig = go.Figure(data)
iplot(fig)

輸出如下所示：

go.Histogram()函式接受histnorm，它指定此直方圖軌跡使用的歸一化型別。預設為""，每個條的跨度對應於出現的次數（即位於箱內的資料點的數量）。如果賦值為"percent" / "probability"，則每個條的跨度對應於相對於樣本點總數的出現百分比/分數。如果它等於"density"，則每個條的跨度對應於箱中出現的次數除以箱區間的尺寸。

還有一個histfunc引數，其預設值為count。結果，箱上矩形的高度對應於資料點的數量。它可以設定為 sum、avg、min 或 max。

histogram()函式可以設定為顯示連續箱中值的累積分佈。為此，您需要將cumulative 屬性設定為啟用。結果如下所示：

data=[go.Histogram(x = x1, cumulative_enabled = True)]
fig = go.Figure(data)
iplot(fig)

輸出如下所示：

Plotly - 箱線圖、小提琴圖和等高線圖

本章重點介紹各種圖表的詳細理解，包括箱線圖、小提琴圖、等高線圖和矢羽圖。首先，我們將從箱線圖開始。

箱線圖

箱線圖顯示一組資料的摘要，其中包含最小值、第一四分位數、中位數、第三四分位數和最大值。在箱線圖中，我們從第一四分位數到第三四分位數繪製一個箱子。一條垂直線穿過箱子的中位數。從箱子垂直延伸的線表示上四分位數和下四分位數之外的變異性，稱為須線。因此，箱線圖也稱為箱須圖。須線從每個四分位數延伸到最小值或最大值。

要繪製箱線圖，我們必須使用go.Box()函式。資料序列可以分配給 x 或 y 引數。相應地，箱線圖將水平或垂直繪製。在下面的示例中，某公司各個分支機構的銷售額被轉換為水平箱線圖。它顯示了最小值和最大值的中位數。

trace1 = go.Box(y = [1140,1460,489,594,502,508,370,200])
data = [trace1]
fig = go.Figure(data)
iplot(fig)

其輸出如下所示：

go.Box()函式可以給出各種其他引數來控制箱線圖的外觀和行為。其中之一是 boxmean 引數。

boxmean引數預設為 true。結果，箱子底層分佈的平均值作為虛線繪製在箱子內。如果將其設定為 sd，則還會繪製分佈的標準差。

boxpoints引數預設為"outliers"。只有位於須線之外的樣本點才會顯示。如果為"suspectedoutliers"，則會顯示異常值點，並且小於 4"Q1-3"Q3 或大於 4"Q3-3"Q1 的點會被高亮顯示。如果為"False"，則只顯示箱子，不顯示樣本點。

在下面的示例中，箱線圖軌跡以標準差和異常值點繪製。

trc = go.Box(
   y = [
      0.75, 5.25, 5.5, 6, 6.2, 6.6, 6.80, 7.0, 7.2, 7.5, 7.5, 7.75, 8.15,
      8.15, 8.65, 8.93, 9.2, 9.5, 10, 10.25, 11.5, 12, 16, 20.90, 22.3, 23.25
   ],
   boxpoints = 'suspectedoutliers', boxmean = 'sd'
)
data = [trc]
fig = go.Figure(data)
iplot(fig)

其輸出如下所示：

小提琴圖

小提琴圖類似於箱線圖，不同之處在於它們還顯示了不同值處資料的機率密度。小提琴圖將包括資料中位數的標記和指示四分位數範圍的框，如同標準箱線圖一樣。疊加在這個箱線圖上的是核密度估計。與箱線圖一樣，小提琴圖用於表示不同“類別”中變數分佈（或樣本分佈）的比較。

小提琴圖比簡單的箱線圖提供更多資訊。事實上，箱線圖只顯示平均值/中位數和四分位數範圍等彙總統計資訊，而小提琴圖則顯示資料的完整分佈。

小提琴圖軌跡物件由graph_objects模組中的go.Violin()函式返回。為了顯示底層的箱線圖，boxplot_visible屬性設定為 True。同樣，透過將meanline_visible屬性設定為 true，樣本均值對應的線將顯示在小提琴圖內。

下面的示例演示瞭如何使用 Plotly 的功能顯示小提琴圖。

import numpy as np
np.random.seed(10)
c1 = np.random.normal(100, 10, 200)
c2 = np.random.normal(80, 30, 200)
trace1 = go.Violin(y = c1, meanline_visible = True)
trace2 = go.Violin(y = c2, box_visible = True)
data = [trace1, trace2]
fig = go.Figure(data = data)
iplot(fig)

輸出如下所示：

等高線圖

二維等高線圖顯示二維數值陣列 z 的等高線，即 z 的等值線的插值線。函式的等高線是函式具有恆定值的曲線，因此曲線連線具有相等值的點。

如果您想檢視某個值 Z 如何隨兩個輸入X和Y的變化而變化，則等高線圖是合適的，使得Z = f(X,Y)。函式的等高線或等值線是函式具有恆定值的曲線。

自變數 x 和 y 通常限制在稱為網格的規則網格中。numpy.meshgrid 從 x 值陣列和 y 值陣列建立矩形網格。

讓我們首先使用 Numpy 庫中的linspace()函式建立 x、y 和 z 的資料值。我們從 x 和 y 值建立網格，並獲得由x2+y2的平方根組成的 z 陣列。

我們在graph_objects模組中具有go.Contour()函式，它接受 x、y和z屬性。以下程式碼片段顯示上面計算的 x、y和z值的等高線圖。

import numpy as np
xlist = np.linspace(-3.0, 3.0, 100)
ylist = np.linspace(-3.0, 3.0, 100)
X, Y = np.meshgrid(xlist, ylist)
Z = np.sqrt(X**2 + Y**2)
trace = go.Contour(x = xlist, y = ylist, z = Z)
data = [trace]
fig = go.Figure(data)
iplot(fig)

輸出如下所示：

等高線圖可以透過一個或多個以下引數進行自定義：

• Transpose (布林值) - 轉置 z 資料。

如果xtype（或ytype）等於"array"，則 x/y 座標由"x"/"y"給出。如果為"scaled"，則 x 座標由"x0"和"dx"給出。

• connectgaps引數決定是否填充 z 資料中的間隙。

• ncontours引數的預設值為 15。實際的輪廓數量將自動選擇為小於或等於`ncontours`的值。只有當`autocontour`為"True"時才有效。

輪廓型別預設為："levels"，因此資料表示為具有多個級別顯示的等高線圖。如果為constrain，則資料表示為約束，無效區域的陰影由operation和value引數指定。

showlines - 決定是否繪製等高線。

zauto預設為True，並決定顏色域是根據輸入資料（此處為`z`）計算還是根據`zmin`和`zmax`中設定的邊界計算。當用戶設定`zmin`和`zmax`時，預設為`False`。

矢羽圖

矢羽圖也稱為速度圖。它將速度向量顯示為具有在 (x,y) 點處的分量 (u,v) 的箭頭。為了繪製矢羽圖，我們將使用 Plotly 中figure_factory模組中定義的create_quiver()函式。

Plotly 的 Python API 包含一個 figure factory 模組，其中包含許多包裝函式，這些函式建立 Plotly 的開源繪相簿plotly.js中尚未包含的獨特圖表型別。

create_quiver() 函式接受以下引數：

• x - 箭頭的 x 座標

• y - 箭頭的 y 座標

• u - 箭頭向量的 x 分量

• v - 箭頭向量的 y 分量

• scale - 縮放箭頭的尺寸

• arrow_scale - 箭頭頭的長度。

• angle - 箭頭頭的角度。

以下程式碼在 Jupyter Notebook 中呈現一個簡單的矢羽圖：

import plotly.figure_factory as ff
import numpy as np
x,y = np.meshgrid(np.arange(-2, 2, .2), np.arange(-2, 2, .25))
z = x*np.exp(-x**2 - y**2)
v, u = np.gradient(z, .2, .2)

# Create quiver figure
fig = ff.create_quiver(x, y, u, v,
scale = .25, arrow_scale = .4,
name = 'quiver', line = dict(width = 1))
iplot(fig)

程式碼輸出如下所示：

Plotly - distplot、密度圖和誤差條形圖

在本章中，我們將詳細瞭解 distplot、密度圖和誤差條形圖。讓我們從學習 distplot 開始。

Distplot

distplot 圖表工廠顯示數值資料的統計表示組合，例如直方圖、核密度估計或正態曲線以及地毯圖。

distplot 可以由以下 3 個元件中的全部或任何組合組成：

• 直方圖
• 曲線：（a）核密度估計或（b）正態曲線，以及
• 地毯圖

figure_factory模組具有create_distplot()函式，它需要一個名為 hist_data 的必填引數。

以下程式碼建立一個由直方圖、kde 圖和地毯圖組成的基本 distplot。

x = np.random.randn(1000)
hist_data = [x]
group_labels = ['distplot']
fig = ff.create_distplot(hist_data, group_labels)
iplot(fig)

上述程式碼的輸出如下所示：

密度圖

密度圖是根據資料估計的直方圖的平滑連續版本。最常見的估計形式稱為核密度估計 (KDE)。在這種方法中，在每個單個數據點處繪製一條連續曲線（核），然後將所有這些曲線加在一起以構成單個平滑的密度估計。

plotly.figure_factory._2d_density模組中的create_2d_density()函式返回二維密度圖的圖形物件。

以下程式碼用於根據直方圖資料生成二維密度圖。

t = np.linspace(-1, 1.2, 2000)
x = (t**3) + (0.3 * np.random.randn(2000))
y = (t**6) + (0.3 * np.random.randn(2000))
fig = ff.create_2d_density( x, y)
iplot(fig)

以下是上述程式碼的輸出結果。

誤差條形圖

誤差條是資料誤差或不確定性的圖形表示，有助於正確解釋資料。出於科學目的，報告誤差對於理解給定資料至關重要。

誤差條對問題解決者很有用，因為誤差條顯示了一組測量值或計算值的置信度或精度。

誤差條通常表示資料集的範圍和標準差。它們可以幫助視覺化資料如何圍繞平均值分佈。誤差條可以在各種圖表上生成，例如條形圖、線形圖、散點圖等。

go.Scatter() 函式具有error_x 和error_y 屬性，用於控制誤差條的生成方式。

• visible (布林值) − 確定這組誤差條是否可見。

Type 屬性的可能值為“percent” | “constant” | “sqrt” | “data”。它設定用於生成誤差條的規則。如果為“percent”，則條形長度對應於基礎資料的百分比。在`value`中設定此百分比。如果為“sqrt”，則條形長度對應於基礎資料的平方。如果為“data”，則條形長度由資料集`array`設定。

• symmetric 屬性可以為 true 或 false。相應地，誤差條的長度在兩個方向上是否相同（垂直條形為頂部/底部，水平條形為左側/右側）。

• array − 設定與每個誤差條長度相對應的資料。值相對於基礎資料繪製。

• arrayminus − 設定與垂直（水平）條形底部（左側）方向上每個誤差條長度相對應的資料。值相對於基礎資料繪製。

以下程式碼顯示散點圖上的對稱誤差條：

trace = go.Scatter(
   x = [0, 1, 2], y = [6, 10, 2],
   error_y = dict(
   type = 'data', # value of error bar given in data coordinates
   array = [1, 2, 3], visible = True)
)
data = [trace]
layout = go.Layout(title = 'Symmetric Error Bar')
fig = go.Figure(data = data, layout = layout)
iplot(fig)

以下是上述程式碼的輸出結果。

非對稱誤差圖由以下指令碼呈現：

trace = go.Scatter(
   x = [1, 2, 3, 4], 
   y =[ 2, 1, 3, 4],
   error_y = dict(
      type = 'data',
      symmetric = False,
      array = [0.1, 0.2, 0.1, 0.1], 
      arrayminus = [0.2, 0.4, 1, 0.2]
   )
)
data = [trace]
layout = go.Layout(title = 'Asymmetric Error Bar')
fig = go.Figure(data = data, layout = layout)
iplot(fig)

其輸出結果如下所示：

Plotly - 熱力圖

熱力圖（或熱圖）是一種資料的圖形表示，其中矩陣中包含的各個值表示為顏色。熱力圖的主要目的是更好地視覺化資料集中位置/事件的數量，並幫助檢視者關注資料視覺化中最重要的地方。

由於熱力圖依賴於顏色來傳達數值，因此它們最常用於顯示數值的更概括檢視。熱力圖在引起人們對趨勢的注意方面非常通用和有效，正是由於這些原因，它們在分析領域越來越受歡迎。

熱力圖天生具有自解釋性。陰影越深，數量越大（值越高，分散性越緊密等）。Plotly 的 graph_objects 模組包含Heatmap() 函式。它需要 x、y 和z 屬性。它們的值可以是列表、NumPy 陣列或 Pandas 資料框。

在以下示例中，我們有一個二維列表或陣列，它定義了要顏色編碼的資料（不同農民的年產量，單位：噸）。然後，我們還需要兩個列表，分別列出農民的姓名和他們種植的蔬菜。

vegetables = [
   "cucumber", 
   "tomato", 
   "lettuce", 
   "asparagus",
   "potato", 
   "wheat", 
   "barley"
]
farmers = [
   "Farmer Joe", 
   "Upland Bros.", 
   "Smith Gardening",
   "Agrifun", 
   "Organiculture", 
   "BioGoods Ltd.", 
   "Cornylee Corp."
]
harvest = np.array(
   [
      [0.8, 2.4, 2.5, 3.9, 0.0, 4.0, 0.0],
      [2.4, 0.0, 4.0, 1.0, 2.7, 0.0, 0.0],
      [1.1, 2.4, 0.8, 4.3, 1.9, 4.4, 0.0],
      [0.6, 0.0, 0.3, 0.0, 3.1, 0.0, 0.0],
      [0.7, 1.7, 0.6, 2.6, 2.2, 6.2, 0.0],
      [1.3, 1.2, 0.0, 0.0, 0.0, 3.2, 5.1],
      [0.1, 2.0, 0.0, 1.4, 0.0, 1.9, 6.3]
   ]
)
trace = go.Heatmap(
   x = vegetables,
   y = farmers,
   z = harvest,
   type = 'heatmap',
   colorscale = 'Viridis'
)
data = [trace]
fig = go.Figure(data = data)
iplot(fig)

上述程式碼的輸出結果如下所示：

Plotly - 極座標圖和雷達圖

本章將學習如何使用 Plotly 繪製極座標圖和雷達圖。

首先，讓我們學習極座標圖。

極座標圖

極座標圖是圓形圖的常見變體。當資料點之間的關係最容易用半徑和角度表示時，它非常有用。

在極座標圖中，一個序列由連線極座標系中點的閉合曲線表示。每個資料點由到極點的距離（徑向座標）和從固定方向的角度（角度座標）確定。

極座標圖沿著徑向和角度軸表示資料。徑向和角度座標由go.Scatterpolar() 函式的r 和theta 引數給出。theta 資料可以是分類的，但數值資料也是可能的，並且是最常用的。

以下程式碼生成一個基本的極座標圖。除了 r 和 theta 引數外，我們還將 mode 設定為lines（它也可以設定為 markers，在這種情況下，只會顯示資料點）。

import numpy as np
r1 = [0,6,12,18,24,30,36,42,48,54,60]
t1 = [1,0.995,0.978,0.951,0.914,0.866,0.809,0.743,0.669,0.588,0.5]
trace = go.Scatterpolar(
   r = [0.5,1,2,2.5,3,4],
   theta = [35,70,120,155,205,240],
   mode = 'lines',
)
data = [trace]
fig = go.Figure(data = data)
iplot(fig)

輸出結果如下所示：

在以下示例中，使用逗號分隔值 (CSV) 檔案中的資料生成極座標圖。polar.csv 的前幾行如下所示：

y,x1,x2,x3,x4,x5,
0,1,1,1,1,1,
6,0.995,0.997,0.996,0.998,0.997,
12,0.978,0.989,0.984,0.993,0.986,
18,0.951,0.976,0.963,0.985,0.969,
24,0.914,0.957,0.935,0.974,0.946,
30,0.866,0.933,0.9,0.96,0.916,
36,0.809,0.905,0.857,0.943,0.88,
42,0.743,0.872,0.807,0.923,0.838,
48,0.669,0.835,0.752,0.901,0.792,
54,0.588,0.794,0.691,0.876,0.74,
60,0.5,0.75,0.625,0.85,0.685,

在筆記本的輸入單元格中輸入以下指令碼以生成如下所示的極座標圖：

import pandas as pd
df = pd.read_csv("polar.csv")
t1 = go.Scatterpolar(
   r = df['x1'], theta = df['y'], mode = 'lines', name = 't1'
)
t2 = go.Scatterpolar(
   r = df['x2'], theta = df['y'], mode = 'lines', name = 't2'
)
t3 = go.Scatterpolar(
   r = df['x3'], theta = df['y'], mode = 'lines', name = 't3'
)
data = [t1,t2,t3]
fig = go.Figure(data = data)
iplot(fig)

以下是上述程式碼的輸出結果：

雷達圖

雷達圖（也稱為蜘蛛圖或星形圖）以二維圖的形式顯示多變數資料，定量變數以從中心發出的軸表示。軸的相對位置和角度通常沒有資訊量。

對於雷達圖，通常情況下，在go.Scatterpolar() 函式中使用具有分類角度變數的極座標圖。

以下程式碼使用Scatterpolar() 函式呈現一個基本的雷達圖：

radar = go.Scatterpolar(
   r = [1, 5, 2, 2, 3],
   theta = [
      'processing cost',
      'mechanical properties',
      'chemical stability', 
      'thermal stability',
      'device integration'
   ],
   fill = 'toself'
)
data = [radar]
fig = go.Figure(data = data)
iplot(fig)

以下是上述程式碼的輸出結果：

OHLC 圖、瀑布圖和漏斗圖

本章重點介紹其他三種類型的圖表，包括 OHLC 圖、瀑布圖和漏斗圖，這些圖表都可以使用 Plotly 繪製。

OHLC 圖

開盤價-最高價-最低價-收盤價圖表（也稱為 OHLC 圖）是一種條形圖，通常用於說明金融工具（如股票）價格的變動。OHLC 圖表很有用，因為它們顯示了一段時間內的四個主要資料點。這種圖表型別很有用，因為它可以顯示上升或下降的動量。最高價和最低價資料點有助於評估波動性。

圖表上的每條垂直線顯示一段時間內（例如一天或一小時）的價格範圍（最高價和最低價）。刻度線從線的每一側延伸，指示左側的開盤價（例如，對於每日條形圖，這將是當天的起始價格），以及該時間段右側的收盤價。

以下是 OHLC 圖表演示的示例資料。它具有與相應日期字串對應的最高價、最低價、開盤價和收盤價的列表物件。使用 datetime 模組中的strtp() 函式將字串的日期表示轉換為日期物件。

open_data = [33.0, 33.3, 33.5, 33.0, 34.1]
high_data = [33.1, 33.3, 33.6, 33.2, 34.8]
low_data = [32.7, 32.7, 32.8, 32.6, 32.8]
close_data = [33.0, 32.9, 33.3, 33.1, 33.1]
date_data = ['10-10-2013', '11-10-2013', '12-10-2013','01-10-2014','02-10-2014']
import datetime
dates = [
   datetime.datetime.strptime(date_str, '%m-%d-%Y').date() 
   for date_str in date_data
]

我們必須將上述日期物件用作 x 引數，並將其他引數用於go.Ohlc() 函式所需的開盤價、最高價、最低價和收盤價引數，該函式返回 OHLC 軌跡。

trace = go.Ohlc(
   x = dates, 
   open = open_data, 
   high = high_data,
   low = low_data, 
   close = close_data
)
data = [trace]
fig = go.Figure(data = data)
iplot(fig)

程式碼的輸出結果如下所示：

K 線圖

K 線圖類似於 OHLC 圖。它就像線形圖和條形圖的組合。方框表示開盤價和收盤價之間的價差，線條表示最低價和最高價之間的價差。收盤價高於（低於）開盤價的樣本點稱為上漲（下跌）。

go.Candlestick() 函式返回 K 線軌跡。我們使用相同的資料（與 OHLC 圖表相同）來呈現如下所示的 K 線圖：

trace = go.Candlestick(
   x = dates, 
   open = open_data, 
   high = high_data,
   low = low_data, 
   close = close_data
)

以下是上述程式碼的輸出結果：

瀑布圖

瀑布圖（也稱為飛磚圖或馬里奧圖）有助於理解按順序引入的正值或負值的累積效應，這些值可以基於時間或類別。

初始值和最終值顯示為列，各個負調整和正調整顯示為浮動步驟。一些瀑布圖連線列之間的線條，使圖表看起來像一座橋。

go.Waterfall() 函式返回一個瀑布軌跡。此物件可以透過各種命名引數或屬性進行自定義。在這裡，x 和 y 屬性設定圖的 x 和 y 座標的資料。兩者都可以是 Python 列表、NumPy 陣列或 Pandas 系列，也可以是字串或日期時間物件。

另一個屬性是measure，它是一個包含值型別的陣列。預設情況下，這些值被認為是relative。將其設定為 'total' 以計算總和。如果它等於absolute，則它會重置計算的總和或宣告所需的值。'base' 屬性設定條形底部的繪製位置（以位置軸單位表示）。

以下程式碼呈現一個瀑布圖：

s1=[
   "Sales", 
   "Consulting", 
   "Net revenue", 
   "Purchases", 
   "Other expenses", 
   "Profit before tax"
]
s2 = [60, 80, 0, -40, -20, 0]
trace = go.Waterfall(
   x = s1,
   y = s2,
   base = 200,
   measure = [
      "relative", 
      "relative", 
      "total", 
      "relative", 
      "relative", 
      "total"
   ]
)
data = [trace]
fig = go.Figure(data = data)
iplot(fig)

以下是上述程式碼的輸出結果。

漏斗圖

漏斗圖表示業務流程不同階段的資料。它是商業智慧中識別流程潛在問題區域的重要機制。漏斗圖用於視覺化資料在從一個階段到另一個階段的過程中如何逐漸減少。這些階段中的每個階段的資料都表示為 100%（整體）的不同部分。

與餅圖一樣，漏斗圖也不使用任何軸。它也可以視為類似於堆疊百分比條形圖。任何漏斗都由稱為頭部（或底部）的上部和稱為頸部的下部組成。漏斗圖最常見的用途是視覺化銷售轉化資料。

Plotly 的go.Funnel() 函式生成漏斗軌跡。要為此函式提供的基本屬性是 x 和y。它們中的每一個都被分配一個 Python 專案列表或陣列。

from plotly import graph_objects as go
fig = go.Figure(
   go.Funnel(
      y = [
         "Website visit", 
         "Downloads", 
         "Potential customers", 
         "Requested price", 
         "invoice sent"
      ],
      x = [39, 27.4, 20.6, 11, 2]
   )
)
fig.show()

輸出結果如下所示：

Plotly - 三維散點圖和曲面圖

本章將介紹三維 (3D) 散點圖和三維曲面圖以及如何使用 Plotly 繪製它們。

三維散點圖

三維 (3D) 散點圖類似於散點圖，但具有三個變數 - x、y 和 z 或 f(x, y) 都是實數。該圖可以表示為三維笛卡爾座標系中的點。它通常使用透視方法（等距或透視）繪製在二維頁面或螢幕上，以便其中一個維度看起來是從頁面中出來的。

三維散點圖用於在三個軸上繪製資料點，試圖顯示三個變數之間的關係。資料表中的每一行都由一個標記表示，其位置取決於在X、Y 和 Z 軸上設定的列中的值。

第四個變數可以設定為對應於標記的顏色或大小，從而為圖表新增另一個維度。不同變數之間的關係稱為相關性。

Scatter3D 軌跡是由 go.Scatter3D() 函式返回的圖形物件。此函式的必填引數是 x、y 和 z，它們都是列表或陣列物件。

例如：

import plotly.graph_objs as go
import numpy as np
z = np.linspace(0, 10, 50)
x = np.cos(z)
y = np.sin(z)
trace = go.Scatter3d(
   x = x, y = y, z = z,mode = 'markers', marker = dict(
      size = 12,
      color = z, # set color to an array/list of desired values
      colorscale = 'Viridis'
      )
   )
layout = go.Layout(title = '3D Scatter plot')
fig = go.Figure(data = [trace], layout = layout)
iplot(fig)

程式碼的輸出結果如下所示：

三維曲面圖

曲面圖是三維資料的圖表。在曲面圖中，每個點由三個座標點定義：它的緯度、經度和高度（X、Y和Z）。曲面圖不顯示單個數據點，而是顯示指定的因變數 (Y)與兩個自變數 (X 和 Z) 之間的函式關係。此圖是等高線圖的補充圖。

這是一個 Python 指令碼，用於渲染簡單的曲面圖，其中y 陣列是 x 的轉置，z 計算為 cos(x²+y²)

import numpy as np
x = np.outer(np.linspace(-2, 2, 30), np.ones(30))
y = x.copy().T # transpose
z = np.cos(x ** 2 + y ** 2)
trace = go.Surface(x = x, y = y, z =z )
data = [trace]
layout = go.Layout(title = '3D Surface plot')
fig = go.Figure(data = data)
iplot(fig)

以下是上面程式碼的輸出結果：

Plotly - 新增按鈕下拉選單

Plotly 透過在繪圖區域使用不同的控制元件（例如按鈕、下拉選單和滑塊等）提供了高度的互動性。這些控制元件與繪圖佈局的updatemenu屬性結合使用。您可以透過指定要呼叫的方法來新增按鈕及其行為。

可以與按鈕關聯的四種可能的方法如下：

• restyle − 修改資料或資料屬性

• relayout − 修改佈局屬性

• update − 修改資料和佈局屬性

• animate − 啟動或暫停動畫

當修改圖形的資料和資料屬性時，應使用restyle方法。在以下示例中，透過Updatemenu()方法向佈局添加了兩個帶有restyle方法的按鈕。

go.layout.Updatemenu(
type = "buttons",
direction = "left",
buttons = list([
   dict(args = ["type", "box"], label = "Box", method = "restyle"),
   dict(args = ["type", "violin"], label = "Violin", method = "restyle" )]
))

type屬性的值預設為buttons。要渲染按鈕的下拉列表，請將 type 更改為dropdown。在更新其佈局之前，將箱線圖跡新增到 Figure 物件中。渲染箱線圖和小提琴圖（取決於單擊的按鈕）的完整程式碼如下：

import plotly.graph_objs as go
fig = go.Figure()
fig.add_trace(go.Box(y = [1140,1460,489,594,502,508,370,200]))
fig.layout.update(
   updatemenus = [
      go.layout.Updatemenu(
         type = "buttons", direction = "left", buttons=list(
            [
               dict(args = ["type", "box"], label = "Box", method = "restyle"),
               dict(args = ["type", "violin"], label = "Violin", method = "restyle")
            ]
         ),
         pad = {"r": 2, "t": 2},
         showactive = True,
         x = 0.11,
         xanchor = "left",
         y = 1.1,
         yanchor = "top"
      ), 
   ]
)
iplot(fig)

程式碼的輸出結果如下所示：

單擊小提琴圖按鈕以顯示相應小提琴圖。

如上所述，Updatemenu()方法中type鍵的值被賦值為dropdown以顯示按鈕的下拉列表。圖如下所示：

當修改圖形的資料和佈局部分時，應使用update方法。以下示例演示如何更新和顯示哪些軌跡，同時更新佈局屬性，例如圖表標題。將對應於正弦波和餘弦波的兩個散點跡新增到Figure 物件中。可見屬性為True的跡將顯示在圖上，其他跡將被隱藏。

import numpy as np
import math #needed for definition of pi

xpoints = np.arange(0, math.pi*2, 0.05)
y1 = np.sin(xpoints)
y2 = np.cos(xpoints)
fig = go.Figure()
# Add Traces
fig.add_trace(
   go.Scatter(
      x = xpoints, y = y1, name = 'Sine'
   )
)
fig.add_trace(
   go.Scatter(
      x = xpoints, y = y2, name = 'cos'
   )
)
fig.layout.update(
   updatemenus = [
      go.layout.Updatemenu(
         type = "buttons", direction = "right", active = 0, x = 0.1, y = 1.2,
         buttons = list(
            [
               dict(
                  label = "first", method = "update",
                  args = [{"visible": [True, False]},{"title": "Sine"} ]
               ),
               dict(
                  label = "second", method = "update", 
                  args = [{"visible": [False, True]},{"title": Cos"}]
               )
            ]
         )
      )
   ]
)
iplot(fig)

最初，將顯示正弦曲線。如果單擊第二個按鈕，則會顯示餘弦跡。

請注意，圖表標題也會相應更新。

為了使用animate方法，我們需要向Figure物件新增一個或多個幀。除了資料和佈局外，幀還可以作為 Figure 物件中的鍵新增。frames 鍵指向一系列圖形，在觸發動畫時將迴圈遍歷每個圖形。

您可以新增播放和暫停按鈕，透過向佈局新增updatemenus 陣列來在圖表中引入動畫。

"updatemenus": [{
   "type": "buttons", "buttons": [{
      "label": "Your Label", "method": "animate", "args": [frames]
   }]
}]

在以下示例中，首先繪製散點曲線跡。然後新增frames，這是一個包含50 個 Frame 物件的列表，每個物件在曲線上表示一個紅色標記。請注意，由於按鈕的args屬性設定為 None，因此所有幀都會被動畫化。

import numpy as np
t = np.linspace(-1, 1, 100)
x = t + t ** 2
y = t - t ** 2
xm = np.min(x) - 1.5
xM = np.max(x) + 1.5
ym = np.min(y) - 1.5
yM = np.max(y) + 1.5
N = 50
s = np.linspace(-1, 1, N)
#s = np.arange(0, math.pi*2, 0.1)
xx = s + s ** 2
yy = s - s ** 2
fig = go.Figure(
   data = [
      go.Scatter(x = x, y = y, mode = "lines", line = dict(width = 2, color = "blue")),
      go.Scatter(x = x, y = y, mode = "lines", line = dict(width = 2, color = "blue"))
   ],
   layout = go.Layout(
      xaxis=dict(range=[xm, xM], autorange=False, zeroline=False),
      yaxis=dict(range=[ym, yM], autorange=False, zeroline=False),
      title_text="Moving marker on curve",
      updatemenus=[
         dict(type="buttons", buttons=[dict(label="Play", method="animate", args=[None])])
      ]
   ),
   frames = [go.Frame(
      data = [
            go.Scatter(
            x = [xx[k]], y = [yy[k]], mode = "markers", marker = dict(
               color = "red", size = 10
            )
         )
      ]
   )
   for k in range(N)]
)
iplot(fig)

程式碼的輸出如下：

單擊播放按鈕，紅色標記將開始沿曲線移動。

Plotly - 滑塊控制元件

Plotly 有一個方便的滑塊，可以透過滑動位於渲染圖底部控制元件上的旋鈕來更改圖的資料/樣式檢視。

滑塊控制元件由不同的屬性組成，如下所示：

• steps 屬性是定義旋鈕在控制元件上的滑動位置所必需的。

• method 屬性的可能值為restyle | relayout | animate | update | skip，預設為restyle。

• args 屬性設定要傳遞給滑動時在 method 中設定的 Plotly 方法的引數值。

我們現在在一個散點圖上部署一個簡單的滑塊控制元件，該控制元件將隨著旋鈕沿控制元件滑動而改變正弦波的頻率。滑塊配置為具有 50 個步長。首先新增 50 個具有遞增頻率的正弦波曲線跡線，除了第 10 個跡線外，所有跡線都設定為可見。

然後，我們使用restyle方法配置每個步驟。對於每個步驟，所有其他步驟物件的可視性都設定為false。最後，透過初始化 sliders 屬性來更新 Figure 物件的佈局。

# Add traces, one for each slider step
for step in np.arange(0, 5, 0.1):
fig.add_trace(
   go.Scatter(
      visible = False,
      line = dict(color = "blue", width = 2),
      name = "𝜈 = " + str(step),
      x = np.arange(0, 10, 0.01),
      y = np.sin(step * np.arange(0, 10, 0.01))
   )
)
fig.data[10].visible=True

# Create and add slider
steps = []
for i in range(len(fig.data)):
step = dict(
   method = "restyle",
   args = ["visible", [False] * len(fig.data)],
)
step["args"][1][i] = True # Toggle i'th trace to "visible"
steps.append(step)
sliders = [dict(active = 10, steps = steps)]
fig.layout.update(sliders=sliders)
iplot(fig)

首先，將顯示第 10 個正弦波跡線。嘗試滑動底部水平控制元件上的旋鈕。您將看到頻率如下所示發生變化。

Plotly - FigureWidget 類

Plotly 3.0.0 引入了一個新的 Jupyter 小部件類：plotly.graph_objs.FigureWidget。它具有與我們現有 Figure 相同的呼叫簽名，並且它是專門為Jupyter Notebook和JupyterLab 環境而設計的。

go.FigureWiget() 函式返回一個帶有預設 x 和y軸的空 FigureWidget 物件。

f = go.FigureWidget()
iplot(f)

以下是程式碼的輸出：

FigureWidget 最重要的特性是生成的 Plotly 圖形，它會在我們繼續向其中新增資料和其他佈局屬性時動態更新。

例如，逐個新增以下圖形軌跡，並檢視原始空圖形的動態更新。這意味著我們不必一次又一次地呼叫 iplot() 函式，因為繪圖會自動重新整理。FigureWidget 的最終外觀如下所示：

f.add_scatter(y = [2, 1, 4, 3]);
f.add_bar(y = [1, 4, 3, 2]);
f.layout.title = 'Hello FigureWidget'

此小部件能夠為懸停、單擊和選擇點以及放大區域提供事件偵聽器。

在以下示例中，FigureWidget 被程式設計為響應繪圖區域上的單擊事件。小部件本身包含一個帶有標記的簡單散點圖。滑鼠單擊位置用不同的顏色和大小標記。

x = np.random.rand(100)
y = np.random.rand(100)
f = go.FigureWidget([go.Scatter(x=x, y=y, mode='markers')])

scatter = f.data[0]
colors = ['#a3a7e4'] * 100

scatter.marker.color = colors
scatter.marker.size = [10] * 100
f.layout.hovermode = 'closest'
def update_point(trace, points, selector):

c = list(scatter.marker.color)
s = list(scatter.marker.size)
for i in points.point_inds:

c[i] = 'red'
s[i] = 20

scatter.marker.color = c
scatter.marker.size = s
scatter.on_click(update_point)
f

在 Jupyter notebook 中執行上述程式碼。將顯示一個散點圖。單擊區域中的某個位置，該位置將用紅色標記。

Plotly 的 FigureWidget 物件也可以使用Ipython自己的小部件。在這裡，我們使用在ipwidgets模組中定義的互動控制元件。我們首先構造一個FigureWidget並新增一個空的散點圖。

from ipywidgets import interact
fig = go.FigureWidget()
scatt = fig.add_scatter()
fig

我們現在定義一個更新函式，該函式輸入頻率和相位，並設定上面定義的散點跡線的 x 和y屬性。@interact 裝飾器來自 ipywidgets 模組，用於建立一組簡單的小部件來控制繪圖的引數。更新函式用ipywidgets 包中的@interact 裝飾器進行裝飾。裝飾器引數用於指定我們想要遍歷的引數範圍。

xs = np.linspace(0, 6, 100)
@interact(a = (1.0, 4.0, 0.01), b = (0, 10.0, 0.01), color = ['red', 'green', 'blue'])
def update(a = 3.6, b = 4.3, color = 'blue'):
with fig.batch_update():
scatt.x = xs
scatt.y = np.sin(a*xs-b)
scatt.line.color = color

現在用藍色填充空的 FigureWidget，其中正弦曲線a 和 b 分別為 3.6 和 4.3。在當前 notebook 單元格下方，您將獲得一組滑塊，用於選擇a和b的值。還有一個下拉選單用於選擇軌跡顏色。這些引數在@interact 裝飾器中定義。

Plotly 與 Pandas 和 Cufflinks 的結合使用

Pandas 是 Python 中非常流行的資料分析庫。它也支援自己的繪圖函式。但是，Pandas 繪圖在視覺化中不提供互動性。值得慶幸的是，可以使用Pandas 資料框物件構建 Plotly 的互動式和動態繪圖。

我們首先從簡單的列表物件構建資料框。

data = [['Ravi',21,67],['Kiran',24,61],['Anita',18,46],['Smita',20,78],['Sunil',17,90]]
df = pd.DataFrame(data,columns = ['name','age','marks'],dtype = float)

資料框列用作圖形物件軌跡的x和y屬性的資料值。在這裡，我們將使用name和marks列生成條形跡線。

trace = go.Bar(x = df.name, y = df.marks)
fig = go.Figure(data = [trace])
iplot(fig)

將在 Jupyter notebook 中顯示一個簡單的條形圖，如下所示：

Plotly 建立在d3.js之上，是一個專門的圖表庫，可以使用另一個名為Cufflinks的庫直接與Pandas 資料框一起使用。

如果尚未安裝，請使用您喜歡的包管理器（如pip）安裝 cufflinks 包，如下所示：

pip install cufflinks
or
conda install -c conda-forge cufflinks-py

首先，匯入 cufflinks 以及其他庫（如Pandas和numpy），可以將其配置為離線使用。

import cufflinks as cf
cf.go_offline()

現在，您可以直接使用Pandas 資料框來顯示各種型別的繪圖，而無需像以前那樣使用graph_objs 模組中的軌跡和圖形物件。

df.iplot(kind = 'bar', x = 'name', y = 'marks')

將顯示與前面非常相似的條形圖，如下所示：

資料庫中的 Pandas 資料框

除了使用 Python 列表來構建資料框外，還可以使用不同型別資料庫中的資料來填充它。例如，可以將來自 CSV 檔案、SQLite 資料庫表或 MySQL 資料庫表的資料提取到 Pandas 資料框中，最終使用Figure 物件或Cufflinks 介面將其用於 Plotly 圖表。

要從CSV 檔案提取資料，我們可以使用 Pandas 庫中的read_csv()函式。

import pandas as pd
df = pd.read_csv('sample-data.csv')

如果資料位於SQLite 資料庫表中，則可以使用SQLAlchemy 庫檢索它，如下所示：

import pandas as pd
from sqlalchemy import create_engine
disk_engine = create_engine('sqlite:///mydb.db')
df = pd.read_sql_query('SELECT name,age,marks', disk_engine)

另一方面，從MySQL 資料庫檢索的資料在 Pandas 資料框中如下所示：

import pymysql
import pandas as pd
conn = pymysql.connect(host = "localhost", user = "root", passwd = "xxxx", db = "mydb")
cursor = conn.cursor()
cursor.execute('select name,age,marks')
rows = cursor.fetchall()
df = pd.DataFrame( [[ij for ij in i] for i in rows] )
df.rename(columns = {0: 'Name', 1: 'age', 2: 'marks'}, inplace = True)

Plotly 與 Matplotlib 和 Chart Studio 的結合使用

本章介紹名為 Matplotlib 的資料視覺化庫和名為 Chart Studio 的線上繪圖製作工具。

Matplotlib

Matplotlib 是一個流行的 Python 資料視覺化庫，能夠生成可用於生產但為靜態繪圖。您可以藉助plotly.tools模組中的mpl_to_plotly()函式將靜態matplotlib 圖形轉換為互動式繪圖。

以下指令碼使用Matplotlib 的 PyPlot API生成正弦波線圖。

from matplotlib import pyplot as plt
import numpy as np
import math 
#needed for definition of pi
x = np.arange(0, math.pi*2, 0.05)
y = np.sin(x)
plt.plot(x,y)
plt.xlabel("angle")
plt.ylabel("sine")
plt.title('sine wave')
plt.show()

現在我們將將其轉換為 Plotly 圖形，如下所示：

fig = plt.gcf()
plotly_fig = tls.mpl_to_plotly(fig)
py.iplot(plotly_fig)

程式碼的輸出如下所示：

Chart Studio

Chart Studio 是 Plotly 提供的線上繪圖製作工具。它提供了一個圖形使用者介面，用於將資料匯入和分析到網格中並使用統計工具。圖表可以嵌入或下載。它主要用於更快、更高效地建立圖表。

登入 Plotly 帳戶後，請訪問連結https://plot.ly/create啟動 Chart Studio 應用。網頁在繪圖區域下方提供一個空白工作表。Chart Studio 允許您透過按下 +軌跡按鈕來新增繪圖軌跡。

選單中提供了各種繪圖結構元素（如註釋、樣式等）以及儲存、匯出和共享繪圖的功能。

讓我們在工作表中新增資料，並從軌跡型別中新增選擇條形圖軌跡。

單擊型別文字框並選擇條形圖。

然後，為x和y軸提供資料列，並輸入繪圖示題。