基础python超级常用的四种可视化函数库

标签：plt 函数库 title python 图表 dict 可视化 data opts

可视化的概念

可视化是指将数据或信息转换为图形表示形式的过程，以便更容易理解和分析。通过可视化，可以将复杂的概念、大量数据或抽象信息转化为直观的图形，使人们能够更快地洞察数据中的模式、趋势和异常情况。数据可视化是数据科学、统计学、信息设计等多个领域的交叉学科，它不仅仅限于图表和图形，还包括任何能够增强人类理解力的视觉表达方式。

说白了，可视化就是把数据以图形的方式展示出来，方便人们观察总结以及做出最后的决策。

python作为处理数据的最好用的语言之一，其内部提供了许多的函数库如pandas专们用于理数据分析。而我们数据可视化主流的几个函数库则有以下四种：

常见的四种可视化库

• Matplotlib

Matplotlib 是一个非常基础且功能全面的数据可视化库，几乎支持所有的基本图表类型，如线图、柱状图、散点图、直方图等。它是许多其他可视化库的基础，很多库（如Seaborn）都是在其之上构建的。适用于科研、数据分析等领域中的数据可视化任务。

matplotlib提供了众多的函数用法，有我们常见pyplot，axis函数等。每个函数对应的功能是不一样的，然而这函数开发商早就已经写完并封装好了的，我们只需要去Matplotlib官方API查看各种函数的用法，然后我们直接导入matplotlib库，通过系统调用使用库里面的函数传入参数就可以直接使用的。

下面是Matplotlib的官方API文档，可自行查阅各函数具体用法

Matplotlib 官方 API 文档

1. 官方网站：

   • 官方主页: Matplotlib 主页
   • 官方文档: Matplotlib 文档

2. API 文档：

   • API 文档: Matplotlib API 文档

这里重点在pycharm中运行以pyplot（）函数绘图为例子

首先安装一下Matplotlib，其他几种库也可以一起安装好

pip install matplotlib

导入所需要的函数库里的pyplot函数，其他的几个库也是一样的。

import matplotlib.pyplot as plt
import numpy as np

接下来我们看看用pyplot绘制简单的几种图

1. 饼图 (Pie Chart)

• 使用场景：展示整体中的部分比例关系；适合于展示有限数量的部分对整体的贡献。
• 优点：直观地展示各部分占总体的比例。
• 缺点：当部分过多时，饼图难以阅读；小部分可能很难区分；不适合展示时间序列数据。

import matplotlib.pyplot as plt


# 数据
sizes = [215, 130, 245, 210]
labels = ['Apples', 'Pears', 'Grapes', 'Bananas']

# 绘制饼图
plt.figure(figsize=(8, 6))
plt.pie(sizes, labels=labels, autopct='%1.1f%%', startangle=140)
plt.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.
plt.title('Fruit Distribution')
plt.show()

2. 箱形图 (Box Plot)

• 使用场景：展示一组数据的五数概括（最小值、下四分位数、中位数、上四分位数、最大值）；发现异常值；比较不同数据集的分布。
• 优点：能有效地展示数据的中心趋势、分散程度和异常值。
• 缺点：无法展示数据的具体数值；对于某些非统计背景的人来说可能不够直观。

import matplotlib.pyplot as plt
# 数据
all_data = [[23, 25, 21, 26, 24, 20, 22],
            [31, 30, 27, 28, 29, 32, 33],
            [12, 14, 16, 15, 18, 17, 19]]
# 绘制箱形图
plt.figure(figsize=(8, 6))
plt.boxplot(all_data, vert=False)  # vert=False makes the boxplot horizontal
plt.yticks([y + 1 for y in range(len(all_data))], ['Group 1', 'Group 2', 'Group 3'])
plt.title('Comparison of Three Groups')
plt.show()

3. 条形图 (Bar Chart)

• 使用场景：比较不同类别之间的数量差异；展示分类数据的分布。
• 优点：直观地展示不同类别的数量对比。
• 缺点：不适合展示大量数据或连续变量的变化趋势

import matplotlib.pyplot as plt

# 数据
heights = [12, 30, 1, 10]
labels = ['A', 'B', 'C', 'D']

# 绘制条形图
plt.figure(figsize=(8, 6))
bars = plt.bar(labels, heights, color=['#0072BD', '#D95319', '#EDB120', '#7E2F8E'])

# Add some text for labels, title and custom x-axis tick labels, etc.
plt.xlabel('Groups')
plt.ylabel('Values')
plt.title('Bar Chart Example', fontsize=16)
plt.xticks(rotation=45)
plt.grid(axis='y')

# Optionally add values on top of each bar
for bar in bars:
    yval = bar.get_height()
    plt.text(bar.get_x() + bar.get_width()/2.0, yval, round(yval, 1),
             va='bottom') # va: vertical alignment

plt.show()

4. 折线图

• 使用场景：展示随时间变化的趋势或序列数据的变化；比较两个或多个变量的变化趋势。
• 优点：能够清楚地展示数据随时间或其他连续尺度的变化趋势。
• 缺点：对于离散的数据，可能不如条形图或柱状图直观。

import numpy as np
import matplotlib.pyplot as plt

# 创建数据
x = np.linspace(0, 10, 100)  # 从0到10均匀地取100个点
y = np.sin(x) + np.random.normal(0, 0.1, size=x.shape)  # 正弦波加上一些随机噪声

# 创建一个新的图形
plt.figure(figsize=(10, 6))

# 绘制折线图
plt.plot(x, y, label='Sine Wave', color='skyblue', linewidth=2)

# 添加标题和坐标轴标签
plt.title("Smooth Sine Wave with Noise", fontsize=18)
plt.xlabel("Time", fontsize=14)
plt.ylabel("Amplitude", fontsize=14)

# 添加图例
plt.legend(fontsize=12)

# 添加网格
plt.grid(True, which="both", linestyle='--', linewidth=0.5)

# 设置坐标轴范围
plt.xlim(0, 10)
plt.ylim(-1.5, 1.5)

# 自定义坐标轴刻度
plt.xticks(np.arange(0, 11, 2), fontsize=12)
plt.yticks(np.arange(-1.5, 1.6, 0.5), fontsize=12)

# 显示图形
plt.show()

5. 散点图

• 使用场景：探索两个变量之间的关系；检测相关性；寻找模式或趋势。
• 优点：可以直观地看出两个变量间是否存在某种关系。
• 缺点：当数据点非常多时，可能会出现“遮挡”现象，导致难以看清数据分布。

import numpy as np
import matplotlib.pyplot as plt

# 创建数据
np.random.seed(0)  # 设置随机种子确保每次运行结果相同
x = np.random.rand(50) * 100  # 随机生成50个在0到100之间的数
y = x + np.random.randn(50) * 10  # 在x的基础上添加正态分布的噪声

# 创建一个新的图形
plt.figure(figsize=(10, 6))

# 绘制散点图
plt.scatter(x, y, c=x, cmap='viridis', s=100, alpha=0.6, edgecolors='w')

# 添加颜色条显示x的值
plt.colorbar(label='Value of X')

# 添加标题和坐标轴标签
plt.title('Scatter Plot Example', fontsize=18)
plt.xlabel('X Axis', fontsize=14)
plt.ylabel('Y Axis', fontsize=14)

# 添加网格
plt.grid(True, which="both", linestyle='--', linewidth=0.5)

# 设置坐标轴范围
plt.xlim(0, 100)
plt.ylim(0, 150)

# 自定义坐标轴刻度
plt.xticks(np.arange(0, 101, 20), fontsize=12)
plt.yticks(np.arange(0, 151, 25), fontsize=12)

# 显示图形
plt.show()

然而，这些可视化的图形只是matplotlib的冰山一角，最为简单最为普通的，同学们可以根据自己的喜好调整不同参数绘画出自己喜欢的风格。

---

• Altair

Altair 是一个声明式的可视化库，强调简洁的API设计。适用于快速原型设计和迭代，尤其适合数据科学领域。适合于创建复杂的多层图表，易于组合不同的数据视图。

 Altair官网API文档：

• 官方网站: Altair Visualization Library
• 官方文档: Documentation

但值得注意的是：Altair 主要设计用于在 Jupyter Notebook 和 JupyterLab 环境中使用，并且在这些环境中通常能够很好地运行。这是因为 Altair 依赖于前端库（如 Vega-Lite 和 Vega）来渲染图表，而这些库通常在浏览器环境中运行得最好。如果直接在idea或者pyachrm里面运行的话不会直接显示图像的。如下所示：

显示解决方法

    1. 保存为 HTML 文件

你可以将 Altair 图表保存为 HTML 文件，并在浏览器中打开它。

import altair as alt
import pandas as pd

# 示例数据
data = {'Category': ['A', 'B', 'C', 'D', 'E'],
        'Value': [30, 15, 25, 20, 10]}
df = pd.DataFrame(data)

# 创建条形图
chart = alt.Chart(df).mark_bar().encode(
    x='Category',
    y='Value'
).properties(
    width=400,
    height=300,
    title='Basic Bar Chart'
)

# 保存为 HTML 文件
chart.save('output.html')

此时就会多出一个名为output.html的文件打开并行就可以看到输出的图像了：

2. 使用 Jupyter Notebook 

在 Jupyter Notebook 中可以直接显示 Altair 图表的原因是因为 Jupyter Notebook 本身支持内联渲染（inline rendering）和交互式图表。当你在 Jupyter Notebook 中运行 Altair 代码时，图表会被自动转换成 HTML 和 JavaScript 代码，并在 Notebook 页面中内联渲染。这种机制使得图表可以直接在 Notebook 页面中显示。

如果还没有学习使用的Jupyter Notebook的同学可以先去学习安装一下。https://jupyter.org/

解决完图像显示的问题后，就可以利用Altiar进行多样的数据可视化了

1.散点图 (Scatter Plot)

1. 导入库：

   • altair 用于创建图表。
   • pandas 用于数据处理。

2. 创建数据：

   • 使用字典创建一个包含两个变量的数据集。
   • 将数据集转换为 Pandas DataFrame。

3. 创建散点图：

   • 使用 alt.Chart(df) 创建一个图表对象。
   • 使用 .mark_circle(size=60) 指定图表类型为散点图，并设置散点的大小。
   • 使用 .encode(x='X', y='Y') 将数据映射到图表的 x 轴和 y 轴。
   • 使用 .properties(width=400, height=300, title='Scatter Plot Example') 设置图表的宽度、高度和标题。
   • 使用 .tooltip(['X', 'Y']) 添加悬停提示。

4. 显示图表：

   • 直接使用 scatter_plot 表达式来显示图表。

   • 保存为html文件scatter_plot.save('scatter_plot.html')

import altair as alt
import pandas as pd
# 示例数据
data = {
    'X': [1, 2, 3, 4, 5],
    'Y': [2, 3, 5, 7, 11]
}
df = pd.DataFrame(data)
# 创建散点图
scatter_plot = alt.Chart(df).mark_circle(size=60).encode(
    x='X',
    y='Y',
    tooltip=['X', 'Y']
).properties(
    width=400,
    height=300,
    title='Scatter Plot Example'
)
# 显示散点图
scatter_plot
scatter_plot.save('scatter_plot.html')

2.折线图 (Line Chart)

1. 导入库：

   • altair 用于创建图表。
   • pandas 用于数据处理。

2. 创建数据：

   • 使用字典创建一个包含时间序列和销售数据的数据集。
   • 将数据集转换为 Pandas DataFrame。

3. 创建折线图：

   • 使用 alt.Chart(df) 创建一个图表对象。
   • 使用 .mark_line() 指定图表类型为折线图。
   • 使用 .encode(x='Year:O', y='Sales:Q') 将数据映射到图表的 x 轴和 y 轴。注意 :O 表示 x 轴是序数类型，:Q 表示 y 轴是定量类型。
   • 使用 .properties(width=400, height=300, title='Line Chart Example') 设置图表的宽度、高度和标题。

4. 显示图表：

   • 直接使用 line_chart 表达式来显示图表

与上述代码大同小异

import altair as alt
import pandas as pd

# 示例数据
data = {
    'Year': [2000, 2001, 2002, 2003, 2004, 2005],
    'Sales': [150, 200, 250, 275, 300, 350]
}
df = pd.DataFrame(data)

# 创建折线图
line_chart = alt.Chart(df).mark_line().encode(
    x='Year:O',
    y='Sales:Q'
).properties(
    width=400,
    height=300,
    title='Line Chart Example'
)
# 显示折线图
line_chart
line_chart.save('line_chart.html')

                               散点图                                                                  折线图

编码完成后便可以在浏览器中打开谷歌浏览器中的html文件了。当然还有很多的的图像小伙伴们可以去官网查询用法，这里就不在赘述了。

• Plotly

plotly 是一个跨平台的交互式图表库，支持Python以及其他多种编程语言。适用于需要创建具有交互性的Web应用或仪表板的情况。可以创建动态图表，如悬停提示、缩放和平移等交互功能。

官方API文档：

• Plotly Python API 文档: https://plotly.com/python-api-reference/
• Plotly 图表库: https://plotly.com/python/

特点：

输出为HTML或JavaScript代码，可以直接嵌入到Web页面中。

支持多种图表类型，包括三维图表、热力图等较为复杂的图表。

提供在线服务（Plotly Online），可以在线分享和协作。

有商业版和免费版，商业版提供更多高级功能。

1. 动态条形图 (Bar Chart with Slider)

2. 动态折线图 (Line Chart with Dropdown Menu)

3. 动态散点图 (Scatter Plot with Slider)

4. 动态面积图 (Area Chart with Dropdown Menu)

5. 动态气泡图 (Bubble Chart with Slider)

等等以上我在点击图像是会有数据显示，能方便观察者更好看清楚具体数据内容，实现的很好的交互性！下面五种图像的代码：注意备注

import plotly.graph_objects as go
import pandas as pd

# 示例数据
years = [2000, 2001, 2002, 2003, 2004, 2005]
data = [
    {'Category': ['A', 'B', 'C', 'D', 'E'], 'Value': [30, 15, 25, 20, 10]},
    {'Category': ['A', 'B', 'C', 'D', 'E'], 'Value': [35, 20, 30, 25, 15]},
    {'Category': ['A', 'B', 'C', 'D', 'E'], 'Value': [40, 25, 35, 30, 20]},
    {'Category': ['A', 'B', 'C', 'D', 'E'], 'Value': [45, 30, 40, 35, 25]},
    {'Category': ['A', 'B', 'C', 'D', 'E'], 'Value': [50, 35, 45, 40, 30]},
    {'Category': ['A', 'B', 'C', 'D', 'E'], 'Value': [55, 40, 50, 45, 35]}
]

frames = []
for i, year in enumerate(years):
    df = pd.DataFrame(data[i])
    frames.append(go.Frame(data=[go.Bar(
        x=df['Category'],
        y=df['Value'],
        text=df['Value'],
        textposition='auto',
        marker=dict(
            color='rgb(55, 83, 109)',
            line=dict(color='rgb(8,48,107)', width=1.5)
        )
    )], name=str(year)))

# 创建初始图表
fig = go.Figure(data=[go.Bar(
    x=data[0]['Category'],
    y=data[0]['Value'],
    text=data[0]['Value'],
    textposition='auto',
    marker=dict(
        color='rgb(55, 83, 109)',
        line=dict(color='rgb(8,48,107)', width=1.5)
    )
)], frames=frames)

# 自定义布局
fig.update_layout(
    title='Dynamic Bar Chart Example',
    xaxis_title='Category',
    yaxis_title='Value',
    updatemenus=[dict(
        type='buttons',
        buttons=[dict(label='Play',
                      method='animate',
                      args=[None, dict(frame=dict(duration=500, redraw=True), fromcurrent=True, mode='immediate')])]
    )],
    sliders=[dict(
        active=0,
        currentvalue={'prefix': 'Year: '},
        pad={'t': 50},
        steps=[dict(method='animate', args=[[f.name], dict(mode='immediate', frame=dict(duration=300, redraw=False))], label=f.name) for f in frames]
    )],
    template='plotly_white'
)

# 显示图表
fig.show()





# 2.动态折统计图
# 示例数据
years = [2000, 2001, 2002, 2003, 2004, 2005]
data = [
    {'Year': years, 'Sales': [150, 200, 250, 275, 300, 350]},
    {'Year': years, 'Profit': [100, 150, 200, 225, 250, 300]},
    {'Year': years, 'Expenses': [50, 75, 100, 125, 150, 200]}
]

# 创建折线图
fig = go.Figure()

for d in data:
    fig.add_trace(go.Scatter(
        x=d['Year'],
        y=d['Sales'] if 'Sales' in d else d['Profit'] if 'Profit' in d else d['Expenses'],
        mode='lines+markers',
        name='Sales' if 'Sales' in d else 'Profit' if 'Profit' in d else 'Expenses',
        line=dict(color='rgb(31, 119, 180)'),
        marker=dict(size=10, color='rgb(255, 127, 14)')
    ))

# 自定义布局
fig.update_layout(
    title='Dynamic Line Chart Example',
    xaxis_title='Year',
    yaxis_title='Value',
    updatemenus=[dict(
        type='dropdown',
        direction='down',
        x=0.1,
        y=1.15,
        showactive=True,
        active=0,
        buttons=list([
            dict(label='Sales',
                 method='update',
                 args=[{'visible': [True, False, False]}, {'title': 'Sales Over Time'}]),
            dict(label='Profit',
                 method='update',
                 args=[{'visible': [False, True, False]}, {'title': 'Profit Over Time'}]),
            dict(label='Expenses',
                 method='update',
                 args=[{'visible': [False, False, True]}, {'title': 'Expenses Over Time'}])
        ])
    )],
    template='plotly_dark'
)

# 显示图表
fig.show()



# 3.动态散点图
# 示例数据
years = [2000, 2001, 2002, 2003, 2004, 2005]
data = [
    {'X': [1, 2, 3, 4, 5], 'Y': [2, 3, 5, 7, 11]},
    {'X': [1, 2, 3, 4, 5], 'Y': [3, 4, 6, 8, 13]},
    {'X': [1, 2, 3, 4, 5], 'Y': [4, 5, 7, 9, 15]},
    {'X': [1, 2, 3, 4, 5], 'Y': [5, 6, 8, 10, 17]},
    {'X': [1, 2, 3, 4, 5], 'Y': [6, 7, 9, 11, 19]},
    {'X': [1, 2, 3, 4, 5], 'Y': [7, 8, 10, 12, 21]}
]

frames = []
for i, year in enumerate(years):
    df = pd.DataFrame(data[i])
    frames.append(go.Frame(data=[go.Scatter(
        x=df['X'],
        y=df['Y'],
        mode='markers',
        marker=dict(size=12, color='rgb(255, 187, 120)', line=dict(width=2, color='DarkSlateGrey'))
    )], name=str(year)))

# 创建初始图表
fig = go.Figure(data=[go.Scatter(
    x=data[0]['X'],
    y=data[0]['Y'],
    mode='markers',
    marker=dict(size=12, color='rgb(255, 187, 120)', line=dict(width=2, color='DarkSlateGrey'))
)], frames=frames)

# 自定义布局
fig.update_layout(
    title='Dynamic Scatter Plot Example',
    xaxis_title='X',
    yaxis_title='Y',
    showlegend=False,
    updatemenus=[dict(
        type='buttons',
        buttons=[dict(label='Play',
                      method='animate',
                      args=[None, dict(frame=dict(duration=500, redraw=True), fromcurrent=True, mode='immediate')])]
    )],
    sliders=[dict(
        active=0,
        currentvalue={'prefix': 'Year: '},
        pad={'t': 50},
        steps=[dict(method='animate', args=[[f.name], dict(mode='immediate', frame=dict(duration=300, redraw=False))], label=f.name) for f in frames]
    )],
    template='plotly_white'
)

# 显示图表
fig.show()



# 4.动态面积图
# 示例数据
years = [2000, 2001, 2002, 2003, 2004, 2005]
data = [
    {'Year': years, 'Sales': [150, 200, 250, 275, 300, 350]},
    {'Year': years, 'Profit': [100, 150, 200, 225, 250, 300]},
    {'Year': years, 'Expenses': [50, 75, 100, 125, 150, 200]}
]

# 创建面积图
fig = go.Figure()

for d in data:
    fig.add_trace(go.Scatter(
        x=d['Year'],
        y=d['Sales'] if 'Sales' in d else d['Profit'] if 'Profit' in d else d['Expenses'],
        fill='tozeroy',
        mode='lines',
        name='Sales' if 'Sales' in d else 'Profit' if 'Profit' in d else 'Expenses',
        line=dict(color='rgb(99, 110, 250)')
    ))

# 自定义布局
fig.update_layout(
    title='Dynamic Area Chart Example',
    xaxis_title='Year',
    yaxis_title='Value',
    updatemenus=[dict(
        type='dropdown',
        direction='down',
        x=0.1,
        y=1.15,
        showactive=True,
        active=0,
        buttons=list([
            dict(label='Sales',
                 method='update',
                 args=[{'visible': [True, False, False]}, {'title': 'Sales Over Time'}]),
            dict(label='Profit',
                 method='update',
                 args=[{'visible': [False, True, False]}, {'title': 'Profit Over Time'}]),
            dict(label='Expenses',
                 method='update',
                 args=[{'visible': [False, False, True]}, {'title': 'Expenses Over Time'}])
        ])
    )],
    template='plotly_white'
)

# 显示图表
fig.show()



# 5.动态气泡图
  # 示例数据
years = [2000, 2001, 2002, 2003, 2004, 2005]
data = [
    {'X': [1, 2, 3, 4, 5], 'Y': [2, 3, 5, 7, 11], 'Size': [10, 20, 30, 40, 50]},
    {'X': [1, 2, 3, 4, 5], 'Y': [3, 4, 6, 8, 13], 'Size': [12, 22, 32, 42, 52]},
    {'X': [1, 2, 3, 4, 5], 'Y': [4, 5, 7, 9, 15], 'Size': [14, 24, 34, 44, 54]},
    {'X': [1, 2, 3, 4, 5], 'Y': [5, 6, 8, 10, 17], 'Size': [16, 26, 36, 46, 56]},
    {'X': [1, 2, 3, 4, 5], 'Y': [6, 7, 9, 11, 19], 'Size': [18, 28, 38, 48, 58]},
    {'X': [1, 2, 3, 4, 5], 'Y': [7, 8, 10, 12, 21], 'Size': [20, 30, 40, 50, 60]}
]

frames = []
for i, year in enumerate(years):
    df = pd.DataFrame(data[i])  # 使用字典构造 DataFrame
    frames.append(go.Frame(data=[go.Scatter(
        x=df['X'],
        y=df['Y'],
        mode='markers',
        marker=dict(size=df['Size'], color='rgb(255, 127, 14)', showscale=True),
        text=df.apply(lambda row: f"X={row['X']}<br>Y={row['Y']}<br>Size={row['Size']}", axis=1),
        hoverinfo='text'
    )], name=str(year)))

# 创建初始图表
fig = go.Figure(data=[go.Scatter(
    x=data[0]['X'],
    y=data[0]['Y'],
    mode='markers',
    marker=dict(size=data[0]['Size'], color='rgb(255, 127, 14)', showscale=True),
    text=pd.DataFrame(data[0]).apply(lambda row: f"X={row['X']}<br>Y={row['Y']}<br>Size={row['Size']}", axis=1),
    hoverinfo='text'
)], frames=frames)

# 自定义布局
fig.update_layout(
    title='Dynamic Bubble Chart Example',
    xaxis_title='X',
    yaxis_title='Y',
    updatemenus=[dict(
        type='buttons',
        buttons=[dict(label='Play',
                      method='animate',
                      args=[None, dict(frame=dict(duration=500, redraw=True), fromcurrent=True, mode='immediate')])]
    )],
    sliders=[dict(
        active=0,
        currentvalue={'prefix': 'Year: '},
        pad={'t': 50},
        steps=[dict(method='animate', args=[[f.name], dict(mode='immediate', frame=dict(duration=300, redraw=False))], label=f.name) for f in frames]
    )],
    template='plotly_white'
)
# 显示图表
fig.show()

---

• PyEcharts

PyEcharts 是一个基于ECharts的Python库，ECharts是一个用JavaScript编写的高性能的可视化库。适用于需要将Python数据可视化结果嵌入到Web应用中的场景。支持多种图表类型，包括一些较为专业的图表，如漏斗图、桑基图等。

与前面的Altair一样。PyEcharts生成的图表通常是通过HTML文件在Web浏览器中显示的。在 PyCharm 或者其他 IDE 中，你通常看不到直接显示的图形，而是需要将生成的 HTML 文件在浏览器中打开。要么用html，要么使用jupterbook运行代码。

PyECharts 官方文档

1. 官方网站：

   • 官网: PyECharts 官方网站
   • GitHub 仓库: PyECharts GitHub 仓库

2. 文档地址：

   • 中文文档: PyECharts 文档
   • 英文文档: PyECharts 英文文档

PyEcharts 的特点

1. 易于上手：PyEcharts 提供了一个简洁的 API 接口，使得绘制图表变得非常简单，只需要几行代码就可以完成。

2. 高度可配置：继承了 ECharts 的所有特性，PyEcharts 允许用户对图表进行高度定制，包括样式、动画、交互行为等。

3. 广泛的图表类型：支持各种类型的图表，如柱状图、饼图、折线图、地图、热力图、散点图等，几乎涵盖了 ECharts 所有的图表类型。

4. 兼容性好：生成的图表可以在各种浏览器中运行，包括移动设备上的浏览器。

5. 中文友好：由于 ECharts 最初是由百度开发的，因此它对中文的支持非常好，对于中文用户来说是一个优势。

6. 文档详尽：PyEcharts 的文档相对详细，并且提供了许多示例，有助于快速上手

1. 三维散点图 (3D Surface Plot)

from pyecharts.charts import Scatter3D
from pyecharts import options as opts

# 数据准备
data = [
    [i, j, (i + j) * 2] for i in range(6) for j in range(6)
]

scatter3d = (
    Scatter3D()
    .add(
        series_name="",
        data=data,
        xaxis3d_opts=opts.Axis3DOpts(type_="value"),
        yaxis3d_opts=opts.Axis3DOpts(type_="value"),
        zaxis3d_opts=opts.Axis3DOpts(type_="value"),
    )
    .set_global_opts(
        visualmap_opts=opts.VisualMapOpts(),
        title_opts=opts.TitleOpts(title="3D Scatter Plot"),
    )
)

# 渲染图表
scatter3d.render_notebook()  # 如果是在 Jupyter Notebook 中显示
# 或者保存为 HTML 文件
scatter3d.render("3d_scatter_plot.html")

 2.三维柱状图 (3D Bar Chart)

from pyecharts.charts import Bar3D
from pyecharts import options as opts

# 数据准备
data = [
    [[i, j, (i + j) * 2] for j in range(6)] for i in range(6)
]

bar3d = (
    Bar3D()
    .add(
        series_name="",
        data=data,
        xaxis3d_opts=opts.Axis3DOpts(type_="value"),
        yaxis3d_opts=opts.Axis3DOpts(type_="value"),
        zaxis3d_opts=opts.Axis3DOpts(type_="value"),
    )
    .set_global_opts(
        visualmap_opts=opts.VisualMapOpts(),
        title_opts=opts.TitleOpts(title="3D Bar Chart"),
    )
)

# 渲染图表
bar3d.render_notebook()  # 如果是在 Jupyter Notebook 中显示
# 或者保存为 HTML 文件
bar3d.render("3d_bar_chart.html")

 3.中国地图

from pyecharts.charts import Map
from pyecharts import options as opts

# 示例数据，这里假设是某个指标的得分
data = [
    ("北京", 89), ("天津", 78), ("上海", 93), ("重庆", 75), ("河北", 65), ("山西", 63), ("辽宁", 72),
    ("吉林", 68), ("黑龙江", 61), ("江苏", 88), ("浙江", 91), ("安徽", 69), ("福建", 80), ("江西", 67),
    ("山东", 85), ("河南", 70), ("湖北", 82), ("湖南", 78), ("广东", 90), ("海南", 75), ("四川", 76),
    ("贵州", 66), ("云南", 71), ("陕西", 73), ("甘肃", 64), ("青海", 62), ("台湾", 85), ("内蒙古", 67),
    ("广西", 71), ("西藏", 63), ("宁夏", 65), ("新疆", 68), ("香港", 88), ("澳门", 90)
]

# 创建地图实例
map_chart = (
    Map()
    .add("示例数据", data, "china")  # 添加数据
    .set_global_opts(
        title_opts=opts.TitleOpts(title="中国省份示例地图"),
        visualmap_opts=opts.VisualMapOpts(),  # 添加颜色渐变图例
    )
)

# 渲染图表
map_chart.render("china_map_example.html")

4.雷达图

from pyecharts.charts import Radar
from pyecharts import options as opts

# 定义雷达图的维度（即各个指标）
dimensions = ["创新性", "团队合作", "工作效率", "专业知识", "个人发展"]

# 构造一些虚构的数据
employee1_scores = [85, 90, 95, 80, 75]
employee2_scores = [75, 80, 90, 95, 85]

# 创建雷达图实例
radar = (
    Radar()
    .add_schema(
        schema=[
            opts.RadarIndicatorItem(name=d, max_=100) for d in dimensions
        ],
        shape="circle",
    )
    .add("员工A", [employee1_scores], color="#CD5C5C")
    .add("员工B", [employee2_scores], color="#1E90FF")
    .set_series_opts(label_opts=opts.LabelOpts(is_show=False))
    .set_global_opts(
        title_opts=opts.TitleOpts(title="员工表现雷达图"),
        legend_opts=opts.LegendOpts()
    )
)

# 将图表渲染到HTML文件
radar.render('employee_performance_radar.html')

---

    以上前面两种可视化库可大致归为静态类图，后面两种则是更侧重于交互式图表，更为动态灵活。

   区别总结

• 交互性：Plotly 和 PyEcharts 更侧重于生成交互式图表，而Matplotlib和Altair则更注重静态图表的生成。
• 易用性：Altair 和 PyEcharts 在API设计上更注重易用性，而Matplotlib虽然功能强大但API较复杂。
• 输出形式：Matplotlib 和 Altair 更多地用于生成静态图表或图像文件，而Plotly 和 PyEcharts 则更适合生成可以直接嵌入Web页面的交互式图表。
• 社区支持：Matplotlib 和 Plotly 拥有较大的社区和丰富的文档资源，而Altair 和 PyEcharts 的社区相对较小但增长迅速。因此Matplotlib 和 Plotly都可以直接在idea或者pyecharm中打开显示，而Altair 和 PyEcharts则需要在网页中打开。

          

标签：plt,函数库,title,python,图表,dict,可视化,data,opts
From： https://blog.csdn.net/m0_64031432/article/details/142193293