PythonGuides-博客中文翻译-四-
PythonGuides 博客中文翻译（四）
python 中的语法无效
在本 Python 教程中，我们将讨论如何修复 python 中的无效语法或者 python 中的语法错误。我们将检查如何修复错误语法错误:无效语法 python 3** 。**
python 中的语法无效
在 python 中，如果您运行代码，它将执行，如果解释器在程序执行期间发现 python 中的任何无效语法，它将向您显示一个名为无效语法的错误，它还将帮助您确定无效语法在代码中的位置和行号。
举例:
my_dict = {"name": "Harry", "roll": "23" "marks": "64"}
my_dict.pop("roll")
print(my_dict)
写完上面的代码(Syntaxerror invalid syntax)，你将打印出 " my_dict " ，然后错误将显示为"" syntax error:invalid syntax"。这里，第 1 行的字典文字中的无效语法，我们可以看到在“roll”后面缺少一个逗号，因此它遇到了一个无效语法。
你可以参考下面的截图语法错误:无效语法
syntaxerror: invalid syntax python 3
这是语法错误:无效语法。
为了解决这个语法错误:无效语法我们需要小心语法，因为一旦解释器遇到一些没有意义的东西或任何缺少的语法，它就会给出一个语法错误。
举例:
my_dict = {"name": "Harry", "roll": "23", "marks": "64"}
my_dict.pop("roll")
print(my_dict)
写完上面的代码后(Syntaxerror 无效语法)，你将打印出 " my_dict " ，然后输出将显示为" {"name": "Harry "，" marks": "64"} 。这里，通过在“roll”后加上逗号来解决错误，因此解释器不会发现任何错误，代码将成功运行。
你可以参考下面的截图语法错误:无效语法
how to fix invalid syntax in python
因此，syntax error:Python中的无效语法得到了解决。
您可能会喜欢以下 Python 教程:
- 如何在 python 中创建变量
- Python 中的阿姆斯特朗数
- Python 回文程序
- 如何在 Python 中创建字符串
- 如何在 python 中使用正则表达式拆分字符串
- 无换行符的 Python 打印
- Python 将列表转换成字符串
- Python 方块一号
- 语法错误标识符 python3 中的无效字符
这是如何修复 python 中的无效语法或****syntax error:python 3中的无效语法或语法错误 python 。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
遍历字典 Python
原文：https://pythonguides.com/iterate-through-dictionary-python/
在这个 Python 教程中，我们将使用 Python 中的一些例子来研究如何在 Python 中迭代字典。此外，我们还将涉及这些主题。
- 使用索引遍历字典 Python
- 遍历字典 Python for 循环
- 遍历字典 Python 反向
- 遍历 Python 排序的字典
- 按顺序遍历字典 Python
- 遍历字典 Python lambda
- 遍历包含多个值的字典 Python
- 使用列表遍历字典 Python
- Python 在字典中遍历字典
- Python 遍历数据帧字典
- Python 遍历字典并删除条目
- Python 遍历字典并更改值
- Python 遍历按关键字排序的字典
- Python 遍历按值排序的字典
目录
- Python 遍历字典 Python
- 使用索引遍历字典 Python
- 循环遍历字典 Python
- 遍历字典 Python 逆向
- 遍历 Python 排序的字典
- 按照顺序遍历字典 Python
- 遍历字典 Python lambda
- 遍历包含多个值的字典 Python
- 用列表遍历字典 Python
- Python 在字典中迭代字典
- Python 遍历数据帧字典
- Python 遍历字典并删除条目
- Python 遍历字典并改变值
- Python 遍历按关键字排序的字典
- Python 遍历按值排序的字典
Python 遍历字典 Python
- 在这一节中，我们将讨论如何在 Python 中迭代字典。
- 要遍历一个字典，我们可以很容易地使用
dictionary.items()方法，它总是以键-值对的形式返回列表和元组等可迭代对象。 - 在 Python dictionary 中，
dict.items()方法用于以键值对的形式显示字典元素列表，该方法在 Python 包模块中可用。
语法:
让我们看一下语法并理解 dict.items() 函数的工作原理
dictionary.items()
举例:
让我们举个例子，看看如何用 Python 迭代一个字典。
源代码:
my_dictionary = {'USA': 678, 'Germany': 145, 'France': 789}
for m in my_dictionary.items():
print("Iterate dictionary elements:",m)
在上面的代码中，我们创建了一个名为‘my _ dictionary’的简单字典，它包含键值对形式的元素。之后，我们使用了 for 循环方法来遍历键-值对，它将操作键和值，并以元组的形式返回。
下面是下面给出的代码的截图。
Iterate through dictionary Python
阅读: Python 字典重复键
使用索引遍历字典 Python
- 这里我们将通过使用 Python 中的 index 方法来迭代字典。
- 为了执行这个特定的任务，我们将使用 for 循环方法，它将迭代给定字典中可用的所有元素。
- 在
for-loop中，我们运行了枚举器函数，该方法将字典和列表等可迭代对象作为参数，并返回枚举对象。在本例中，这些函数返回键和索引位置。
举例:
new_dictionary = {'George': 134, 'John': 245, 'James': 120}
for new_indices, new_k in enumerate(new_dictionary):
print('Iterate dictionary: ', new_indices, ' :- ', new_k)
下面是以下给定代码的执行过程
Iterate through the dictionary with index in Python
阅读: Python 字典计数+实例
循环遍历字典 Python
- 在这个程序中，我们将讨论如何使用 for 循环方法在 Python 中迭代一个字典。
- 这个方法将帮助用户迭代字典中的每个值和键。例如，假设您有一个包含水果元素的字典，其形式为键-值对，您希望打印出特定水果名称的键和值。
举例:
Fruit={'Orange':567,'Mango':134,'Cherry':167}
for i in Fruit:
print(i, Fruit[i])
在下面给出的代码中，我们创建了一个字典‘Fruit’，它包含了键值对形式的元素。之后，我们使用 for 循环并迭代字典中的每个值。
下面是以下给定代码的实现。
Iterate through dictionary Python for loop
阅读: Python 字典增量值
遍历字典 Python 逆向
- 在这一节中，我们将讨论如何通过 Python 中的字典迭代来反转元素。
- 为了迭代字典元素，我们可以很容易地使用 list comprehension 方法和
dict.items()，它将返回一个逆序元素。 - 假设您已经以键:值对的形式指定了元素。一旦应用了这个函数，它就会以值:键对的形式反转元素。
语法:
下面是 Pythondictionary . items()函数的语法
dictionary.items()
举例:
让我们举一个例子，看看如何通过在 Python 中遍历字典来反转元素
源代码:
my_dictionary={'USA':345,'United Kingdom':789,'Germany':145,'France':654}
print("Original dictionary:",my_dictionary)
new_result={new_val:new_key for new_key,new_val in my_dictionary.items()}
print("Iterate reversed dictionary:",new_result)
在下面给定的代码中，我们创建了一个名为‘my _ dictionary’的字典，然后使用列表理解方法，在该方法中，我们必须分配键和值变量来迭代给定的字典。
下面是以下给定代码的输出。
Iterate through dictionary Python reverse
遍历 Python 排序的字典
- 在这一节中，我们将讨论如何通过在 Python 中遍历字典来对元素进行排序。
- 为了执行这个特定的任务，我们将使用
sorted()函数，这个方法将总是以一种排序的方式返回一个值的列表。在本例中，我们将首先进行排序，然后使用 for-loop 方法迭代这些值。 - 在这个例子中，首先，我们将使用
sorted(dict.keys())方法对键进行排序，这个函数将始终返回字典中可用的所有键，然后我们将使用sorted(dict.values())方法对所有值进行排序。
语法:
下面是 Python dictionary.keys() 方法的语法
dict.keys()
举例:
my_dictionary={'USA':345,'United Kingdom':789,'Germany':145,'France':654}
for new_k in sorted(my_dictionary.keys()):
print("Sorted keys:",new_k, ':', my_dictionary[new_k])
for new_val in sorted(my_dictionary.values()):
print("Sorted values:",new_val)
下面是下面给出的代码的截图。
Python iterate through dictionary sorted
正如您在屏幕截图中看到的，输出显示了排序的键和值。
阅读: Python 字典副本带示例
按照顺序遍历字典 Python
- 在这一节中，我们将讨论如何以顺序方法迭代一个字典。
- 在这个例子中，我们将使用 list comprehension 方法，在这个函数中，我们已经设置了用于迭代字典值的键和值变量，然后使用
dict.items()方法。
举例:
my_dictionary={'Newzealand':345,'Australia':345,'Paris':897,'France':234}
for new_k, new_val in sorted(my_dictionary.items()):
print((new_k, new_val))
下面是以下给定代码的实现。
iterate through dictionary Python in order
阅读: Python 字典多键
遍历字典 Python lambda
- 在这一节中，我们将讨论如何使用 lambda 函数来遍历 Python 中的字典。
- 在这个例子中，我们将使用 lambda 表达式来声明一个内联函数，其中
new_k是 lambda 的参数，map 函数执行一个 lambda 函数，它将返回列表中的所有键。
举例:
my_dictionary={'Newzealand':345,'Australia':345,'Paris':897,'France':234}
new_result = list(map(lambda new_k: my_dictionary[new_k], my_dictionary.keys()))
print("Iterate values using lambda:",new_result)
在上面的代码中，我们创建了一个名为‘my _ dictionary’的字典，它包含键值对形式的元素。之后，我们使用了 lambda 函数和 dictionary.keys() 方法，它将迭代给定字典的键，并将它们存储到列表中。
下面是下面给出的代码的截图。
iterate through dictionary Python lambda
阅读: Python 字典转 CSV
遍历包含多个值的字典 Python
- 在这一节中，我们将学习如何用 Python 迭代一个包含多个值的字典。
- 为了执行这个特定的任务，我们将使用 list comprehension 方法，它将迭代给定键的所有列表值。在这个例子中，我们将创建一个字典，为这个键分配多个值。
- 接下来，我们将使用 for 循环和
items()方法迭代字典，它将迭代列表中的所有条目。
举例:
让我们举一个例子，看看如何用 Python 迭代一个有多个值的字典
new_dictionary = {'USA':[23,67,89,12]}
new_list=[]
new_list = [[new_k,new_val] for new_k, values in new_dictionary.items() for new_val in values]
print("Iterate multiple values in dictionary:",new_list)
在下面的代码中，我们创建了一个名为“new_dictionary”的字典，其中包含一个具有多个值的键。之后，我们创建了一个空列表，通过使用 for 循环和 dict.items() 方法可以将所有的值存储在这个空列表中。
一旦执行了这段代码，输出将显示键保持不变而值不同的对的列表。
下面是下面给出的代码的截图。
Iterate through dictionary Python with multiple values
阅读: Python 将字典转换为数组
用列表遍历字典 Python
- 在这一节中，我们将讨论如何使用 list 在 Python 中迭代一个字典。
- 通过使用列表理解方法，我们可以很容易地用列表迭代字典。为了完成这项任务，首先我们将创建一个字典，并分配可以存储在列表中的键值对和值。
- 接下来为了迭代值和键，我们将使用 for 循环方法和
dict.keys()方法。
举例:
new_dictionary = {'USA' : [24,36,16], 'United Kingdom' : [89, 24,56], 'France' : [97,56,66]}
new_output = [[m for m in new_dictionary[new_k]] for new_k in new_dictionary.keys()]
print("Iterate dictionary with lists:",new_output)
下面是以下给定代码的实现。
Iterate through dictionary Python with list
Python 在字典中迭代字典
- 这里我们将讨论如何在 Python 中迭代一个嵌套字典。
- 为了执行这个特定的任务，我们将使用 for 循环和
dict.items()方法，它将迭代嵌套字典中的所有值。 - 在 Python 中，嵌套字典指定了字典中的字典，它是一个无序的条目集合。
- 在这个例子中，有两个字典，每个都有自己的键和值，现在我想迭代给定嵌套字典的所有元素。
举例:
让我们举个例子，看看如何在 Python 中迭代一个嵌套的字典。
源代码:
Country_name = {'A': {'Germany': 67, 'France': 456, 'Polland': 456},
'B': {'China': 456, 'Australia': 789, 'Japan': 567}}
for new_k, new_val in Country_name.items():
print(new_k)
for i in new_val:
print(i + ':-', new_val[i])
在上面的代码中，我们创建了一个名为' Country_name '的嵌套字典，内部字典' A '和' B '被赋给了 'Country_name' 。
之后，我们有一个关键名称作为国家名称以及它们的随机值。通过使用 for 循环和 dict.items() 方法，我们可以很容易地从一个列表中提取值。
下面是以下给定代码的执行。
Python iterate through dictionary within a dictionary
Python 遍历数据帧字典
- 在这个程序中，我们将讨论如何迭代一个字典并将它们转换成熊猫数据帧。
- 在 Python Pandas 中，DataFrame 是一种在二维行和列中计算的结构。
- 在这个例子中，我们将首先导入 Pandas 库，然后我们将创建一个字典，其中包含以键-值对形式的元素。为了迭代字典，我们将使用 for 循环方法，它将帮助用户迭代字典中的所有值。
- 接下来，我们将使用
Pd.dataframe并指定 iterable 属性‘I’作为参数，它将很容易转换成 dataframe。
举例:
让我们举个例子，看看如何迭代一个字典，并把它们转换成 Pandas DataFrame。
源代码:
import pandas as pd
dict={'Student_name':'John','Student_id':456,'Student_age':234}
for i in dict.items():
print(pd.DataFrame(i))
下面是以下代码的截图
Python iterate through a dictionary of data frames
阅读: Python 字典包含+示例
Python 遍历字典并删除条目
- 在本节中，我们将学习如何迭代一个字典并从 Python 字典中移除条目。
- 为了完成这个任务，我们将使用 for 循环方法来迭代字典元素，为了从字典中移除项目，我们将使用
del关键字。 - 在 Python 中，
del用于从可迭代对象(如字典)中删除特定项，这个关键字在 Python 字典包中可用。
语法:
让我们看一下语法并理解 del 关键字的工作原理
del[object name]
举例:
让我们举一个例子，看看如何迭代一个字典并从字典中删除条目。
源代码:
my_dictionary={'Cherry':234,'Apple':453,'Mango':13,'Grapes':12}
for new_k, new_val in dict(my_dictionary).items():
if new_val % 3 == 0:
del my_dictionary[new_k]
print(my_dictionary)
在下面的代码中，我们创建了一个包含键值对的字典。之后，我们使用 for 循环方法和 dict.items()函数，它将迭代字典中的所有元素。
迭代完所有元素后，我们设置了条件 if new_val %3==0 ，它将检查条件，如果值被 3 除，那么它将从字典中删除那些没有被 3 除的值，然后它将返回元组形式。
下面是以下给定代码的实现
Python iterate through a dictionary and remove items
阅读: Python 字典理解
Python 遍历字典并改变值
- 这里我们将讨论如何在 Python 字典中迭代和改变值。
- 为了迭代字典中的元素，我们将使用 for 循环方法，为了更新值，我们将使用‘if’条件。
举例:
dictionary = {'Africa':200,'australia':300,'England':400}
for new_k, new_values in dictionary.items():
if new_values==300:
dictionary[new_k] = 600
print(dictionary)
在上面的代码中，我们创建了一个包含键值对形式的元素的字典。之后，我们使用 for-loop 方法迭代元素，如果 new_values==300，则设置条件，如果 300 值可用，它将检查条件，然后用 600 值更新。
你可以参考下面的截图。
Python iterate through dictionary and change values
阅读: Python 字典删除
Python 遍历按关键字排序的字典
- 在这一节中，我们将学习如何在 Python 中迭代字典并按键排序。
- 为了在 Python 中遍历一个字典，我们将使用 for-loop 方法，为了得到排序的键，我们可以很容易地使用
sorted()函数，在这个函数中，我们将把字典作为一个参数。 - 在 Python 中，
sorted()函数用于对给定的类 iterable 对象的值进行排序。一旦执行了这段代码，输出将根据需求显示排序后的键。
举例:
让我们举个例子，看看如何在 Python 中迭代一个字典并按键排序。
源代码:
dictionary = {'George':200,'Micheal':300,'Oliva':400,'James':345}
for new_k in sorted (dictionary):
print("Sorted keys by iterating dictionary:",new_k)
下面是下面给出的代码的截图。
Python iterate through dictionary sorted by key
Python 遍历按值排序的字典
- 在这个程序中，我们将学习如何在 Python 中遍历字典并按值排序。
- 为了执行这个特定的任务，我们将使用 sorted()函数和
dict.values()方法。要按值对字典中的条目进行排序，我们可以使用sorted()函数中的dict.values()作为参数。 - 在 Python 中，这个方法在字典模块中可用，它用于提取字典中的值。
语法:
下面是 dict.values() 方法的语法
dict.values()
举例:
new_dict = {'Australia':200,'Germany':300,'France':400,'Polland':345}
for new_k in sorted (new_dict.values()):
print("Sorted keys by iterating dictionary:",new_k)
下面是以下给定代码的执行。
Python iterate through dictionary sorted by value
您可能也喜欢阅读以下 Python 教程。
在这篇 Python 教程中，我们已经学习了如何使用 Python 中的一些例子在 Python 中迭代字典。此外，我们还讨论了这些主题。
- 使用索引遍历字典 Python
- 遍历字典 Python for 循环
- 遍历字典 Python 反向
- 遍历 Python 排序的字典
- 按顺序遍历字典 Python
- 遍历字典 Python lambda
- 遍历包含多个值的字典 Python
- 使用列表遍历字典 Python
- Python 在字典中遍历字典
- Python 遍历数据帧字典
- Python 遍历字典并删除条目
- Python 遍历字典并更改值
- Python 遍历按关键字排序的字典
- Python 遍历按值排序的字典
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Jax 与 py torch[主要区别]
在本 Python 教程中，我们将学习 Python 中的 Jax Vs PyTorch 。Jax 是一种显示和创建数值程序转换的编程语言。它还能够为 CPU 或加速 GPU 编译数值程序。
而 PyTorch 是一个开源的机器学习库，主要用于 python 中的计算机视觉和自然语言处理。我们还将介绍与 Jax vs PyTorch 相关的不同例子。这些是我们将在本教程中讨论的主题。
- Jax 简介
- PyTorch 简介
- Jax Vs PyTorch
- Jax Vs PyTorch Vs Tensorflow
- Jax 与 PyTorch 基准测试
目录
Jax 简介
在这一节中，我们将学习什么是 JAX 以及它在 python 中是如何工作的。
JAX 代表处决后。它是由 DeepMind 开发的机器学习库。Jax 是一个 JIT( Just In Time)编译器，它专注于控制在使用 python 时创建优化代码的 FLOPS 的最大数量。
Jax 是一种显示和创建数值程序转换的编程语言。它还能够为 CPU 或加速 GPU 编译数值程序。
Jax 不仅为 CPU，也为 GPU 和 TPU 启用了 Numpy 代码。
代码:
在下面的代码中，我们将导入所有必要的库如*import jax . numpy as jnp*， *import grad* ， jit ， *vmap from jax* ， 和 import random from jax 。
- rd =随机。PRNGKey(0) 用于生成随机数据，随机状态由两个无符号的 32 位整数描述，我们称之为密钥。
- y = random.normal(rd，(8，))用于生成从正态分布中抽取的数字样本。
print(y)用于使用 print()函数打印 y 值。size = 2899用于给出尺寸。- random.normal(rd，(size，size)，dtype=jnp.float32) 用于生成从正态分布中抽取的数字样本。
- %timeit jnp.dot(y，y.T)。block_until_ready() 当 GPU 可用时在 GPU 上运行，否则在 CPU 上运行。
# Importing libraries
import jax.numpy as jnp
from jax import grad, jit, vmap
from jax import random
# Generating random data
rd = random.PRNGKey(0)
y = random.normal(rd, (8,))
print(y)
# Multiply two matrices
size = 2899
y = random.normal(rd, (size, size), dtype=jnp.float32)
# runs on the GPU
%timeit jnp.dot(y, y.T).block_until_ready()
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到两个矩阵的乘积被打印在屏幕上。
Introduction to JAX
至此，我们理解了 Jax 及其在 python 中的工作方式。
阅读: PyTorch 激活功能
py torch 简介
在本节中，我们将了解什么是 PyTorch 以及如何在 python 中使用 PyTorch。
PyTorch 是一个开源的机器学习库，主要用于 python 中的计算机视觉和自然语言处理。它是由脸书人工智能研究实验室开发的。
它是在修改的 BSD 许可证下发布的软件。它是基于 python 构建的，python 支持在 GPU(图形处理器)上计算张量。
PyTorch 易于使用，具有高效的内存使用，动态计算图，灵活，并创建可行的编码来提高处理速度。PyTorch 是最值得推荐的深度学习和人工智能库。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch 和 import math。
- y = torch.linspace(-math.pi，math.pi，2000，device=device，dtype=dtype) 用于创建随机输入输出数据。
- m = torch.randn(()，device=device，dtype=dtype) 用于随机初始化权重。
z _ pred = m+n * y+o * y * * 2+p * y * * 3用作前向传递来计算预测的 z。- 损失=(z _ pred–z)。pow(2)。sum()。item() 用于计算损失。
- print(int，loss) 用于打印损失。
- grad _ m = grad _ z _ pred . sum():这里我们应用反向传播来计算与损耗有关的 m、n、o 和 p 的梯度。
m -= learning_rate * grad_m用于使用梯度下降更新权重。- print(f ' result:z = { m . item()}+{ n . item()} y+{ o . item()} y^2+{ p . item()}y^3′)用于使用 print()函数打印结果。
# Importing libraries
import torch
import math
# Device Used
dtype = torch.float
device = torch.device("cpu")
# Create random input and output data
y = torch.linspace(-math.pi, math.pi, 2000, device=device, dtype=dtype)
z = torch.sin(y)
# Randomly initialize weights
m = torch.randn((), device=device, dtype=dtype)
n = torch.randn((), device=device, dtype=dtype)
o = torch.randn((), device=device, dtype=dtype)
p = torch.randn((), device=device, dtype=dtype)
learning_rate = 1e-6
for i in range(2000):
# Forward pass: compute predicted z
z_pred = m + n * y + o * y ` 2 + p * y ` 3
# Compute and print loss
loss = (z_pred - z).pow(2).sum().item()
if i % 100 == 99:
print(int, loss)
# Backprop to compute gradients of m, n, o, p with respect to loss
grad_z_pred = 2.0 * (z_pred - z)
grad_m = grad_z_pred.sum()
grad_n = (grad_z_pred * y).sum()
grad_o = (grad_z_pred * y ** 2).sum()
grad_p = (grad_z_pred * y ** 3).sum()
# Update weights using gradient descent
m -= learning_rate * grad_m
n -= learning_rate * grad_n
o -= learning_rate * grad_o
p -= learning_rate * grad_p
# Print the result
print(f'Result: z = {m.item()} + {n.item()} y + {o.item()} y^2 + {p.item()} y^3')
输出:
在下面的输出中，您可以看到项目的结果被打印在屏幕上。
Introduction to PyTorch
至此，我们理解了 PyTorch 及其实现。
阅读: PyTorch 全连接层
Jax Vs PyTorch
在本节中，我们将了解 python 中 Jax 和 PyTorch 的主要区别。
| Jax | 指针 |
| Jax 于 2018 年 12 月发布 | PyTorch 于 2016 年 10 月发布。 |
| Jax 是由 Google 开发的 | PyTorch 是脸书开发的 |
| 它的图形创建是静态的 | 它的图形创建是动态的 |
| 目标受众是研究人员 | 目标受众是研究人员和开发人员 |
| Jax 实现具有线性运行时复杂性。 | PyTorch 实现具有二次时间复杂度。 |
| Jax 比 PyTorch 更灵活，因为它允许您定义函数，然后自动计算这些函数的导数。 | PyTorch 很灵活。 |
| 开发阶段正在开发(v0.1.55) | 发展阶段成熟(v1.8.0) |
| Jax 比 PyTorch 更高效，因为它可以跨多个 CPU 自动并行化我们的代码。 | PyTorch 效率很高。 |
Jax Vs PyTorch
至此，我们了解了 Jax 和 PyTorch 之间的主要区别。
阅读: PyTorch 逻辑回归
Jax Vs PyTorch Vs TensorFlow
在本节中，我们将了解 python 中 Jax Vs py torch Vstensor flow的主要区别。
| Jax | PyTorch | 张量流 |
| Jax 是 Google 开发的。 | PyTorch 是脸书开发的。 | TensorFlow 是 Google 开发的。 |
| Jax 是灵活的。 | PyTorch 很灵活。 | TensorFlow 不灵活。 |
| Jax 的目标受众是研究人员 | PyTorch 的目标受众是研究人员和开发人员 | TensorFlow 的目标受众是研究人员和开发人员。 |
| Jax 创建了静态图 | PyTorch 创造了动态图表 | TensorFlow 创建了静态和动态图形 |
| Jax 既有高级 API，也有低级 API | PyTorch 有一个低级 API | TensorFlow 有一个高级 API |
| Jax 比 PyTorch 和 TensorFlow 更高效 | PyTorch 的效率比 Jax 低 | Tensorflow 的效率也不如 Jax |
| Jax 的开发阶段是 Developing(v0.1.55) | PyTorch 开发阶段已经成熟(1.8.0 版) | TensorFlow 开发阶段已经成熟(v2.4.1) |
Jax Vs PyTorch Vs TensorFlow
这样，我们理解了 Jax Vs PyTorch Vs TensorFlow。
阅读: PyTorch 数据加载器+示例
Jax Vs PyTorch 基准测试
在本节中，我们将学习 python 中的 Jax Vs PyTorch 基准测试。
Jax 是一个用于改变数值函数的机器学习库。它可以为 CPU 或加速器 GPU 汇编数值程序。
代码:
- 在下面的代码中，我们将导入所有必要的库，如 import jax.numpy as jnp，import grad，jit，vmap from jax，import random from jax。
- m =随机。PRNGKey(0) 用于生成随机数据，随机状态由两个无符号的 32 位整数描述，我们称之为密钥。
i = random.normal(rd，(8，))用于生成从正态分布中抽取的数字样本。 print(y)用于使用 print()函数打印 y 值。
size = 2899用来给尺寸。
random.normal(rd，(size，size)，dtype=jnp.float32) 用于生成从正态分布中抽取的数字样本。
%timeit jnp.dot(y，y.T)。block_until_ready() 当 GPU 可用时在 GPU 上运行，否则在 CPU 上运行。- %timeit jnp.dot(i，i.T)。block_until_ready(): 这里我们使用 block_until_ready，因为 jax 使用异步执行。
- i = num.random.normal(size=(siz，siz))。astype(num.float32) 用于传输 GPU 上的数据
# Importing Libraries
import jax.numpy as jnp
from jax import grad, jit, vmap
from jax import random
# Multiplying Matrices
m = random.PRNGKey(0)
i = random.normal(m, (10,))
print(i)
# Multiply two big matrices
siz = 2800
i = random.normal(m, (siz, siz), dtype=jnp.float32)
%timeit jnp.dot(i, i.T).block_until_ready()
# Jax Numpy function work on regular numpy array
import numpy as num
i = num.random.normal(size=(siz, siz)).astype(num.float32)
%timeit jnp.dot(i, i.T).block_until_ready()
# Transfer the data to GPU
from jax import device_put
i = num.random.normal(size=(siz, siz)).astype(num.float32)
i = device_put(i)
%timeit jnp.dot(i, i.T).block_until_ready()
输出:
运行上面的代码后，我们得到下面的输出，从中我们可以看到使用 Jax 的矩阵乘法是在屏幕上完成的。
Jax Vs PyTorch benchmark
PyTorch 基准
PyTorch benchmark 帮助我们验证我们的代码符合性能预期，并比较解决问题的不同方法。
代码:
在下面的代码中，我们将导入所有必要的库，如 import torch 和 import timeit。
- 返回 m.mul(n)。sum(-1) 用于通过相乘和求和来计算批量点。
- m = m . shape(-1，1，m.shape[-1]) 用于通过简化为 bmm 来计算批量点。
- i = torch.randn(1000，62) 用作基准测试的输入。
- print(f'multiply_sum(i，I):{ j . time it(100)/100 * 1e 6:>5.1f } us ')用于打印乘法和求和值。
- print(f'bmm(i，I):{ J1 . time it(100)/100 * 1e 6:>5.1f } us ')用于打印 bmm 值。
# Import library
import torch
import timeit
# Define the Model
def batcheddot_multiply_sum(m, n):
# Calculates batched dot by multiplying and sum
return m.mul(n).sum(-1)
def batcheddot_bmm(m, n):
#Calculates batched dot by reducing to bmm
m = m.reshape(-1, 1, m.shape[-1])
n = n.reshape(-1, n.shape[-1], 1)
return torch.bmm(m, n).flatten(-3)
# Input for benchmarking
i = torch.randn(1000, 62)
# Ensure that both functions compute the same output
assert batcheddot_multiply_sum(i, i).allclose(batcheddot_bmm(i, i))
# Using timeit.Timer() method
j = timeit.Timer(
stmt='batcheddot_multiply_sum(i, i)',
setup='from __main__ import batcheddot_multiply_sum',
globals={'i': i})
j1 = timeit.Timer(
stmt='batcheddot_bmm(i, i)',
setup='from __main__ import batcheddot_bmm',
globals={'i': i})
print(f'multiply_sum(i, i): {j.timeit(100) / 100 * 1e6:>5.1f} us')
print(f'bmm(i, i): {j1.timeit(100) / 100 * 1e6:>5.1f} us')
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到使用 PyTorch 基准的乘法和求和值打印在屏幕上。
Jax Vs PyTorch benchmark
至此，我们了解了 python 中 Jax 与 PyTorch 的基准测试。
另外，再看看一些 PyTorch 教程。
因此，在本教程中，我们讨论了 Jax Vs Pytorch ，并且我们还讨论了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- Jax 简介
- PyTorch 简介
- Jax Vs PyTorch
- Jax Vs PyTorch Vs TensorFlow
- Jax 与 PyTorch 基准测试
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
在 Python 中使用 JSON 数据
在本教程中，我们将讨论如何在 Python 中使用 JSON 数据。此外，我们将看到以下主题:
- 使用 python 的 JSON
- Python 从 JSON 文件中提取数据
- 从 JSON python 中提取特定数据
- 读取 JSON 文件 python
- Python 逐行读取 JSON 文件
- JSON 的 Python 对象
- Python 创建 JSON 数组
- Python 写 JSON 文件漂亮吗
- Python 字符串到 JSON
- 使用 JSON 的项目
目录
- json 与 python
- Python 从 JSON 文件中提取数据
- 从 JSON python 中提取特定数据
- 读取 JSON 文件 python
- Python 逐行读取 JSON 文件
- Python 对象到 JSON
- Python 创建 JSON 数组
- Python 写 json 到文件蛮
- Python 字符串到 JSON
- 使用 JSON 的项目
json 与 python
- JSON 代表 JavaScript 对象符号。
- JSON 因其轻量级数据交换格式而广受欢迎。
- JSON 格式看起来像 python 中的字典
- 它是一个键和值的格式
- JSON 模块总是产生
str对象。 dumps():将 Python 转换成 JSONloads():将 JSON 转换成 Python
Python 从 JSON 文件中提取数据
在这一节中，我们将学习如何用 python 从 JSON 文件中提取数据。
第一步:导入 json 模块
第二步:下载日期集
第三步:使用 open() 读取文件，并将其存储在 f 变量中
第四步:使用 load() 将 f 解析成 python 对象。
第五步: pass ' 键 ' '索引号' ' 键' &打印信息。
我们的目标是获取所有老师的名字。
JSON File for this project >>Download
import json
f = open('data.json', 'r')
db = json.load(f)
print(db['teacher_db'][0]['name'])
输出:
在这个输出中，我们打印了所有教师的姓名。 db['教师 _db'][0]['姓名'] 。
如果这令人困惑，你可以查看下一节的解释(从 JSON python 中提取字段)。
JSON data in Python
从 JSON python 中提取特定数据
现在，让我们看看如何用 Python 从 JSON 中提取特定数据。
- 提取信息是一门艺术。
- 在本节中，我们将学习如何得到我们想要的。
- 在处理数组时，要注意嵌套数组。
- 在前面的场景中，我们使用
db['teacher_db'][0]['name']来获取教师的姓名。 - 其中
db是保存所有值的变量，这就是它被放在第一个位置的原因。 - 现在我们有两个选择。(学生 _ 数据库 & 教师 _ 数据库)
- 我们选择
teacher_db，所以我们把它放在第二个位置。 - 现在我们有了选项( t_id，name，class，isPermanet )
- 每个都有一个从0–3开始的索引值。
- 因为我们想要一个名称，所以我们提供了索引值为【1】
(名称位于位置 1) - 然后我们在这个案例中提到了键即[‘名称’]。
- 这就是为什么完整的语句变成了db[' teacher _ db '][0][' name ']
- 这就是我们提取特定值的方法。
读取 JSON 文件 python
本节我们将学习如何用 python 读取 json 文件。
第一步:导入 json 模块
第二步:使用 open() 读取 json 文件，并将这些信息存储在文件变量中。
第三步:使用 load() 将 json 转换为 python ，并将信息存储在 db 变量中。
第四步:打印变量。
代码:
import json
with open('record.json') as file:
db = json.load(file)
print(db)
输出:
输出显示文件中的所有信息，一切都在一个键 & 值对中..
Read JSON file python
这就是我们如何在 python 中读取 json 文件数据的方法。
Python 逐行读取 JSON 文件
在这一节中，我们将看到如何用 Python 逐行读取 json 文件，并把它保存在一个空的 python 列表中。
第一步:导入 json 模块。
第二步: 创建名为lineByLine的空 python 列表
第三步:使用 open() 读取 json 文件，并将信息存储在文件变量中。
第四步:使用 load() &将项从 json 转换为 python，并将信息存储在 db 变量中。
第五步:在 lineByLine 空列表中追加 db 。
第六步:开始循环&打印 lineByLine 列表的项目
代码:
import json
lineByLine = []
with open('record.json') as file:
db = json.load(file)
lineByLine.append(db)
for line in lineByLine:
print(line[0],"\n",line[1],"\n",line[2])
print(type(line[0]))
输出:
输出逐行显示 json 文件的内容。每个项目显示在不同的行中。每行的数据类型是 Python dict 。
read json file by line in Python
这就是我们如何在 python 中逐行读取 json 文件。
Python 对象到 JSON
现在，让我们看看如何将 Python 对象转换成 json 。
- JSON 是一个 javascript 对象。这些对象需要被解析成 python 对象，然后只有我们可以使用和操作它们。
- json。
dumps()用于将 python 对象转换或解析为 JSON
代码:
import json
people = {'name': 'vin',
'age': 35,
'profession': 'Software Engineer',
'salary': 180000,
'police_rec': False}
print(people)
print(type(people))
to_json = json.dumps(people)
print(to_json)
print(type(to_json))
输出:
在这个输出中，python 对象即 dict 已经被解析或转换成 json 对象即 str 。
也，假 &假假已被指。python 有带大写' F 的 False，其中有 json 有小写' f' 。
Python object to JSON
Python 创建 JSON 数组
- Python 数组在数据结构化中起着主要作用。
- 在这一节。我们将学习如何在 Python 中创建一个数组&嵌套数组。
- 嵌套数组表示一个数组在另一个数组里面。
- 嵌套数组的数量决定了对象的维度。
代码:
import json
with open('array.json') as file:
db = json.load(file)
r = json.dumps(db, indent=2)
print(r)
输出:
在这个输出中，使用 JSON 创建了多维数组。
Python create JSON array
Python 写 json 到文件蛮
- 听起来真的很漂亮。
- 它改善了输出的外观。让它更具可读性。
- 它通过缩进和排序来显示数据。
- 在 JSON 中默认
indent = none&Sort _ file = false - 但是它可以被更改为任何值，比如
indent = 2 - 而
sort_file可以是true。这将按升序排列所有的键。
代码:
import json
with open('array.json') as file:
db = json.load(file)
print("Without PrettyPrint: \n", db)
print("\n")
r = json.dumps(db, indent=2)
print("with PrettyPrint: \n", r)
无漂亮打印的输出
在这个输出中，你可以注意到所有的东西都包含在 3 行中，这不容易理解。
Python write json to file pretty
用 prettyprint 输出
在这个输出中，你可以看到它看起来很好，很容易理解。我们所做的就是使用 Dump 将 python 转换成 json，并提供 2 的缩进。
Python 字符串到 JSON
- 在这一节中，我们将学习如何在 Python 中将字符串转换成 JSON
- JSON 总是返回‘str’
- 因此，这里看不到任何变化，但它被转换为 json。
代码:
import json
game = "God of war"
to_json = json.dumps(game)
print(type(to_json))
输出:
在这个输出中，字符串被转换为 JSON，JSON 总是返回 str 这就是为什么数据类型仍然显示 <类‘str’>
convert string to JSON in Python
使用 JSON 的项目
在这个项目中，我们使用 JSON 创建一个字典。用户可以搜索任何单词的意思。如果单词不可用，程序将显示错误提示。
改进范围:
虽然该项目已经完成，但仍有更多的功能，你可以尝试自己添加的余地。如果你遇到任何问题，请写在评论框里。
- 部分添加新单词
- 退出按钮
- 改进 Gui。
代码:
JSON File for this project >>Download
import json
from tkinter import *
from tkinter import messagebox
ws = Tk()
ws.geometry('300x140')
ws.title('Dictonary')
def find():
k = word_Tf.get()
try:
with open('data.json') as f:
db = json.load(f)
meaning = db[k]
return messagebox.showinfo('search result',meaning)
except Exception as ep:
return messagebox.showerror('error'," Word Not found!")
Label(ws, text='Enter word to search').place(x=30, y=10)
word_Tf = Entry(ws, width=40)
word_Tf.place(x=30, y=30)
search_Btn = Button(ws, text="Search", command=find, padx=20, pady=5, width=10)
search_Btn.place(x=145, y=70, anchor=CENTER)
ws.mainloop()
输出:
在这个输出中，创建了一个字典应用程序。你可以搜索一个词的任何意思。该词的含义将使用弹出消息框显示。如果单词不可用，将出现错误弹出消息。
如果这个词在 JSON 文件中不存在，你将会看到错误信息。
您可能会喜欢以下 Python 教程:
- 使用 Python 发送电子邮件
- Python 获得一个 IP 地址
- Python – stderr, stdin and stdout
- Python GUI 编程
- Python 中的递增和递减运算符
- Python 中的构造函数
- 面向对象编程 python
- Python 匿名函数(Lambda 函数)
我们学到了这些:
- 使用 python 的 JSON
- Python 从 JSON 文件中提取数据
- 从 JSON python 中提取特定数据
- 读取 JSON 文件 python
- Python 逐行读取 JSON 文件
- JSON 的 Python 对象
- Python 创建 JSON 数组
- Python 写 JSON 文件漂亮吗
- Python 字符串到 JSON
- 使用 JSON 的项目
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Keras 与 py torch–主要区别
在这个 Python 教程中，我们将学习 Python 中的 Keras Vs PyTorch ，我们还将涵盖与 Keras Vs PyTorch 相关的不同示例。这些是我们将在本教程中讨论的主题。
- Keras 简介
- PyTorch 简介
- Keras Vs PyTorch
Keras vs PyTorch
目录
Keras 简介
在本节中，我们将了解什么是 Keras 以及它在 python 中是如何工作的。
- Keras 是用 python 编写的，专为人类设计的高级神经网络 API。这是一个开源库，旨在提供快速实验。
- Keras 还用于减少认知负荷，也合并到 TensorFlow 中，用户可以作为 tf 访问它。Keras 。
- Keras 充当 Tensorflow 库的接口。
举例:
在这个例子中，我们将导入一些 Keras 库来使用 mnist 数据集构建模型。
- input_shape = (28，28，1) 用作数据参数。
- (xtrain，ytrain)，(xtest，y test)= keras . datasets . Mn ist . load _ data()用于将数据拆分为训练和测试数据集。
- ytrain = keras . utils . to _ categorial(ytrain，num_classes) 用于将类别向量转换为二进制类别矩阵。
model.summary()用于定义模型的摘要。batchsize = 126用于给出批量大小。- model . compile(loss = " categorial _ cross entropy "，optimizer="adam "，metrics=["accuracy"]) 用于编译模型。
- model.fit(xtrain，ytrain，batch_size=batchsize，epochs=epoch，validation_split=0.1) 用于拟合模型。
- scores = model.evaluate(xtest，ytest，verbose=0) 用于评估模型得分。
- print("Test loss:"，scores[0]) 用于在屏幕上打印测试损失分数。
- print("Test accuracy:"，scores[1]) 用于在屏幕上打印测试准确度分数。
import numpy as num
from tensorflow import keras
from tensorflow.keras import layers
**# Model**
num_classes = 10
input_shape = (28, 28, 1)
(xtrain, ytrain), (xtest, ytest) = keras.datasets.mnist.load_data()
**# Scale images to the [0, 1] range**
xtrain = xtrain.astype("float32") / 255
xtest = xtest.astype("float32") / 255
# Make sure images have shape (28, 28, 1)
xtrain = num.expand_dims(xtrain, -1)
xtest = num.expand_dims(xtest, -1)
print("xtrain shape:", xtrain.shape)
print(xtrain.shape[0], "Train samples")
print(xtest.shape[0], "Test samples")
ytrain = keras.utils.to_categorical(ytrain, num_classes)
ytest = keras.utils.to_categorical(ytest, num_classes)
model = keras.Sequential(
[
keras.Input(shape=input_shape),
layers.Conv2D(30, kernel_size=(3, 3), activation="relu"),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Conv2D(62, kernel_size=(3, 3), activation="relu"),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Flatten(),
layers.Dropout(0.3),
layers.Dense(num_classes, activation="softmax"),
]
)
model.summary()
batchsize = 126
epoch = 8
model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
model.fit(xtrain, ytrain, batch_size=batchsize, epochs=epoch, validation_split=0.1)
scores = model.evaluate(xtest, ytest, verbose=0)
print("Test loss:", scores[0])
print("Test accuracy:", scores[1])
输出:
在运行上面的代码之后，我们得到了下面的输出，其中我们可以看到带有测试损失分数和测试准确性分数的模型被打印在屏幕上。
Keras Example
另外，请查看: PyTorch 保存模型–完整指南
py torch 简介
在本节中，我们将了解什么是 PyTorch，以及如何在 python 中使用 PyTorch。
- PyTorch 是一个开源的机器学习库。它是在修改后的 BSD 许可证下发布的。
- PyTorch 用于计算机版本和自然语言处理应用程序，由脸书人工智能研究实验室开发。
举例:
在下面的例子中，我们将导入 torch 库来构建 PyTorch 模型。
- nn。Conv2d() 用于对输入应用 2d 卷积。
- nn。(linear())用于制作前馈神经网络。
- nn。MaxPool2d() 用于应用一个输入信号。
model = Net()用于描述模型的净值。- 打印(模型)用于打印模型输出。
import torch
from torch import nn
import torch.nn.functional as fun
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv = nn.Conv2d(6, 35, 6)
self.conv1 = nn.Conv2d(35, 19, 6)
self.fc = nn.Linear(16 * 6 * 6, 10)
self.pool = nn.MaxPool2d(2, 2)
def forward(self, y):
y = self.pool(fun.relu(self.conv(y)))
y = self.pool(fun.relu(self.conv1(y)))
y = y.view(-1, 16 * 6 * 6)
y = fun.log_softmax(self.fc(y), dim=-1)
return y
model = Net()
print(model)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到 PyTorch 模型被打印在屏幕上。
What is PyTorch
Keras Vs PyTorch
在本节中，我们将学习 python 中 Keras 和 PyTorch 的区别。
| Keras | 指针 |
| 1.Keras 于 2015 年 3 月发布。 | 1.PyTorch 于 2016 年 10 月发布。 |
| 2.Keras 有一个高级的 API | 2.PyTorch 有一个低级 API。 |
| 3.Keras 的数据集更小 | 3.PyTorch 拥有大数据集，高性能。 |
| 4.Keras 提供了静态计算图。 | 4.PyTorch 提供了动态计算图。 |
| 5.由于网络简单，Keras 通常不需要调试。 | 5.PyTorch 具有良好的调试能力。 |
| 6.Keras 的社区支持较少。 | 6.PyTorch 拥有更强的社区支持。 |
| 7.Keras 的速度很慢，这就是它性能低的原因。 | 7.PyTorch 的速度很快，这就是它性能高的原因。 |
| 8.Keras 的后端实现包括 Tensorflow。 | 8.PyTorch 没有后端实现。 |
| 9.Keras 是用 python 写的。 | 9.PyTorch 是用 Lua 写的。 |
| 10.在 Keras 中，由于计算垃圾的存在，调试很困难。 | 10.在 PyTorch 中，调试更加容易和快速。 |
Keras vs PyTorch
你可能会喜欢下面的 PyTorch 教程
因此，在本教程中，我们讨论了 Keras Vs PyTorch 并且我们也讨论了与此相关的例子。这是我们已经讨论过的例子列表。
- Keras 简介
- PyTorch 简介
- Keras Vs PyTorch
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
从初级到高级免费学习 Python
根据各种调查，Python 是世界上最流行的编程语言之一。学习 Python 很容易，我写了一系列详细的文章，你可以按照从初级到高级免费学习 Python。
无论你是 Python 初学者还是专家，PythonGuides.com都有一些的 Python 教程供你学习。
Learn Python from beginner to advanced free
如果你是一个编程初学者，那么 Python 是最容易学习的编程语言之一。我们所有的 Python 教程都是详细的教程，涵盖了多个例子。
除此之外，您还可以通过我们的 PythonGuides 脸书页面获得任何问题、建议和更新。
我们发布了带示例的逐步 Python 教程，确保在阅读的同时，也开始练习。
如果你没有任何编程知识，不要担心。还有，如果你在想学 Python 难吗？不，不是，学 Python 很容易。只要跟随我们的一步一步的 Python 教程。免费学习 Python！
目录
- 学习 Python 基础知识
- Python 变量和数据类型
- Python 编程概念
- Python 循环
- Python 函数
- Python 文件
- Python 类
- Python Tkinter
- 高级 Python 教程
- 机器学习
学习 Python 基础知识
在本节中，让我们学习一些 Python 基础知识。从下面的教程一个一个开始。
- 什么是 Python +优缺点及更多？
- 下载并安装 Python 和 Python 的代码编辑器
- 创建你的第一个 Hello World Python 程序
Python 变量和数据类型
在本节中，我们将学习 Python 变量和 Python 数据类型。
- Python 变量
- Python 字符串变量
- 在 Python 中把整数转换成字符串
- 在 Python 中连接字符串
- 在 Python 中使用正则表达式拆分字符串
- 删除 python 中的 Unicode 字符
- 检查一个数是否是素数 Python
- 从字符串 Python 中删除字符
- Python 关键词
- Python 检查变量是否为整数
- Python 中的递增和递减运算符
- Python 格式数字加逗号
- Python 打印 2 位小数
- 如何在 Python 中把字符串转换成日期时间
- 如何将 Python 角度转换为弧度
- Python 比较运算符
- 如何将 Python 字符串转换成字节数组
- Python 要求用户输入
- 使用 if-else 理解 Python 列表
Python 编程概念
让我们看看更多的 Python 编程概念。
- 什么是 Python 字典 +如何用 Python 创建字典
- Python 字典追加
- Python 列表
- Python 将列表转换成字符串
- 在 Python 中检查列表是否为空
- Python 从列表中选择
- Python 加法示例
- Python 中的乘法与例题
- 在 Python 中创建一个元组
- Python 元组排序列表
- Python 将元组转换为列表
- Python 中的注释行
- Python 数组
- Python 空数组
- Python 创建空集
- python 中的哈希表
- Python 中的排序算法
- Python 优先级队列
- Python 中的链表
- 如何用 Python 制作矩阵
- Python 中的正则表达式
- Python 布尔函数
- 集合 Python 的并集
- Python 中的转义序列
- Python 形状的一个数组
- 使用 if-else 理解 Python 列表
Python 循环
在这一节中，让我们检查一下 Python 循环。
Python 函数
让我们看看几个 Python 函数博客。
Python 文件
让我们看看如何在 Python 中处理文件。
- 获取当前目录 Python
- Python 读写 excel 文件
- Python 读取 CSV 文件并写入 CSV 文件
- Python 从路径中获取文件名
- Python 将列表写入文件
- Python 将字符串写入文件
- Python 将变量写入文件
- Python 文件方法
- Python 读取二进制文件
- Python 复制文件
Python 类
让我们检查一下 Python 类、接口、访问修饰符和 oops 概念。
Python Tkinter
在本节中，我们将学习 Python Tkinter 或 Python GUI 编程。
- Python GUI 编程 (Python Tkinter)
- Python tkinter 标签
- Python Tkinter 条目
- Python Tkinter Button
- Python Tkinter 单选按钮
- Python Tkinter Checkbutton
- Python Tkinter Menu bar
- Python Tkinter 计算器
- Python tkinter messagebox
- Python Tkinter 帧
- Python Tkinter 列表框
- Python Tkinter Stopwatch
- Python Tkinter 进度条
- Python Tkinter 画布教程
- 如何进入 Python Tkinter 程序的下一页
- 如何使用 Python Tkinter 读取文本文件
- 如何使用 Python Tkinter 获取用户输入并存储在变量中
- Python Tkinter 退出程序
- Python Tkinter TreeView 示例
- Python Tkinter 待办事项列表
- Python Tkinter 窗口大小
高级 Python 教程
让我们来看看一些高级 Python 教程。
- Python 命名约定
- Python 退出命令(quit()、exit()、sys.exit())
- 在 Python 中使用 JSON 数据
- 使用 Python 发送电子邮件
- Python 中的构造函数
- Python 二分搜索法和线性搜索
- Python 点积和叉积
- Python 递归
- Python 生成随机数和字符串
- Python 生成器
- Python 日历
- Python 计算器
- Python 线程和多线程
- Python 列表理解λ
- Python 中的 Turtle 编程
- Python 通过引用或值传递
- 使用蟒蛇龟绘制彩色填充形状
- 如何用 Turtle 创建 Python 中的贪吃蛇游戏
机器学习
让我们来看看一些关于机器学习的有用教程:
希望大家按照上面的循序渐进的 Python 教程和从初级到高级免费学习 Python。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python 中的链表
在本 Python 教程中，我们将讨论关于 Python 中的链表。此外，我们将看到以下主题:
- python 中的链表是什么？
- 用 python 创建一个链表
- python 中的链表程序
- 在 python 中遍历链表
- 在 python 中在链表的开头插入
- 在 python 中的链表末尾插入
- python 中链表的删除
目录
- python 中的链表是什么？
- 用 python 创建一个链表
- python 中的链表程序
- 在 python 中遍历链表
- 在 Python 中的链表开头插入
- 在 python 中的链表末尾插入
- python 中链表的删除
python 中的链表是什么？
- Python 中的链表是一种线性数据结构，其中的元素不存储在连续的内存位置。
- 每个数据元素以指针的形式连接到另一个数据元素。
- 链表由节点组成，其中每个节点都有一个数据字段和一个到下一个节点的链接。
- 第一个节点称为头部，它是遍历一个列表的起点。
- 最后一个节点的下一个引用指向 none，这意味着它是列表的末尾。
- Python 的标准库中没有链表。
Linked Lists in Python
你可能喜欢 Python 复制文件(示例)
用 python 创建一个链表
现在，我们可以看到如何在 python 中创建链表。
让我们创建一个单独的节点，首先我们将创建一个保存一些数据和一个指针 next 的节点类，它将用于指向链表中的下一个节点。
举例:
class Node:
def__init__(self, data, next=None):
self.data = data
self.next = next
s = Node(5)
print(s.data)
写完上面的代码(用 python 创建一个链表)，当你要打印 "s.data" 的时候那么输出会出现 "5" 。在这里，我创建了一个单独的节点“s = Node(5)”，打印后，它将返回该节点的数据。
你可以参考下面的截图，用 python 创建一个链表。
Create a linked list in python
python 中的链表程序
- 首先，用实例变量 data 和 next 创建一个类节点。
- 现在，我将用实例变量 head 和 last_node 创建一个类 Linkedlist。
- 变量 head 指向链表中的第一个元素，last_node 指向最后一个元素。
- 此外，在 linkedlist 类中定义 append 和 display 方法，以追加数据并显示一个链接列表
- 为链表创建一个实例，向其追加数据，并显示它。
举例:
class Node:
def__init__(self, data):
self.data = data
self.next = None
class Linkedlist:
def__init__(self):
self.head = None
self.last_node = None
def append(self, data):
if self.last_node is None:
self.head = Node(data)
self.last_node = self.head
else:
self.last_node.next = Node(data)
self.last_node = self.last_node.next
def display(self):
curr = self.head
while curr is not None:
print(curr.data, end = ' ')
curr = curr.next
my_llist = Linkedlist()
a = int(input('How many elements you will like to add? '))
for i in range(a):
data = int(input('Enter data item: '))
my_llist.append(data)
print('The linked list: ', end = ' ')
my_llist.display()
写完上面的代码(python 中的链表程序)，当你要显示列表时，输出就会出现。这里，要求用户输入要添加的元素数量，并使用一个循环将数据追加到链表中。链接列表值将显示在输出中。
Linked list program in python
你可以参考下面的输出:
Python linked list example
在 python 中遍历链表
遍历是指遍历每一个节点，单链表从链表头开始向前遍历，到下一个值为 None 的节点结束。
举例:
class Node:
def__init__(self, data=None):
self.data = data
self.next = None
class Linkedlist:
def__init__(self):
self.headvalue = None
def listprint(self):
printvalue = self.headvalue
while printvalue is not None:
print (printvalue.data)
printvalue = printvalue.next
list = Linkedlist()
list.headvalue = Node("first")
x2 = Node("second")
x3 = Node("third")
list.headvalue.next = x2
x2.next = x3
list.listprint()
写完上面的代码(在 python 中遍历一个链表)，当你打印时，输出将显示为 "first second third" 。这里，我们简单地打印当前数据项的值，并通过分配下一个节点的指针来打印下一个数据项。
你可以参考下面的截图，在 python 中遍历一个链表。
Traversing a linked list in python
在 Python 中的链表开头插入
现在，我们将看到如何将插入到链表的开头。
为了将插入到链表的开头，我们将在给定链表的头部之前添加一个新的节点。新添加的节点将成为链表的新头。
举例:
class Node:
def__init__(self, data=None):
self.data = data
self.next = None
class Linkedlist:
def__init__(self):
self.headvalue = None
def listprint(self):
printvalue = self.headvalue
while printvalue is not None:
print (printvalue.data)
printvalue = printvalue.next
def Atbegining(self,newdata):
NewNode = Node(newdata)
NewNode.next = self.headvalue
self.headvalue = NewNode
my_list = Linkedlist()
my_list.headvalue = Node("jan")
x2 = Node("feb")
x3 = Node("march")
my_list.headvalue.next = x2
x2.next = x3
my_list.Atbegining("dec")
my_list.listprint()
在编写完上面的代码(在 python 中插入链表的开头)后，当您打印时，输出将显示为 "dec jan feb march" 。现在，我们将调用在列表开头添加的函数，新节点将被插入到列表的开头
在链表的开头插入，可以参考下面的截图。
Inserting at the beginning of the linked list in python
你可以参考下面的输出:
在 python 中的链表末尾插入
节点被添加到链表的端，这包括将最后一个节点的下一个指针指向链表的新数据节点。现在，当前最后一个节点将成为倒数第二个数据，而新节点将成为链表的最后一个节点。
举例:
class Node:
def__init__(self, data=None):
self.data = data
self.next = None
class Linkedlist:
def__init__(self):
self.headvalue = None
def AtEnd(self,newdata):
NewNode = Node(newdata)
if self.headvalue is None:
self.headvalue = NewNode
return
last = self.headvalue
while(last.next):
last = last.next
last.next=NewNode
def listprint(self):
printvalue = self.headvalue
while printvalue is not None:
print (printvalue.data)
printvalue = printvalue.next
my_list = Linkedlist()
my_list.headvalue = Node("jan")
x2 = Node("feb")
x3 = Node("march")
my_list.headvalue.next = x2
x2.next = x3
my_list.AtEnd("april")
my_list.listprint()
在编写完上面的代码(在 python 中插入链表的末尾)之后，当您打印时，输出将显示为 " jan feb march april" 。现在，我们将调用在列表末尾添加新节点的函数。
python 中在链表末尾插入可以参考下面的截图。
Inserting at the end of the linked list in python
你可以参考下面的输出:
Insert at the end of the linked list in python
python 中链表的删除
让我们看看如何在链表中删除一个节点。
要删除链表中的一个节点，我们会找到要删除的节点的前一个节点。我们将改变前一个节点的下一个，并调用一个函数来删除一个节点。
举例:
class Node:
def __init__(self, data=None):
self.data = data
self.next = None
class Linkedlist:
def __init__(self):
self.head = None
def Atbegining(self, data_n):
NewNode = Node(data_n)
NewNode.next = self.head
self.head = NewNode
def RemoveNode(self, Removekey):
Headvalue = self.head
if (Headvalue is not None):
if (Headvalue.data == Removekey):
self.head = Headvalue.next
Headvalue = None
return
while (Headvalue is not None):
if Headvalue.data == Removekey:
break
previous = Headvalue
Headvalue = Headvalue.next
if (Headvalue == None):
return
previous.next = Headvalue.next
Headvalue = None
def list_print(self):
printvalue = self.head
while (printvalue):
print(printvalue.data),
printvalue = printvalue.next
my_list = Linkedlist()
my_list.Atbegining("jan")
my_list.Atbegining("feb")
my_list.Atbegining("march")
my_list.RemoveNode("jan")
my_list.list_print()
在编写了上面的代码(在 python 中插入链表的末尾)之后，当您打印时，输出将显示为 " march feb" 。现在，我们将调用从列表中删除指定节点的函数。
可以参考下面的输出:
Deletion in a linked list in python
您可能会喜欢以下 Python 教程:
- 如何用 Python 显示日历
- 如何用 Python 制作计算器
- Python 中的正则表达式
- Python 打印 2 位小数
- Python 递归
- Python 中的递增和递减运算符
- Python 中的构造函数
- Python 匿名函数(Lambda 函数)
- 集合的并集 Python +实例
在本 Python 教程中，我们学习了 Python 中的链表。此外，我们还讨论了以下主题:
- python 中的链表是什么？
- 用 python 创建一个链表
- python 中的链表程序
- 在 python 中遍历链表
- python 中如何在链表的开头插入
- 如何在 python 中的链表末尾插入
- python 中链表的删除
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中创建元组列表
在这篇文章中，我们将通过几种不同的方法在 Python 中创建元组列表。列表是可变的，而元组是不可变的，这是这两种类型的数据之间的关键区别。这具体是什么意思？换句话说，列表的项目可以被编辑或修改，但是元组的项目不能。
- 如何在 Python 中创建元组列表
- 如何使用 map()函数在 Python 中创建元组列表
- 如何使用列表理解和元组方法在 Python 中创建元组列表
- 如何使用 zip 方法在 Python 中创建元组列表
- Python 程序创建元组列表
目录
- 如何在 Python 中创建元组列表
- 如何使用 map()函数在 Python 中创建元组列表
- 如何使用列表理解和元组方法在 Python 中创建元组列表
- 如何使用 zip 方法在 Python 中创建元组列表
- Python 程序创建元组列表
如何在 Python 中创建元组列表
- 这里我们将讨论如何用 Python 创建元组列表。
- 在这个例子中，我们将简单地创建一个列表和元组并显示它。像数组一样，列表对象也是声明的。
- 由于列表并不总是同质的，它们可以同时存储几种数据类型的对象。列表中的项目包含在方括号中[] 。
- 所有的项目(元素)必须用括号()括起来，每个项目用逗号隔开，形成一个元组。任意数量的对象可以是各种类型，并且可以包含在一个元组(整数、浮点、列表、字符串等)中。)。
举例:
让我们举一个例子，看看如何用 Python 创建元组列表
源代码:
# Created list of tuple
Country_name = [(67, 'U.S.A'), (25, 'France'), (96, 'Germany'),
(15, 'Australia'), (34, 'China')]
# Display the Content
print(" Creation list of tuple:",Country_name)
上面，我们定义了一个名为 Country_name 的变量，它保存了一个国家名称和整数的列表。列表由括号[] 和元组包围，元组定义为括起来的括号()。
下面是以下给定代码的实现。
Created tuples within the list in Python
这就是我们在 Python 中创建列表元组的方式。
如何使用 map()函数在 Python 中创建元组列表
- 在本节中，我们将讨论如何使用
map()函数在 Python 中创建元组列表。Map()是 Python 中的内置函数。 - Python 的 map()方法将函数应用于迭代器中作为输入提供的每一项。例如，迭代器可以返回一个可迭代的 map 对象，它可以是一个列表、元组、集合、字典或字符串。
- 当您想要使用单个转换函数改变每个可迭代元素时，可以使用它。在 Python 中，iterable 和函数作为参数提供给地图。
语法:
让我们看一下语法并理解 Python 中的 map() 函数的工作原理。
map(function, iterables)
- 它由两个主要参数组成
- 功能:地图提供每个可迭代项目的功能。
iterables:你要映射的序列。
举例:
让我们举一个例子，看看如何使用 map()函数在 Python 中创建一个元组列表。
源代码:
# Creation list of tuples
Cities_in_USA = [["Phoenix"],["San Antonio"],["Dallas"],["San Jose"]]
# By using the map() function
new_output =list(map(tuple, Cities_in_USA ))
# Display the Content
print("Creation list of tuples :",new_output)
这里， Cities_in_USA 是创建元组列表的输入列表。使用 map() 函数，我们将给定的列表映射到元组函数。然后使用 list() 函数将映射的元组值创建为一个列表。
你可以参考下面的截图。
Using the map function we created a list of tuples
正如你在截图中看到的，我们已经讨论了如何使用 map()函数在 Python 中创建元组列表。
如何使用列表理解和元组方法在 Python 中创建元组列表
- 在这个例子中，我们将讨论如何使用 Python 中的列表理解和元组方法来创建元组列表。
- Python 的 list comprehension 语法使得从字符串创建列表变得简单而高效。对原始列表中的每个项目执行一个过程是构建新列表的一种非常简洁的技术。
- 可以使用 List Comprehension 和 Python 中的
tuple()函数创建元组列表。给予tuple()函数的元素集合有助于创建元组。
语法:
下面是 Python 中列表理解方法的语法。
[tuple(x) for x in inout_value]
注意:这里的 tuple(x) 是一个迭代器，将对象转换成元组。
举例:
让我们举一个例子，检查如何使用 Python 中的 list comprehension 和 tuple 方法创建元组列表。
源代码:
# create a list with name
bikes_in_USA = [['Harley Davidson'], ['Confederate'], ['Motus MSTR'],
['Alta Motors Redshift']]
# By using the list comprehension method
new_result = [tuple(x) for x in bikes_in_USA ]
# Display the Content
print(new_result)
在下面给出的代码中，首先，我们在列表中创建了一个列表，并为元素赋值。接下来，我们使用 list comprehension 并迭代条目，通过使用 tuple() 方法，它将被转换为元组列表。
下面是以下给定代码的执行。
Created a list of tuples from the input nested list
这就是我们如何从输入嵌套列表中创建元组列表。
如何使用 zip 方法在 Python 中创建元组列表
- 这里我们将讨论如何使用 Python 中的 zip 方法创建元组列表。
- Python 中的内置 zip() 函数允许用户组合任意数量的 iterables (list、str 等。)从每个被指定为输入的 iterable 中取出项目。
- 在这个例子中，我们将使用 list 方法，在这个方法中，我们将 zip()函数作为参数传递，这个函数将返回元组的迭代器。
语法:
让我们看一下语法并理解 Python 中的 zip() 函数的工作原理。
zip(iterable1, iterable2, ...)
注意:这个函数只需要 iterable 参数，这些迭代器对象组合在一起。
举例:
让我们举一个例子，看看如何使用 Python 中的 zip 方法创建元组列表。
源代码:
# Create two lists with state zipcode and state_name from U.S.A
State_Zipcode = [35004 , 90001, 80001]
State_name = ['Alabama', 'California', 'Colorado']
# By using the zip() function
new_result = list(zip(State_Zipcode, State_name))
# Display the Content
print("Created list of tuple :",new_result)
在上面的代码中，我们首先创建了两个名为 State_Zipcode 和 State_name 的列表。现在我们必须开发一个元组列表，为此我们使用了 list 函数，它会通过使用 zip 方法创建一个元组列表，在这个方法中，我们将 iterables 作为参数传递。在本例中，列出了 iterables。
下面是以下代码的截图
Using the zip method to create a list of tuple
在这个例子中，我们已经理解了如何使用 Python 中的 zip 方法创建元组列表。
Python 程序创建元组列表
- 在这一节中，我们将讨论如何创建一个元组列表，第一项是数字，第二项是数字的平方。
- 在本例中，我们将获取一个范围并生成一个元组列表，只要该范围在该范围内，第一项就是数字，第二项就是数字的平方。
- 首先，我们将通过输入用户来设置上限值和下限值的范围，通过使用列表理解方法，我们可以轻松地创建元组列表，在这种情况下，第一项是数字，第二项是数字的平方。
举例:
让我们举一个例子，检查如何使用列表理解方法并接受用户的输入来创建元组列表。
源代码:
new_lower_val=int(input("Enter the lower value:"))
new_higher_val=int(input("Enter the upper value:"))
# By using the list comprehension method
new_result=[(m,m**2) for m in range(new_lower_val,new_higher_val+1)]
print(new_result)
下面是以下给定代码的执行。
Python Program to Create a list of tuples
您可能也喜欢阅读以下 Python 教程。
- 如何用 Python 将列表追加到另一个列表中
- 如何在 Python 中反转一个数字
- 偶数或奇数的 Python 程序
- 如何在 Python 中访问元组的条目
- 删除 Python 中字符串的最后一个字符
在本文中，我们讨论了用 Python 制作元组列表的几种不同方法。下面这个话题我们已经讲过了。
- 如何在 Python 中创建元组列表
- 如何使用 map()函数在 Python 中创建元组列表
- 如何使用列表理解和元组方法在 Python 中创建元组列表
- 如何使用 zip 方法在 Python 中创建元组列表
- Python 程序创建元组列表
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python Django 中的登录系统
在本 Python Django 教程中，我们将学习在 Python Django 中创建一个登录系统 。而且我们还会举一些与此相关的例子。这些是我们将在本教程中讨论的以下主题。
- Python Django 中的登录系统
- 如何创建 Django 内置登录系统
- 如何创建 Django 定制登录系统
- 如何创建 Django 多模式登录系统
目录
在 Python Django 中登录系统
在这一节中，我们将学习在 python Django 中登录系统是什么意思。
登录系统是一种安全功能，可以防止未经授权的用户访问网站上的资源。登录系统有三个部分:
- 注册:注册是创建新账户的过程。如果你想第一次使用一个门户或应用程序，你必须先注册。
- 登录:登录是用来验证用户身份的凭证集合。它表示用户已经被识别和认证，以便获得对网站的访问。最常见的组合是用户名和密码。
- 注销:要注销一个网站，必须先登录。当您注销时，您是在告诉网站您想要停止登录会话。
如何创建 django 内置登录系统
在这一节中，我们将学习如何使用 Django 的内置特性来开发登录系统的登录页面。我将用一个例子一步一步地指导你。
1。创建项目
如果您开始一个新项目，首先创建一个新的 Django 项目。创建新项目命令如下:
django-admin startproject project_name
示例:在这里，我创建了一个名为 LoginSystem 的新项目。
命令:
django-admin startproject LoginSystem
Start Project
2。检查必要的设置
在创建登录系统之前，请确保您的安装的应用中有 django.contrib.auth ，并且您的认证中间件在中间件设置中配置正确。
An application that is already included
3。进行迁移
迁移是一种将我们对模型所做的更改应用到数据库模式中的方法。为了根据迁移文件中定义的模式创建所有表，我们运行以下命令。
python manage.py migrate
4。定义项目 URL
网址被称为 URL。每次访问网站时，您都可以在浏览器的地址栏中看到该网址。每个网页必须有自己独特的网址。因此，您的应用程序将知道向访问该 URL 的用户显示什么。
打开项目的 urls.py 文件并指定特定的 URL。
from django.contrib import admin
from django.urls import path, include
from django.contrib.auth import views as auth_views
urlpatterns = [
path('admin/', admin.site.urls),
path('login/', auth_views.LoginView.as_view(), name='login'),
path('login/',include('home.urls')),
]
导入 django.contrib.auth.views 模块，并将登录页面和主页的 URLconf 添加到 urls.py 文件中。
5。登录模板
基本上，Django 模板用于生成最终用户可见的动态 HTML 网页。Django 中的模板是用 html、CSS 和 Javascript 在一个. HTML 文件中编写的。
默认情况下，LoginView 将尝试呈现 registration/login.html。在你的模板文件夹中创建一个注册文件夹，并在里面创建一个 login.html 页面。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>LoginSystem</title>
</head>
<body>
<form method="post">
{% csrf_token %}
{{form.as_p}}
<input type="submit" value="Login"/>
</form>
</body>
</html>
6。模板配置
要配置模板系统，我们必须在 settings.py 文件中指定几个项目。我们的模板目录的名称是 templates。Django Templates 在默认情况下会在每个已安装的应用程序子目录中搜索一个 Templates 子目录。
Template Configuration
7。重定向到主页
成功登录后，我们需要重定向到下一页，即主页。所以，让我们先学习创建应用程序
创建应用程序的命令:
python manage.py startapp app_name
这里我创建了一个名为 Home 的应用程序。
Create App
现在，我们要将应用程序包含在您的项目中，将您的应用程序名称添加到项目的 settings.py 中的已安装应用程序列表中。
INSTALLED_APPS = [
'home',
]
接下来，在应用程序的 urls.py 文件中定义 URL。
from django.urls import path, include
from home import views
urlpatterns = [
path('home/', views.home, name='home'),
]
之后，定义应用程序的视图。
from django.shortcuts import render, HttpResponse
# Create your views here.
def home(request):
return render(request, 'home.html')
接下来，在 Home 应用程序的模板文件夹中创建一个 home.html 文件。
<!doctype html>
<html lang="en">
<head>
<!-- Required meta tags -->
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<!-- Bootstrap CSS -->
<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-EVSTQN3/azprG1Anm3QDgpJLIm9Nao0Yz1ztcQTwFspd3yD65VohhpuuCOmLASjC" crossorigin="anonymous">
<title>PythonGuides!</title>
</head>
<body>
<nav class="navbar navbar-expand-lg navbar-dark bg-dark">
<div class="container-fluid">
<a class="navbar-brand" href="#">PythonGuides</a>
<button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
<span class="navbar-toggler-icon"></span>
</button>
<div class="collapse navbar-collapse" id="navbarSupportedContent">
<ul class="navbar-nav me-auto mb-2 mb-lg-0">
<li class="nav-item">
<a class="nav-link active" aria-current="page" href="#">Home</a>
</li>
</ul>
<form class="d-flex">
<input class="form-control me-2" type="search" placeholder="Search" aria-label="Search">
<button class="btn btn-outline-success" type="submit">Search</button>
</form>
</div>
</div>
</nav>
<div class="container my-3">
<h1 style="text-align:center;">Welcome to Python Guides</h1>
</div>
<div class="card">
<div class="card-body">
<h3 style="text-align:center;">Thanks for landing on this page to know more about PythonGuides.com.</h3>
<br>
<h6>I welcome you to the website and hopefully, you got to learn something in Python. I started this website to share my finding and learnings in Python with you.</h6>
<h6>To keep things simple, I am trying to write a lot of articles on Python. Feel free to give your valuable comments and also share the articles if you are liking and hoping it will be helpful to someone.</h6>
<br>
<h2 style="text-align:center;">Also, Subscribe to Our YouTube Channel for FREE Python Video Tutorials.</h2>
</div>
<!-- Optional JavaScript; choose one of the two! -->
<!-- Option 1: Bootstrap Bundle with Popper -->
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js" integrity="sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM" crossorigin="anonymous"></script>
<!-- Option 2: Separate Popper and Bootstrap JS -->
<!--
<script src="https://cdn.jsdelivr.net/npm/@popperjs/core@2.9.2/dist/umd/popper.min.js" integrity="sha384-IQsoLXl5PILFhosVNubq5LC7Qb9DXgDA9i+tQ8Zj3iwWAwPtgFTxbJ8NT4GN1R8p" crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.min.js" integrity="sha384-cVKIPhGWiC2Al4u+LWgxfKTRIcfu0JTxR+EQDz/bgldoEyl4H0zUF0QKbrJ0EcQF" crossorigin="anonymous"></script>
-->
</body>
</html>
我们现在需要重定向到下一页。可以将以下代码添加到 settings.py 中来设置下一页:
LOGIN_REDIRECT_URL = next_page
在我的例子中，我想在成功登录后重定向到主页。
LOGIN_REDIRECT_URL = 'home/'
Login Settings
如果没有指定登录重定向 URL，将使用默认 URL/accounts/profile/，导致模板不存在问题。
8。创建超级用户
到目前为止，我们还没有为此创建任何用户。因此，我们将创建一个用户。所以，看看我们如何做到这一点。
要创建超级用户，请运行以下命令:
python manage.py createsuperuser
- 然后输入您选择的用户名，如果您愿意的话。否则，它将使用默认的系统名称。
- 然后输入电子邮件地址并按回车键。您也可以将其留空。
- 然后，在密码字段前面，键入密码并按 enter 键。为确保安全，请输入强密码。
- 然后再次输入相同的密码进行确认。
9。运行服务器
在这一节中，我们将学习如何在 Django 中运行服务器。要启动服务器，请在终端中使用以下命令。
python manage.py runserver
输出如下:
现在，输入用户名和密码，然后单击登录按钮。成功登录后，您将重定向到主页。
Home Page
如何创建 Django 定制登录系统
在这一节中，我们将学习在不使用 Django 内置特性的情况下创建注册页面、登录页面和注销页面。我将用一个例子一步一步地指导你。
1。基本步骤
在创建注册、登录或注销页面之前，我们必须首先完成以下步骤。
创建项目: 首先，我们必须创建一个 Django 项目。创建 Django 项目的命令是:
django-admin startproject project_name
因此，我构建了一个名为 CustomLogin 的项目。
Create Project
创建应用: 创建 Django 项目后，我们需要创建一个 Django 应用。创建 Django 应用程序的命令是:
python manage.py startapp app_name
所以，我建立了一个名为账户的应用。
Create App
安装应用: 创建 Django 应用后，我们需要安装一个 Django 应用。为此，请转到项目目录并打开 settings.py 文件。现在，在 INSTALLED_APPS 中，键入您的应用程序的名称。
Install App
模板: 你需要一个模板文件夹来存放你的 HTML 文件。因此，在你的应用程序目录下，创建一个模板文件夹。转到 settings.py 文件，在模板中定义 DIRS 路径。
Define Templates
2。定义 URL 文件
根据 Django 的说法，所有资源都应该使用 urls.py 文件进行映射。
项目 URLs 文件:Django 默认在项目中包含一个 urls.py 文件。该文件有一个到管理应用程序的预定义路径。我们在应用程序下定义新创建的 urls.py 文件的路径。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('accounts/', include('accounts.urls'))
]
App URLs 文件: 首先我们要在 App 目录下创建一个名为 urls.py 的文件。现在，我们定义在应用程序的 views.py 文件下创建的不同视图的路径。
from django.urls import path
from . import views
urlpatterns = [
path("register", views.register, name="register"),
path("login_user", views.login_user, name="login_user"),
path("logout_user", views.logout_user, name="logout_user"),
path("home", views.home, name="home")
]
3。注册
现在，我们将学习创建注册视图。为此，我们必须在 app 目录的 views.py 文件中创建一个函数寄存器。
from django.contrib import messages
from django.shortcuts import render, redirect
def register(request):
if request.method == 'POST':
first_name = request.POST['first_name']
last_name = request.POST['last_name']
username = request.POST['username']
email = request.POST['email']
password = request.POST['password']
confirm_password = request.POST['confirm_password']
if password==confirm_password:
if User.objects.filter(username=username).exists():
messages.info(request, 'Username is already taken')
return redirect(register)
elif User.objects.filter(email=email).exists():
messages.info(request, 'Email is already taken')
return redirect(register)
else:
user = User.objects.create_user(username=username, password=password,
email=email, first_name=first_name, last_name=last_name)
user.save()
return redirect('login_user')
else:
messages.info(request, 'Both passwords are not matching')
return redirect(register)
else:
return render(request, 'registeration.html')
- 我们首先定义寄存器函数，它利用了请求对象。当页面被请求时，Django 发出 HttpRequest。在这种情况下，我们将利用 HTTP 方法 Post 向服务器提交数据，以便创建或更新资源。
- 向服务器发送名、姓、用户名、电子邮件、密码，以及确认密码。
- 然后，我们使用各种对象过滤器来检查密码是否与确认密码相同(如果电子邮件地址已经存在)，并相应地打印邮件，以及根据过滤器响应重定向页面。
现在，我们来看看registration.html:
resgistration.html 文件指定了注册网页的外观。
<!doctype html>
<html lang="en">
<head>
<!-- Required meta tags -->
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
<!-- Bootstrap CSS -->
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"
integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
<title>SIGNUP</title>
</head>
<body>
<form action="/accounts/register" method="POST" class="form-horizontal">
{% csrf_token%}
<div class="mx-auto" style="width: 400px;">
<div class="col-xs-8 col-xs-offset-4">
<h2 style="text-align:center;">SIGN UP</h2>
</div>
<hr />
<div class="form-group">
<label for="username">Username</label>
<input type="text" class="form-control" name="username" id="username" placeholder="Enter Username"
Required>
</div>
<div class="form-group">
<label for="fanme">First Name</label>
<input type="text" class="form-control" name="first_name" id="first_name" placeholder="Enter First Name"
Required>
</div>
<div class="form-group">
<label for="lname">Last Name</label>
<input type="text" class="form-control" name="last_name" id="last_name" placeholder="Enter Last Name"
Required>
</div>
<div class="form-group">
<label for="email">Email address</label>
<input type="email" class="form-control" name="email" id="email" placeholder="Enter email" Required>
</div>
<div class="form-group">
<label for="password">Password</label>
<input type="password" class="form-control" name="password" id="password" placeholder="Enter Password"
Required>
</div>
<div class="form-group">
<label for="confirm_password">Confirm Password</label>
<input type="password" class="form-control" name="confirm_password" id="confirm_password"
placeholder="Confirm Your Password" Required>
</div>
<button type="submit" class="btn btn-primary">SIGNUP</button>
<a class="btn btn-dark" href="login_user" role="button">LOGIN</a>
</div>
</form>
<div class="form-group">
{% for message in messages %}
<div class="alert alert-danger" role="alert">
{{message}}
</div>
{% endfor %}
</div>
<!-- Optional JavaScript -->
<!-- jQuery first, then Popper.js, then Bootstrap JS -->
<script src="https://code.jquery.com/jquery-3.2.1.slim.min.js"
integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN"
crossorigin="anonymous"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js"
integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q"
crossorigin="anonymous"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js"
integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl"
crossorigin="anonymous"></script>
</body>
</html>
- 在表单中，我们使用 Django 模板标签 {%csrf_token%} 。通过使用这个标签，我们可以避免 CSRF 攻击，并保证从用户到服务器的 post 请求的安全性。
- 我们还使用 Django 模板标签 {%for%} 来显示消息通知。
现在，运行服务器并查看注册网页。
Signup Page
5。登录
现在，我们将学习创建 login_user 视图。为此，我们必须在 app 目录的 views.py 文件中创建一个函数 login_user 。
from django.contrib import messages
from django.shortcuts import render, redirect
from django.contrib.auth.models import User, auth
def login_user(request):
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
user = auth.authenticate(username=username, password=password)
if user is not None:
auth.login(request, user)
return redirect('home')
else:
messages.info(request, 'Invalid Username or Password')
return redirect('login_user')
else:
return render(request, 'login.html')
- 首先，我们将创建 login_user 函数，它使用 POST 请求对象。
- 然后用户名和密码被发送到服务器。
- 然后，authenticate 函数用于验证用户名和密码。
- 如果用户通过了身份验证，则转到主页；如果没有，转到登录页面并打印消息无效用户名或密码。
现在，我们来看看login.html:
login.html 文件指定了登录网页的外观。
<!doctype html>
<html lang="en">
<head>
<!-- Required meta tags -->
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
<!-- Bootstrap CSS -->
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"
integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
<title>LOGIN</title>
</head>
<body>
<div class="mx-auto" style="width: 500px" ;>
<form action="login_user" method="post" class="form-horizontal">
{% csrf_token%}
<div class="col-xs-8 col-xs-offset-4">
<h2 style="text-align:center;">LOGIN</h2>
</div>
<div class="form-group">
<label for="username">Username</label>
<input type="text" class="form-control" name="username" id="username" placeholder="Enter Username">
</div>
<div class="form-group">
<label for="password">Password</label>
<input type="password" class="form-control" name="password" id="password" placeholder="Enter Password">
</div>
<button type="submit" class="btn btn-primary">LOGIN</button>
<br />
<div class="form-group">
{% for message in messages %}
<div class="alert alert-danger" role="alert">
{{message}}
</div>
{% endfor %}
</div>
</form>
<!-- Optional JavaScript -->
<!-- jQuery first, then Popper.js, then Bootstrap JS -->
<script src="https://code.jquery.com/jquery-3.2.1.slim.min.js"
integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN"
crossorigin="anonymous"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js"
integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q"
crossorigin="anonymous"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js"
integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl"
crossorigin="anonymous"></script>
</body>
</html>
- 为了显示消息通知，我们使用 Django 模板标签 {%for%} 。
注册成功后，我们会将您重定向到登录页面，如果您已经是用户，您也可以直接转到登录页面。
Login Page
5。首页
现在，我们将学习创建主视图。为此，我们必须在 app 目录的 views.py 文件中创建一个函数 home 。
from django.contrib import messages
from django.shortcuts import render, redirect
def home(request):
return render(request, 'home.html')
- 首先，我们将创建带有请求对象的 home 函数。
- 主页功能重定向到 home.html。
现在，我们来看看home.html:
home.html 文件指定主页的外观。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"
integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
<title>Login System</title>
</head>
<body>
<script src="https://code.jquery.com/jquery-3.2.1.slim.min.js"
integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN"
crossorigin="anonymous"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js"
integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q"
crossorigin="anonymous"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js"
integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl"
crossorigin="anonymous"></script>
<nav class="navbar navbar-expand-lg navbar-dark bg-dark">
<a class="navbar-brand" href="home">Login System</a>
<button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarNav"
aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
<span class="navbar-toggler-icon"></span>
</button>
<div class="collapse navbar-collapse" id="navbarNav">
<ul class="navbar-nav">
<li class="nav-item active">
<a class="nav-link" href="home">HOME<span class="sr-only">(current)</span></a>
</li>
{% if user.is_authenticated %}
<li class="nav-item">
<a class="nav-link" href="#">Hi, {{user.first_name}}</a>
</li>
<li class="nav-item">
<a class="nav-link" href="logout_user">LOGOUT</a>
</li>
{% else %}
<li class="nav-item">
<a class="nav-link" href="register">SIGN UP</a>
</li>
<li class="nav-item">
<a class="nav-link" href="login_user">LOGIN</a>
</li>
{% endif %}
</ul>
</div>
</nav>
<div class="container my-3">
<h1 style="text-align:center;">Welcome to Python Guides</h1>
</div>
<div class="card">
<div class="card-body">
<h3 style="text-align:center;">Thanks for landing on this page to know more about PythonGuides.com.</h3>
<br>
<h6>I welcome you to the website and hopefully, you got to learn something in Python. I started this website to
share my finding and learnings in Python with you.</h6>
<h6>To keep things simple, I am trying to write a lot of articles on Python. Feel free to give your valuable
comments and also share the articles if you are liking and hoping it will be helpful to someone.</h6>
<br>
<h2 style="text-align:center;">Also, Subscribe to Our YouTube Channel for FREE Python Video Tutorials.</h2>
</div>
</body>
</html>
- 这里我们使用带有
is_authenticated属性的 {%if%} 模板标签来验证用户是否被授权。 - 如果用户通过了身份验证，我们会在导航栏上打印用户的名字。为此，我们使用标签 {{user.first_name}} 。
- 在导航栏上，我们还添加了一个注销按钮。
让我们看看主页，当用户成功登录。
Home Page
6。注销
现在，我们将学习创建 logout_user 视图。为此，我们必须在 app 目录的 views.py 文件中创建一个函数 logout_user 。
from django.contrib import messages
from django.shortcuts import render, redirect
from django.contrib.auth.models import User, auth
def logout_user(request):
auth.logout(request)
return redirect('home')
- 首先，我们将创建带有请求对象的 logout_user 函数。
- 为了注销用户，我们使用 django.contrib.auth 的 log out()函数。
- logout_user 函数重定向到 home。
当我们点击 logout 按钮时，logout()函数被调用。而且，它完全清除了当前请求的会话数据。
让我们看看当我们点击 logout 按钮时主页是什么样子的。
Home Page
如何创建 Django 多模式登录系统
在这一节中，我们将学习如何使用 Django 开发一个具有多种模型的登录系统。这个登录系统由三个模块组成:注册、登录和注销。
基本步骤
在我们开始学习如何开发上述登录系统的三个模块之前，我们必须首先完成一些基本和必要的程序。
创建项目:
我们必须首先建立一个 Django 项目。并且，要创建一个 Django 项目，使用以下命令:
django-admin startproject MultiLogin
- 因此，在这里我构建了一个名为
MultiLogin的项目
创建 APP:
在我们完成 Django 项目后，我们需要开发一个 Django 应用程序。要制作 Django 应用程序，请使用以下命令:
python manage.py startapp accounts
- 所以，在这里我构建了一个名为
accounts的应用。
安装 APP:
创建 Django 应用程序后，我们需要安装它。为此，请打开项目目录中的 settings.py 文件。现在在已安装应用中输入你的应用名称。
INSTALL APP
安装/激活模板 :
要存储 HTML 文件，您需要一个模板文件夹。在您的应用程序目录中创建一个模板文件夹。在 settings.py 文件的模板中定义 DIRS 路径。
TEMPLATE
定义 URL 文件
在创建一个项目和一个应用程序后，我们必须创建 URL 文件，因为根据 Django，所有的资源都应该使用这些文件进行映射。
项目 URL 文件:
Django 在项目中默认包含一个 urls.py 文件( MultiLogin )。在该文件中添加以下代码。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('accounts/', include('accounts.urls'))
]
- 在这个文件中，管理应用程序的路径是预定义的。
- 现在，我们必须指定 urls.py 文件在应用程序
(accounts)中的位置。
APP 网址文件:
默认情况下，应用程序不包含任何 urls.py 文件。所以首先，我们必须在应用程序目录(账户)中创建一个名为 urls.py 的文件。
from django.urls import path
from . import views
urlpatterns = [
path('register/', views.register, name='register'),
path('login/', views.login_user, name='login_user'),
path('logout/', views.logout_user, name='logout_user'),
path('home/', views.home, name='home'),
path('student_register/', views.student_register.as_view(), name='student_register'),
path('teacher_register/', views.teacher_register.as_view(), name='teacher_register')
]
- 这里，我们定义了在应用程序的
views.py文件下创建的不同视图的路径。
创建模型
基本上，数据库中的一个表就是一个 Django 模型。默认情况下，当我们在 Django 中构建项目时，我们在项目的根文件夹 (MUTILOGIN) 中得到一个空的 SQLite 数据库。所以，要做一张新桌子，我们需要做一个新模型。
打开 accounts 文件夹中的 models.py 文件。默认情况下，它是空的，所以添加以下代码:
from django.db import models
from django.contrib.auth.models import AbstractUser
class User(AbstractUser):
is_student = models.BooleanField(default=False)
is_teacher = models.BooleanField(default=False)
first_name = models.CharField(max_length=80)
last_name = models.CharField(max_length=80)
class Student(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE, primary_key=True)
phone_number = models.CharField(max_length=10)
class_name = models.CharField(max_length=100)
class Teacher(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE, primary_key=True)
phone_number = models.CharField(max_length=10)
department = models.CharField(max_length=30)
因此，这里我们创建了三个名为 User、Student 和 Teacher 的类。所以，让我们详细讨论每一个类:
- 用户类别:
- 这里，我们创建一个定制的用户模型，并通过使用 AbstractUser 扩展它的功能。
- 因此，AbstractUser 是一个具有完整字段的模型，类似于一个抽象类，这样你就可以很容易地从它那里继承你在其他模型类中也需要的字段。
- 学生班级:
- 在这里，我们创建学生模型类。在这个类中，我们定义了上面创建的 User 类的字段之间的一对一关系。
- 除此之外，我们还创建了一个文本字段“phone _ number”，它将包含最大长度为 10 的学生的电话号码。
- 然后，我们再创建一个文本字段“class _ name”，它将包含学生的班级。
- 教师班级:
- 在这里，我们创建教师示范班。在这个类中，我们再次定义了上面创建的 User 类的字段之间的一对一关系。
- 除此之外，我们还创建了一个文本字段“phone _ number”，它将包含最大长度为 10 的老师的电话号码。
- 然后，我们再创建一个文本字段“department”，它将包含教师所在的部门。
注册型号
打开账户文件夹中的 admin.py 文件。默认情况下，它是空的，所以添加以下代码:
from django.contrib import admin
from .models import User, Student, Teacher
# Register your models here.
admin.site.register(Student)
admin.site.register(Teacher)
- 所以，在这里我们注册上面创建的两个模型，即学生模型和教师模型与管理界面。
创建表单
表单是包含多个字段或空间的页面，用户可以在其中输入数据。在 accounts 文件夹中创建并打开 forms.py 文件。默认情况下，它是空的，因此添加以下代码:
from django.contrib.auth.forms import UserCreationForm
from django.db import transaction
from django import forms
from .models import Student, Teacher, User
class StudentSignUpForm(UserCreationForm):
first_name = forms.CharField(required=True)
last_name = forms.CharField(required=True)
phone_number = forms.CharField(required=True)
class_name = forms.CharField(required=True)
class Meta(UserCreationForm.Meta):
model = User
@transaction.atomic
def data_save(self):
user = super().save(commit=False)
user.first_name = self.cleaned_data.get('first_name')
user.last_name = self.cleaned_data.get('last_name')
user.is_student = True
user.save()
student = Student.objects.create(user=user)
student.class_name = self.cleaned_data.get('class_name')
student.phone_number = self.cleaned_data.get('phone_number')
student.save()
return user
class TeacherSignUpForm(UserCreationForm):
first_name = forms.CharField(required=True)
last_name = forms.CharField(required=True)
department = forms.CharField(required=True)
class Meta(UserCreationForm.Meta):
model = User
@transaction.atomic
def data_save(self):
user = super().save(commit=False)
user.first_name = self.cleaned_data.get('first_name')
user.last_name = self.cleaned_data.get('last_name')
user.is_teacher = True
user.save()
teacher = teacher.objects.create(user=user)
teacher.phone_number = self.cleaned_data.get('phone_number')
teacher.department = self.cleaned_data.get('department')
teacher.save()
return user
因此，我们在这里创建了两个名为 StudentSignUpForm 和 TeacherSignUpForm 的表单类，让我们详细讨论每个类:
- 学生签名表单:
- Django 有一个集成的用户认证系统。因此，我们在这里导入用户身份验证模块，允许我们创建学生注册。
- 这里，我们使用
UserCreationForm为我们的应用程序创建一个新用户。默认情况下，该表单有三个字段:用户名、密码和确认密码。 - 除此之外，我们还分别创建了四个文本字段名、姓、电话号码和类名。
- 我们定义元类，因为我们需要添加关于模型用户的数据。
- 然后我们使用学生注册表单的原子事务，它是一个或多个 SQL 操作的序列，被视为一个单元。原子事务的目的是提供四个通常称为 ACID 的属性。
- 教师签名表格:
- 在这里，我们导入用户认证模块，允许我们创建教师注册。
- 接下来，我们使用
UserCreationForm为我们的应用程序创建一个新用户。默认情况下，该表单有三个字段:用户名、密码和确认密码。 - 然后，除此之外，我们分别创建三个文本字段名、姓和部门。
- 我们定义元类是因为我们需要添加关于用户模型的数据。
- 然后我们使用教师注册表单的原子事务，因为原子事务的目的是提供四个通常称为 ACID 的属性。
定义视图文件
基本上，Django 视图和 HTML 文档一样，都是接受 http 请求并返回 http 响应的 Python 函数。所以，我们可以说基于 Django 的网站有很多视图，有不同的任务和目标。
而且，视图通常存储在应用程序文件夹中一个名为 views.py 的文件中。默认情况下，它是空的，因此添加以下代码:
from email import message
from django.shortcuts import render, redirect
from django.contrib.auth import login, logout,authenticate
from django.contrib.auth.forms import AuthenticationForm
from django.contrib import messages
from django.views.generic import CreateView
from .models import User
from .forms import StudentSignUpForm, TeacherSignUpForm
# Create your views here.
def home(request):
return render(request, 'home.html')
def register(request):
return render(request, 'register.html')
class student_register(CreateView):
model = User
form_class = StudentSignUpForm
template_name= 'student_register.html'
def form_valid(self, form):
user = form.save()
login(self.request, user)
return redirect('/accounts/home')
class teacher_register(CreateView):
model = User
form_class = TeacherSignUpForm
template_name= 'teacher_register.html'
def form_valid(self, form):
user = form.save()
login(self.request, user)
return redirect('/accounts/home')
def login_user(request):
if request.method=='POST':
form = AuthenticationForm(data=request.POST)
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
user = authenticate(username=username, password=password)
if user is not None :
login(request,user)
return redirect('/accounts/home')
else:
messages.error(request,"Invalid username or password")
else:
messages.error(request,"Invalid username or password")
return render(request, 'login.html',context={'form':AuthenticationForm()})
def logout_user(request):
logout(request)
return redirect('/accounts/home')
所以，这里我们创建了六个视图，分别命名为首页、注册、学生 _ 注册、教师 _ 注册、登录 _ 用户和注销 _ 用户。所以，让我们详细讨论一下每个观点:
- 主页:
- 在 home 视图中，我们简单的渲染到‘home . html’模板。
- 注册:
- 在注册视图中，我们简单的渲染到‘register . html’模板。
- student_regsiter:
- 然后，我们基于通用视图创建
student_register类。 - 接下来，我们使用
CreateView,因为页面上需要学生注册表单,并且在提交有效表单时需要插入数据库。
- 然后，我们基于通用视图创建
- teacher_regsiter:
- 然后，我们基于通用视图创建了
teacher_register类。 - 接下来，我们使用
CreateView,因为页面上需要教师注册表单,并且在提交有效表单时需要插入数据库。
- 然后，我们基于通用视图创建了
- 登录 _ 用户:
- 我们将创建
login_user视图，它使用 POST 请求对象。 - 然后用户名和密码被发送到服务器。
- 然后，authenticate 函数用于验证用户名和密码。
- 如果用户通过了身份验证，则转到主页；如果没有，转到登录页面并打印消息无效用户名或密码。
- 我们将创建
- 注销 _ 用户:
- 使用请求对象，我们将创建注销用户功能。
- 接下来，使用 django.contrib.auth 的
logout()函数注销用户。 - 成功注销后，用户将返回到您的'主页'。
创建模板
我们从 Django 中了解到，结果应该是 HTML，HTML 文件是在模板中创建的。
所以在根文件夹 (MULTILOGIN) 里面创建一个 templates 文件夹，并创建五个 HTML 文件，分别命名为‘home . HTML’，‘log in . HTML’，‘register . HTML’，‘student _ register . HTML’，‘teacher _ regsiter . HTML’。
因此，让我们讨论并创建每个 HTML 文件:
- home.html:
- home.html 文件指定了主页的外观。下面是 home.html 文件的代码。
- 这里我们使用带有
is_authenticated属性的 {%if%} 模板标签来验证用户是否被授权。 - 如果用户通过了身份验证，我们将打印 Hi 用户名。为此，我们使用标签 {{user.get_username}} 。
- 我们还添加了一个注销按钮。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<h1>Welcome to PythonGuides</h1>
{% if user.is_authenticated%}
<h3>Hi {{user.get_username}}</h3>
<a href="{% url 'logout_user' %}">Logout</a> <br>
{% else %}
<a href="{% url 'register' %}">Register</a> <br>
<a href="{% url 'login_user' %}">Login</a>
{% endif %}
</body>
</html>
- login.html
- login.html 文件指定了登录网页的外观。下面是 login.html 文件的代码。
- 这里我们添加学生 _ 注册和教师 _ 注册的链接。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Login</title>
</head>
<body>
<h2>Login</h2>
<form action="{% url 'login_user' %}" method="POST" novalidate>
{% csrf_token %}
{{form.as_p}}
<br>
<input type="submit" value="Login" class="btn btn-block btn-primary">
</div>
</form>
</body>
</html>
- 注册. html:
- register.html 文件指定了注册网页的外观。下面是 register.html 文件的代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>User Registration</title>
</head>
<body>
<section>
<div class="container">
<div class="row">
<div class="col-md-6 mx-auto">
<div class="card">
<div class="card-header text-black">
<h2>User Registration</h2>
</div>
<div class="card-body">
<div class="row">
<div class="col-lg-6">
<a type="button" class="btn btn-block" href="{% url 'student_register' %}">I am a student</a>
</div>
<div class="col-lg-6">
<a type="button" class="btn btn-block" href="{% url 'teacher_register' %}">I am an teacher</a>
</div>
</div>
</form>
</div>
</div>
</div>
</div>
</div>
</section>
</body>
</html>
- 学生 _ 注册. html:
student_register.html文件指定学生注册网页的外观。下面是student_register.html文件的代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Student Registration</title>
</head>
<body>
<h2> Student Registeration Form</h2>
<form action="{% url 'student_register' %}" method="POST" novalidate>
{% csrf_token %}
{{form.as_p}}
<input type="submit" value="Register" class="btn btn-block btn-primary">
</body>
</html>
- teacher_register.html:
teacher_register.html文件指定了教师注册网页的外观。而下面是教师 _ 注册. html 文件的代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Teacher Registration</title>
</head>
<body>
<h2>Teacher Registeration Form</h2>
<form action="{% url 'teacher_register' %}" method="POST" novalidate>
{% csrf_token %}
{{form.as_p}}
<input type="submit" value="Register" class="btn btn-block btn-primary">
</body>
</html>
执行 Django 应用程序的步骤
进行迁移:
如果模型已经被修改，这个命令为我们的新模型准备一个 makemigrations 文件。在终端中运行以下命令。
python manage.py makemigartions
迁徙:
migrate 命令执行数据库的最近迁移文件中给出的指令。在终端中运行以下命令。
python manage.py migrate
运行服务器:
要运行开发服务器，请在终端中运行以下命令。
python manage.py runserver
输出
Home Page Multiple Model Login System
在主页上，我们有两个选项注册和登录。如果您是新用户，请单击“注册”。如果您已经注册，请单击“登录”。
Register Page
当我们点击注册，我们得到两个选项'我是学生'和'我是老师'。如果你是学生，点击学生的，否则点击教师的。
Student Registration
如果你点击“我是学生”，你会看到这样的页面。
Student Login
当你点击注册时，页面将会是这样的。
Multi model Login System
当我们点击注销，我们移动到主页。
Login Page
当我们点击登录，我们将进入登录页面。当你点击登录时，你将再次进入主页，显示你的用户名和你好。
Register Page
如果你点击我是老师。
Teacher Register
您将转到教师注册页面，在这里教师可以注册。
Home Page of Teacher
您将转到主页，在那里您将获得教师用户名和 Hi 消息。如果你点击注销按钮，你将进入主页，在这里我们有两个选项注册或登录。
你可能也喜欢阅读下面的 Django 教程。
- Python 改 Django 版本
- Python 过滤器不在 Django 中
- Python Django vs 金字塔
- Python Django 长度过滤器
- 获取 Django 中的 URL 参数
在这个 Python Django 教程中，我们讨论了 Python Django 中的登录系统。此外，我们还将讨论以下主题列表。
- Python Django 中的登录系统
- 如何创建 Django 内置登录系统
- 如何创建 Django 定制登录系统
- 如何创建 Django 多模式登录系统
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
使用 Python 的机器学习
想学机器学习？在本教程中，我们将了解什么是机器学习？使用 Python 的机器学习。我们还将讨论机器学习的类型，机器学习所需的各种软件，如何为机器学习建立环境，以及各种流行的机器学习库。
目录
机器学习简介
- 机器学习是让机器像人类一样行动的工程。
- 机器学习使用算法根据类似的数据对未来进行预测。
- 机器学习是当今市场的热门话题&每个公司都想实现它。
- 机器学习就是使用数据和做出预测。
- 在传统时代，数据是在纸上存储和处理的，随着数据的快速增长，我们开始使用电子表格，后来关系数据库进入了大数据领域，然后引入了机器学习。
- 随着时间推移，技术随着数据的增加而改进。
- 机器学习是人工智能的子集。
- 在机器学习中创建的算法被称为模态。
如果你是 Python 新手，看看如何学习 Python ？还有 Python Pygame 教程+ 17 个例子。
机器学习类型
主要有三种类型的机器学习，它们是:
- 监督机器学习
- 无监督机器学习
- 强化机器学习
现在你知道了 ML 类型的名字，让我们学习一下这些名字&理解为什么，什么时候以及如何使用它们。
你可能会喜欢 Python 里的熊猫。
监督机器学习
- 监督学习是一个提供数据(输入)和标签(输出)的过程。如标签中所述，该算法使用数据来预测输出。如果失败，它会进行一些更改并重试。这个过程一直持续到&，除非预测是按照标签或者接近标签。
- 例:一个艺术家正在画一个苹果。他有一张苹果的图片，并一直画，直到两张图片看起来相似。
- 监督学习进一步分为:
- 分类
- 回归
- 分类生成二进制输出。它被用来识别事物是否如此。例如发热或不发热、可用或不可用等。
- 回归处理数值。它谈论的数字主要是监控值。
无监督机器学习
- 无监督学习有数据(输入)，没有标签(输出)。使用数据，算法试图找到数据中的模式。它被用来寻找两个或更多事物的相似之处。
- 目标是很好地逼近映射函数，使得算法可以预测新的数据输出。
- 神经网络是无监督学习的最好例子。
- 无监督学习进一步分为:
- 聚类
- 关联
- 聚类指将相似的事物或特征进行分组。
- 关联发现描述大部分数据的规则。
强化机器学习
- 强化学习训练模型做出一系列决策。每一个正确的决定都会奖励模型，每一个错误的决定都会惩罚模型。这样，他们就知道什么是对什么是错了。
- 该算法记录对与错&当暴露于新数据或现实生活中时使用它。这类似于训练一只宠物。每当宠物做了我们想让它做的事情，我们就给它食物。
- 游戏是强化学习的最好例子。
机器学习软件
在本节中，我们将讨论我们将用来执行机器学习模型的软件。
Python 3- 迷你康达
- Jupyter 笔记型电脑
机器学习入门需要这三个软件。让我们理解为什么我们需要他们&谁是他们的竞争对手。
Python 3
- Python 是一种解释型、交互式、面向对象的高级语言，由吉多·范·罗苏姆于 1990 年创建。
- Python 提供简洁可读的代码，而机器学习有复杂的算法。python 的简单性有助于开发人员更轻松地构建复杂的机器学习模型。这就是 python 在开发者中出名的原因。
- 机器学习模型也可以用 R 编程来写。
- 在本教程中，我们将使用 Python 3。点击这里了解如何下载安装 python。
迷你康达
Miniconda是软件包管理器，它有助于- 为项目创建环境
- 重要库的安装
- Miniconda 是 anaconda 的轻点版本。Anaconda 附带了预安装的库，方便用户在安装后立即开始工作。而 miniconda 没有安装任何库。
- 我们强烈建议使用 miniconda，这样你就知道你有什么。理解您的系统对于编写更好的 python 代码同样重要。注意力集中，手动做事，会对机器产生更好的理解。
- 你越了解机器，你写的代码就越好。
- 根据您的操作系统，点击此处下载 miniconda。
miniconda download page
- 我们强调了当今常见的选项。如果你有一个 32 位操作系统，那么你可以下载到 32 位 miniconda。但是一定要为
Python 3下载。
安装迷你康达
点击下载的文件&你会看到这个界面。该程序在 windows 10 中执行，但类似的屏幕会出现在 mac 和 linux 上。
Installation of Miniconda
- 点击下一个按钮。
Installation of Miniconda
2.点击我同意接受许可协议。
3.选择仅我单选按钮，然后点击下一步。
Installation of Miniconda
4.如果您想在其他位置安装程序，可以更改路径。很好，然后点击下一步。
Miniconda installation steps
5.如果您将点击添加到路径复选框，那么您将能够在命令提示符、Powershell &终端上访问 conda 。这完全取决于用户对我们的偏好，我们只想在 miniconda 提示符下使用 conda。
第二个复选框将 Python 3.8 设置为默认用于 miniconda。点击安装。
Miniconda installation steps
6.安装完成后，点击下一个按钮。
Miniconda installation steps
7.点击完成按钮，取消选中所有复选框。
8.在 windows 上搜索 miniconda 在 windows 上搜索，在 mac 上搜索 spotlight
9.这是您将看到的 miniconda 的界面
Jupyter 笔记型电脑
- Jupyter notebook 是一个允许创建、阅读、共享文档的网络应用程序。它使用代码以文本和可视化的形式显示输出。这是一个编写机器学习模型的强大平台。
- 由于其简单的外观和有效的工作，Jupyter 笔记本是一种广泛使用的机器学习工具。
- 也可以在
vscode、google collab、Ibm平台等进行 ML 操作。但是在本课程中，我们将使用 jupyter 笔记本。
Jupyter notebook
机器学习环境设置
- 在机器学习中，设置环境起着重要的作用。如果你掌握了为你的机器学习项目建立环境的艺术，那么你已经是半个传奇人物了。
- 机器学习的项目很大，包括一群人。因此，重要的是，每个队友都必须以类似的方式配置他们的系统，以避免混淆。事情不仅到此结束，而且当项目与用户共享时，也需要相同的配置。这就是为什么环境设置被认为是一个重要的步骤。
- 在本节中，我们将学习如何
- 创造环境
- 激活和停用环境
- 将所有库存储在一个环境中
- 与他人共享环境
创建环境
- 在您的计算机上创建一个项目文件夹。在我的例子中，文件夹的名称是‘python guides-ML’
- 打开 miniconda 并导航到该文件夹
- 我们将我们的环境文件夹命名为
env。 - 我们既可以在创建
env时提供库的名称，也可以稍后安装。 - 在这里，我们将安装 pandas 和 NumPy 库，同时创建
env。
conda create --prefix ./env pandas numpy
Conda是一个跨平台的包和环境管理器，它安装和管理来自Anaconda仓库和Anaconda云的conda包。- 创建是创建环境的指令
- –当我们必须在特定位置创建环境时，使用前缀。如果我们想创建全球环境，那么我们可以使用–name。这将为环境命名。我们不能在同一个命令中使用名称和前缀。
- 熊猫& numpy 是我们在创建环境时安装的库。
Machine Learning Environment Setup
这样，我们可以在项目文件夹中为我们的项目创建一个环境。这整个文件夹可以与其他队友共享&他们将有相同的设置。
激活和停用环境
在我们开始工作之前，我们必须激活我们创建的环境。一旦环境被激活，我们就可以开始安装更多的包或库。在现实生活中，我们有多个项目，所以我们需要在不同的环境中切换。要访问另一个环境，我们必须先停用该环境。
语法:
下面是激活和停用环境的语法。这里的 path 指的是项目的路径。
# activate environment
conda activate path/env
# deactivate environment
conda deactivate
举例:
在本例中，我们将激活在上一节中创建的环境。
# to view the existing environment
conda env list
# activating environment
conda activate
# deactivate enviroment
conda deactivate
Machine Learning Environment Setup
将所有库存储在一个环境中
现在我们已经学会了如何创建环境和在创建环境的同时安装库。在本节中，我们将学习如何在特定的环境中安装更多的库。将所有的库存储在一个环境中有助于开发人员将项目的所有必要内容保存在一个文件夹中&共享变得很容易。
第一步。激活开始工作的环境。
第二步。在这里输入**conda install <name of the package>**，确保你正在安装的包在 anaconda 包中是可用的。键入不正确或不完整的名称将显示错误。
要验证该包是否存在于 anaconda 包列表中，您可以尝试使用包名。如果出现错误，意味着包不可用，或者你可以查看 anaconda 的文档。
与他人共享环境
在团队中工作时，每个成员在他们的机器上设置相同的环境变得很重要。这有助于避免当前或未来的问题。另一方面，如果你已经在 GitHub 这样的开源平台上共享了代码。然后，您可以简单地添加指令来激活环境。用户会爱上你的帖子，因为它看起来很容易设置。
共享项目有两种方式:
- 共享项目文件夹
如果项目很小并且只有很少的库，那么您可以简单地与他人共享项目文件夹。令人惊讶的是，环境文件夹是一个很大的文件，所以上传或下载文件需要时间和带宽。
- 分享 YAML
分享。yaml 文件是共享项目环境的有效方式，因为它们是轻量级的，并且依赖于版本。稍后当另一个用户将使用。yaml 文件，那么他将能够拥有相同版本的相同依赖项。
下面是将导出到 YAML 文件的代码。
conda env export --prefix C:\Users\MainFrame\Desktop\PythonGuides-ML\env > environment.yaml
conda env export: 这是导出文件的主要指令。- 这是我们想要导出的环境。
environment.yaml是您要为导出的文件提供的名称。- 执行该命令时，您可以在项目文件夹中看到
environment.yaml文件。 - 打开文件，更改环境的名称。在我们的例子中，我们给出了新的名字
newenv
一旦我们更改了环境的名称，现在我们需要使用这个 yaml 文件创建环境。
下面是使用YAML 文件导入或创建环境的代码。
# create envirnoment using yaml file
conda env create -f environment.yaml
# activating environment
conda activate newenv
conda env create -f environment.yaml将用该命令创建。conda activate newenv:由于我们已经将环境重命名为newenv，所以我们必须在这里提供相同的名称来激活环境。
机器学习热门库
在这一节中，我们将向初学者简要介绍在使用 Python 进行机器学习时使用的流行库。
- 熊猫
NumPyMatplotlibSckiti-Learn
您可能会喜欢以下 Python 教程:
- Python Tkinter TreeView 示例
- 巨蟒龟命令
- Python Tkinter 画布教程
- Python 命名约定
- Python 下载和安装步骤
- Python Hello World 程序
结论
在本教程中，我们已经了解了什么是机器学习，使用 python 的机器学习，环境设置，使用各种流行的机器学习库，如 Pandas，NumPy，matlpotlib & scikit-learn。我们会用专门的博客更多的讨论更多的 Python 机器学习库。敬请关注我们，如果您有任何疑问或建议，请留下您的评论。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何用 Python + Python Tkinter 计算器制作计算器
在本 Python 教程中，我们将用 python 制作一个计算器，它可以根据用户输入的输入进行加减乘除。
此外，我们将讨论如何使用 Tkinter 创建一个 Python 计算器。
目录
用 Python 制作计算器
让我们看看如何使用函数在 python 中创建一个计算器。
你可以看到，我们用 python 创建了一个简单的计算器，它可以执行不同的算术运算，如加、减、乘、除。用户定义的函数是 add()、subtract()、multiply()和 divide()将计算各自的运算并显示输出。
举例:
def add(x,y):
return x + y
def subtract(x,y):
return x - y
def multiply(x,y):
return x * y
def divide(x,y):
return x / y
print("Select operation.")
print("1.Add")
print("2.Subtract")
print("3.Multiply")
print("4.Divide")
while True:
choice = input("Enter your choice(1/2/3/4): ")
if choice in ('1', '2', '3', '4'):
number1 = float(input("Enter first number: "))
number2 = float(input("Enter second number: "))
if choice == '1':
print(number1, "+", number2, "=", add(number1, number2))
elif choice == '2':
print(number1, "-", number2, "=", subtract(number1, number2))
elif choice == '3':
print(number1, "*", number2, "=", multiply(number1, number2))
elif choice == '4':
print(number1, "/", number2, "=", divide(number1, number2))
break
else:
print("Entered input is invalid")
可以参考下面截图来用 Python 做一个计算器。
How to make a calculator in Python
输出:
这里，我们要求用户选择一个他们所选择的操作。如果选项为 1、2、3 和 4 则有效，否则显示“无效输入”。如果选项有效，那么我们必须输入两个数字，根据用户输入的选择，它将执行操作。
calculator in Python
您可能还会喜欢 Python Tkinter 秒表和如何使用 Python Tkinter 获取用户输入并存储在变量中。
python 中的计算器使用类
让我们一步一步地看看如何创建一个执行基本计算器操作的类。
- 用类制作计算器。创建对象需要类。类使得代码更加有效，并且简单易懂。
- 首先，我们将创建一个类
calculator,所有的函数都定义为加法、减法、乘法和除法。 Self在使用obj1.function()调用函数时使用。在这里，函数将调用自己。- 现在，我们将接受用户的输入，并创建对象。
- 最后，创建用户选择来执行他们需要的操作，并在输出中打印值。
举例:
class calculator:
def addition(self):
print(x + y)
def subtraction(self):
print(x - y)
def multiplication(self):
print(x * y)
def division(self):
print(x / y)
x = int(input("Enter first number:"))
y = int(input("Enter second number:"))
obj1 = calculator()
choice = 1
while choice !=0:
print("1\. ADDITION")
print("2\. SUBTRACTION")
print("3\. MULTIPLICATION")
print("4\. DIVISION")
choice = int(input("Enter your choice:"))
if choice == 1:
print(obj1.addition())
elif choice == 2:
print(obj1.subtraction())
elif choice == 3:
print(obj1.multiplication())
elif choice == 4:
print(obj1.division())
else:
print("Invalid choice")
现在，您可以看到代码的输出。
Calculator in python using class
输出:
Calculator in python using class
你可能会喜欢，如何在 Python Tkinter 中设置背景为图像
python 中不带函数的计算器
我们在 python 中创建了一个简单的计算器，没有函数可以执行不同的算术运算，如加、减、乘和除。
举例:
first_val = input("Enter 1st number: ")
first_val = int(first_val)
cal = input("Enter operator: ")
second_val = input("Enter 2nd number: ")
second_val = int(second_val)
if cal == "+":
print(first_val + second_val)
elif cal == "-":
print(first_val - second_val)
elif cal == "*":
print(first_val * second_val)
elif cal == "/":
print(first_val / second_val)
下面的截图显示了我们如何创建一个没有功能的计算器。
Calculator in python without function
你可能还喜欢，如何使用 Python Tkinter 在文本框中显示数据？
python 代码中的计算器
在这里，我们将看到 python 中计算器的代码。这里，我们创建一个单独的函数来执行类似于加、减、乘、除的操作。它将接受用户的输入以及操作符的选择，并返回结果。
举例:
def add(x, y):
return x + y
def subtract(x, y):
return x - y
def multiply(x, y):
return x * y
def divide(x, y):
return x / y
print("select an operation")
print("+")
print("-")
print("*")
print("/")
choice = input("Enter any operator to use")
a = int(input("Enter first number: "))
b = int(input("Enter second number: "))
if choice == '+':
print(a,"+",b,"=", add(a,b))
elif choice == '-':
print(a,"-",b,"=", subtract(a,b))
elif choice == '*':
print(a,"*",b,"=", multiply(a,b))
elif choice == '/':
print(a,"/",b,"=", divide(a,b))
else:
print("Invalid input")
你可以看到下面 python 代码的计算器截图和输出。
Calculator in python code
输出:
Calculator in python code
这就是我们如何用 Python 制作计算器的方法。
Python Tkinter 计算器
让我们看看如何使用 Python Tkinter 创建一个简单的计算器。我希望这个 Python Tkinter 计算器的例子能帮助你用 Python 创建一个简单的计算器。
如果您是 Python GUI 编程或 Python Tkinter 的新手，请查看 Python GUI 编程(Python Tkinter)
使用 Python Tkinter 创建一个简单的计算器
- Python Tkinter 用于各种 GUI 应用程序，其中之一是计算器。
- 使用计算器应用程序将有助于您更好地理解 python。
- 在这一节中，我们将为您提供完整的源代码和解释。
- 请阅读整个博客，并留下评论来澄清任何疑问。
规划 Python Tkinter 计算器
在这一节中，我们将讨论在为 python Tkinter 计算器编写代码之前训练自己的秘密。我们将讨论一个应用程序的外观，它将要执行的功能，以及灵感的来源。
- 灵感来源是 Windows 10 操作系统上的计算器。
- 它在显示屏上有灰色背景，在按钮上有黑色背景。
- 整个应用程序的文本颜色是白色。
- 应用程序总是在右下角打开。
- 数字显示在屏幕的右侧。
在观察了整个 windows 10 计算器应用程序之后，现在是时候编写我们将在应用程序中使用或实现的东西了。
- 每次应用程序都会在右下角打开。
- 该应用程序将有一个灰色背景的显示和黑色背景的按钮。
- 整个应用程序的文本颜色将是白色
- 一个窗口将有一个固定的大小&不能调整大小。
- 该计算器将具有加、减、乘、除的基本功能。
- 数字将显示在屏幕的右侧。
创建 Python Tkinter 计算器的算法
在本节中，我们将讨论创建 python Tkinter 计算器的算法。此外，我们将提供相同的数据流图(DFD)。
ws = Tk() ws.title('Calculator') ws.geometry('250x400+500+100') ws.resizable(0,0)
- 代码的第一行用于初始化父层。
- 第二行用于设置窗口的标题。标题是羽毛旁边的窗口顶部的名称。
- 第三行是设置窗口的宽度、高度和位置。
- 宽度= 250
- 高度= 400
- 位置 x = 500
- 位置 y = 100
- Resizable 确定可以拉伸的屏幕大小。屏幕可以在 x 和 y 轴上拉伸。因为我们已经将这两个值都设置为 0。这意味着屏幕不能以任何方式拉伸。
frame_1 = Frame(ws) frame_1.pack(expand=True, fill=BOTH)
- 要放置标签和按钮等小部件，我们必须创建 4 个框架。
- 如果空间可用，允许每个帧在 x 和 y 方向上完全扩展。
- 这样，所有的框架将有相似的空间&放置在其中的按钮将具有对称性。
expand=True:这允许可用空间的扩展。fill=both:膨胀方向
key_1 = Button( frame_1, text='1', font=('Arial', 22), border = 0, relief = GROOVE, bg = '#2E2E2B', fg = 'white', command = lambda: display(1) )
在这段代码中，我们创建了一个按钮。要了解按钮，请参考我们的按钮章节。这里，在命令下，我们可以调用一个函数，但不能传递一个参数给函数。这就是我们在这里使用匿名函数 lambda 的原因。要了解更多关于匿名功能的信息，请参考我们关于匿名功能的章节。
这是计算器的 DFD
全局变量
num = ''
- 函数中使用的变量仅限于该函数
- 如果我们想在其他函数中使用一个特定变量
- 然后我们必须声明这个变量是一个全局变量。
- 在这段代码中，我们将
num声明为一个全局变量。 - 任何引用该变量的函数必须在变量名前使用全局关键字
- 其他函数也会观察到任何函数对此变量所做的更改。
- 例如，如果任何函数将 num 的值设置为“10”，那么使用 num 的其他函数也将把
num的值设置为“10”。
解释功能:
equal_btn()
def equal_btn():
global num
add=str(eval(num))
scr_lbl['text'] = add
num=''
equal_btn()函数多次使用，第 3 行&第 4 行变量名略有变化。- 在这里，内置函数 eval()起着重要的作用。
eval()将一个字符串作为输入，并将其转换为一个整数&执行运算。- 这意味着如果将字符串“2+3”传递给 eval，它将返回 5 作为输出
def clear_scr (数字)
def clear_scr():
global num
num = ''
scr_lbl['text'] = num
- 当用户点击
C时调用该函数。 - 它清除显示屏上的所有内容，并将
num的值设置为空字符串。
def 显示(数字)
def display(number):
global num
num = num + str(number)
scr_lbl['text'] = num
- 该功能负责在屏幕上显示数字。
- 每当用户单击编号按钮时，它就会与现有的字符串连接起来。
- 所以当点击 1 时，它在屏幕上显示 1。然后，当我们单击 2 时，它会显示 12，依此类推。
代码:
from tkinter import *
ws = Tk()
ws.title('Calculator')
ws.geometry('250x400+500+100')
ws.resizable(0,0)
# global variables
num = ''
# functions
def display(number):
global num
num = num + str(number)
scr_lbl['text'] = num
def `clear_scr()`:
global num
num = ''
scr_lbl['text'] = num
def equal_btn():
global num
add=str(eval(num))
scr_lbl['text'] = add
num=''
def equal_btn():
global num
sub=str(eval(num))
scr_lbl['text'] = sub
num=''
def equal_btn():
global num
mul=str(eval(num))
scr_lbl['text'] = mul
num=''
def equal_btn():
global num
div=str(eval(num))
scr_lbl['text'] = div
num=''
var = StringVar()
# frames
frame_1 = Frame(ws)
frame_1.pack(expand=True, fill=BOTH)
frame_2 = Frame(ws)
frame_2.pack(expand=True, fill=BOTH)
frame_3 = Frame(ws)
frame_3.pack(expand=True, fill=BOTH)
frame_4 = Frame(ws)
frame_4.pack(expand=True, fill=BOTH)
# label
scr_lbl = Label(
frame_1,
textvariable='',
font=('Arial', 20),
anchor = SE,
bg = '#595954',
fg = 'white'
)
scr_lbl.pack(expand=True, fill=BOTH)
# buttons
key_1 = Button(
frame_1,
text='1',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = lambda: display(1)
)
key_1.pack(expand=True, fill=BOTH, side=LEFT)
key_2 = Button(
frame_1,
text='2',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = lambda: display(2)
)
key_2.pack(expand=True, fill=BOTH, side=LEFT)
key_3 = Button(
frame_1,
text='3',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = lambda: display(3)
)
key_3.pack(expand=True, fill=BOTH, side=LEFT)
key_add = Button(
frame_1,
text='+',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = lambda: display('+')
)
key_add.pack(expand=True, fill=BOTH, side=LEFT)
key_4 = Button(
frame_2,
text='4',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = lambda: display(4)
)
key_4.pack(expand=True, fill=BOTH, side=LEFT)
key_5 = Button(
frame_2,
text='5',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = lambda: display(5)
)
key_5.pack(expand=True, fill=BOTH, side=LEFT)
key_6 = Button(
frame_2,
text='6',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = lambda: display(6)
)
key_6.pack(expand=True, fill=BOTH, side=LEFT)
key_sub = Button(
frame_2,
text='-',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = lambda: display('-')
)
key_sub.pack(expand=True, fill=BOTH, side=LEFT)
key_7 = Button(
frame_3,
text='7',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = lambda: display(7)
)
key_7.pack(expand=True, fill=BOTH, side=LEFT)
key_8 = Button(
frame_3,
text='8',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = lambda: display(8)
)
key_8.pack(expand=True, fill=BOTH, side=LEFT)
key_9 = Button(
frame_3,
text='9',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = lambda: display(9)
)
key_9.pack(expand=True, fill=BOTH, side=LEFT)
key_mul = Button(
frame_3,
text='*',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = lambda: display('*')
)
key_mul.pack(expand=True, fill=BOTH, side=LEFT)
key_clr = Button(
frame_4,
text='C',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = clear_scr
)
key_clr.pack(expand=True, fill=BOTH, side=LEFT)
key_0 = Button(
frame_4,
text='0',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = lambda: display(0)
)
key_0.pack(expand=True, fill=BOTH, side=LEFT)
key_res = Button(
frame_4,
text='=',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = equal_btn
)
key_res.pack(expand=True, fill=BOTH, side=LEFT)
key_div = Button(
frame_4,
text='/',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = lambda: display('/')
)
key_div.pack(expand=True, fill=BOTH, side=LEFT)
ws.mainloop()
输出:
Python tkinter calculator
因此，在本教程中，我们学习了如何使用 python tkinter 创建计算器。
您可能会喜欢以下 Python 教程:
- Python 中的正则表达式
- Python 布尔函数
- Python 打印 2 位小数
- Python 生成器(Python 生成器 vs 迭代器)
- Python 递归
- Python 元组排序列表
- Python 对于基数为 10 的 int()无效文字
- 删除 python 中的 Unicode 字符
- Python 中的注释行
- 如何用 Python 制作矩阵
- Python Tkinter 进度条
- Python Tkinter 退出程序
在这个 Python 教程中，我们学习了如何用 Python 制作计算器。此外，我们还讨论了以下主题:
- python 中使用类的计算器
- python 中不带函数的计算器
- python 代码中的计算器
- Python Tkinter 计算器
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何用 Python 制作矩阵
在本 Python 教程中，我们将讨论如何在 python 中制作矩阵。此外，我们将看到以下主题:
- python 中的矩阵是什么？
- 如何使用用户输入在 python 中创建矩阵
- 在 python 中使用 NumPy 创建一个空矩阵
- 如何在 python 3 中创建矩阵
- 如何用 python 做矩阵乘法
- 如何在 python 中使用 for 循环创建矩阵
- 如何使用列表在 Python 中创建矩阵
- 将 8 行 1 列的矩阵和 1 行 8 列的矩阵相乘得到 8 行。
目录
- python 中的矩阵是什么？
- 如何使用用户输入在 python 中创建矩阵
- 使用 python 中的 NumPy 创建一个空矩阵
- 如何在 python 3 中创建矩阵
- 如何用 python 做矩阵乘法
- 如何在 python 中使用 for 循环创建矩阵
- 如何使用列表在 Python 中创建矩阵
- 将一个 8 行 1 列的矩阵和一个 1 行 8 列的矩阵相乘得到一个 8 行的矩阵
python 中的矩阵是什么？
- 一个 Python 矩阵是以行和列存储的数据的二维矩形数组。
- 矩阵中的水平项称为“行”，垂直项称为“列”。
- 如果一个矩阵有 r 行 c 列，那么矩阵的阶由
r xc 给出。 - 存储在矩阵中的数据可以是字符串、数字等。
- 在矩阵中，数据被排列成行和列。
- 矩阵是数学和科学计算的重要数据结构。
- Python 没有内置的矩阵类型，所以我们可以把一个列表当作一个矩阵。
你可能喜欢 Python 中的复制文件(示例)和 Crosstab 熊猫。
如何使用用户输入在 python 中创建矩阵
让我们看看如何用 python 创建矩阵:
- 在 Python 中，有一个流行的库叫做
NumPy。 - 要使用 NumPy ，我们需要安装它。安装 NumPy 的命令是‘pip install NumPy’。
- 为了在代码中使用 NumPy，我们必须将其作为' import NumPy as np' 。
- 使用
NumPy.matrix()函数创建矩阵。 - 我们将采取矩阵的用户输入，然后它会在输出中显示一个矩阵。
举例:
import numpy as np
a = int(input("Enter the number of rows:"))
b = int(input("Enter the number of columns:"))
print("Enter the number in a single line separated by space:")
val = list(map(int, input().split()))
matrix = np.array(val).reshape(a,b)
print(matrix)
写完上面的代码(如何使用用户输入在 python 中创建一个矩阵)，一旦你将打印 "matrix" 那么输出将显示为 "[[2 4] [6 3]] " 。在这里， np.array()。reshape() 用于打印矩阵。
你可以参考下面的截图如何使用用户输入在 python 中创建矩阵。
How to create a matrix in python using user input
使用 python 中的 NumPy 创建一个空矩阵
在这里，我们将看到如何在 python 中使用 NumPy 创建一个空矩阵。
为了创建一个空矩阵，我们将首先导入 NumPy 作为 np ，然后我们将使用 np.empty() 来创建一个空矩阵。
举例:
import numpy as np
m = np.empty((0,0))
print(m)
在编写完上面的代码(在 python 中使用 NumPy 创建一个空矩阵)之后，一旦打印出 "m" ，那么输出将显示为 " [ ] " 。这里，NP . empty()0 行 0 列的矩阵用于在 python 中创建空矩阵。
可以参考下面截图用 python 中的 NumPy 创建一个空矩阵。
Create an empty matrix using NumPy in python
如何在 python 3 中创建矩阵
我们将首先将 numpy 作为 np 导入，然后使用 numpy.matrix() 创建一个矩阵。这样就可以用 python 创建一个矩阵。
举例:
import numpy as np
m = np.matrix([[3, 4], [5, 2]])
print('Matrix is:\n', m)
写完上面的代码(如何在 python 3 中创建一个矩阵)，一旦你将打印出 "m" 那么输出就会出现为 "[[3 4] [5 2]] " 。这里， np.matrix() 用于打印矩阵，它将返回矩阵。
可以参考下面截图如何在 python 3 中创建矩阵。
How to create a matrix in python 3
如何用 python 做矩阵乘法
矩阵乘法是以两个矩阵作为输入的运算。为了获得元素级乘法，我们可以使用 np.multiply() 函数。
举例:
import numpy as np
mat1 = np.matrix([[2, 5],[4, 1]])
mat2 = np.matrix([[6, 5],[4, 7]])
matrix_result = np.multiply(mat1, mat2)
print(matrix_result)
写完上面的代码(python 中如何做矩阵乘法)，一旦你将打印出 "matrix_result" 那么输出会出现一个 "[[12 25] [16 7]]"。这里， np.multiply() 用于两个矩阵相乘，相乘后会产生一个矩阵。
你可以参考下面的截图如何用 python 做矩阵乘法。
How to do matrix multiplication in python
如何在 python 中使用 for 循环创建矩阵
让我们看看如何在 python 中使用 for 循环创建矩阵。
为了使用 For 循环创建矩阵，我们需要接受用户输入。矩阵由创建并分配给列和行的列表组成，for 循环用于行和列。
举例:
c_size = int(input("Enter size of column: "))
r_size = int(input("Enter size of row: "))
x = []
y = []
for j in range(0, c_size):
y.append(0)
for i in range(0, r_size):
x.append(y)
print(x)
写完上面的代码(如何在 python 中使用 for 循环创建一个矩阵)，一旦你将打印 "x" 那么输出将显示为 "[[0，0，0]，[0，0，0]，[0，0，0]]"。在这里，用户将输入行和列的大小，它将把列附加到每一行。矩阵将作为输出打印出来。
可以参考下面截图如何在 python 中使用 for 循环创建矩阵。
How to create a matrix using for loop in python
如何使用列表在 Python 中创建矩阵
让我们看看如何使用列表在 Python 中创建矩阵？
我们可以使用嵌套列表在 Python 中创建一个矩阵。首先我们将导入 NumPy ，然后我们可以使用列表使用 np.array() ，它将以矩阵的形式给出输出。
举例:
import numpy as np
mat = np.array([[1, 3, 2], [5, 6, 4]])
print(mat)
写完上面的代码(如何使用列表在 Python 中创建一个矩阵)，一旦你将打印“mat”那么输出将显示为“[[1 3 2][5 6 4]]”。这里，np.array()用于使用列表创建矩阵，它将给出矩阵作为输出。
你可以参考下面关于如何使用列表在 Python 中创建矩阵的截图
How to create a matrix in Python using a list
将一个 8 行 1 列的矩阵和一个 1 行 8 列的矩阵相乘得到一个 8 行的矩阵
在本节中，我们将学习如何将一个 8 行 1 列的矩阵和一个 1 行 8 列的矩阵相乘得到一个 8 行的矩阵。这是这个主题的图示。
matrix multiplication in python
- 在上图中，我们有 8 行 1 列，我们必须乘以 1 行 8 列。
- 矩阵乘法的主要规则是“第一个矩阵中的行数必须等于第二个矩阵中的列数”，在这种情况下，该规则得到满足，因此我们现在可以继续乘法。
- 第一个矩阵的每个元素将与第二个矩阵的每个元素相乘。下面是 Python 中矩阵乘法的图解。
Matrix Multiplication in Python
-
Python 中实现矩阵乘法主要有 3 种方式。
numpy.dot()方法- 在 2 个矩阵上使用 @ 运算符。
- Tensorflow 中的
tf.matmul()方法
-
Numpy 点法用于求两个数组的乘积。
-
数组和矩阵之间只有一线之差。因此，如果您在用其他两种方法执行乘法时看到错误，那么尝试
numpy.dot()方法。这会给你正确的结果，没有任何错误。 -
下面是在 Python 中使用
numpy.dot()方法的语法。
import numpy as np
np.dot(matrix1, matrix2)
- 这里，矩阵 1 和矩阵 2 是彼此相乘的矩阵。我们没有在语法中创建它们，但是它们在下面的例子中是可用的。
- 另一种解决方案是在 Python 中使用' @ '运算符。 @ '运算符在 Python 中用作矩阵乘法的符号。
- 请注意，它只对矩阵有效，对数组无效。
- 下面是在 Python 中使用 @ 进行矩阵乘法的语法。
matrix1 @ matrix2
- 第三种解决方案是使用张量流。Tensorflow 是与 Python 和 R 一起使用的高级工具，用于高级计算。
- 它有各种内置模块，可以加速复杂算法的计算。
- 如果您正在处理大型矩阵，那么您可以使用 python tensorflow 中的 tensorflow 模块
tf.matmul()来减少计算时间。 - 以下是使用 Python Tensorflow 执行矩阵乘法的语法
import tensorflow as tf
tf.matmul(matrix1, matrix2)
下面是 1 行 8 列和 8 行 1 列的矩阵乘法在 Python Jupyter 笔记本上的实现。
Matplotlib 1.3.1 需要未安装的 nose
原文：https://pythonguides.com/matplotlib-1-3-1-requires-nose-which-is-not-installed/
在本 Python 教程中，我们将讨论错误“ matplotlib 1.3.1 需要 nose 而 matplotlib 中 未安装”。在这里，我们将使用 matplotlib 涵盖与此错误相关的不同原因。我们将讨论以下主题:
- 错误:matplotlib 1.3.1 需要 nose，但没有安装
- 解决方案:matplotlib 1.3.1 需要未安装的 nose
Matplotlib Error
目录
错误:matplotlib 1.3.1 需要 nose，但没有安装
这里我们要讨论的错误: matplotlib 1.3.1 需要 nose 而 python 中没有安装。所以在这里，你会在这里得到所有可能的原因和解决方法。
nose 是一个流行的 Python 测试自动化框架，它扩展了单元测试来帮助测试。使用 Nose 框架的其他优势包括自动定位测试用例并收集文档的能力。
nose 框架有大量插件，用于测试执行、多重处理测试、日志和报告。
此外，检查:模块' matplotlib '没有属性' plot'
解决方案:matplotlib 1.3.1 需要 nose，但没有安装
matplotlib 1.3.1 的解决方案需要未安装的 nosematplotlib 中的错误是在您的系统中安装 nose。
在大多数类似 UNIX 的平台上，你可能需要以 root 用户身份运行这些命令。
- 使用 setuptools / distribute 安装 nose:
sudo easy_install nose
- 使用 pip 安装鼻部:
pip install nose
- 如果没有安装 setuptools/distribute，可以从下载链接下载源码包并安装。
下载并安装后，执行以下步骤:
- 解压缩源文件包
- cd 到新目录
- 写下下面给出的命令
python setup.py install
这将安装 nose 库和 nose 测试脚本，它们可用于自动查找和运行测试。
注:
除非安装了 setuptools/distribute，否则您将无法使用第三方 nose 插件。
你可能也喜欢阅读下面的 Matplotlib 教程。
在本 Python 教程中，我们已经讨论了" matplotlib 1.3.1 需要 nose，而 nose 是 未安装"我们还讨论了与之相关的原因和解决方案。这些是我们在本教程中讨论过的以下主题。
- 错误:matplotlib 1.3.1 需要 nose，但没有安装
- 解决方案:matplotlib 1.3.1 需要未安装的 nose
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib 二维表面图
在本 Python Matplotlib 教程中，我们将讨论 Matplotlib 2d 表面绘图。在这里，我们将介绍与使用 matplotlib 的 2d 表面绘图相关的不同示例。我们还将讨论以下主题:
- Matplotlib 二维表面图
- Matplotlib 二维轮廓打印
- Matplotlib 二维彩色表面图
目录
Matplotlib 2d 表面图
在 1.0 版本发布之前，matplotlib 仅用于二维绘图。但是在 1.0 版之后，您可以在 2d 工具的基础上开发 3d 工具。导入 mplot3d 包启用 3d 绘图。
表面图是三维数据集的表示。为了创建一个表面图，我们导入 Matplotlib 的 mpl_toolkits.mplot3d 工具包，该工具包具有创建一个 3d 表面图的功能。
创建表面图的语法:
ax.plot_surface(X, Y, Z)
这里我们的主要动机是使用 matplotlib 生成二维数据，并用三维效果(即表面)绘制它。
我们来看一个与此相关的例子:
- 这里我们需要
x和y的值，从 x 和 y 我们计算出z的值叫做身高。 - 然后我们使用
z在地图上绘制 x 轴和 y 轴，使用表面绘制来获得 3D 效果。 - 我们使用 numpy 的
linspace方法将x和y的值放在一个一维数组中，然后我们需要将它们转换成一个二维数组，所以我们使用 numpy 的meshgrid函数。
源代码:
**# Import Library**
import numpy as np
**# 1D array**
x = np.linspace(-10,10,50)
y = np.linspace(-10,10,50)
**# Print Values**
print('Value of X in 1D', x,'\n')
print ('Value of Y in 1D',y,'\n')
**# Print Shapes**
print('Shape of X in 1D',x.shape,'\n')
print('Shape of Y in 1D',y.shape,'\n')
Value and Shape of 1D Array
**# Convert 1D Array to 2D Array**
x_2d, y_2d = np.meshgrid(x,y)
**# Print Values**
print('Value of X in 2D', x_2d,'\n')
print ('Value of Y in 2D',y_2d,'\n')
**# Print Shapes**
print('Shape of X in 2D',x_2d.shape,'\n')
print('Shape of Y in 2D',y_2d.shape,'\n')
Values and Shapes of 2D Array
**# Compute Z**
z = np.exp(np.cos(5*xx)-np.sin(5*yy))-0.5
**# Print Value**
print('Value of Z', z,'\n')
**# Print Shape**
print('Shape of Z',z.shape,'\n')
Compute Z
- 从 mpl_toolkits.mplot3d 导入 Axes3D 库导入。
- 导入
matplotlib.pyplot库。 - 使用
plt.figure()函数和figsize()方法生成并设置图形的大小。 - 通过定义 axes object =
add _ subplot()将投影设置为 3d。 - 使用
plot_surface()函数绘制表面。 - 分别使用
set_xlabel()、set_ylabel()、set_zlabel()函数设置 x、y、z 轴的轴标签。 - 要显示该图，请使用
show()函数。
**# Import Libraries**
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import matplotlib.cm as cm
**# 3D Projection**
fig = plt.figure(figsize=(6,5))
ax = fig.add_subplot(111, projection='3d')
**# Surface Plot**
ax.plot_surface(x_2d, y_2d, z, cmap=cm.jet)
**# Labels**
ax.set_xlabel('X-Axis')
ax.set_ylabel('Y-Axis')
ax.set_zlabel('Z-Axis')
**# Display**
plt.show()
Surface Plot
我们再来看一个例子:
**# Import Library**
import numpy as np
**# 1D array**
x = np.linspace(-2,2,5)
y = np.linspace(-2,2,5)
**# Print Values**
print('Value of X in 1D', x,'\n')
print ('Value of Y in 1D',y,'\n')
**# Print Shapes**
print('Shape of X in 1D',x.shape,'\n')
print('Shape of Y in 1D',y.shape,'\n')
**# Convert 1D Array to 2D Array**
x_2d, y_2d = np.meshgrid(x,y)
**# Print Values**
print('Value of X in 2D', x_2d,'\n')
print ('Value of Y in 2D',y_2d,'\n')
**# Print Shapes**
print('Shape of X in 2D',x_2d.shape,'\n')
print('Shape of Y in 2D',y_2d.shape,'\n')
**# Compute Z**
z = (np.exp(20*x_2d)-np.tan(5*y_2d**4))-1.5
**# Print Value**
print('Value of Z', z,'\n')
**# Print Shape**
print('Shape of Z',z.shape,'\n')
1D Array
2D Array
Compute Z
**# Import Libraries**
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import matplotlib.cm as cm
**# 3D Projection**
fig = plt.figure(figsize=(6,5))
ax = fig.add_subplot(111, projection='3d')
**# Surface Plot**
ax.plot_surface(x_2d, y_2d,z, cmap=cm.flag)
**# Labels**
ax.set_xlabel('X-Axis')
ax.set_ylabel('Y-Axis')
ax.set_zlabel('Z-Axis')
**# Display**
plt.show()
surface_plot()
此外，请查看Matplotlib xlim–完整指南
Matplotlib 2d 轮廓图
等值线图，也称为水平图，是一种多元分析工具，允许您在二维空间中可视化三维图。当我们将 X 和 Y 作为变量绘制时，响应 Z 显示为 X-Y 平面上的切片，这就是为什么等高线有时被称为 Z 切片。
等高线图的使用:
等高线图通常用于气象部门来说明密度、海拔或山的高度。
创建等高线图:
在 matplotlib 中， matplotlib.pyplot 包含了一个方法 contour ，由于它的广泛使用，使得构造等值线图变得容易。
语法:
matplotlib.pyplot.contour([x, y, ] z, [levels], **kwargs)
参数如下:
- x 和 y: 指定用于绘图的 2D 或 1D 数字阵列。
- z: 指定绘制轮廓的高度。
- 层次:确定轮廓线的数量和位置。
我们来看一个例子:
- 我们使用 numpy 的
array方法将x和y的值放在一个一维数组中，然后我们需要将它们转换成一个二维数组，所以我们使用 numpy 的meshgrid函数。 - 从 mpl_toolkits.mplot3d 导入 Axes3D 库导入。
- 导入
matplotlib.pyplot库。 - 导入
numpy库。 - 使用
plt.figure()函数和figsize()方法生成并设置图形的大小。 - 通过定义 axes object =
add _ subplot()将投影设置为 3d。 - 使用
contour()功能绘制等高线。 - 分别使用
set_xlabel()、set_ylabel()、set_zlabel()函数设置 x、y、z 轴的轴标签。 - 要显示该图，请使用
show()函数。
1D Array
2D Array
Compute Z
Contour Plot
我们再来看一个例子:
**# Import Library**
import numpy as np
**# 1D array**
x = np.linspace(-2,2,10)
y = np.linspace(-3,3,15)
**# Print Values**
print('Value of X in 1D', x,'\n')
print ('Value of Y in 1D',y,'\n')
**# Print Shapes**
print('Shape of X in 1D',x.shape,'\n')
print('Shape of Y in 1D',y.shape,'\n')
- 我们使用 numpy 的
array方法获取一维数组中的 x 和 y 值，然后使用 numpy 的meshgrid函数将其转换为二维数组。
1D Array
**# Convert 1D Array to 2D Array**
x_2d, y_2d = np.meshgrid(x,y)
**# Print Values**
print('Value of X in 2D', x_2d,'\n')
print ('Value of Y in 2D',y_2d,'\n')
**# Print Shapes**
print('Shape of X in 2D',x_2d.shape,'\n')
print('Shape of Y in 2D',y_2d.shape,'\n')
2D Array
- 然后我们用 z 轴在地图上画出 x 轴和 y 轴的等高线图。
**# Compute z**
z = np.exp(np.cos(4*x_2d)`2-np.sin(5*y_2d)`2)-0.8
**# Print Values**
print('Value of Z', z,'\n')
**# Print Shape**
print('Shape of Z',z.shape,'\n')
- 汇入
matplot lib . pyplot程式库 - 要绘制等高线图，使用
contour()功能。 - 要添加 x 轴标签，请使用
xlabel()函数。 - 要添加 y 轴标签，请使用
ylabel()函数。 - 要显示图形，使用
show()功能。
plt.contour()
Matplotlib 2d 彩色表面图
Matplotlib 库的 pyplot 模块的 pcolor() 方法用于创建带有不规则矩形网格的伪彩色图。
语法如下:
matplotlib.pyplot.pcolor(*args, alpha=None, norm=None,
cmap=None, vmin=None, vmax=None,
data=None, **kwargs)
我们来看一个例子:
- 这里我们需要 x 和 y 的值，从 x 和 y 我们计算出 z 的值叫做高度。
- 然后我们使用
z使用颜色图在一张带有 x 轴和 y 轴的地图上绘图。
**# Import Library**
import numpy as np
**# 1D array**
x = np.linspace(-2,2,10)
y = np.linspace(-3,3,15)
**# Print Values**
print('Value of X in 1D', x,'\n')
print ('Value of Y in 1D',y,'\n')
**# Print Shapes**
print('Shape of X in 1D',x.shape,'\n')
print('Shape of Y in 1D',y.shape,'\n')
1D Array
- 我们使用 numpy 的
linspace方法将x和y的值放在一个一维数组中，然后我们需要将它们转换成一个二维数组，所以我们使用 numpy 的meshgrid函数。
2D Array
**# Compute z**
z = np.exp(np.sin(4*x_2d+y_2d)**2)-2.5
**# Print Value**
print('Value of Z', z,'\n')
**# Print Shape**
print('Shape of Z',z.shape,'\n')
Compute Z
- 汇入
matplot lib . pyplot程式库。 - 要绘制 2d 彩色表面图，使用
pcolor()函数。 - 将
edgecolor和线宽分别设置为黑色和2。 - 要添加 x 轴标签，请使用
xlabel()函数。 - 要添加 y 轴标签，请使用
ylabel()函数。 - 要显示图形，使用
show()功能。
**# Import Library**
import matplotlib.pyplot as plt
**# Color Plot**
plt.pcolor(x, y, z, edgecolors='k', linewidths=2)
**# Labels**
plt.xlabel('X-Axis')
plt.ylabel('Y-Axis')
**# Show**
plt.show()
plt.pcolor()
我们再来看一个例子:
- 这里我们需要 x 和 y 的值，从 x 和 y 我们计算出 z 的值叫做高度。
- 我们使用 numpy 的
linspace方法将 x 和 y 值转换成一维数组，然后我们使用 numpy 的meshgrid函数将它们转换成二维数组。 - 将
matplotlib.pyplot库导入到项目中。 - 使用
pcolor()方法创建一个二维彩色表面图。 - 将线宽和边缘颜色分别设置为 2 和黑色。
- 使用
xlabel()函数添加 x 轴标签。 - 使用
ylabel()函数添加一个 y 轴标签。 - 使用
show()功能显示图形。
源代码:
**# Import Library**
import numpy as np
**# 1D array**
x = np.linspace(-5,5,10)
y = np.linspace(-1,1,35)
**# Print Values**
print('Value of X in 1D', x,'\n')
print ('Value of Y in 1D',y,'\n')
**# Print Shapes**
print('Shape of X in 1D',x.shape,'\n')
print('Shape of Y in 1D',y.shape,'\n')
1D Array
**# Convert 1D Array to 2D Array**
x_2d, y_2d = np.meshgrid(x,y)
**# Print Values**
print('Value of X in 2D', x_2d,'\n')
print ('Value of Y in 2D',y_2d,'\n')
**# Print Shapes**
print('Shape of X in 2D',x_2d.shape,'\n')
print('Shape of Y in 2D',y_2d.shape,'\n')
2D Array
**# Compute z**
z = (x_2d`4+y_2d`6)+2
**# Print Value**
print('Value of Z', z,'\n')
**# Print Shape**
print('Shape of Z',z.shape,'\n')
Compute Z
**# Import Library**
import matplotlib.pyplot as plt
**# Color Plot**
plt.pcolor(x, y, z, edgecolors='k', linewidths=2)
**# Labels**
plt.xlabel('X-Axis')
plt.ylabel('Y-Axis')
**# Show**
plt.show()
plt.pcolor()
你可能也喜欢阅读下面的 Matplotlib 教程。
- 堆积条形图 Matplotlib
- Matplotlib 散点图图例
- Matplotlib 增加地块大小
- Matplotlib legend font size
- Matplotlib tight_layout
- 什么是 add_axes matplotlib
- 画垂直线 matplotlib
在本 Python 教程中，我们已经讨论了" Matplotlib 2d 表面绘图"并且我们还介绍了一些与之相关的例子。这些是我们在本教程中讨论过的以下主题。
- Matplotlib 二维表面图
- Matplotlib 二维轮廓打印
- Matplotlib 二维彩色表面图
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib 3D 散点图
在本 Python 教程中，我们将讨论 Python 中的 Matplotlib 3D 散点。在这里，我们将使用 matplotlib 讲述与 3D 散射相关的不同示例。我们还将讨论以下主题:
- Matplotlib 3D scatter plot
- Matplotlib 3D 散点图示例
- Matplotlib 3D 散布颜色
- 带颜色条的 Matplotlib 3D 散点图
- Matplotlib 3D 散点图标记大小
- Matplotlib 3D 散点图标签
- Matplotlib 3D 散点图图例
- Matplotlib 3D 散点图按值显示颜色
- Matplotlib 3D 散布旋转
- Matplotlib 3D 散点图更改视角
- Matplotlib 3D 散点图标题
- Matplotlib 3D 散布文本
- 带线条的 Matplotlib 3D 散点图
- 带表面的 Matplotlib 3D 散点图
- Matplotlib 三维抖动透明度
- matplot lib 3d sactor depthshade
- Matplotlib 3D 散点图轴限制
- Matplotlib 三维散点图坐标轴刻度
- Matplotlib 3D 散点图大小
- Matplotlib 3D 散点图网格
- Matplotlib 3D 散点子图
- Matplotlib 3D 散点保存
- Matplotlib 3D 散布背景颜色
- Matplotlib 3D 散点图数组
- Matplotlib 3D 散点图标记颜色
- matplot lib 3d scatter zlem
- Matplotlib 3D scatter z label
- Matplotlib 3D scatter xlim
- Matplotlib 3D scatter zoom
- Matplotlib 3D 散布原点
- Matplotlib 3D 散点图对数标度
- Matplotlib 3D scatter dataframe
- Matplotlib 3D 散布动画
目录
- Matplotlib 3D 散点图
- Matplotlib 3D 散点图示例
- Matplotlib 3D 散布颜色
- 带彩条的 Matplotlib 3D 散点图
- Matplotlib 3D 散点图标记尺寸
- Matplotlib 3D scatter label
- Matplotlib 3D 散点图图例
- Matplotlib 3D 散点图颜色值
- Matplotlib 3D 散点旋转
- Matplotlib 3D 散点变化视角
- Matplotlib 3D 散点图标题
- Matplotlib 3D 散点图文本
- Matplotlib 3D 散点图，带线条
- Matplotlib 3D 散点图与表面
- Matplotlib 3D 散射透明度
- matplot lib 3d sactor depthshade
- Matplotlib 3D 散点图轴限制
- Matplotlib 3D 散点图轴刻度
- Matplotlib 3D 散点图尺寸
- Matplotlib 3D 散点图网格
- Matplotlib 3D 散点子图
- Matplotlib 3D 散点保存
- Matplotlib 3D 散点背景色
- matplot lib 3d scatter num array
- Matplotlib 3D 散点标记颜色
- Matplotlib 3D scatter zlim
- matplot lib 3d scatter zlabel
- Matplotlib 3d scatter xlim
- Matplotlib 3D scatter zoom
- Matplotlib 3D 散点原点
- Matplotlib 3D 散点图对数标度
- matplot lib 3d scatter data frame
- Matplotlib 3D 散点动画
Matplotlib 3D 散点图
在本节中，我们将学习如何在 Python 中的 matplotlib 中绘制 3D 散点图图。在开始这个话题之前，我们首先要明白 3D 和散点图是什么意思:
"
3D代表三维"现实世界中的任何三维物体都称为 3D 物体。具有三维即高度、宽度和深度。
散点图是使用点沿轴绘制变量值的图形。
3D 散点图是一种数学图表，用于使用笛卡尔坐标将数据属性显示为三个变量。在 matplotlib 中创建 3D 散点图，我们必须导入 mplot3d 工具包。
matplotlib 库的 scatter3D() 函数接受 X 、 Y 和 Z 数据集，用于构建 3D 散点图。
以下步骤用于绘制 3D 散点图，概述如下:
- 定义库:导入绘制 3D 图形所需的最重要的库
mplot3d toolkit，还导入数据创建和操作所需的其他库numpy和pandas，用于数据可视化:matplotlib 中的pyplot。 - 定义 X 和 Y :定义用于 X 轴和 Y 轴数据绘图的数据坐标值。
- 绘制 3D 散点图:通过使用 matplotlib 库的
scatter3D()方法，我们可以绘制 3D 散点图。 - 可视化绘图:通过使用
show()方法，用户可以在他们的屏幕上生成一个绘图。
Matplotlib 3D 散点图示例
**# Import Library**
from mpl_toolkits import mplot3d
**# Function to create 3D scatter plot**
matplotlib.axes.Axis.scatter3D(x, y, z)
这里的 x 、 y 、 z 代表了地块的三维。
让我们看一个例子来更清楚地理解这个概念:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x = np.arange(0, 20, 0.2)
y = np.sin(x)
z = np.cos(x)
**# Create Figure**
fig = plt.figure(figsize = (10, 7))
ax = plt.axes(projection ="3d")
**# Create Plot**
ax.scatter3D(x, y, z)
**# Show plot**
plt.show()
- 在上面的例子中，我们导入了 mplot3d 工具包、
numpy和pyplot库。 - 接下来，我们使用
arange()、sin()和cos()方法定义数据。 plt.figure()方法用于设置图形大小这里我们将figsize作为参数传递，plt.axes()方法用于设置轴，这里我们将投影作为参数传递。ax.scatter3D()方法用于创建三维散点图，这里我们传递x、y、z作为参数。plt.show()方法用于在用户屏幕上生成图形。
plt.scatter3D()
Matplotlib 3D 散布颜色
在本节中，我们将学习如何更改 3D 散点图的颜色。
改变颜色的语法如下:
matplotlib.axes.Axis.scatter3D(x, y, z, color=None)
- x: 指定轴的 x 坐标。
- y: 指定轴的 y 坐标。
- z: 指定轴的 z 坐标。
- 颜色:指定散点的颜色。
让我们看一个改变 3D 散射颜色的例子:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x = [2, 4, 6, 8, 10]
y = [5, 10, 15, 20, 25]
z = [3, 6, 9, 12, 15]
**# Create Figure**
fig = plt.figure(figsize = (10, 7))
ax = plt.axes(projection ="3d")
**# Create Plot and change color**
ax.scatter3D(x, y, z, color='red')
**# Show plot**
plt.show()
- 在上面的例子中，我们导入了 mplot3d 工具包 、
numpy和pyplot库。 - 接下来，我们定义数据。
plt.figure()方法用于设置图形大小这里我们将figsize作为参数传递，plt.axes()方法用于设置轴，这里我们将投影作为参数传递。ax.scatter3D()方法用于创建三维散点图，这里我们通过x、y、z和颜色作为参数。这里颜色改变绘图的颜色。plt.show()方法用于在用户屏幕上生成图形。
ax.scatter3D(color=None)
阅读: Matplotlib 虚线
带彩条的 Matplotlib 3D 散点图
这里我们用颜色条绘制了一个 3D 散点图。通过使用 get_cmap() 方法，我们创建了一个颜色图。
绘制颜色条的语法:
**# Create scatter Plot**
matplotlib.axis.Axis.scatter3D(x, y, z, cmap)
**# To Plot colorbar**
matplotlib.pyplot.colorbar(mappable=None, cax=None, ax=None, label, ticks)
在这里 cmap 指定颜色图。
举例:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Dataset** x = np.random.randint(100,size=(80))
y = np.random.randint(150, size=(80))
z = np.random.randint(200, size=(80))
**# Creating figure** fig = plt.figure(figsize = (16, 9))
ax = plt.axes(projection ="3d")
**# Creat color map**
color_map = plt.get_cmap('spring')
**# Create scatter plot and colorbar** scatter_plot = ax.scatter3D(x, y, z,
c=(x+y+z),
cmap = color_map)
plt.colorbar(scatter_plot)
**# Show plot**
plt.show()
- 在上面的例子中，我们导入了 mplot3d 工具包 、
numpy和pyplot库。 - 接下来，我们使用
random.randint()方法定义数据。 plt.axes()方法用于设置轴，这里我们将投影作为参数传递。plt.get_cmap()方法用于创建特定颜色的色图。ax.scatter3D()方法用于创建三维散点图，这里我们通过x、y、z和cmap作为参数。这里cmap定义颜色贴图贴图。fig.colorbar()方法用于将 colorbar 添加到指示色标的绘图中。
plt.colorbar()
阅读: Matplotlib 散点图标记
Matplotlib 3D 散点图标记尺寸
在这里，我们将学习如何在 matplotlib 中更改 3D 散点图的标记和标记大小。
改变标记大小的语法如下:
matplotlib.axis.Axis.scatter(x, y, z, s=None, marker=None)
上面使用的参数是:
- x: 指定 x 轴上的数据位置。
- y: 指定 y 轴上的数据位置。
- s: 以点**2 为单位指定标记尺寸。
- 标记:指定标记样式。
让我们来看一个改变散点标记及其大小的例子:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x = np.arange(0, 20, 0.2)
y = np.sin(x)
z = np.cos(x)
**# Create Figure**
fig = plt.figure(figsize = (8,6))
ax = plt.axes(projection ="3d")
**# Create Plot**
ax.scatter3D(x, y, z, marker= '>', s=50)
**# Show plot**
plt.show()
这里我们使用一个 ax.scatter() 方法来创建一个散点图，我们将标记和 s 作为参数来分别改变标记样式和标记大小。我们将标记大小设置为 50。
ax.scatter3D(marker, s=None)
Matplotlib 3D scatter label
在这里，我们将学习如何向 3D 散点图添加标签。
添加标签的语法如下:
**# To add x-axis label**
ax.set_xlabel()
**# To add y-axis label**
ax.set_ylabel()
**# To add z-axis label**
ax.set_zlabel()
举例:
这里我们用 ax.scatter3D() 函数来绘制 3D 散点图。
ax.set_xlabel() 、 ax.set_ylabel() 、 ax.set_zlabel() 函数用于给绘图添加标签。我们将 X 轴、 Y 轴和 Z 轴传递给各自的功能。
代码:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
z = [3, 6, 9, 12, 15]
x = [2, 4, 6, 8, 10]
y = [5, 10, 15, 20, 25]
**# Create Figure**
fig = plt.figure(figsize = (10, 7))
ax = plt.axes(projection ="3d")
**# Create Plot**
ax.scatter3D(x, y, z, color='red')
**# Add axis**
ax.set_xlabel('X-axis', fontweight ='bold')
ax.set_ylabel('Y-axis', fontweight ='bold')
ax.set_zlabel('Z-axis', fontweight ='bold')
**# Show plot**
plt.show()
输出:
” 3D Scatter Plot with Labels “
另外，检查: Matplotlib 旋转刻度标签
Matplotlib 3D 散点图图例
在这里，我们学习如何向 3D 散点图添加图例。通过使用 legend() 函数我们可以很容易地添加。
举例:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x = np.arange(0, 20, 0.2)
y = np.sin(x)
z1 = np.cos(x)
z2 = np.exp(8)
**# Create Figure**
fig = plt.figure(figsize = (10, 7))
ax = plt.axes(projection ="3d")
**# Create Plot**
ax.scatter3D(x, y, z1, marker='<', s=20, label='Triangle')
ax.scatter3D(x, y, z2, marker='o', s=20, label='Circle' )
**# Add legend**
ax.legend(loc=1)
**# Show plot**
plt.show()
- 这里我们绘制了
x、y和z1轴与x、y和z2轴之间的三维散点图。 - 通过使用
ax . sacter3d)(方法，我们绘制 3D sactter 图，并将标签作为参数。 ax.legend()方法用于给绘图添加图例。
ax.legend()
Matplotlib 3D 散点图颜色值
在这里，我们将学习如何绘制不同数据和颜色的 3D 散点图。
让我们看一个例子来更清楚地理解这个概念:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data** x1 = np.random.randint(450,size=(80))
y1 = np.random.randint(260, size=(80))
z1 = np.random.randint(490, size=(80))
x2 = np.random.randint(100,size=(50))
y2 = np.random.randint(150, size=(50))
z2 = np.random.randint(200, size=(50))
x3 = [3, 6, 9, 12, 15]
y3 = [2, 4, 6, 8, 10]
z3 = [5, 10, 15, 20, 25]
**# Create Figure**
fig = plt.figure(figsize = (8,6))
ax = plt.axes(projection ="3d")
**# Create Plot**
ax.scatter3D(x1, y1, z1, s=50, color='red')
ax.scatter3D(x2, y2, z2, s=50, color='yellow')
ax.scatter3D(x3, y3, z3, s=50, color='pink')
**# Show plot**
plt.show()
- 这里我们用三个不同的数据集绘制了一个 3D 散点图。
- 然后通过使用
ax.scatter3D()函数，我们为不同的数据集绘制散点图。 - 绕过作为参数的颜色,我们用数值给散点图着色。
” 3D Scatter Plot Color by Value “
另外，阅读: Matplotlib 绘图误差线
Matplotlib 3D 散点旋转
在这里，我们将学习如何仅通过移动鼠标来旋转 3D 散点图。
要打开交互性或使用鼠标旋转 3D 散点图，请在代码中使用这一行:
%matplotlib notebook
我们来看一个例子:
**# Interactive Mode**
%matplotlib notebook
**# Import Library**
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
**# Create Plot**
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
**# Define Data**
X = [1,2,3,4,5,6,7,8,9,10]
Y = [5,6,2,3,13,4,1,2,4,8]
Z = [2,3,3,3,5,7,9,11,9,10]
**# Plot 3D scatter Plot**
ax.scatter(X,Y,Z, c='r', marker='o')
**# Define Label**
ax.set_xlabel('x axis')
ax.set_ylabel('y axis')
ax.set_zlabel('z axis')
**# Display**
plt.show()
- 在上面的例子中，我们从后端启用的交互模式。
- 接下来，我们导入库
mplot3D和pyplot。 - 然后我们创建一个图并定义数据。
ax.scatter3D()方法用于绘制三维散点图。set_xlabel()、set_ylabel、set_zlabel()方法用于给绘图添加标签。plt.show()方法用于显示绘图用户屏幕。
” Original 3D Scatter Plot”
” Rotation of 3D scatter by mouse “
” Rotation using Mouse “
阅读:在 Python 中添加文本到 plot matplotlib
Matplotlib 3D 散点变化视角
在这里，我们可以了解如何从不同角度查看 3D 散点图。通过使用 view_init() 方法，我们可以改变视角。
改变视角的语法如下:
matplotlib.axis.Axis.view_init(elev,azim)
上面使用的参数如下:
- elev: 指定 z 平面的仰角。
- azim: 指定 x，y 平面的方位角。
让我们看一个改变视角的例子:
**# Import Library**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Plotting 3D axis figures**
fig = plt.figure(figsize = (8,8))
ax = plt.axes(projection = '3d')
**# Define Data**
z = np.linspace(0, 20, 500)
x = np.sin(z)
y = np.cos(z)
ax.plot3D(x, y, z, 'green')
**# Change view angle**
ax.view_init(50, 20)
**# Display**
plt.show()
- 在这个例子中，我们导入了
mplot3d、numpy和pyplot库。 - 然后我们使用
plt.figure()和plt.axes()方法绘制三维轴图形，并分别传递figsize和投影作为参数。 - 之后，我们为三个轴创建一个数据集。
ax.scatter3D()方法用于绘制三维散点图。view_init()方法用于改变视角。
输出:无旋转出图。
” 3D scatter plot without rotation “
输出:绘制仰角 50 度，水平角 20 度的 3D 散点图。
” 3D Scatter Plot with rotation “
Matplotlib 3D 散点图标题
在这里，我们将学习如何绘制带有标题的 3D 散点图。
向三维散点图添加标题的语法:
matplotlib.pyplot.title()
我们来看一个例子:
**# Import Library**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Plotting 3D axis figures**
fig = plt.figure(figsize = (6,4))
ax = plt.axes(projection = '3d')
**# Define Data**
z = np.linspace(0,15,150)
x = np.sin(z)
y = np.cos(z)
**# Plot 3D scatter**
ax.scatter3D(x, y, z, color='m')
**# Add Title**
plt.title('3D SCATTER PLOT', fontweight='bold', size=20)
**# Display**
plt.show()
- 在上面的例子中，我们导入了
mplot3d、numpy和pyplot库。 - 接下来，我们使用
linespace()、sin()和cos()方法定义数据。 ax.scatter3D()方法用于绘制散点图。plt.title()方法用于将标题添加到 3D 散点图中。
plt.title()
阅读: Matplotlib 条形图标签
Matplotlib 3D 散点图文本
在这里，我们将学习如何向 3D 散点图添加文本。通过使用 ax.text() 方法我们可以做到这一点。
让我们来看一个在 3D 散点图的固定位置添加文本的例子:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
z = [3, 6, 9, 12, 15]
x = [2, 4, 6, 8, 10]
y = [5, 10, 15, 20, 25]
**# Create Figure**
fig = plt.figure(figsize = (10, 7))
ax = plt.axes(projection ="3d")
**# Create Plot**
ax.scatter3D(x, y, z)
**# Add axis**
ax.set_xlabel('X-axis')
ax.set_ylabel('Y-axis')
ax.set_zlabel('Z-axis')
**# Add Text**
ax.text3D(6, 4, 10,"Point 2")
**# Show plot**
plt.show()
- 这里我们首先定义用于绘图的数据，然后通过使用
ax.scatter()函数绘制 3D 散点图。 ax.text()方法用于将文本添加到绘图的固定位置。我们传递放置文本的三个位置( x，y，z 轴)和我们想要添加的文本。
ax.text()
Matplotlib 3D 散点图，带线条
在这里，我们将学习如何用线条绘制 3D 散点图。为了连接散点，我们使用带有 x 、 y 和 z 数据点的 plot3D() 方法。
让我们看一个例子，用线绘制一个 3D 散点图:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
z = [3, 6, 9, 12, 15]
x = [2, 4, 6, 8, 10]
y = [5, 10, 15, 20, 25]
**# Create Figure**
fig = plt.figure(figsize = (10, 7))
ax = plt.axes(projection ="3d")
**# Create Plot**
ax.scatter3D(x, y, z, color='red')
**# Add line**
ax.plot3D(x,y,z)
**# Add axis**
ax.set_xlabel('X-axis')
ax.set_ylabel('Y-axis')
ax.set_zlabel('Z-axis')
**# Show plot**
plt.show()
- 通过使用
figure()函数，我们创建了一个新图形，并在当前图形中添加了一个轴作为子图形。 - 定义数据点
x、y和z。 ax.scatter3D()函数用于绘制散点图。ax.plot3D()函数用于连接点与x、y、z数据点。plt.show()方法用于显示图。
ax.plot3D()
Matplotlib 3D 散点图与表面
在这里，我们将学习如何绘制一个表面的三维散点图。首先，我们必须了解什么是表面情节:
表面图是三维数据集的表示。它表示两个变量 X 和 Z 与因变量 y 之间的关系。
ax.plot_surface() 函数用于创建表面图。
给定方法的语法如下:
matplotlib.axis.Axis.plot_surface(X, Y, Z)
其中 X 、 Y 、 Z 为三维数据坐标点。
让我们来看一个 3D 表面散射的例子:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Function**
def function_z(x,y):
return 100 - (x`2 + y`2)
**# Define Data**
x_val = np.linspace(-3, 3, 30)
y_val = np.linspace(-3, 3, 30)
X, Y = np.meshgrid(x_val, y_val)
**# Call function**
z = function_z(X, Y)
**# Create figure** fig = plt.figure(figsize =(10,6))
ax = plt.axes(projection='3d')
**# Create surface plot**
ax.plot_surface(X, Y, z, color='yellow');
**# Display**
plt.show()
- 在上面的例子中，首先我们导入
matplotlib.pyplot、numpy和mplot3D。 - 接下来，我们为 z 坐标创建一个用户定义函数。
- 然后通过使用
np.linspace()函数，我们为 x 和 y 坐标定义数据。 - 通过使用
plt.figure()方法我们创建一个函数和plt.axes()方法来定义轴。 ax.plot_surface()方法用于绘制带表面的三维散点图。- 要显示图形，请使用
show()方法。
ax.plot_surface()
Matplotlib 3D 散射透明度
在这里，我们将学习如何调整 3D 散点图的不透明度或透明度。通过使用 alpha 属性，我们可以改变 matplotlib 中绘图的透明度。
默认情况下，alpha 为 1。它的范围在 0 到 1 之间。我们可以通过降低 alpha 值来降低透明度。
改变透明度的语法如下:
matplotlib.axis.Axis.scatter3D(x, y, z, alpha=1)
这里 x，y，z 是数据坐标，alpha 用来设置透明度。
让我们看一个改变绘图透明度的例子:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x = np.arange(0, 20, 0.2)
y = np.sin(x)
z = np.cos(x)
**# Create Figure**
fig = plt.figure(figsize = (10, 7))
ax = plt.axes(projection ="3d")
**# Create Plot**
ax.scatter3D(x, y, z)
**# OR**
ax.scatter3D(x, y, z, alpha=0)
**# OR**
ax.scatter3D(x, y, z, alpha=0.5)
**# OR**
ax.scatter3D(x, y, z, alpha=1)
**# Show plot**
plt.show()
- 在上面的例子中，我们使用
arange()、sin()、cos()的方法定义数据。 - 通过使用
figure()函数我们创建图，【轴()】方法用于定义投影到 3d。 ax.scatter3D()方法用于绘制 3D 散点图，我们通过alpha参数来改变不透明度。
” Scatter3D plot without alpha argument “
” Scatter3D plot with alpha=0 “
” Scatter3D plot with alpha=0.5 “
” Scatter3D plot with alpha=1 “
阅读: Matplotlib 另存为 pdf + 13 示例
matplot lib 3d sactor depthshade
通常，当我们绘制 3D 散点图时，数据点的透明度会根据距离进行调整。这意味着透明度以磅的距离增加和减少。
总的来说，我们看到一些数据点是深色的，一些是透明的。
通过使用 depthshade 属性，我们可以关闭 matplotlib 中的透明度。要关闭它，将其值设置为假。
语法如下:
matplotlib.axis.Axis.scatter3D(x, y, z, depthshade=False)
我们来看一个例子:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
z = [3, 6, 9, 12, 15]
x = [2, 4, 6, 8, 10]
y = [5, 10, 15, 20, 25]
**# Create Figure** fig = plt.figure(figsize = (10, 7))
ax = plt.axes(projection ="3d")
**# Create Plot**
ax.scatter3D(x, y, z, s=100, color='green', depthshade=False)
**# Add axis**
ax.set_xlabel('X-axis')
ax.set_ylabel('Y-axis')
ax.set_zlabel('Z-axis')
**# Show plot**
plt.show()
这里我们使用 ax.scatter3D() 方法来绘制 3D 散点图，并通过 depthshade 属性来关闭其透明度。
” 3D scatter Plot with depthshade attribute “
这里你可以看到 3D 散点图的透明度。
” 3D Scatter Plot with depthshade attribute “
这里你可以看到数据点没有透明度。
Matplotlib 3D 散点图轴限制
在这里，我们将学习如何更改 3D 散点图的轴限制。默认情况下，轴上的值范围是根据输入值自动设置的。
为了修改每个轴上的最小和最大限制，我们使用了 set_xlim() 、 set_ylim() 和 set_zlim() 方法。
修改轴限制的语法如下:
**# For x-axis limit** matplotlib.axis.Axis.set_xlim(min, max)
**# For y-axis limit** matplotlib.axis.Axis.set_ylim(min, max)
**# For z-axis limit** matplotlib.axis.Axis.set_zlim(min, max)
让我们看一个调整轴限制的例子:
代码:带默认轴
**# Import libraries** from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x1 = np.random.randint(450,size=(80))
y1 = np.random.randint(260, size=(80))
z1 = np.random.randint(490, size=(80))
**# Create Figure**
fig = plt.figure(figsize = (8,6))
ax = plt.axes(projection ="3d")
**# Create Plot** ax.scatter3D(x1, y1, z1, s=50, color='red')
**# Show plot** plt.show()
这里我们使用 ax.scatter3D() 方法绘制一个 3D 散点图。并且我们使用 np.random.randint() 方法来定义数据。
” 3D Scatter Plot “
代码:带修改轴
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x1 = np.random.randint(450,size=(80))
y1 = np.random.randint(260, size=(80))
z1 = np.random.randint(490, size=(80))
**# Create Figure**
fig = plt.figure(figsize = (8,6))
ax = plt.axes(projection ="3d")
**# Create Plot**
ax.scatter3D(x1, y1, z1, s=50, color='red')
**# Modify axis**
ax.set_xlim(50,150)
ax.set_ylim(30,160)
ax.set_zlim(0,350)
**# Show plot**
plt.show()
这里我们使用 set_xlim() ， set_ylim() ， set_zlim() 方法，根据传递的最小值和最大值修改三个轴的限值。
” 3D Scatter Plot with modified axes “
Matplotlib 3D 散点图轴刻度
在这里，我们将学习如何更改三维散点图的轴刻度。我们可以修改每个轴的刻度。修改 ticks 的方法有 set_xticks() ， set_yticks() ， set_zticks() 。
修改轴限制的语法如下:
**# For x-axis limit** matplotlib.axis.Axis.set_xticks()
**# For y-axis limit** matplotlib.axis.Axis.set_yticks()
# `For z-axis limit` matplotlib.axis.Axis.set_zticks()
让我们看一个调整坐标轴刻度的例子:
代码:带默认刻度
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x = np.arange(0, 20, 0.2)
y = np.sin(x)
z = np.cos(x)
**# Create Figure**
fig = plt.figure(figsize = (8,6))
ax = plt.axes(projection ="3d")
**# Create Plot**
ax.scatter3D(x, y, z)
**# Show plot**
plt.show()
这里我们用 ax.scatter3D() 的方法来绘制 3D 散点图。使用 arange() 、 sin() 和 cos() 方法来定义数据。
” 3D Scatter Plot “
这里 x 轴刻度是[0.0，2.5，5.0，7.5，10.0，12.5，15.5，17.5，20.0]
代码:带修改记号
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x = np.arange(0, 20, 0.2)
y = np.sin(x)
z = np.cos(x)
**# Create Figure**
fig = plt.figure(figsize = (8,6))
ax = plt.axes(projection ="3d")
**# Create Plot**
ax.scatter3D(x, y, z)
**# Set tick labels**
ax.set_xticks([1.5, 3.5, 5.5, 7.5, 12.5, 14.5, 16.5, 18.5])
**# Show plot**
plt.show()
这里我们使用 ax.set_xticks() 方法并传递一个 x 刻度列表来修改 x 轴刻度。
” 3D axis with modifying x ticks “
现在 x 个刻度是[1.5，3.5，5.5，7.5，12.5，14.5，16.5，18.5]。
我们还可以分别使用 set_yticks() 和 z_ticks() 方法更新 Y ticks 和 Z ticks。
Matplotlib 3D 散点图尺寸
在这里，我们将学习如何改变三维散点图的大小。我们可以轻松地使我们的地块比默认大小更大或更小。
以下方式用于改变绘图的大小:
- 使用 plt.figure()方法
- 使用 set_size_inches()方法
通过使用 plt.figure()方法
我们将 figsize 参数传递给 plt.figure() 方法来改变绘图的大小。我们必须以英寸为单位指定绘图的宽度和高度。
其语法如下:
matplotlib.pyplot.figure(figsize(w,h))
这里 w 和 h 指定宽度和高度
我们来看一个例子:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x = np.arange(0, 20, 0.2)
y = np.sin(x)
z = np.exp(8)
**# Change figure size**
fig = plt.figure(figsize = (10, 7))
ax = plt.axes(projection ="3d")
**# Create Plot**
ax.scatter3D(x, y, z, marker='<', s=20)
**# Show plot**
plt.show()
这里我们使用 plt.figure() 方法的 figsize 参数来改变图形大小。我们设置 w = 10 和 h= 7 。
plt.figure(figsize())
通过使用 set_size_inches()方法
我们将以英寸为单位的绘图的宽度和高度传递给 set_size_inches() 方法来修改绘图的大小。
其语法如下:
matplotlib.figure.Figure.set_size_inches(w,h)
这里 w 和 h 指定宽度和高度。
我们来看一个例子:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
z = [3, 6, 9, 12, 15, 23, 14, 16, 21]
x = [2, 4, 6, 8, 10, 13, 18, 16, 15]
y = [5, 10, 15, 20, 25, 32, 29, 45, 20]
**# Change figure size**
fig = plt.figure()
fig.set_size_inches(10, 10)
ax = plt.axes(projection ="3d")
**# Create Plot**
ax.scatter3D(x, y, z)
**# Add axis**
ax.set_xlabel('X-axis')
ax.set_ylabel('Y-axis')
ax.set_zlabel('Z-axis')
**# Show plot**
plt.show()
这里我们使用图的 set_size_inches() 方法来修改绘图的大小。
fig.set_size_inches()
这里我们将绘图的宽度和高度设置为 10 英寸。
Matplotlib 3D 散点图网格
当我们绘制 3D 散点图时，默认情况下所有的图都有网格线。如果我们愿意，我们可以去掉网格线。要删除网格线，调用 axes 对象的 grid() 方法。
传递值‘False’来移除网格线，并再次获取网格线。传递值‘True’。
其语法如下:
matplotlib.axis.Axis.grid()
让我们看一个没有 网格的 3D 散点图的例子:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Function**
def function_z(x,y):
return np.cos(x ` 2 + y ` 2)
**# Define Data**
x_val = np.linspace(-3, 3, 30)
y_val = np.linspace(-3, 3, 30)
X, Y = np.meshgrid(x_val, y_val)
**# Call function**
z = function_z(X, Y)
**# Create figure**
fig = plt.figure(figsize =(10,6))
ax = plt.axes(projection='3d')
**# Create surface plot**
ax.plot_surface(X, Y, z);
**# Grid**
ax.grid(False)
**# Display**
plt.show()
- 在上面的例子中，我们使用用户自定义函数定义了 z 轴，使用 numpy 的
linspace()方法定义了 x 轴、 y 轴。 - 然后我们用
ax.plot_surface()的方法用曲面绘制 3D 散点图。 - 我们使用
ax.grid()方法并传递关键字False来关闭网格线。
ax.grid(False)
Matplotlib 3D 散点子图
这里我们将讨论如何在多个情节中的一个特定支线情节中绘制 3D 散点图。
我们使用 scatter3D() 方法创建 3D 散点图。
让我们借助一个例子来理解这个概念:
**# Importing Libraries**
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits import mplot3d
**# Create 1st subplot**
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(1, 2, 1, projection='3d')
**# Define Data**
x1= [0.2, 0.4, 0.6, 0.8, 1]
y1= [0.3, 0.6, 0.8, 0.9, 1.5]
z1= [2, 6, 7, 9, 10]
**# Plot graph**
ax.scatter3D(x1, y1, z1, color='m')
**# Create 2nd subplot**
ax = fig.add_subplot(1, 2, 2, projection='3d')
**# Define Data**
x2 = np.arange(0, 20, 0.2)
y2 = np.sin(x)
z2 = np.cos(x)
**# Plot graph**
ax.scatter3D(x2, y2, z2, color='r')
**# Display graph**
fig.tight_layout()
plt.show()
- 在上面的例子中，通过使用
add_subplot()方法，我们创建了第一个子绘图，然后我们定义了用于绘图的数据。 ax.scatter3D()方法用于创建 3D 散点图。- 之后，我们再次使用
add_subplot()方法创建 2nmd 子绘图，然后我们定义用于绘图的数据。 - 同样，我们使用
ax.scatter3D()方法绘制另一个 3D 散点图。
” 3D Scatter Subplots “
Matplotlib 3D 散点保存
在这里，我们将学习如何在系统内存中保存 3D 散点图。我们将 3D 散点图保存在“png”中。
为了保存它，我们使用 matplotlib 的 savefig() 方法，并将路径传递到您想要保存它的地方。
我们来看一个例子:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x1 = np.random.randint(450,size=(80))
y1 = np.random.randint(260, size=(80))
z1 = np.random.randint(490, size=(80))
**# Create Figure**
fig = plt.figure(figsize = (8,6))
ax = plt.axes(projection ="3d")
**# Create Plot**
ax.scatter3D(x1, y1, z1, s=50, color='red')
**# save plot**
plt.savefig('3D Scatter Plot.png')
**# Show plot**
plt.show()
- 在上面的例子中，我们使用
random.randit()方法定义数据，使用scatter3D()方法绘制 3D 散点图。 - 然后，我们使用
plt.savefig()方法在系统中保存绘图，并将路径作为参数传递给该函数。
plt.savefig()
Matplotlib 3D 散点背景色
set_facecolor() 方法在 axes 模块中用来改变或设置绘图的背景颜色。
它用于设置图形的表面颜色，或者我们可以说是绘图的轴颜色。将参数作为要设置的颜色名称进行传递。
figure(face color = ' color ')方法用于改变绘图的外部背景颜色。
改变图形背景颜色的语法如下:
**# Inner color**
matplotlib.pyplot.axes.set_facecolor(color=None)
**# Outer color**
plt.figure(facecolor=None)
让我们借助一个例子来理解这个概念:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x = np.arange(0, 20, 0.2)
y = np.sin(x)
z = np.cos(x)
**# Create Figure**
fig = plt.figure(figsize = (8,8))
**# Set Outer color**
plt.figure(facecolor='red')
ax = plt.axes(projection ="3d")
**# Set Inner color**
ax.set_facecolor('yellow')
**# Create Plot**
ax.scatter3D(x, y, z, marker= '>', s=50)
**# Show Plot**
plt.show()
- 在上面的例子中，我们改变了绘图背景的内部和外部的颜色。
- 在
figure()方法中使用了"facecolor"属性来改变外部区域的颜色。 axes()对象的“set_facecolor()”方法改变绘图的内部区域颜色。
” 3D Scatter Background Color “
这里我们将内层颜色设置为【黄色】，将外层颜色设置为【红色】。
matplot lib 3d scatter num array
在这里，我们将学习如何使用 numpy 数组创建一个 3D 散点图。
为了定义 3D 散点图的三维数据轴，我们使用 numpy 方法。
我们来看一个例子:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Create Figure**
fig = plt.figure(figsize = (8,8))
ax = plt.axes(projection ="3d")
**# Define Data using numpy**
data = np.random.randint(2, 10, size=(3, 3, 3))
x , y , z = data.nonzero()
**# Create Plot**
ax.scatter3D(x, y, z, s=50)
**# Show plot**
plt.show()
- 在上面的例子中，我们使用 numpy 和额外的三维数据点创建了一个 3D 数组。
- 首先，我们导入
mplot3d、numpy和pyplot库，然后我们使用figure()方法创建一个新的图形。 - 通过使用 numpy
random.randint()方法，我们创建数据。 - 然后通过使用非零()方法，我们额外的 x、y 和 z 数据点来绘制 3D 散点图。
- 接下来，我们使用
ax.scatter3D()方法在创建的轴上绘制 3D 散点。 - 为了显示该图，我们使用了
show()方法。
” 3D Scatter Plot Using Numpy Array “
Matplotlib 3D 散点标记颜色
在这里，我们将学习如何改变三维散点图中的标记颜色。
在 3D 散点图中，数据点用点表示，这些点被称为标记。
因此，要改变标记的颜色，我们只需将 color 作为参数传递给 scatter3D() 方法，要改变标记的边缘颜色，我们在 scatter3D() 方法中使用 edgecolor 作为参数。
改变标记颜色和边缘颜色的语法:
matplotlib.axis.Axis.scatter3D(x, y, z, color=None, edgecolr=None)
上面使用的参数是:
- x: 指定 x 轴坐标。
- y: 指定 y 轴坐标。
- z: 指定 z 轴坐标。
- 颜色:指定标记的颜色。
- 边缘颜色:指定标记的边缘颜色。
举例:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Create Figure**
fig = plt.figure(figsize = (8,8))
ax = plt.axes(projection ="3d")
**# Define Data using numpy**
data = np.random.random(size=(5, 4, 3))
x , y , z = data.nonzero()
**# Create Plot and set color and edge color**
ax.scatter3D(x, y, z, s=150, color='yellow', edgecolor='black')
**# Show plot**
plt.show()
- 在上面的例子中，我们使用
scatter3D()方法并传递一个颜色参数来设置标记颜色。这里我们将标记的颜色设置为【黄色】。 - 我们还将
edgecolor参数传递给scatter3D()方法，以改变标记边缘的颜色。这里我们设置标记的边缘颜色为“黑色”。
” 3D Scatter Plot Color and Edgecolor “
Matplotlib 3D scatter zlim
set_zlim() 方法用于设置 z 轴的极限。
zlim()方法的语法如下:
matplotlib.axis.Axis.set_zlim(min, max)
让我们看看 zlim()方法的例子:
例 1
**# Import Library**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Plotting 3D axis figures**
fig = plt.figure(figsize = (8, 6))
ax = plt.axes(projection = '3d')
**# Define Data**
z = np.linspace(0,15,150)
x = np.sin(z)
y = np.cos(z)
**# Plot 3D scatter**
ax.scatter3D(x, y, z)
**# zlim() method**
ax.set_zlim(-1.5, 4)
**# Display**
plt.show()
这里我们使用 set_zlim() 方法来设置 z 轴的极限。我们将最小极限设置为 -1.5 ，将最大极限设置为 4 。
set_zlim()
例 2
**# Importing Libraries**
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits import mplot3d
**# Create figure**
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(1, 2, 1, projection='3d')
**# Define Data**
x= [0.2, 0.4, 0.6, 0.8, 1]
y= [0.3, 0.6, 0.8, 0.9, 1.5]
z= [2, 6, 7, 9, 10]
**# Plot graph**
ax.scatter3D(x, y, z, color='m', depthshade=False)
**# zlim() method**
ax.set_zlim(3, 6)
**# Display**
plt.show()
在上面的例子中，我们使用 set_zlim() 方法来设置 z 轴的最小值和最大值极限。这里我们设置一个从 3 到 6 的范围。
set_zlim()
matplot lib 3d scatter zlabel
set_zlabel() 方法用于给绘图的 z 轴添加标签。
zlabel()方法的语法:
matplotlib.axis.Axis.set_zlabel()
让我们看看 zlabel()方法的例子:
举例:
**# Import Library**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Plotting 3D axis figures**
fig = plt.figure(figsize = (4,6))
ax = plt.axes(projection = '3d')
**# Define Data**
x = np.random.randint(150, size=(50))
y = np.random.randint(260, size=(50))
z = np.random.randint(450, size=(50))
**# Plot**
ax.scatter3D(x, y, z, 'green')
**# zlabel()**
ax.set_zlabel('Quality')
**# Display**
plt.show()
在上面的例子中，我们使用 set_zlabel() 方法给 z 轴添加一个标签。
ax.set_zlabel()
Matplotlib 3d scatter xlim
set_xlim() 方法用于设置 x 轴的极限。
xlim()方法的语法如下:
matplotlib.axis.Axis.set_xlim(min, max)
让我们看看 xlim()方法的例子:
**# Import Library**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Plotting 3D axis figures**
fig = plt.figure(figsize = (4,6))
ax = plt.axes(projection = '3d')
**# Define Data**
x = np.random.randint(150, size=(50))
y = np.random.randint(260, size=(50))
z = np.random.randint(450, size=(50))
**# Plot**
ax.scatter3D(x, y, z, s=60)
**# xlim()**
ax.set_xlim(35,62)
**# Display**
plt.show()
这里我们使用 set_xlim() 方法来设置限制。我们将其范围设定在 35 到 62 之间。
set_xlim()
Matplotlib 3D scatter zoom
在 matplotlib 中 zoom() 方法用于在轴上放大或缩小。
zoom()方法的语法如下:
matplotlib.axis.Axis.zoom(self, direction)
这里方向> 0 用于放大，方向< =0 用于缩小。
我们来看一个例子:
代码:
**# Importing Libraries**
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits import mplot3d
**# Create 1st subplot**
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(1, 2, 1, projection='3d')
**# Define Data**
x1= [0.2, 0.4, 0.6, 0.8, 1]
y1= [0.3, 0.6, 0.8, 0.9, 1.5]
z1= [2, 6, 7, 9, 10]
**# Plot graph**
ax.scatter3D(x1, y1, z1, color='m', depthshade=False)
**# For zoom**
ax.xaxis.zoom(-2.5)
**# Display**
plt.show()
- 在上面的例子中，我们导入了
numpy、pyplot和mplot3d库。 - 然后我们用 numpy 的
figure()方法创建一个图形，用random.randint()方法定义数据。 ax.scatter3D()方法用于绘制 3D 散点图。- 然后我们使用
zoom()方法来放大和缩小轴。
输出:
您会得到这样的警告，因为 matplotlib 3.3 不赞成使用 zoom() 方法
Matplotlib 3D 散点原点
在 matplotlib 中，我们可以得到 3D 的原点到散点原点。为了获得原点，我们使用 NumPy 库的 zeros() 方法。
我们来看一个例子:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
**# Create Figure**
fig = plt.figure(figsize = (8,8))
ax = plt.axes(projection ="3d")
**# Define Data**
x , y , z = np.zeros((3,3))
**# Create Plot and set color and edge color**
ax.scatter3D(x, y, z, s=150, color='yellow', edgecolor='black')
**# Show plot**
plt.show()
- 在上面的例子中，我们导入 matplotlib 的库
mplot3d、numpy和pyplot。 - 然后我们通过使用
figure()方法创建一个图形。 - 在这之后，为了得到 3D 散点图的原点，我们使用了
np.zeros()方法。 ax.scatter3D()方法用于在 3D 平面上绘制散点图。
“3D Scatter Origin”
Matplotlib 3D 散点图对数标度
在这里，我们将学习如何将轴刻度值设置为对数刻度。
让我们来看一个对数标度的 3D 散点图示例:
**# Import libraries**
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as mticker
**# Define Function**
def function_z(x,y):
return 100 - (x`2 + y`2)
**# Define Data**
x_val = np.linspace(-3, 3, 30)
y_val = np.linspace(-3, 3, 30)
X, Y = np.meshgrid(x_val, y_val)
**# Call function**
z = function_z(X, Y)
**# Create figure**
fig = plt.figure(figsize =(10,6))
ax = plt.axes(projection='3d')
**# Create surface plot**
ax.plot_surface(X, Y, z, color='yellow');
**# Log Scale**
def log_tick_formatter(val, pos=None):
return f"$10^{{{int(val)}}}$"
ax.zaxis.set_major_formatter(mticker.FuncFormatter(log_tick_formatter))
ax.zaxis.set_major_locator(mticker.MaxNLocator(integer=True))
**# Set Title**
ax.set(title="Logarithmic z-aix")
**# Display**
plt.show()
- 在上面的例子中，我们导入了 matplotlib 的
mplot3d、numpy、pyplot和ticker库。 - 然后我们创建用户自定义函数来定义
z坐标。 - 之后，我们定义
x和y坐标，并使用figure()方法创建图形。 ax.plot_surface()方法用于在 3D 中创建表面图。- 然后我们创建用户自定义函数来创建一个主定位器，并在日志表单中定义刻度。
“3D Scatter Log Scale”
这里我们以对数的形式设置 z 轴。
matplot lib 3d scatter data frame
在这里，我们将学习如何使用 pandas 数据框创建 3D 散点图。
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from mpl_toolkits import mplot3d
**# Create figure**
fig = plt.figure(figsize = (4,6))
ax = plt.axes(projection = '3d')
**# Define dataframe**
df=pd.DataFrame(np.random.rand(30,20))
x = df.iloc[:,0]
y = df.iloc[:,5]
z = df.iloc[:,10]
**# Plot 3d Scatter Graph**
ax.scatter3D(x,y,z)
**# Display**
plt.show()
- 在上面的例子中，我们在 matplotlib 中导入了
pyplot、numpy、pandas和mplot3d库。 - 之后，我们使用
figure()方法创建图形，并在 3D 中定义投影。 - 然后我们创建熊猫数据帧并且我们使用
np.random.rand()方法。 - 我们使用熊猫 dataframe 的
iloc()方法定义x、y、z数据坐标。 ax.scatter3D()方法用于创建 3D 散点图。
“3D Scatter DataFrame”
阅读: Matplotlib 二维表面图
Matplotlib 3D 散点动画
在这里，我们将学习如何用动画创建 3D 散点图。
让我们来看一个动画 3D 散点图的例子:
**# Interactive Mode**
%matplotlib notebook
**# Import Library**
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.animation import FuncAnimation, PillowWriter
**# Define Data**
data = np.random.random(size=(1000,3))
df = pd.DataFrame(data, columns=["x","y","z"])
**# Create Figure**
fig = plt.figure()
ax = fig.add_subplot(111,projection='3d')
**# Plot Graph**
scatter_plot = ax.scatter3D([],[],[], color='m')
**# Define Update function**
def update(i):
scatter_plot._offsets3d = (df.x.values[:i], df.y.values[:i], df.z.values[:i])
**# Set annimation**
ani = matplotlib.animation.FuncAnimation(fig, update, frames=len(df), interval=50)
**# Show**
plt.tight_layout()
plt.show()
**# Save**
ani.save('3D Scatter Animation.gif', writer='pillow', fps=30)
- 在上面的例子中，我们首先启用交互模式。
- 然后我们导入 matplotlib 的熊猫、
numpy、pyplot、mplot3d和动画库。 - 接下来，我们使用 numpy 的
random.random()方法定义数据。 - 之后，我们在 pandas 中创建数据帧，并定义
x、y和z坐标。 plt.figure()方法用于创建一个图，add_subplot()方法创建 subplot，我们将投影设置为3D。ax.scatter3D()方法用于绘制 3D 散点图。- 在这之后，我们创建一个更新函数。
- 通过使用动画。FuncAnimation() 方法我们在 3D 散点图中添加动画。
- 然后，最后我们使用
save()方法将一个情节保存为gif。
” 3D Scatter Animation “
在本 Python 教程中，我们已经讨论了“Matplotlib 3D 散点图”，并且我们还介绍了一些与之相关的例子。这些是我们在本教程中讨论过的以下主题。
- Matplotlib 3D scatter plot
- Matplotlib 3D 散点图示例
- Matplotlib 3D 散布颜色
- 带颜色条的 Matplotlib 3D 散点图
- Matplotlib 3D 散点图标记大小
- Matplotlib 3D 散点图标签
- Matplotlib 3D 散点图图例
- Matplotlib 3D 散点图按值显示颜色
- Matplotlib 3D 散布旋转
- Matplotlib 3D 散点图更改视角
- Matplotlib 3D 散点图标题
- Matplotlib 3D 散布文本
- 带线条的 Matplotlib 3D 散点图
- 带表面的 Matplotlib 3D 散点图
- Matplotlib 三维抖动透明度
- matplot lib 3d sactor depthshade
- Matplotlib 3D 散点图轴限制
- Matplotlib 三维散点图坐标轴刻度
- Matplotlib 3D 散点图大小
- Matplotlib 3D 散点图网格
- Matplotlib 3D 散点子图
- Matplotlib 3D 散点保存
- Matplotlib 3D 散布背景颜色
- Matplotlib 3D 散点图数组
- Matplotlib 3D 散点图标记颜色
- matplot lib 3d scatter zlem
- Matplotlib 3D scatter z label
- Matplotlib 3D scatter xlim
- Matplotlib 3D scatter zoom
- Matplotlib 3D 散布原点
- Matplotlib 3D 散点图对数标度
- Matplotlib 3D scatter dataframe
- Matplotlib 3D 散布动画
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib 条形图标签
在本 Python 教程中，我们将讨论 Python 中的 Matplotlib 条形图标签。在这里，我们将介绍使用 matplotlib 与条形图标签相关的不同示例。我们还将讨论以下主题:
- Matplotlib 条形图标签
- Matplotlib 条形图 x 轴标签
- Matplotlib 条形图 y 轴标签
- Matplotlib 条形图刻度标签
- Matplotlib 条形图标签值
- 带字符串标签的 Matplotlib 条形图
- Matplotlib 条形图标签垂直
- Matplotlib 水平条形图标签
- Matplotlib 条形图 x 轴标签水平
- Matplotlib 条形图标签旋转
- Matplotlib 条形图标签字体大小
- Matplotlib 条形图文本标签
- 带标签的 Matplotlib 分组条形图
- Matplotlib 条形图标签重叠
- Matplotlib 条形图对角线刻度标签
- 带标签的 Matplotlib 堆积条形图
如果您是 Matplotlib 的新手，请查看什么是 Matplotlib 以及如何在 Python 中使用它以及如何安装 matplotlib python
目录
- Matplotlib 条形图标签
- Matplotlib 条形图 x 轴标签
- Matplotlib 条形图 y 轴标签
- Matplotlib 条形图刻度标签
- Matplotlib 条形图标签值
- 带字符串标签的 Matplotlib 条形图
- Matplotlib 条形图标签垂直
- Matplotlib 水平条形图标签
- Matplotlib 条形图 x 轴标签水平
- Matplotlib 条形图标签旋转
- Matplotlib 条形图标签字体大小
- Matplotlib 条形图文本标签
- 带标签的 Matplotlib 分组条形图
- Matplotlib 条形图标签重叠
- Matplotlib 条形图对角线刻度标签
- 带标签的 Matplotlib 堆积条形图
Matplotlib 条形图标签
在本节中，我们将了解 matplotlib 条形图标签。在开始这个话题之前，我们首先要了解一下【标签】是什么意思。
标签是条形图中条形的短语或名称。
以下步骤用于向条形图添加标签，概述如下:
- 定义库:导入在绘图中添加文本所需的重要库(用于数据创建和操作:Numpy，用于数据可视化:来自 matplotlib 的 pyplot)。
- 定义 X 和 Y: 定义用于 X 轴和 Y 轴的数据值。
- 绘制条形图:采用条()的方法绘制条形图。
- 添加标签:通过使用
text()、xlabels()、ylabels()等函数，我们可以很容易地给条形图添加标签。 - 显示:为了显示图形，我们使用了
show()函数。
Matplotlib 条形图 x 轴标签
Matplotlib 为我们提供了在绘图的 x 轴上添加标签的功能。在这里，首先你知道如何绘制条形图，标签定义了 x 轴代表什么。
通过使用 xlabels() 方法，您可以轻松地在轴上添加标签。
绘制条形图和定义 x 轴标签的语法如下:
**# Plot bar chart**
matplotlib.pyplot.bar(x, height)
**# Define x-axis labels**
matplotlib.pyplot.xlabels()
上面定义的参数概述如下:
- x: 指定横条的 x 坐标。
- height: 指定条形的 y 坐标。
让我们看一个条形图上 x 轴标签的例子:
**# Import Library** import matplotlib.pyplot as plt
**# Define Data**
student = [3,2,0,5,9,1]
weight = [30,35,40,45,50,55]
**# Plot Graph**
plt.bar(weight,student)
**# Define x-axis label**
plt.xlabel("Weight of the students")
**# Display Graph**
plt.show()
- 在上面的例子中，我们导入
matplotlib.pyplot库，然后定义 x 坐标和 y 坐标。 plt.bar()方法用于绘制条形图，plt.xlabels()方法定义 x 轴代表什么。- 最后，我们使用
plt.show()来可视化条形图。
plt.xlabels() “Labels on x-axis”
读取: Matplotlib 绘图误差线
Matplotlib 条形图 y 轴标签
在本节中，我们将学习在绘图的 y 轴上添加标签。
通过使用 ylabels() 方法，我们可以很容易地在轴上添加标签。
定义 y 轴标签的语法如下:
**# Y-axis label**
matplotlib.pyplot.ylabels()
我们来看一个在 y 轴上添加标签的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
student = [3,2,0,5,9,1]
weight = [30,35,40,45,50,55]
**# Plot Graph**
plt.bar(weight,student)
**# Define y-axis label**
plt.ylabel("No.of students")
**# Display Graph**
plt.show()
这里我们使用 bar() 方法绘制条形图，使用 ylabel() 方法定义 y 轴标签。
plt.ylabels() “Labels on Y-axis”
Matplotlib 条形图刻度标签
首先，我们必须了解刻度标签是什么意思。基本上，记号是标记，标签是它们的名称。
或者我们可以说记号是代表轴上数据点的标记。
添加刻度标签的语法如下:
# x-axis tick labels
matplotlib.axes.Axes.set_xticklabels(self,xlabel,fontdict=None,labelpad=None)
上述使用的参数如下:
- xlabel: 指定标签文本。
- fontdict: 指定字体样式的字典。
- labelpad: 以磅为单位指定间距。
让我们看一个设置刻度标签的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = [1, 2, 3, 4]
ax1 = plt.subplot()
ax1.set_xticks(x)
ax1.set_yticks(x)
**# plot bar chart**
plt.bar(x,[2,3,4,12])
**# Define tick labels**
ax1.set_xticklabels(["A","B","C","D"])
ax1.set_yticklabels([1, 2, 3, 4])
**# Display graph**
plt.show()
- 在上面的例子中，我们列出了定义轴中使用的刻度的
x。 - 在此之后，我们使用
subplot()方法来获取图形的轴。 - 然后我们使用
set_xticks()和set_yticks()方法来设置 X 轴和 Y 轴上的刻度。 set_xticklabels()和set_yticklabels()方法用于设置你选择的刻度标签。- 为了展示这个图，我们使用
plt.show()方法。
ax.set_xticklabels() and ax.set_yticklabels()
Matplotlib 条形图标签值
通过使用条形图，我们可以很容易地通过观察不同高度的条形来比较数据。默认情况下，条形图不会在每个条形上显示数值标签。
为了方便检查棒线的准确值，我们必须在棒线上添加值标签。通过使用 plt.text() 方法，我们可以很容易地添加数值标签。
Matplotlib 提供了根据您的选择定制值标签的功能。
在条形图上添加数值标签的语法:
**# To add value labels**
matplotlib.pyplot.text(x, y, s, ha, vs, bbox)
上面使用的参数定义如下:
- x:x——文本的坐标。
- y:y-文本的坐标。
- s: 指定要显示的值标签。
- ha: 数值标签水平对齐。
- va: 数值标签垂直对齐。
- bbox: 指定标签值周围的矩形框。
为了更清楚地理解这个概念，我们来看一个例子:
**# Import library**
import matplotlib.pyplot as plt
**# Function to add value labels**
def valuelabel(weight,students):
for i in range(len(weight)):
plt.text(i,students[i],students[i], ha = 'center',
bbox = dict(facecolor = 'cyan', alpha =0.8))
**# Main function**
if __name__ == '__main__':
**# Define data**
weight = ["35 Kg", "40 Kg", "43 Kg", "48 Kg", "65 Kg", "72 Kg"]
students = [15, 12, 3, 5, 1, 2]
**# Plot bar chart**
plt.bar(weight, students, color= 'orange')
**# Call function**
valuelabel(weight, students)
**# Define labels**
plt.xlabel("Weight of the students")
plt.ylabel("Number of students")
**# Display plot**
plt.show()
- 在这里，我们创建了一个函数
valuelabel()，用于将每个条形上的值相加。我们使用 for 循环来计算学生体重的长度，所以我们通过len()方法。 - 为了定制标签，我们将水平对齐参数设置为居中，并使用
bbox参数来定义具有样式的 box 的字典。 plt.text()方法用于添加数值标签，我们分别传递代表高度的i和代表要打印的字符串的学生[i] 。- 在主函数中，我们定义了数据点，之后我们用
plt.bar()方法来绘制条形图。 - 最后，我们在轴上定义标签，并使用
plt.show()函数来可视化绘图或图表。
plt.text() “Add label value”
带字符串标签的 Matplotlib 条形图
在这里，我们绘制了一个带有字符串数据类型标记的条形图。我们绘制了喜欢不同活动的学生人数之间的关系。
让我们看一个带有字符串标签的条形图的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
students = [5, 6, 2, 3]
activities= ["Joging", "Gyming", "Swimming", "Shopping"]
**# Plot bar chart**
plt.bar( activities, students, color= 'r')
**# Display chart**
plt.show()
- 在上面的例子中，我们简单地通过在引号中定义字符串数据类型的数据。
- 在这里，我们使用双引号定义了不同的活动，因此它们可以用字符串格式表示。
- 在这之后，我们使用
plt.bar()方法绘制一个条形图，我们传递颜色参数并将其设置为红色以改变条形的颜色。
“String labels”
阅读: Matplotlib 散点图标记
Matplotlib 条形图标签垂直
通过使用 plt.bar() 方法我们可以绘制条形图，通过使用 xticks()、yticks() 方法我们可以很容易地分别对齐 x 轴和 y 轴上的标签。
这里我们将旋转键设置为“垂直”，这样我们就可以在垂直方向上对齐条形图标签。
让我们看一个垂直对齐标签的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data** students = [5, 6, 2, 3]
subjects= ["English","Computers","Maths","Science"]
**# Plot bar chart**
plt.bar(subjects, students, color= 'm')
**# Vertical aligned**
plt.xticks(rotation='vertical')
**#OR**
plt.yticks(rotation='vertical')
**# Display chart**
plt.show()
- 在上面的例子中，我们导入了
matplotlib.pyplot库，然后定义数据。 plt.bar()方法用来绘制学生人数和他们喜欢的科目之间的条形图。plt.xticks()方法用于垂直对齐 xticks。plt.yticks()方法用于垂直对齐 yticks。
plt.xticks(rotation=’vertical’)
plt.yticks(rotation=’vertical’)
阅读: Matplotlib 虚线
Matplotlib 水平条形图标签
在本节中，我们将学习如何创建水平条形图，尤其是带有数据标签的条形图。
为了绘制一个水平条形图，我们使用 barh() 方法，我们得到每个条形的宽度，以便在条形图的条形上写入数据标签。
绘制水平条形图的语法:
matplotlib.pyplot.barh(x, height)
- x: 指定 x 坐标。
- 高度:指定 y 坐标。
让我们看一个带有数据标签的水平条形图的例子:
**# Import Library** import matplotlib.pyplot as plt
**# Define Data**
grades = ["A","B","C","D","E","Fail"]
students = [15, 12, 3, 5, 1, 2]
**# Plot horizontal bar chart**
bars = plt.barh(grades,students)
**# To get data labels**
for bar in bars:
width = bar.get_width()
label_y = bar.get_y() + bar.get_height() / 2
plt.text(width, label_y, s=f'{width}')
**# Define axes labels**
plt.xlabel("No. of students")
plt.ylabel("Grades of students")
**# Display a bar chart**
plt.show()
- 在上面的例子中，首先我们导入
matplotlib.pyplot库，然后我们定义数据。 - 我们使用
plt.barh()的方法绘制水平条形图。 - 现在，我们需要每个条形的宽度，为此我们通过使用
bar.get_y()方法获得 y 轴标签的位置。 plt.text()方法用于在每个条形上添加数据标签，我们使用宽度作为 x 位置和要显示的字符串。- 最后，我们使用
show()方法对条形图进行可视化。
plt.barh()
Matplotlib 条形图 x 轴标签水平
通过使用 xticks() 方法，我们可以很容易地在 x 轴上对齐标签。这里我们必须将旋转键设置为“水平”，这样我们就可以在水平方向上对齐 x 轴上的条形图标签。
让我们看一个水平对齐标签的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
students = [5, 6, 2, 3]
subjects= ["English","Computers","Maths","Science"]
**# Plot bar chart**
plt.bar(subjects, students, color= 'm')
**# Horizontal aligned**
plt.xticks(rotation='horizontal')
**# Display chart**
plt.show()
- 在上面的例子中，我们导入了
matplotlib.pyplot库，然后定义数据。 plt.bar()方法用来绘制学生人数和他们喜欢的科目之间的条形图。plt.xticks()方法用于对齐 xticks，我们传递旋转参数并将其值设置为水平。
plt.xticks(rotation=’horizontal’)
注意:当我们将旋转设置为水平时，x 轴标签没有变化，因为默认情况下 x 轴标签设置为水平。
Matplotlib 条形图标签旋转
Matplotlib 提供了一个功能，可以根据您的选择旋转条形图的坐标轴标签。我们可以将标签设置到我们喜欢的任何角度。
我们有不同的方法来旋转条形图标签:
- 通过使用 plt.xticks()
- 通过使用 ax.set_xticklabels()
- 通过使用 ax.get_xticklabels()
- 通过使用 ax.tick_params()
Matplotlib 条形图标签旋转由 plt.xticks()
这里我们使用 plt.xticks() 方法旋转 x 轴标签，并将旋转参数传递给它。我们将旋转值设置为 30 度。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
students = [5, 6, 2, 3]
activities= ["Joging", "Gyming", "Swimming", "Shopping"]
**# Plot bar chart**
plt.bar( activities, students, color= 'cyan')
**# Rotation of x-axis label**
plt.xticks(rotation=30)
**# display chart**
plt.show()
Rotation of x-axis labels to 30 degrees
Matplotlib 条形图标签旋转 by ax.set_xticklabels()
这里我们使用 ax.set_xticklabels() 方法来旋转 x 轴标签，并传递想要旋转的旋转参数和标签。我们将旋转值设置为 15 度。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
students = [5, 6, 2, 3]
activities= ["Joging", "Gyming", "Swimming", "Shopping"]
**# Plot bar chart**
ax = plt.subplot()
plt.bar( activities, students, color= 'cyan')
**# Rotate labels**
ax.set_xticklabels(activities, rotation=15)
**# display chart**
plt.show()
“Rotation of x-axis labels to 15 degrees”
Matplotlib 条形图标签旋转 by ax.get_xticklabels()
这里我们使用 ax.get_xticklabels() 方法来旋转 x 轴标签。
然后我们将标签的旋转设置为 180 度。
这种方法的好处是我们得到了一个标签列表，我们遍历每个标签来设置它的旋转。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
students = [5, 6, 2, 3]
activities= ["Joging", "Gyming", "Swimming", "Shopping"]
**# Plot bar chart**
ax = plt.subplot()
plt.bar( activities, students, color= 'cyan')
**# Rotate labels**
for label in ax.get_xticklabels():
label.set_rotation(180)
**# display chart**
plt.show()
“Rotation of bar chart label at 180 degrees”
Matplotlib 条形图标签旋转 by ax.tick_params()
这里我们使用 ax.tick_params() 方法来旋转标签。
然后我们传递轴和标签旋转参数，并将它们的值分别设置为 x 和 65 度。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
students = [5, 6, 2, 3]
activities= ["Joging", "Gyming", "Swimming", "Shopping"]
**# Plot bar chart**
ax = plt.subplot()
plt.bar( activities, students, color= 'cyan')
**# Rotate labels**
ax.tick_params(axis='x', labelrotation=65)
**# Display chart**
plt.show()
“Labelroation at 65 degrees”
读取: Matplotlib 日志日志图
Matplotlib 条形图标签字体大小
我们可以改变被称为刻度标签的数据轴标签和告诉我们轴代表什么的 T2 轴标签的大小。
您只需传递参数 fontsize 并设置它们的值。
让我们看一个改变标签字体大小的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
students = [5, 6, 2, 3]
subjects= ["English","Computers","Maths","Science"]
**# Plot bar chart**
plt.bar(subjects, students)
**# Fontsize of tick labels**
plt.xticks(fontsize=15,color='r')
**# Font size of axes labels**
plt.xlabel("Favourite subject", fontsize=15)
plt.ylabel("No.of.students", fontsize= 20)
**# Display chart**
plt.show()
- 在上面的例子中，通过使用
plt.bar()方法，我们绘制了一个条形图。 plt.xticks()方法用于绘制条形图的刻度标签，我们给它传递一个参数fontsize和color，并分别将其值设置为15和red。plt.xlabel()方法绘制 x 轴标签，我们将字体大小设置为15。plt.ylabel()方法在 y 轴上绘制标签，我们传递fontsize参数并将其值设置为20。
“Font size change”
Matplotlib 条形图文本标签
在这里，我们学习如何在条形图的特定条中添加文本标签。首先，您必须使用 plt.bar() 方法定义数据并绘制条形图。
这之后使用 plt.text() 方法在栏上添加文本标签。这里我们定义了位置，或者我们可以说文本标签的坐标为' 1 '，' y[1]'【T3]，这意味着我们要在条形图的 2 条上添加文本。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = ["A","B","C","D"]
y = [2, 6, 15, 10]
**# Plot bar chart**
plt.bar(x,y,color='pink')
**# Add Text Label**
plt.text(1,y[1],"Text Label",ha='center',fontsize=12)
**# Plot bar chart**
plt.show()
“Text label at a specific position of the bar in bar chart”
带标签的 Matplotlib 分组条形图
条形图用于比较一维或二维数据。当我们必须比较二维数据时，我们需要一个分组条形图。
这里我们看到一个带有标签的分组条形图示例:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data**
labels = ['A', 'B', 'C', 'D', 'E', 'Fail']
Term1 = [30, 14, 20, 5, 7, 15]
Term2 = [45, 12, 24, 2, 6, 5]
x = np.arange(len(labels))
**# Plot bar chart**
width = 0.4
fig, ax = plt.subplots()
rect1 = ax.bar(x - width/2, Term1, label='Term1')
rect2 = ax.bar(x + width/2, Term2, label='Term2')
**# text in grouped bar chart**
for bar in ax.patches:
value = bar.get_height()
text = f'{value}'
text_x = bar.get_x() + bar.get_width() / 2
text_y = bar.get_y() + value
ax.text(text_x, text_y, text, ha='center',color='r',size=12)
**# Add some text for labels,x-axis tick labels**
ax.set_ylabel('No.of students')
ax.set_xlabel('Grades')
ax.set_xticks(x)
ax.set_xticklabels(labels)
ax.legend()
**# Display plot**
plt.show()
- 首先导入重要的库，如
matplotlib.pyplot和numpy。之后，我们定义数据坐标和标签，并通过使用arrange()方法找到标签位置。 - 设置条形的宽度这里我们将其设置为 0.4。通过使用
ax.bar()方法我们绘制了分组条形图。 - 然后我们使用 for 循环在条形图的每个条中添加一个文本标签。
get_height()方法用于获取条形的高度并格式化我们使用的文本 f'{value} '。- 为了得到 x 轴上每个条形的中点，我们使用了
get_x()和get_width()方法。之后我们给get_y()方法加上高度，因为从get_y()开始。 - 最后，我们使用
ax.text()方法在分组条形图的每个条上添加文本，并将它的颜色设置为红色，并将它的大小更改为 12。 plt.show()方法用于可视化接地条形图。
“Grouped Bar Chart”
阅读: Matplotlib 最佳拟合线
Matplotlib 条形图标签重叠
在本节中，我们将讨论条形图标签开始相互重叠的情况。因此，我们必须对它们进行格式化，以便条形图看起来清晰。
让我们看看下面的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = ['I am the Label 1', "I am the Label 2", "I am the Label 3", "I am the Label 4"]
y = [2, 4, 5, 6]
**# Plot Bar chart**
ax= plt.subplot()
plt.bar(x, y)
**# Display Chart**
plt.show()
“Overlapping Case In Bar Chart”
在上面的输出中，您已经看到条形图的 x 轴标签相互重叠，看起来非常不整洁。
现在，看看克服这个问题的解决方案:
在 matplotlib 中，我们有一个函数 setp()，用于设置刻度标签旋转和对齐属性。
setp()方法的语法如下:
matplotlib.pyplot.setp(object, **kwargs)
上面使用的参数如下:
- 对象:指定艺术家对象。
- kwargs: 指定额外的属性来改变样式、旋转等。
让我们借助一个例子来理解这个概念:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = ['I am the Label 1', "I am the Label 2", "I am the Label 3", "I am the Label 4"]
y = [2, 4, 5, 6]
**# Plot Bar chart**
ax= plt.subplot()
plt.bar(x, y)
**# Function to avoid overlapping** plt.setp(ax.get_xticklabels(), rotation=30, ha='right')
**# Display Chart**
plt.show()
在上面的例子中，我们使用 plt.setp() 方法和 get.xticklabels() 方法来获取 ticklabels，我们通过旋转参数将其值设置为 30 度。
“Bar Chart Labels without Overlapping”
结论！ plt.setp() 方法去除了重叠问题，我们得到了一个清晰的柱状图视图。
Matplotlib 条形图对角线刻度标签
要在对角线方向设置条形图刻度标签，我们必须将刻度旋转设置为 45 度，将水平对齐设置为向右。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = ['Label 1', "Label 2", "Label 3", "Label 4"]
y = [2, 4, 5, 6]
**# Plot Bar chart**
plt.bar(x, y)
**# Diagonal tick labels** plt.xticks(rotation=45, ha="right")
**# Display Chart**
plt.show()
“Diagonal Tick Labels”
阅读: Matplotlib 绘图条形图
带标签的 Matplotlib 堆积条形图
堆积条形图显示数据类别之间的比较。每个条形段代表不同的部分或类别。
这里我们创建一个熊猫数据框来创建一个堆叠条形图。
让我们看一个带标签的堆积条形图的例子:
**# Import libraries**
import matplotlib.pyplot as plt
import pandas as pd
**# Define Data**
df = pd.DataFrame({
'Maths': [12, 15, 10, 3, 1, 5],
'Science': [15, 10, 5, 4, 3, 6],
'Computers':[20, 12, 5, 3, 5, 2]
})
labels = ['A','B','C','D','E','Fail']
**# Plot stacked bar chart**
ax = df.plot(stacked=True, kind='bar')
for bar in ax.patches:
height = bar.get_height()
width = bar.get_width()
x = bar.get_x()
y = bar.get_y()
label_text = height
label_x = x + width / 2
label_y = y + height / 2
ax.text(label_x, label_y, label_text, ha='center', va='center')
**# Set Tick labels**
ax.set_xticklabels(labels,rotation='horizontal')
**# Display chart**
plt.show()
- 在上面的例子中，我们导入了
matplotlib.pyplot和pandas库。 - 之后，我们创建数据帧并定义标签。
- 然后通过使用
plot()方法绘制堆积条形图。 - 我们将循环的定义为小块，而小块包含图表中的所有内容。
- 通过使用
get_height()和get_width()方法得到高度和宽度。 - 最后，我们使用
text()方法来定义每个堆叠棒线的高度。
“Stacked Bar Chart With Labels”
另外，检查: Matplotlib 散点图颜色
在本 Python 教程中，我们已经讨论了“Matplotlib 条形图标签”，并且我们还介绍了一些与之相关的例子。这些是我们在本教程中讨论过的以下主题。
- Matplotlib 条形图标签
- Matplotlib 条形图 x 轴标签
- Matplotlib 条形图 y 轴标签
- Matplotlib 条形图刻度标签
- Matplotlib 条形图标签值
- 带字符串标签的 Matplotlib 条形图
- Matplotlib 条形图标签垂直
- Matplotlib 水平条形图标签
- Matplotlib 条形图 x 轴标签水平
- Matplotlib 条形图标签旋转
- Matplotlib 条形图标签字体大小
- Matplotlib 条形图文本标签
- 带标签的 Matplotlib 分组条形图
- Matplotlib 条形图标签重叠
- Matplotlib 条形图对角线刻度标签
- 带标签的 Matplotlib 堆积条形图
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib 最佳拟合线
在本 Python 教程中，我们将讨论如何在 Python 的 matplotlib 中绘制最佳拟合线，我们还将涉及以下主题:
- 最佳拟合线
- Matplotlib 最佳拟合线
- 使用 numpy.polyfit()的 Matplotlib 最佳拟合线
- Matplotlib 最佳拟合直线直方图
- Matplotlib 最佳拟合曲线
- Matplotlib 散点图的最佳拟合线
目录
- 最佳拟合线
- Matplotlib 最佳拟合线
- 使用 numpy.polyfit()的 Matplotlib 最佳拟合线
- Matplotlib 最佳拟合线直方图
- Matplotlib 最佳拟合曲线
- Matplotlib 散点图的最佳拟合线
最佳拟合线
二维图形中的最佳拟合线是指定义在图形上绘制为散点图的数据点的 x 轴和 y 轴坐标的最佳关系的线。
最佳拟合线或最佳关系可以通过最小化数据点与目标线的距离来实现。
线性方程在数学上代表一条线。这条线的法线方程如下:
(A * x) + (B * y) + C = 0
- 这里，
x和y是代表数据点的 x 轴和 y 轴值的变量。 A和B是变量x和y的系数，C是常数。这些统称为线的参数，决定了线的形状和在图上的位置。
但是，最常用的直线形式是截距-斜率形式，如下所示:
y = (m * x) + c
- 这里，
x和y是代表数据点的 x 轴和 y 轴值的变量。 m是变量x的系数，代表图上直线的斜率。斜率是线条的参数，它决定了图形上线条的角度。c是一个常数值，代表图形上直线的 y 轴截距。截距是线条的参数，它决定了线条在图上的位置。
我们可以将标准形式转换为斜率截距形式，如下所示:
(A * x) + (B * y) + C = 0
(B * y)=-C-(A * x)
y =(-(A * x)-C)/B
y = ((-A / B) * x) + (-C / B)
将这个方程与直线的斜率截距形式相比较。
我们得到， m = (-A / B) 和 c = (-C / B)
在这篇文章中，我们将使用直线的斜率截距形式。
寻找与给定数据点最佳拟合的直线参数的最常用方法是回归分析中的最小二乘方法。
简单回归分析是指定单个数字因变量(此处为 y)和数字自变量(此处为 x)之间关系的方法。
Matplotlib 最佳拟合线
我们可以在 matplotlib 中绘制一条最适合分散数据点的直线。首先，我们需要找到使其最佳拟合的线的参数。
我们将通过应用线性代数的矢量化概念来做到这一点。
首先，让我们了解我们将用来寻找最佳拟合线参数的算法。
直线的方程是: y = (m * x) + c
我们把这个改成y =θ0+(θ1 * x)；这里，θ0 和θ1 是分别代表线的 c(截距)和 m(斜率)的参数。
现在，让我们把这个方程变成矢量形式:
- 设，
N为给定数据点的数量。 - 设
y为N行的列向量，其中每行代表每个数据点的 y 坐标。 - 设，θ为
2行的列向量，行的每个参数(θ0和θ1)为向量的行值。 - 设，
X为2XN的矩阵，其中第一列由每行的值1组成，第二列由N个数据点的 X 坐标值组成。
现在，向量形式的方程会是这样的:y = Xθ
我们可以通过使用向量形式的最小二乘法方程来计算并获得给定数据点的最佳参数值(θ0 和θ1)，如下所示:
θ=(X^T。X) ^(-1) 。(X ^T 。y)；这里，X^T是矩阵 X 的转置**，而 (X ^T 。X) ^(-1) 是 (X ^T 所得矩阵的逆矩阵。X)**
现在，让我们使用 python 实现这个算法，并绘制出结果线。
# Importing the necessary libraries
from matplotlib import pyplot as plt
import numpy as np
# Preparing the data to be computed and plotted
dt = np.array([
[0.05, 0.11],
[0.13, 0.14],
[0.19, 0.17],
[0.24, 0.21],
[0.27, 0.24],
[0.29, 0.32],
[0.32, 0.30],
[0.36, 0.39],
[0.37, 0.42],
[0.40, 0.40],
[0.07, 0.09],
[0.02, 0.04],
[0.15, 0.19],
[0.39, 0.32],
[0.43, 0.48],
[0.44, 0.41],
[0.47, 0.49],
[0.50, 0.57],
[0.53, 0.59],
[0.57, 0.51],
[0.58, 0.60]
])
# Preparing X and y data from the given data
x = dt[:, 0].reshape(dt.shape[0], 1)
X = np.append(x, np.ones((dt.shape[0], 1)), axis=1)
y = dt[:, 1].reshape(dt.shape[0], 1)
# Calculating the parameters using the least square method
theta = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(y)
print(f'The parameters of the line: {theta}')
# Now, calculating the y-axis values against x-values according to
# the parameters theta0 and theta1
y_line = X.dot(theta)
# Plotting the data points and the best fit line
plt.scatter(x, y)
plt.plot(x, y_line, 'r')
plt.title('Best fit line using regression method')
plt.xlabel('x-axis')
plt.ylabel('y-axis')
plt.show()
Matplotlib best fit line
阅读: Matplotlib 绘图条形图
使用 numpy.polyfit()的 Matplotlib 最佳拟合线
我们可以使用 numpy.polyfit() 函数绘制给定数据点的最佳拟合线。
这个函数是一个预定义函数，它采用 3 个强制参数作为 x 坐标值(作为可迭代对象)、y 坐标值(作为可迭代对象)和方程的次数(1 表示线性，2 表示二次，3 表示三次，…)。
语法如下:
numpy.polyfit(x, y, degree)
现在，让我们来看看这个例子，并理解函数的实现。
# Importing the necessary libraries
from matplotlib import pyplot as plt
import numpy as np
# Preparing the data to be computed and plotted
dt = np.array([
[0.05, 0.11],
[0.13, 0.14],
[0.19, 0.17],
[0.24, 0.21],
[0.27, 0.24],
[0.29, 0.32],
[0.32, 0.30],
[0.36, 0.39],
[0.37, 0.42],
[0.40, 0.40],
[0.07, 0.09],
[0.02, 0.04],
[0.15, 0.19],
[0.39, 0.32],
[0.43, 0.48],
[0.44, 0.41],
[0.47, 0.49],
[0.50, 0.57],
[0.53, 0.59],
[0.57, 0.51],
[0.58, 0.60]
])
# Preparing X and y from the given data
X = dt[:, 0]
y = dt[:, 1]
# Calculating parameters (Here, intercept-theta1 and slope-theta0)
# of the line using the numpy.polyfit() function
theta = np.polyfit(X, y, 1)
print(f'The parameters of the line: {theta}')
# Now, calculating the y-axis values against x-values according to
# the parameters theta0, theta1 and theta2
y_line = theta[1] + theta[0] * X
# Plotting the data points and the best fit line
plt.scatter(X, y)
plt.plot(X, y_line, 'r')
plt.title('Best fit line using numpy.polyfit()')
plt.xlabel('x-axis')
plt.ylabel('y-axis')
plt.show()
Matplotlib best fit line using numpy.polyfit()
Matplotlib 最佳拟合线直方图
我们可以拟合直方图的分布，并用 python 绘制曲线/直线。
我们可以使用 python 中的库 scipy ，完成该任务的步骤如下所示:
- 首先，我们可以调用带有参数数据的函数
scipy.stats.norm.fit()来绘制直方图，得到类似均值和标准差的数据统计。 - 然后，我们将调用函数
scipy.stats.norm.pdf()，参数为 x (直方图的条柱)平均值，数据的标准差，以获得最佳拟合曲线的给定数据的 y 值。 - 然后，我们可以用直方图绘制曲线。
让我们按照上面的
# Importing the necessary libraries
from matplotlib import pyplot as plt
import numpy as np
import scipy.stats
dt = np.random.normal(0, 1, 1000)
# Plotting the sample data on histogram and getting the bins
_, bins, _ = plt.hist(dt, 25, density=1, alpha=0.5)
# Getting the mean and standard deviation of the sample data dt
mn, std = scipy.stats.norm.fit(dt)
# Getting the best fit curve y values against the x data, bins
y_curve = scipy.stats.norm.pdf(bins, mn, std)
# Plotting the best fit curve
plt.plot(bins, y_curve, 'k')
plt.title('Best fit curve for histogram')
plt.xlabel('x-axis')
plt.ylabel('y-axis')
plt.show()
Matplotlib best fit line histogram
阅读: Python 使用 Matplotlib 绘制多条线
Matplotlib 最佳拟合曲线
如果散点图上绘制的数据点显示了某种高次曲线趋势(二次曲线、三次曲线等)，我们可以在 python 中绘制一条最适合给定数据点的曲线。
我们可以使用 numpy.polyfit() 函数。该函数实际上会返回任何多项式趋势的最佳拟合曲线。正如我们在前面的主题中讨论的那样，为了更好地理解，我们来练习一个例子:
# Importing the necessary libraries
from matplotlib import pyplot as plt
import numpy as np
# Preparing the data to be computed and plotted
dt = np.array([
[0.5, 0.28],
[0.5, 0.29],
[0.5, 0.33],
[0.7, 0.21],
[0.7, 0.23],
[0.7, 0.26],
[0.8, 0.24],
[0.8, 0.25],
[0.8, 0.29],
[0.9, 0.28],
[0.9, 0.30],
[0.9, 0.31],
[1.0, 0.30],
[1.0, 0.33],
[1.0, 0.35]
])
# Preparing X and y from the given data
X = dt[:, 0]
y = dt[:, 1]
# Calculating parameters (theta0, theta1 and theta2)
# of the 2nd degree curve using the numpy.polyfit() function
theta = np.polyfit(X, y, 2)
print(f'The parameters of the curve: {theta}')
# Now, calculating the y-axis values against x-values according to
# the parameters theta0, theta1 and theta2
y_line = theta[2] + theta[1] * pow(X, 1) + theta[0] * pow(X, 2)
# Plotting the data points and the best fit 2nd degree curve
plt.scatter(X, y)
plt.plot(X, y_line, 'r')
plt.title('2nd degree best fit curve using numpy.polyfit()')
plt.xlabel('x-axis')
plt.ylabel('y-axis')
plt.show()
Matplotlib best fit curve
阅读: Matplotlib 绘制一条线
Matplotlib 散点图的最佳拟合线
我们已经讨论了两种不同的方法，以获得最佳拟合线分散。所以，让我们用另一种方法来得到最佳拟合线。
我们可以使用sk learnlibrary/module 的 linear_model 子模块中预先定义的线性回归模型来获得给定数据点的最佳拟合线。创建模型和获得最佳拟合线参数的步骤如下:
- 首先，从
sklearn.linear_model子模块中导入LinearRegression。 - 然后，使用线性回归()创建一个新的模型，假设模型=线性回归()。
- 并且，使用带有两个参数 x 和 y 的
model.fit()方法将给定的数据拟合到创建的模型中。 - 然后，使用函数
model.predict()对照函数中作为参数给出的 x 值，获得预测的最佳拟合线的 y 值。 - 现在，我们可以将得到的 y 值和 x 值绘制成一个线图，给出给定数据点的最佳拟合线。
# Importing the necessary libraries
from matplotlib import pyplot as plt
import numpy as np
# Importing the sklearn's linear_model,
# a pre-defined linear regression model
from sklearn.linear_model import LinearRegression
# Preparing the data to be computed and plotted
dt = np.array([
[0.05, 0.11],
[0.13, 0.14],
[0.19, 0.17],
[0.24, 0.21],
[0.27, 0.24],
[0.29, 0.32],
[0.32, 0.30],
[0.36, 0.39],
[0.37, 0.42],
[0.40, 0.40],
[0.07, 0.09],
[0.02, 0.04],
[0.15, 0.19],
[0.39, 0.32],
[0.43, 0.48],
[0.44, 0.41],
[0.47, 0.49],
[0.50, 0.57],
[0.53, 0.59],
[0.57, 0.51],
[0.58, 0.60]
])
# Preparing X and y from the given data
X = dt[:, 0].reshape(len(dt), 1)
y = dt[:, 1].reshape(len(dt), 1)
# Creatoing a linear regression model and fitting the data to the model
model = LinearRegression()
model.fit(X, y)
# Now, predicting the y values according to the model
y_line = model.predict(X)
# Printing thr coffecient/parameter of the resulted line
print(f'The parameters of the line: {model.coef_}')
# Plotting the data points and the best fit line
plt.scatter(X, y)
plt.plot(X, y_line, 'r')
plt.title('Best fit line using linear regression model from sklearn')
plt.xlabel('x-axis')
plt.ylabel('y-axis')
plt.show()
Matplotlib best fit line to scatter
你可能也喜欢阅读下面的教程。
- 如何安装 matplotlib python
- Matplotlib 子情节 _adjust
- Matplotlib 散点图标记
- Matplotlib 测井记录图
- 什么是 Matplotlib，如何在 Python 中使用它
- modulenotfounderror:没有名为“matplotlib”的模块
- Matplotlib plot_date
- Matplotlib 虚线
- Matplotlib savefig 空白图像
在本 python 教程中，我们讨论了如何在 Python 的 matplotlib 中绘制最佳拟合线，我们还讨论了以下主题:
- 最佳拟合线
- Matplotlib 最佳拟合线
- 使用 numpy.polyfit()的 Matplotlib 最佳拟合线
- Matplotlib 最佳拟合直线直方图
- Matplotlib 最佳拟合曲线
- Matplotlib 散点图的最佳拟合线
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib 更改背景颜色
原文：https://pythonguides.com/matplotlib-change-background-color/
在本 Python 教程中，我们将讨论 Python 中的 Matplotlib 改变背景色。在这里，我们学习如何改变背景颜色的情节，我们还将涵盖以下主题:
- Matplotlib 更改背景颜色
- Matplotlib 改变绘图的背景颜色
- Matplotlib 更改背景色示例
- Matplotlib 更改背景颜色默认值
- Matplotlib 更改背景颜色更改默认颜色
- Matplotlib 改变背景颜色的内部和外部颜色
- Matplotlib 改变图像的背景颜色
- Matplotlib 改变背景颜色透明
- Matplotlib 更改背景色图例
- Matplotlib 改变背景颜色子图
- Matplotlib 根据值改变背景颜色
目录
- Matplotlib 背景颜色
- Matplotlib 改变绘图的背景颜色
- Matplotlib 改变背景颜色示例
- Matplotlib 改变背景颜色默认值
- Matplotlib 改变背景颜色改变默认颜色
- Matplotlib 改变背景颜色的内部和外部颜色
- Matplotlib 改变图像的背景颜色
- Matplotlib 改变背景颜色透明
- Matplotlib 改变背景颜色图例
- Matplotlib 改变背景颜色子情节
- Matplotlib 根据值改变背景颜色
Matplotlib 背景颜色
Matplotlib 是 Python 中使用最广泛的数据可视化库。通过使用这个库，我们可以自定义绘图的背景颜色。它还提供了改变轴区域和图形区域背景的功能
以下步骤用于改变图背景的颜色，如下图所示:
- 定义库:导入需要改变绘图背景颜色的重要库。(对于可视化:来自 matplotlib 的 pyplot，对于数据创建和操作:numpy 和 pandas)。
- 绘制图形:定义轴，绘制图形。
- 改变背景颜色:通过使用
set_facecolor()方法你可以改变背景颜色。 - 显示:最后通过使用
show()的方法显示剧情。
Matplotlib 改变绘图的背景颜色
set_facecolor() 方法在 axes 模块中用来改变或设置绘图的背景颜色。
它用于设置图形的表面颜色，或者我们可以说是绘图的轴颜色。
将参数作为要设置的颜色名称进行传递。
改变图形背景颜色的语法如下:
matplotlib.pyplot.axes.set_facecolor(color=None)
上述使用的参数概述如下:
- 颜色:指定要设置的颜色名称。
Matplotlib 改变背景颜色示例
在上面的章节中，我们讨论了背景色的确切含义。我们还讨论了用于改变绘图背景颜色的各种步骤。现在，让我们看看如何改变背景颜色。
下面我们通过一个例子来理解这个概念:
**# Import library**
import matplotlib.pyplot as plt
**# Define Data**
x = [5, 6, 3.5, 9.3, 6.8, 9]
y = [2, 3, 6, 8, 15, 6.5]
**# Plot Graph**
plt.plot(x,y)
ax=plt.axes()
**# Set color**
ax.set_facecolor('pink')
**# Display Graph**
plt.show()
- 在上面的例子中，我们导入库
matplotlib。 - 之后，我们定义绘图的 x 轴和 y 轴。
plt.plot()方法用于绘制数据plt.axes()方法被赋给变量 ax。set_facecolor()方法用于改变绘图的背景颜色。这里我们可以把背景改成“粉色”。- 最后，使用
show()方法显示绘制的图形。
set_facecolor()
阅读: Matplotlib 绘制一条线
Matplotlib 改变背景颜色默认值
让我们看看这个图的默认背景色是什么。
默认情况下，绘图的背景颜色为【白色】。
让我们做一个例子来理解这个概念:
**# Import library**
import matplotlib.pyplot as plt
**# Define Data**
x = [5, 6, 3.5, 9.3, 6.8, 9]
y = [2, 3, 6, 8, 15, 6.5]
**# Plot Graph**
plt.plot(x,y)
**# Display Graph**
plt.show()
- 在上面的例子中，我们导入了
matplotlib.pyplot库。 - 然后我们定义 X 轴和 Y 轴点。
plt.plot()方法用于绘制数据点。- 然后我们最后使用方法
plt.show()来显示绘制的图形。
plt.plot() “default background color”
阅读: Python 使用 Matplotlib 绘制多条线
Matplotlib 改变背景颜色改变默认颜色
如上所述，默认的背景颜色是“白色”。
我们还可以通过更新配置来更新默认颜色。
重置默认颜色的语法如下:
**# To reset the plot configurations**
matplotlib.pyplot.plt.rcdefaults()
**# To set the new deault color for all plots**
matplotlib.pyplot.plt.rcParams.update()
让我们借助一个例子来理解改变默认背景色的概念:
**# Import library**
import matplotlib.pyplot as plt
**# reset the plot configurations to default**
plt.rcdefaults()
**# set the axes color glbally for all plots**
plt.rcParams.update({'axes.facecolor':'lightgreen'})
**# Define Data**
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
**# Plot the Graph**
plt.plot(x,y)
**# Display the plot**
plt.show()
rcdefaults()方法用于重置 matplotlib 配置。plt.rcParams.update()更新默认轴面颜色。这里我们将它设置为“浅绿色”。- 之后，我们在图上定义 x 轴和 y 轴。
plt.plot()绘制图形的方法。plt.show()显示图形。
plt.rcdefaults()
现在让我们看看，如果我们创建一个新的情节没有设置颜色会发生什么。
**# Import library**
import matplotlib.pyplot as plt
**# Define Data**
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
**# Plot the Graph**
plt.scatter(x,y)
**# Display the plot**
plt.show()
从上面我们得出结论，改变默认颜色后。所有的图将有我们设置的相同的颜色。它将默认从“白色”更改为“浅绿色”。
Matplotlib 改变背景颜色的内部和外部颜色
我们可以设置绘图的内部和外部颜色。
set_facecolor() 方法用于改变绘图的内部背景颜色。
figure(face color = ' color ')方法用于改变绘图的外部背景颜色。
让我们借助一个例子来理解这个概念:
**# Import Libraries**
import matplotlib.pyplot as plt
**# Define Data**
x = [2,4,5,6,8,12]
y = [3,4,9,18,13,16]
**# Set Outer Color**
plt.figure(facecolor='red')
**# Plot the graph**
plt.plot(x,y)
plt.xlabel("X", fontweight='bold')
plt.ylabel("Y", fontweight='bold')
ax = plt.axes()
**# Set Inner Color**
ax.set_facecolor('yellow')
**# Display the graph**
plt.show()
- 在上面的例子中，我们已经改变了绘图背景的内部和外部颜色。
- "
facecolor"属性在图中使用()方法来改变外区颜色。 set _ face color()``axes()对象的方法来改变绘图的内部区域颜色。
Inner and Outer area background color change
阅读: Matplotlib 绘图条形图
Matplotlib 改变图像的背景颜色
我们将改变情节的背景，并设置一个图像作为背景。
在 Python 中，我们有两个函数 imread() 和 imshow() 来设置一张图片作为背景。
将图像设置为背景的语法:
**# Set image**
plt.imread("path of image")
**# Show image**
ax.imshow(image)
让我们借助一个例子来理解将图像设置为背景的概念:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = [10, 20, 30, 40, 50, 6]
y = [3,4,5, 9, 15, 16]
**# Set Image**
img = plt.imread("download.jpg")
**# Plot the graph**
fig, ax = plt.subplots()
ax.scatter(x,y, s= 250 , color="yellow")
**# Show Image**
ax.imshow(img, extent=[-5, 80, -5, 30])
**# Display graph**
plt.show()
- 在上面的例子中，我们使用了
imread()方法来设置图像的背景色。我们通过“图像的路径”作为论证。 imshow()函数用来指定图像的区域。我们传递一个参数“范围，信息为水平 _ 最小，水平 _ 最大，垂直 _ 最小，垂直 _ 最大。
plt.imread()
Matplotlib 改变背景颜色透明
如果我们想要设置图形的背景颜色，并将轴设置为透明，或者需要将图形区域设置为透明，我们需要使用 set_alpha() 方法。
alpha 的默认值为 1.0，表示完全不透明。
我们可以通过减小这个值来改变它。
set _ alpha()函数的语法如下:
matplotlib.patches.Patch.set_alpha(alpha)
上述使用的参数概述如下:
alpha:设置透明度的浮点值。
这里的补丁是有脸色和边色的艺人。
让我们借助一个例子来理解这个概念:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = [10, 20, 30, 40, 50, 6]
y = [3,4,5, 9, 15, 16]
**# Plot Graph**
fig = plt.figure()
**# Set background color of Figure**
fig.patch.set_facecolor('blue')
**# Set transparency of figure**
fig.patch.set_alpha(1)
**# Plot graph**
ax = fig.add_subplot(111)
**# Background color of axes**
ax.patch.set_facecolor('orange')
**# Set transaprency of axes**
ax.patch.set_alpha(1)
**# Display Graph**
plt.scatter(x,y)
plt.show()
- 在上面的例子中，我们使用
set_alpha()方法来设置背景颜色的透明度。 - 在这里，我们为图形和轴区域设置
alpha的值为1。 - 这意味着两个区域都是完全不透明的。
set_alpha()
让我们看看如果我们将轴区域的 set_alpha 更改为 0 会发生什么。
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = [10, 20, 30, 40, 50, 6]
y = [3,4,5, 9, 15, 16]
**# Plot Graph**
fig = plt.figure()
**# Set background color of Figure**
fig.patch.set_facecolor('blue')
**# Set transparency of figure**
fig.patch.set_alpha(1)
**# Plot graph**
ax = fig.add_subplot(111)
**# Background color of axes**
ax.patch.set_facecolor('orange')
**# Set transaprency of axes**
ax.patch.set_alpha(1)
**# Display Graph**
plt.scatter(x,y)
plt.show()
set_alpha() “set to be 0”
结论！现在看，这些轴变成了‘蓝色。
阅读: Matplotlib 最佳拟合线
Matplotlib 改变背景颜色图例
Matplotlib 提供了更改图例背景颜色的功能。
plt.legend() 方法用于改变图例的背景色。
改变图例颜色的语法如下:
matplotlib.pyplot.plt.legend(facecolor=None)
上述使用的参数概述如下:
- facecolor: 改变图例的背景颜色。
让我们借助一个改变图例背景颜色的例子来理解这个概念:
**# Import Libraries**
import matplotlib.pyplot as plt
**#Define Data**
plt.plot([0, 2], [0, 3.6], label='Line-1')
plt.plot([1, 4], [0, 3.7], label='Line-2')
**#Background color of legend**
plt.legend(facecolor="yellow")
**# Display Graph**
plt.show()
- 在上面的例子中，我们使用
plt.legend()方法来改变图例的背景颜色。 - 这里我们将“face color”作为参数传递，并将其值设置为“
Yellow”。
plt.legend(facecolor=’yellow’)
Matplotlib 改变背景颜色子情节
这里我们将讨论如果我们在一个图形区域中绘制多个图，我们如何改变特定子图的背景颜色。
我们使用 set_facecolor() 方法来改变特定子情节的背景颜色。
让我们借助一个例子来理解这个概念:
**# Importing Libraries**
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x1= [0.2, 0.4, 0.6, 0.8, 1]
y1= [0.3, 0.6, 0.8, 0.9, 1.5]
x2= [2, 6, 7, 9, 10]
y2= [3, 4, 6, 9, 12]
x3= [5, 8, 12]
y3= [3, 6, 9]
x4= [7, 8, 15]
y4= [6, 12, 18]
fig, ax = plt.subplots(2, 2)
**# Set background color of specfic plot**
ax[0, 0].set_facecolor('cyan')
**# Plot graph**
ax[0, 0].plot(x1, y1)
ax[0, 1].plot(x2, y2)
ax[1, 0].plot(x3, y3)
ax[1, 1].plot(x4,y4)
**# Display Graph**
fig.tight_layout()
plt.show()
- 在上面的例子中，我们在一个图形区域中绘制了多个图。并且我们想改变特定情节的背景颜色。
- 这里我们使用
set_facecolor()方法来改变绘图的背景。 - 我们对第一个子情节使用了
set_facecolor()方法，并将其背景设置为“青色”。
Set the background color of a specific subplot
读取: Matplotlib 日志日志图
Matplotlib 根据值改变背景颜色
如果我们想在绘图的特定区域设置背景颜色。
我们必须将" facecolor" 参数传递给axh span()方法和 axvspan() 方法。
这里的轴跨距和轴跨距分别是水平和垂直的矩形区域。
其语法如下:
matplotlib.axes.Axes.axhspan(facecolor=None)
matplotlib.axes.Axes.axvspan(facecolor=None)
上述使用的参数概述如下:
- facecolor: 设置特定颜色
让我们借助一个例子来理解这个概念:
**# Import Library**
import matplotlib.pyplot as plt
**# Plot figure**
plt.figure()
plt.xlim(0, 10)
plt.ylim(0, 10)
**# Set color**
for i in range(0, 6):
plt.axhspan(i, i+.3, facecolor='r')
plt.axvspan(i, i+.15, facecolor='b')
**# Display graph**
plt.show()
在上面的例子中，我们使用 axhspan() 和 axvspan() 方法通过值来设置背景颜色。这里我们通过一个" facecolor "参数来设置颜色。
Change background color by value
你可能也喜欢读下面的文章。
- Matplotlib plot_date
- Matplotlib 另存为 png
- Matplotlib 绘图误差线
- Matplotlib 虚线
- Matplotlib 散点图标记
- Matplotlib 条形图标签
- Matplotlib 反转 y 轴
在这个 Python 教程中，我们已经讨论了" Matplotlib 改变背景色"并且我们还涉及了一些与之相关的例子。我们在本教程中讨论了以下主题。
- Matplotlib 更改背景颜色
- Matplotlib 改变绘图的背景颜色
- Matplotlib 更改背景色示例
- Matplotlib 更改背景颜色默认值
- Matplotlib 更改背景颜色更改默认颜色
- Matplotlib 改变背景颜色的内部和外部颜色
- Matplotlib 改变图像的背景颜色
- Matplotlib 改变背景颜色透明
- Matplotlib 更改背景色图例
- Matplotlib 改变背景颜色子图
- Matplotlib 根据值改变背景颜色
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib 虚线–完整教程
在本 python 教程中，我们将讨论 Python 中的 Matplotlib 虚线以虚线样式绘制图形，我们还将涵盖以下主题:
- Matplotlib 虚线
- Matplotlib 虚线如何绘图
- Matplotlib 虚线示例
- Matplotlib 虚线样式
- Matplotlib 虚线颜色
- 带标记的 Matplotlib 虚线
- Matplotlib 虚线水平线
- Matplotlib 虚线垂直线
- Matplotlib 虚线间距
- Matplotlib 虚线图例
- Matplotlib 虚线轮廓
- Matplotlib 虚线宽度
- Matplotlib 虚线误差线
目录
- Matplotlib 虚线
- Matplotlib 虚线如何绘图
- Matplotlib 虚线示例
- Matplotlib 虚线样式
- Matplotlib 虚线颜色
- 带标记的 Matplotlib 虚线
- Matplotlib 虚线水平线
- Matplotlib 虚线垂直线
- Matplotlib 虚线间距
- Matplotlib 虚线图例
- Matplotlib 虚线轮廓
- Matplotlib 虚线宽度
- Matplotlib 虚线误差条
Matplotlib 虚线
- 在 Python 中， Matplotlib 是广泛用于数据可视化的库。
- 通过使用这个库，我们可以使用
pyplot子模块或方法在 python 中创建一个线图。 - 折线图将 X-Y 平面或坐标平面上的 X 轴和 Y 轴上的两个量之间的关系可视化。
Matplotlib 虚线是一个特殊样式的折线图，用线型虚线表示 X 轴和 Y 轴之间的关系。
另外，请阅读: Matplotlib 子情节
Matplotlib 虚线如何绘图
以下步骤用于创建 matplotlib 虚线图，概述如下:
- 定义库:导入创建虚线图所需的重要库(可视化:来自 matplotlib 的 pyplot，数据创建和操作:numpy)
- 定义 X 和 Y: 定义 X 轴和 Y 轴上的数据值。
- 绘制一条线:使用
pyplot()方法，特殊参数线样式为虚线。 - 显示:最后显示剧情。
创建 matplotlib 虚线图的语法如下:
matplotlib.pyplt.plot(x, y, linestyle='dashed')
上述使用的参数概述如下:
- x: 线上点的 X 轴坐标。
- y: 线上点的 Y 轴坐标。
- 线条样式:用于改变线条样式的特殊功能。我们称之为虚线是因为我们的主要目标是创建一个虚线图。
阅读: Matplotlib 绘图条形图
Matplotlib 虚线示例
在上面几节中，我们讨论了虚线图的确切含义以及创建或绘制 matplotlib 虚线图的各个步骤。
下面我们通过一个例子来理解这个概念:
**# Import libraries**
import matplotlib.pyplot as plt
**# Define Ax**es
x_points = [1.5, 2.6, 3.5, 4, 9]
y_points = [3.25, 6.3, 4.23, 1.35, 3]
**# Plot a graph**
plt.plot(x_points, y_points, linestyle = 'dashed')
**# Display graph**
plt.show()
- 在上面的例子中，我们导入了
matplotlib.pyplot库。 - 然后我们定义笛卡尔平面的 X 轴和 Y 轴。
plt.plot()方法与参数 linestyle "dashed "一起使用，用虚线绘制图形。- 然后我们最后使用方法
plt.show()来显示绘制的图形。
plt.plot(linestyle=’dashed’)
Matplotlib 虚线样式
为了给图形或图表添加一些额外的特征或样式，我们使用不同的样式。基本上，样式用于改变绘图或图表的整体外观。
为了实现对样式的更多控制，我们必须提供一个破折号元组。
**# Create dash tuple as:** dash tuple (offset, (on_off_seq))
举例:('松散虚线'，(0，(5，20)))其中 5 表示 5pt 线，20 表示 20pt 空格。
在 matplotlib 虚线中，可使用下列样式:
- 松散虚线
- 虚线
- 密集虚线
为了便于理解，让我们借助示例逐一讨论不同的风格:
Matplotlib 虚线样式"松散虚线 "
现在，我们将向虚线添加更多功能。
让我们借助一个例子来理解这个概念:
**# Import libraries**
import matplotlib.pyplot as plt
from collections import OrderedDict
**# Define dash tuple**
linestyles = OrderedDict(
[
('loosely dashed', (0, (5, 20))),
('dashed', (0, (10, 4))),
('densely dashed', (0, (1, 3))),
])
**# Plot the graph**
plt.plot([0,100], [0,1], linestyle=linestyles['loosely dashed'])
**# Display the plot**
plt.show()
- 在上面的例子中，首先我们导入
matplotlib.pyplot库，然后我们从集合中导入 OrderedDict。 - 接下来，我们用所有可用的样式定义破折号元组。
- 然后我们使用
plt.plot()方法绘制具有松散虚线特征的图，具有 1pt 线和 3pt 空间。 - 最后，我们使用方法
plt.show()来显示这个图。
plt.plot() linestyle “loosely dashed”
Matplotlib 虚线样式【虚线】
给虚线添加一些额外的功能。
让我们借助一个例子来理解这个概念:
**# Import libraries**
import matplotlib.pyplot as plt
from collections import OrderedDict
**# Define dash tuple**
linestyles = OrderedDict(
[
('loosely dashed', (0, (5, 20))),
('dashed', (0, (10, 4))),
('densely dashed', (0, (1, 3))),
])
**# Plot the graph**
plt.plot([0,100], [0,1], linestyle=linestyles['dashed'])
**# Display the plot**
plt.show()
- 在上面的例子中，首先我们导入
matplotlib.pyplot库，然后我们从集合中导入 OrderedDict。 - 接下来，我们用所有可用的样式定义破折号元组。
- 然后我们用
plt.plot()的方法，用 10pt 的线和 4pt 的间距画出带有虚线特征的图。 - 最后，我们使用方法
plt.show()来显示这个图。
plt.plot() linestyle “dashed”
Matplotlib 虚线样式“密集虚线”
给虚线添加一些额外的功能。
让我们借助一个例子来理解这个概念:
**# Import libraries**
import matplotlib.pyplot as plt
from collections import OrderedDict
**# Define dash tuple**
linestyles = OrderedDict(
[
('loosely dashed', (0, (5, 20))),
('dashed', (0, (10, 4))),
('densely dashed', (0, (1, 3))),
])
**# Plot the graph**
plt.plot([0,100], [0,1], linestyle=linestyles['densely dashed'])
**# Display the plot**
plt.show()
- 在上面的例子中，首先我们导入
matplotlib . py plot库，然后我们 从集合 中导入 OrderedDict。 - 接下来，我们用所有可用的样式定义破折号元组。
- 然后我们用
plt.plot()的方法，用 1 点的线和 3 点的空间，画出带有虚线特征的图形。 - 最后，我们用
plt.show()的方法展示这个图。
plt.plot() linestyle “densely dashed “
阅读: Python 使用 Matplotlib 绘制多条线
Matplotlib 虚线颜色
plt.plot() 方法主要用于绘制 X 轴和 Y 轴上的数据之间的关系，参数 color 指定了不同的颜色，我们用这些颜色来突出不同的绘制线。
其语法如下:
matplotlib.pyplot.plot(x, y, linestyle='dashed', color=None)
matplotlib 中可用的颜色如下:
- 蓝色:写为‘蓝色’或‘b’。
- 红色:写为‘红色’或‘r’。
- 绿色:写为‘绿色’或‘g’。
- 青色:写为‘青色’或‘c’。
- 洋红色:写为‘洋红色’或‘m’。
- 黄色:写为‘黄色’或‘y’。
- 黑色:写为‘黑色’或‘k’。
- 白色:写为‘白色’或‘w’。
让我们借助下面的例子来理解改变地块线颜色的概念:
**# Import libraries**
import matplotlib.pyplot as plt
**# Define Ax**es
x_points = [1.5, 2.6, 3.5, 4, 9]
y1_points = [1, 2, 3, 4, 5]
y2_points = [6, 7, 8, 9, 10]
y3_points = [3, 4.3, 4.23, 6, 3]
**# Plot a graph**
plt.plot(x_points, y1_points, linestyle = 'dashed', color = 'cyan')
plt.plot(x_points, y2_points, linestyle = 'dashed',color = 'm')
plt.plot(x_points, y3_points, linestyle = 'dashed', color = 'green')
**# Display graph**
plt.show()
- 在上面的例子中，我们使用了
plt.plot()方法，通过使用线条样式虚线来绘制数据。 - 为了容易区分绘制的线，我们使用颜色参数。
- 这里我们绘制了三个不同的虚线图，我们使用三种不同的颜色作为青色、品红色和绿色。
plt.plot(linestyle=’dashed’,color=’None’)
阅读: Matplotlib 绘制一条线
带标记的 Matplotlib 虚线
标记向我们展示数据点。基本上，它们用于突出显示最高和最低的数据点。
我们可以设置不同的图案、颜色、大小等标记。
甚至，我们还可以设置 markeredgecolor 、 facecolor 等。
其语法如下:
matplotlib.pyplot.plot(x, y, linestyle='dashed', marker=None, markersize=None,markeredgecolor=None ... )
让我们借助一个例子来理解这个概念:
**# Import libraries**
import matplotlib.pyplot as plt
**# Define Ax**es
x_points = [1.5, 2.6, 3.5, 4, 9]
y_points = [1, 2, 3, 4, 5]
**# Plot a graph**
plt.plot(x_points, y1_points, linestyle = 'dashed', marker = '*' )
**# OR**
plt.plot(x_points, y1_points, linestyle = 'dashed', marker = 'd', ms= '20')
**# OR**
plt.plot(x_points, y1_points, linestyle = 'dashed', marker = '>', ms= '20', mec= 'r')
**# OR**
plt.plot(x_points, y1_points, linestyle = 'dashed', marker = '>', ms= '20', mec= 'r', mfc='y')
**# Display graph**
plt.show()
- 在上面的例子中，我们通过使用标记作为参数来使用虚线图中的标记，并且我们还根据您的需要来调整标记。
- 第一种情况:我们使用标记
- 第二种情况:我们使用标记
- 第三种情况:我们使用标记
- 第四种情况:我们使用标记
First Case Output
Second Case Output
Third Case Output
Fourth Case Output
Matplotlib 虚线水平线
在某些情况下，我们需要在图表或绘图中画一条水平线。
对于绘制水平线使用 axhline() 方法。
在指定日期绘制水平线的语法:
matplotlib.pyplot,axhline(x=0, ymin=0, ymax=1, **kwargs)
在上面的语法中，使用了下面概述的参数:
- x: 在数据坐标中放置水平线。
- ymin:y 轴上的水平线起始位置。它取 0 到 1 之间的值。0 代表轴的底部，1 代表轴的顶部。
ymax:y 轴上的水平线结束位置。它取 0 到 1 之间的值。0 代表轴的底部，1 代表轴的顶部。- kwargs: 指定属性来改变线条的样式、颜色、线宽。
让我们借助一个例子来理解这个概念:
**# Import libraries**
import matplotlib.pyplot as plt
**# Plot the graph**
plt.plot([0,10], [0,6])
**# Plot horizontal line**
plt.axhline(y=1.5, linestyle='dashed', color='black')
**# Display the plot**
plt.show()
- 在上面的例子中，首先我们导入
matplotlib . py plot库，然后我们 从集合 中导入 OrderedDict。 - 然后我们用
plt.plot()的方法画出带有虚线自变量的图形。 - 然后我们用
axhline()的方法画一条水平线。 - 最后，我们用
plt.show()的方法展示这个图。
plt.axhline()
Matplotlib 虚线垂直线
在某些情况下，我们需要在图表或绘图中画一条垂直线。
对于绘制水平线使用 axvline() 方法。
在指定日期绘制水平线的语法:
matplotlib.pyplot,axvline(x=0, ymin=0, ymax=1, **kwargs)
在上面的语法中，使用了下面概述的参数:
- x: 在数据坐标中放置垂直线。
- ymin:y 轴上的垂直线起始位置。它取 0 到 1 之间的值。0 代表轴的底部，1 代表轴的顶部。
ymax:y 轴上的垂直线结束位置。它取 0 到 1 之间的值。0 代表轴的底部，1 代表轴的顶部。- kwargs: 指定属性来改变线条的样式、颜色、线宽。
让我们借助一个例子来理解这个概念:
**# Import libraries**
import matplotlib.pyplot as plt
**# Plot the graph**
plt.plot([0,10], [0,6])
**# Plot vertical line**
plt.axvline(x=1.5, linestyle='dashed', color='black')
**# Display the plot**
plt.show()
plt.axvline()
读取: Matplotlib 日志日志图
Matplotlib 虚线间距
间距指定破折号之间的空间长度。您可以根据需要增加或减少空间。
改变空间的语法描述如下:
matplotlib.plt.plot(x,y,linestyle='dashed',dashes= ( length of line , space of line ) )
让我们借助一个例子来理解这个概念:
**# Import libraries**
import matplotlib.pyplot as plt
**# Plot the graph**
plt.plot([0,10], [0,1], linestyle='dashed', dashes=(1,3))
plt.plot([0,10], [0,2], linestyle='dashed', dashes=(3,2))
plt.plot([0,10], [0,3], linestyle='dashed', dashes=(5,10))
**# Display the plot**
plt.show()
- 在上面的例子中，我们使用
plt.plot()方法绘制了一个图形 - 我们在
plt.plot()方法中通过破折号作为参数来改变虚线之间的间距。 - 从输出中，您观察到在所有三种情况下，破折号之间的间距是不同的。
plt.plot()
Matplotlib 虚线图例
- 图例用于表示图形的坐标。
- 在 matplotlib 中，我们有一个方法
legend()。 legend()用于在轴上放置一个图例。
上述内容的语法如下:
matplotlib.pyplot.legend()
图例函数具有以下参数，概述如下:
- loc: 指定图例的位置。默认情况下，loc 的值是“最佳”或左上角。其他位置被定义为“右上”、“右下”、“左下”。
- bbox_to_anchor((x，y)，ncol) : x 和 y 指定坐标，ncol 表示列数。默认情况下，ncol 的值为 1。
- 标记刻度:指定图例标记的大小。
- facecolor: 指定图例的背景颜色。
- 边缘颜色:指定图例的边缘颜色。
让我们借助一个例子来理解这个概念:
**#Import Libraries**
import numpy as np
import matplotlib.pyplot as plt
**# Data to be plotted**
x = np.arange(5)
y1 = [1, 2, 3, 4, 5]
y2 = [1, 8, 27, 64, 125]
**# Function to plot**
plt.plot(x, y1, '--', label ='Numbers')
plt.plot(x, y2, label ='Cube of numbers')
**# Function add a legend**
plt.legend(bbox_to_anchor =(0.85, 1.12), ncol = 3)
**#OR**
plt.legend( loc='upper center')
**# Function to show the plot**
plt.show()
- 在上面的例子中，首先我们导入库
matplotlib.pylot和NumPy。 - 接下来，通过使用 NumPy
arrange()方法我们定义数据。 - 然后我们使用
plt.plot()方法绘制数据，并设置它们的标签。 plt.legend ()方法用于定义图例- 案例 1:我们使用
bbox_to_anchor()方法 - 情况 2:我们用
loc来指定位置。 - 最后，我们使用
show()来显示图形。
plt.legend() “Output of Case 1”
plt.legend() “Output of Case 2”
阅读: Matplotlib 最佳拟合线
Matplotlib 虚线轮廓
等高线用于绘制二维的三维数据。
plt.contour() 和PLT . contour()方法用于创建 3D 数据图。
上述内容的语法如下:
matplotlib.pyplot.contour([X,Y]Z,[levels],**kwargs)
以下是对上述论点的如下描述:
- X: 指定 2 D 数组，其中 len(X)是 z 的行数。
- Y: 指定 2 D 数组，其中 len(Y)是 z 的列。
- Z: 绘制(X，Y)的形状，并指定高度值。
- 级别:指定轮廓线的数量和位置。
让我们借助一个例子来理解 的概念:
**# Import Libraries**
import numpy as np
import matplotlib.cm as cm
import matplotlib.pyplot as plt
**# Define data**
delta = 0.035
x = np.arange(-3.0, 3.0, delta)
y = np.arange(-2.0, 2.0, delta)
X, Y = np.meshgrid(x, y)
Z = np.exp(-X`2 - Y`2)
**# contour() method**
fig,axis = plt.subplots()
Counter_plot = axis.contour(X, Y, Z, 6, colors='k', linestyles='dashed')
**# Plot the graph**
plt.show()
- 导入必要的库，如
matplotlib.pyplot、matplotlib.cm、numpy。 - 使用
arrange()方法定义数据或二维数据。 - 使用
meshgrid()方法创建一个网格，并传递 x 和 y 的值。 - 定义 Z 为 X 和 y 的函数。
- 然后使用
contour()方法绘制 3D 图，并将不同的参数 x、y 和 metion 传递给虚线所示的线条样式。 - 最后，使用
show()方法显示图形。
counter()
阅读: Matplotlib 散点图标记
Matplotlib 虚线宽度
我们可以很容易地在 matplotlib 中自定义 linestyle dashed。通过定义线条宽度，我们可以修改线条的粗细。或者我们可以说，我们可以增加或减少线的宽度。默认情况下，我们以像素为单位指定线宽大小。
上述内容的语法如下:
**#Import Libraries**
import numpy as np
import matplotlib.pyplot as plt
**# Data to be plotted**
x = np.arange(5)
y1 = [1, 2, 3, 4, 5]
y2 = [1, 8, 27, 64, 125]
**# Function to plot**
plt.plot(x, y1, '--', linewidth = 8, label ='Numbers')
plt.plot(x, y2, '--', linewidth = 4, label ='Cube of numbers')
**# Function add a legend **
plt.legend(loc='upper center')
**# Function to show the plot**
plt.show()
在上面的例子中，通过使用 plt.plot() 方法，我们绘制了图形。并且通过添加额外的参数线宽，我们可以改变虚线的粗细。
plt.plot() “Change dashed line thickness”
另外，请阅读: Matplotlib 移除刻度标签
Matplotlib 虚线误差条
Matplotlib 虚线有误差线，用于绘制计算值的置信度或精度，我们使用误差线。
errorbar() 方法用于绘制图形中的误差线。
绘制误差线的语法如下:
matplotlib.pyplot.errorbar(x, y, xerr=None, yeer=None, ...)
下面描述上面使用的下列参数:
- x: 指定水平坐标
- y: 指定垂直坐标
- xeer: 数组状结构，指定水平方向的误差线大小。
- 叶儿:阵列状结构，指定垂直方向的误差线大小。
我们用一个例子来理解这个概念:
**#Import Libraries**
import numpy as np
import matplotlib.pyplot as plt
**# Data to be plotted**
x = np.arange(5)
y = [1, 2, 3, 4, 5]
**# Function to plot errorbars**
plt.errorbar(x, y, xerr = 0.3, linestyle='dashed')
**# Function to show the plot**
plt.show()
在上面的例子中，我们使用 plt.errorbar() 方法，在水平方向绘制误差线，尺寸为 0.3，线条样式为虚线。
plt.errorbar()
另外，检查:画垂直线 matplotlib
在本 Python 教程中，我们已经讨论了" Matplotlib 虚线"并且我们还涵盖了一些与之相关的例子。我们在本教程中讨论了以下主题。
- Matplotlib 虚线
- Matplotlib 虚线如何绘图
- Matplotlib 虚线示例
- Matplotlib 虚线样式
- Matplotlib 虚线颜色
- 带标记的 Matplotlib 虚线
- Matplotlib 虚线水平线
- Matplotlib 虚线垂直线
- Matplotlib 虚线间距
- Matplotlib 虚线图例
- Matplotlib 虚线轮廓
- Matplotlib 虚线宽度
- Matplotlib 虚线误差线
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib 默认图形大小
在本 Python 教程中，我们将讨论 Python 中的 Matplotlib 默认图形大小。这里我们将介绍使用 matplotlib 改变默认图形大小的不同例子。我们还将讨论以下主题:
- matplotlib 默认图形大小
- 木星笔记本 matplotlib 默认图大小
- google colab matplotlib 默认图形大小
- visual studio matplotlib 默认图形大小
- spyder matplotlib 默认图形大小
- jupiter lab matplotlib 默认图形大小
目录
- matplotlib 默认图形尺寸
- jupyter 笔记本 matplotlib 默认图尺寸
- Google colab matplotlib 默认图尺寸
- Visual studio matplotlib 默认图尺寸
- spyder matplotlib 默认图形尺寸
- jupyter lab matplotlib 默认图形大小
matplotlib 默认图形尺寸
要检查 matplotlib 中的默认图形尺寸，必须打印 matplotlib 的默认设置。
打印默认设置的语法如下:
**# Default all settings**
matplotlib.pyplot.rcParams
您也可以在 matplotlib 中仅检查默认图形大小。
检查默认图形尺寸的语法:
**# Default figure size**
matplotlib.pyplot.rcParams["figure.figsize"]
`OR`
matplotlib.pyplot.rcParams.get('figure.figsize)
现在，让我们看一个在 matplotlib 中检查默认设置的例子
**# Import Library**
import matplotlib.pyplot as plt
**# Check default settings**
print(plt.rcParams)
” Default settings “
jupyter 笔记本 matplotlib 默认图尺寸
在本节中，我们将检查“jupyter notebook”中图形的默认大小，并尝试根据需要进行更改。
在 jupyter 笔记本中获取默认图形尺寸的语法如下:
matplotlib.pyplot.rcParams.get('figure.figsize')
jupyter 笔记本示例:
**# Import Library**
import matplotlib.pyplot as plt
**# Default figure size**
fig_size = plt.rcParams.get('figure.figsize')
**# Print**
print(" The Default figure size in jupyter notebook is: ", fig_size)
” Output of jupyter notebook “
Matplotlib 提供了改变 jupyter 笔记本中图形默认尺寸的功能。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# New figure size** new_size = plt.rcParams["figure.figsize"] = (50,50)
**# Print**
print(" New figure size: ",new_size)
” New Figure size set in jupyter notebook “
更改默认体形大小后，现在检查默认体形大小设置发生了什么变化:
代码:
**# Import Library**
import matplotlib.pyplot as plt
**# Default figure size**
fig_size = plt.rcParams.get('figure.figsize')
**# Print**
print(" After, New Default figure size in jupyter notebook is: ", fig_size)
” Output after changing Default Figure Size “
阅读蟒龟圈
Google colab matplotlib 默认图尺寸
在本节中，我们将检查“Google colab”中图形的默认大小，并尝试根据需要进行更改。
在 google colab 中获取默认图形尺寸的语法如下:
matplotlib.pyplot.rcParams.get('figure.figsize')
Google colab 的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Default figure size**
fig_size = plt.rcParams.get('figure.figsize')
**# Print**
print(" The Default figure size in google colab is: ", fig_size)
” Output of google colab “
Matplotlib 提供了在 google colab 中改变图形默认大小的功能。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# New figure size**
new_size = plt.rcParams["figure.figsize"] = (20,15)
**# Print**
print(" New figure size: ",new_size)
” New Figure size set in google colab “
现在让我们看看更改默认体形大小后，默认体形大小设置会发生什么变化:
代码:
**# Import Library**
import matplotlib.pyplot as plt
**# Default figure size**
fig_size = plt.rcParams.get('figure.figsize')
**# Print**
print(" After, New Default figure size in google colab is: ", fig_size)
” Output after changing Default Figure Size “
Visual studio matplotlib 默认图尺寸
在本节中，我们将检查“visual studio”中图形的默认大小，并根据需要尝试更改它。
在 visual studio 中获取默认图形大小的语法如下:
matplotlib.pyplot.rcParams.get('figure.figsize')
visual studio 的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Default figure size**
print(plt.rcParams.get('figure.figsize'))
” Output of visual studio “
Matplotlib 提供了在 visual studio 中改变图形默认尺寸的功能。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# New figure size**
new_size = plt.rcParams["figure.figsize"] = (35, 10)
**# Print**
print("After changing figure default size is: ",new_size)
“ Output after changing figure size “
spyder matplotlib 默认图尺寸
在本节中，我们将检查“spyder”中图形的默认大小，并根据需要尝试更改它。
spyder 中获取默认图形尺寸的语法如下:
matplotlib.pyplot.rcParams.get('figure.figsize')
spyder 笔记本示例:
# `Import Library`
import matplotlib.pyplot as plt
**# Default figure size**
fig_size = plt.rcParams.get('figure.figsize')
**# Print**
print(" The Default figure size in jupyter notebook is: ", fig_size)
” Output of spyder “
Matplotlib 提供了改变 spyder 中图形默认尺寸的功能。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# New figure size** new_size = plt.rcParams["figure.figsize"] = (15,20)
**# Print**
print(" New figure size: ",new_size)
” New Figure size set in spyder “
另外，阅读 Python 中的添加文本到绘图 matplotlib
jupyter lab matplotlib 默认图形大小
在这里，我们将检查“jupyter lab”中图形的默认大小，并根据需要尝试更改。
在 jupyter lab 中获取默认图形尺寸的语法如下:
matplotlib.pyplot.rcParams.get('figure.figsize')
jupyter 实验室示例:
**# Import Library**
import matplotlib.pyplot as plt
**# Default figure size**
fig_size = plt.rcParams.get('figure.figsize')
**# Print**
print(" The Default figure size in jupyter lab is: ", fig_size)
” Output of jupyter lab “
Matplotlib 提供了改变 jupyter lab 中图形默认尺寸的功能。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# New figure size**
new_size = plt.rcParams["figure.figsize"] = (45, 52)
**# Print**
print(" New figure size: ",new_size)
” New Figure size set in jupyter lab “
现在让我们看看更改默认体形大小后，默认体形大小设置会发生什么变化:
代码:
**# Import Library**
import matplotlib.pyplot as plt
**# Default figure size**
fig_size = plt.rcParams.get('figure.figsize')
**# Print**
print(" After, New Default figure size in jupyter lab is: ", fig_size)
” Output after changing Default Figure Size “
您可能会喜欢以下 Matplotlib 教程:
- Matplotlib 绘图误差线
- Matplotlib Plot NumPy 数组
- 水平线 matplotlib
- Matplotlib 移除刻度标签
- Matplotlib 旋转刻度标签
- Matplotlib 改变背景颜色
- Matplotlib 散点图标记
- Matplotlib 标题字体大小
- Matplotlib tight_layout
在本 Python 教程中，我们已经讨论了“Matplotlib 默认图形大小”，并且我们还涵盖了一些与之相关的示例。这些是我们在本教程中讨论过的以下主题。
- matplotlib 默认图形大小
- 木星笔记本 matplotlib 默认图大小
- google colab matplotlib 默认图形大小
- visual studio matplotlib 默认图形大小
- spyder matplotlib 默认图形大小
- jupiter lab matplotlib 默认图形大小
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
matplotlib fill _ between–完整指南
在本 Python Matplotlib 教程中，我们将讨论 Python 中的 Matplotlib fill_between 。这里我们将介绍使用 matplotlib 填充 _between 的不同例子。我们还将讨论以下主题:
- Matplotlib 填充 _ 之间
- Matplotlib fill_between 示例
- Matplotlib 填充 _ 颜色之间
- Matplotlib 填充 _ 填充线之间
- Matplotlib 填充 _ 步间
- Matplotlib fill_between 阴影颜色
- 面颜色之间的 Matplotlib 填充
- Matplotlib fill_between 图案填充密度
- Matplotlib fill_between where
- 三行之间的 Matplotlib 填充
- 两条曲线之间的 Matplotlib 填充
- 散点之间的 Matplotlib 填充
- 虚线之间的 Matplotlib 填充
- 圆之间的 Matplotlib 填充
- 两行之间的 Matplotlib 填充
- Matplotlib fill_between alpha
- Matplotlib 填充 _ 对数刻度之间
- Matplotlib 填充 _ 图例之间
- Matplotlib fill_between 线条颜色
- Matplotlib fill_between 线条宽度
- Matplotlib fill_between 无边缘
- Matplotlib 填充 _ 边缘之间
- Matplotlib 填充 _ 边缘颜色之间
- Matplotlib fill_between datetime
- 范围之间的 Matplotlib 填充
- 误差线之间的 Matplotlib 填充
- 两条垂直线之间的 Matplotlib 填充
- 两条水平线之间的 Matplotlib 填充
- 顶部之间的 Matplotlib 填充
- 熊猫之间的 Matplotlib 填充
- 0 之间的 Matplotlib 填充
- 点之间的 Matplotlib 填充
- 不同颜色之间的 Matplotlib 填充
- 样式之间的 Matplotlib 填充
- fill_between 的 Matplotlib 标签
- Matplotlib fill_between 插值
- Matplotlib fill_between 置信区间
- 标准偏差之间的 Matplotlib 填充
- x 轴之间的 Matplotlib 填充
- 多边形之间的 Matplotlib 填充
- Matplotlib 填充 _ 极坐标间
- Matplotlib fill_between 动画
目录
- Matplotlib fill_between
- Matplotlib fill_between 示例
- Matplotlib fill _ between color
- Matplotlib fill _ between hatch
- Matplotlib fill_between 步骤
- Matplotlib fill_between 阴影颜色
- Matplotlib 面间填充颜色
- Matplotlib fill_between 影线密度
- Matplotlib fill _ between where
- 三行之间的 Matplotlib 填充
- 两条曲线之间的 Matplotlib 填充
- 散点间 Matplotlib 填充
- 虚线之间的 Matplotlib 填充
- 圆圈之间的 Matplotlib 填充
- 两行之间的 Matplotlib 填充
- Matplotlib fill _ between alpha
- Matplotlib fill _ between log scale
- Matplotlib fill_between 图例
- Matplotlib fill_between 线条颜色
- Matplotlib fill_between 线宽
- Matplotlib fill _ between no edge
- Matplotlib fill _ between edge
- Matplotlib fill _ between edge color
- Matplotlib fill _ between datetime
- Matplotlib 填充范围之间
- 误差线之间的 Matplotlib 填充
- 两条垂直线之间的 Matplotlib 填充
- 两条水平线之间的 Matplotlib 填充
- Matplotlib 填充在顶部之间
- Matplotlib 填充 _ 熊猫之间
- Matplotlib 在 0 之间填充
- 点与点之间的 Matplotlib 填充
- 不同颜色之间的 Matplotlib 填充
- 样式间 Matplotlib 填充
- 用于 fill_between 的 Matplotlib 标签
- Matplotlib fill_between 插值
- Matplotlib fill_between 置信区间
- 标准偏差之间的 Matplotlib 填充
- x 轴之间的 Matplotlib 填充
- 多边形之间的 Matplotlib 填充
- Matplotlib 填充 _ 极坐标间
- Matplotlib fill_between 动画
Matplotlib fill_between
在这一节中，我们将学习 Python 中 matplotlib 的 pyplot 模块中的 fill_between 函数。
fill_between函数用于填充两条水平曲线或直线之间的空间或区域。点 (x，y1) 和 (x，y2) 用于定义曲线，这些曲线形成一个或多个描述填充区域的多边形。- 通过使用“ 其中 ”参数，您可以忽略一些水平截面的填充。
- 默认情况下，边直接连接所提供的位置。但是，如果填充应该是阶跃函数(x 之间的常数)，则可以使用
"step"参数。
fill _ between 函数的语法是:
matplotlib.pyplot.fill_between(x, y1, y2=0, where=None,
interpolate=False,
step=False, *,
data=None, **kwargs)
fill _ between 函数的参数有:
| 参数 | 值 | 描述 |
| x | 长度为 N 的数组 | x 坐标的节点用于定义曲线。 |
| y1 | 长度为 N 或标量的数组 | 节点的 y 坐标，用于定义第一条曲线。 |
| y2 | 默认情况下，长度为 N 或标量
的数组:0 | 节点的 y 坐标，用于定义第二条曲线 |
| 在哪里 | 长度为 N 的布尔值数组 | 当需要从填充中排除一些水平区域时，使用它。这里，填充区域由坐标 x[其中]定义。更准确地说，在 x[i]和 x[i+1]之间填充 if where[i]和 where[i+1]。
注: 这个定义意味着一个孤立的 真值 在两个 假值 中 在 中不会导致填充。
由于邻近 假 值，两边的 真 位置仍然空着。 |
| 插入 | bool
默认为:False | 仅当使用了 where 参数并且两条曲线相交时，才使用此选项。 其中 用于 y1 > y2 或 类似 。
默认情况下，用于定义填充区域的多边形的节点仅插入 x 数组位置。上面的语义似乎无法描述这样的多边形。
x 截面中的交叉点被简单剪切。当您将“插值”设置为“真”时，填充区域将延伸到实际的交点。 |
| 步骤 | { '前'，'后'，'头脑' } | 如果填充是一个阶跃函数，即 x 之间的常数，则使用该参数。该值决定了阶跃将发生的位置:
“前”*:y 值从每个 x 位置持续向左。
*** " post ":y 值从每个 x 位置持续向右。
*“mid”:如果步进发生在 x 位置的中间。 |
| 数据 | 可转位对象 | 此参数还接受字符串，该字符串被解释为数据(除非出现异常)。 |
| ** kwargs | | 用于控制多边形属性的所有其他参数。 |
Parameters
退货:
从 PolyCollection 返回一个绘制的多边形。
另外，检查:画垂直线 matplotlib
Matplotlib fill_between 示例
这里我们将学习一个简单的 fill_between() 函数的例子。我们将使用 matplotlib 的 plot() 方法创建一个简单的线图，然后使用 fill_between 函数填充曲线下的整个区域。
源代码:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates**
x = [0, 1, 2, 3, 4, 5]
y = [1.5, 3, 5.3, 6, 10, 2]
**# Plot**
plt.plot(x, y, '-o', color='red')
**# fill_between**
plt.fill_between(x, y)
**# Add title**
plt.suptitle('Simple fill_between Example', fontweight='bold')
**# Display**
plt.show()
源代码说明:
- 为了导入 matplotlib 库，我们使用
import matplotlib.pyplot。 - 之后，我们定义 x 和 y 数据坐标，它们定义了曲线。
- 为了创建一个线图，我们使用
plt.plot()方法。 - 为了填充曲线下的整个区域，我们使用
plt.fill_between()方法。 - 然后我们添加一个 suptitle，通过使用
plt.suptitle()方法。 - 为了在用户的屏幕上可视化绘图，我们使用了
plt.show()方法。
输出:
fill_between
Matplotlib fill _ between color
这里我们将学习如何使用 Python 在 matplotlib 中用你选择的颜色填充图形区域。为此，我们必须将一个颜色参数传递给 fiil_between 函数，并设置您选择的颜色。
以下是语法:
matplotlib.pyplot.fill_between(x, y, color=None)
源代码:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates**
x = [0, 1, 2, 3, 4, 5]
y = [1.5, 3.6, 4.6, 5, 8, 2.5]
**# Plot**
plt.plot(x, y, '-o')
**# fill_between**
plt.fill_between(x, y, color='yellow')
**# Add title**
plt.suptitle('fill_between color', fontweight='bold')
**# Display**
plt.show()
源代码说明:
- 首先，我们导入
matplotlib.pyplot库。 - 之后，我们定义定义曲线的数据坐标。
- 为了绘制折线图，我们使用 matplotlib 的
plt.plot()方法。 - 然后用你选择的颜色填充曲线下的区域，我们将
color作为参数传递给fill_between函数。 - 通过使用
plt.suptitle()方法，我们定义了绘图的标题。 - 为了在用户屏幕上可视化图表，我们使用了
plt.show()方法。
生成的图表:
fill_between(color=’yellow’)
Matplotlib fill _ between hatch
在本节中，我们将了解填充 _ 在和之间填充。我们已经在上述主题中学习了 fill_between 。现在是时候学习一些关于舱口的知识了。
在大多数情况下，我们在创建地块时使用颜色填充背景，但在以下情况下，使用图案填充背景是一种很好的替代方法:
- 当绘图包括黑白背景时。
- 当我们想减少颜色的数量时。
为了用图案填充图，我们分配一个新的参数影线，其值为一个字符串。部分字符串值有: / 、 \ 、 | 、–、 + 、 x 、 o 、。， *
语法如下:
matplotlib.pyplot.fill_between(x, y, hatch=None)
源代码:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates**
x = [2, 6]
y = [2, 6]
**# Plot**
plt.plot(x, y)
**# fill_between**
plt.fill_between(x, y, color= 'none', hatch="o",
edgecolor="g")
**# Display**
plt.show()
源代码说明:
- 这里我们用一个绕过 matplotlib 的
fill_between()方法的hatch参数的图案填充曲线下面的整个区域。我们还将none分配给color参数，这样背景就保持了纯色。 - 我们将绿色分配给边缘颜色参数。
输出:
fill_between(hatch=’o’)
Matplotlib fill_between 步骤
这里我们将学习步骤参数。如果填充应在 x 之间保持不变，则使用该参数。
以下是语法:
matplotlib.pyplot.fill_between(x, y, step=None)
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.linspace(20, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)
**# Plot**
plt.plot(x, y1)
plt.plot(x, y2)
**# fill_between**
plt.fill_between(x, y1, step="pre", alpha=0.2)
plt.fill_between(x, y2, step="pre", alpha=5.5)
**# Display**
plt.show()
说明:
- 这里我们导入了
matplotlib.pyplot和numpy库。 - 之后，我们使用
numpy定义数据坐标。 - 为了绘制曲线 (x，y1) 和 (x，y2) ，我们使用 matplotlib 的
plt.plot()方法。 - 为了填充曲线下方的区域，我们使用了
fill_between()方法，并使用step参数传递x和y，并将它们赋值为"pre"。该值决定了该步骤发生的位置。 - 要显示该图，请使用
show()方法。
输出:
fill_between(step=’pre’)
Matplotlib fill_between 阴影颜色
这里我们将了解当我们使用 color 作为参数来指定颜色时，hatch 会发生什么。
以下是语法:
matplotlib.pyplot.fill_between(x, y, hatch=None, color=None)
源代码:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates**
x = [1, 3]
y = [1, 3]
**# Plot**
plt.plot(x, y)
**# fill_between**
plt.fill_between(x, y, hatch='+', color='red')
**# Display**
plt.show()
说明:
- 在上面的例子中，我们定义了数据坐标 x 和 y，并使用 matplotlib 的
plt.plot()方法绘制曲线。 - 之后，我们使用带有
x、y、阴影、和颜色的fill_between()函数作为参数，并分别将它们的值设置为 x 坐标、 y 坐标、+和红色。
输出:
hatch with color
观察:
指定颜色时，阴影在输出中不可见。
Matplotlib 面间填充颜色
这里我们将看到一个例子，其中我们使用了带有 facecolor 参数的 fill_between() 函数。
以下是语法:
matplotlib.pyplot.fill_between(x, y, hatch=None, facecolor=None)
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.linspace(20, 10, 100)
y = np.sin(x)
**# Plot**
plt.plot(x, y)
**# fill_between**
plt.fill_between(x, y, hatch='O', facecolor='yellow')
**# Display**
plt.show()
源代码说明:
- 在上面的例子中，我们使用 numpy 的
linespace()和sin()方法来定义数据坐标。 - 为了绘制曲线，我们使用 matplotlib 的
plt.plot()方法。 - 然后我们使用带有
x、y、hatch和facecolor参数的fill_between()方法。
fill_between(facecolor=’yellow’)
结论:
当使用 facecolor 参数时，阴影在输出中可见，但当我们使用 color 参数时，阴影不可见。
Matplotlib fill_between 影线密度
在这里，我们将学习如何增加填充图案的密度。为了获得更密集的图案，我们必须将偶数中的图案串分配给影线参数。
以下是语法:
matplotlib.pyplot.fill_between(x, y, hatch=string pattern in even number)
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.linspace(20, 10, 100)
y = np.cos(x)
**# Plot**
plt.plot(x, y)
**# fill_between**
plt.fill_between(x, y, hatch='\\\\', facecolor='cyan')
**# OR**
plt.fill_between(x, y, hatch='\\\\\\\\', facecolor='cyan')
**# Display**
plt.show()
说明:
- 这里我们使用带有
facecolor和hatch参数的fill_between()方法，并将它们的值分别设置为青色、反斜杠。 - 在第一种情况下，我们通过 4 个反斜杠，在第二种情况下，我们通过 8 个反斜杠。
输出:
With 4 slashes
With 8 slashes
结论:
我们得出结论，我们可以通过增加图案的数量来增加影线的密度。
Matplotlib fill _ between where
这里我们将学习一下 fill_between() 方法的 where 参数。当需要从填充中排除一些水平区域时，使用该参数。
以下是语法:
matplotlib.pyplot.fill_between(x, y, where= condition applied )
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.linspace(0,10,25)
y = np.sin(x)
**# Plot curves**
plt.plot(x,y, color='k')
**# fill_between**
plt.fill_between(x, y, where = (x > 5) & (y <= 4),
color = 'orange')
**# Display**
plt.show()
说明:
- 在上面的例子中，我们首先导入重要的库，如
matplotlib.pyplot和numpy。 - 之后，我们通过使用
numpy函数来定义数据坐标。 - 要绘制曲线，请使用 pyplot 的
plot()方法。 - 接下来，我们使用带有的
fill_between()方法，其中参数指定了填充区域的条件。这里我们指定填充 x > 5 和 y < =4 之间区域的条件。
fill_between(where)
三行之间的 Matplotlib 填充
在本节中，我们将看到在填充三条线之间的区域时使用 fill_between 。
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data**
x = np.linspace(0,3,100)
y1 = X**4 + 20
y2 = np.exp(X) + 5
y3 = np.sin(X)
**# Plot**
plt.plot(x , y1, color='k')
plt.plot(x, y2, color='k')
plt.plot(x, y3, color='k')
**# fill_between**
plt.fill_between(x, y1, y2, color='red')
plt.fill_between(x, y2, y3, color='yellow')
**# Display**
plt.show()
说明:
- 在上面的例子中，我们创建了三个线条图，通过使用
fill_between()方法，我们用不同的颜色填充线条之间的区域。 - 首先，我们使用
fill_between()方法填充 y1 和 y2 之间的区域，并使用参数color设置红色。 - 然后，我们使用
fill_between()方法填充 y2 和 y3 之间的区域，并使用颜色参数将其颜色设置为黄色。
fill between three lines
阅读:在 Python 中添加文本到 plot matplotlib
两条曲线之间的 Matplotlib 填充
这里我们看到一个例子，我们使用 fill_between() 方法填充两条曲线之间的区域。
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data**
x = np.arange(0.01,20,0.1)
y1 = 5.0 / np.exp(x)
y2 = np.log(x)
**# Plot**
plt.plot(x, y1, color='k')
plt.plot(x, y2, color='k')
**# fill_between**
plt.fill_between(x, y1, y2, color='red')
**# Display**
plt.show()
- 这里我们使用 numpy 的
arange()、exp()、log()方法来创建曲线。 - 然后我们使用
fill_between()方法填充曲线之间的区域。
fill between curves
阅读: Matplotlib 条形图标签
散点间 Matplotlib 填充
这里我们将看到一个例子，我们使用 matplotlib 库的 fill_between 方法填充散点图之间的区域。
源代码:
**# Import library**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data**
x = np.arange(0, 20, 0.2)
y1 = np.sin(x)
y2 = np.cos(x)
**# Scatter Plot**
plt.scatter(x, y1)
plt.scatter(x, y2)
**# fill_between**
plt.fill_between(x, y1, where = (x <=3 ) & (y1 <= 4))
**# Display**
plt.show()
这里我们使用 plt.scatter() 方法创建一个散点图，然后使用 fill_between() 方法填充 x < = 3 和 y1 < =4 的区域。
fill between scatter
阅读:Matplotlib set _ yticklabels–实用指南
虚线之间的 Matplotlib 填充
这里我们将看到一个虚线图的例子。
源代码:
**# Import library**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data coordinates**
x = np.arange(2, 8, 0.2)
y = x*2
**# Plot**
plt.plot(x,y,'k--', linewidth = 8)
**# fill_between**
plt.fill_between(x, y, np.min(x), color='m')
**# Display**
plt.show()
说明:
- 在上面的例子中，我们导入了
matplotlib.pypplot和numpy库。 - 接下来，我们使用 numpy 的
arange()方法定义数据坐标。 - 然后我们使用
plot()方法和linestyle参数在 x 和 y 之间绘制一条虚线。 - 为了填充两条水平曲线之间的区域，我们使用了
fill_between()方法，我们还将区域的颜色指定为洋红色。
fill between dashed
阅读:Matplotlib tight _ layout–有用教程
圆圈之间的 Matplotlib 填充
在这里，我们将看到一个例子，我们填补了圆圈之间的颜色。
源代码:
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
**# Create subplots**
figure, axes = plt.subplots( 1 )
**# Define Data**
data = np.linspace( 0 , 2 * np.pi , 150 )
radius = 0.6
a = radius * np.cos( data )
b = radius * np.sin( data )
**# Plot**
axes.plot( a, b )
**# fill between**
plt.fill_between(a, b, facecolor='yellow')
**# Display**
plt.show()
- 这里我们用圆的参数方程画一个圆。
- 之后，我们使用
fill_between()方法填充圆之间的区域。
fill between circle
阅读:Python Matplotlib tick _ params
两行之间的 Matplotlib 填充
在这里，我们将看到一个例子，我们将阴影两条线之间的区域。
源代码:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data coordinates**
x = [0, 1, 2, 3, 4, 5]
y1 = [30, 60, 90, 120, 150, 180]
y2 = [20, 40, 60, 80, 100, 120]
**# Shade the region**
plt.fill_between(x, y1, y2, facecolor='pink')
**# Show the plot**
plt.show()
这里我们使用 fill_between() 方法对两条线之间的区域进行着色。我们还传递了 facecolor 参数，并将其值设置为 pink 。
fill between two lines
读取: Matplotlib x 轴标签
Matplotlib fill _ between alpha
这里我们将学习在 fill_between()方法中使用 alpha 参数。通过使用一个 alpha 属性，我们可以调节图形绘制的透明度，默认情况下， alpha=1 。
以下是语法:
matplotlib.pyplot.fill_between(x, y, facecolor=None, alpha=1)
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.arange(2, 8, 0.2)
y = np.sin(30*x)
**# Plot**
plt.plot(x, y)
**# fill_between**
plt.fill_between(x, y, facecolor='blue', alpha=0.2)
**# Display**
plt.show()
在这里，我们将使用 fill_between() 方法对区域进行着色，我们还将传递 facecolor 和 alpha 参数来分别设置绘图的颜色和透明度。
输出:
fill_between(alpha=1)
阅读: Matplotlib 多条形图
Matplotlib fill _ between log scale
在本节中，我们将学习在 matplotlib python 中以对数比例填充曲线下的区域。为了创建对数刻度，我们将轴的刻度设置为对数。
设置坐标轴刻度的语法:
**# For x-axis**
matplotlib.pyplot.xscale('log')
**# For y-axis**
matplotlib.pyplot.yscale('log')
我们来看一个例子:
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.linspace(-5, 5, 100)
y = np.sin(x)
**# Plot**
plt.plot(x, y)
**# fill_between**
plt.fill_between(x, y)
**# Log scale**
plt.xscale('log')
plt.yscale('log')
**# Display**
plt.show()
说明:
- 我们导入了
matplotlib.pyplot和numpy库。 - 接下来，我们使用
numpy创建数据点。 - 然后，我们使用
plot()方法绘制 x 和 y 数据点。 - 为了填充曲线之间的区域，我们使用了
fill_between()方法。 - 为了创建一个对数刻度，我们设置轴的刻度。
- 要显示该图，请使用
show()方法。
输出:
fill_between log scale
阅读: Matplotlib 散点图图例
Matplotlib fill_between 图例
我们将在这里学习向 fill_between 图添加图例。
以下是语法:
matplotlib.pyplot.fill_between(x,y, y1, label=)
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.linspace(-2, 2, 100)
y1 = np.sin(x)
y2 = np.cos(x)
**# Plot**
plt.plot(x, y1, color='k', label='Sin')
plt.plot(x, y2, color='k', label='Cos')
**# fill_between**
plt.fill_between(x, y1, y2, color='cyan', label='Area')
**# Add legend**
plt.legend()
**# Display**
plt.show()
说明:
- 我们导入
matplotlib.pyplot和numpy库。 - 使用
numpy创建 x、y1 和 y2 数据点。 - 为了绘制 x、y1 和 y2 数据点，我们使用了
plot()方法。 fill_between()方法用于填充两条曲线之间的区域。- 为了在图上放置一个图例，我们使用了
legend()方法。 - 要显示该图，请使用
show()方法。
输出:
fill_between(label=)
Matplotlib fill_between 线条颜色
这里我们将学习如何用填充 _ 间隔方法改变线条颜色。要改变线条的颜色，我们必须将参数 edgecolor 传递给这个方法。
以下是语法:
matplotlib.fill_between(x, y1, y2, edgecolor=None)
源代码:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data coordinates**
x = [0, 1, 2, 3, 4, 5]
y1 = [30, 60, 90, 120, 150, 180]
y2 = [20, 40, 60, 80, 100, 120]
**# Shade the region**
plt.fill_between(x, y1, y2, facecolor='pink',
edgecolor='green')
**# Show the plot**
plt.show()
说明:
- 我们导入
matplotlib.pyplot方法。 - 接下来，我们定义数据坐标 x、y1 和 y2。
- 为了填充曲线之间的区域，我们使用
fill_between()方法，并传递facecolor参数来设置颜色。 - 为了用
fill_between()方法改变线条颜色，我们将edgecolor参数传递给该方法。这里我们设置线条颜色为绿色。
输出:
fill_between(edgecolor=None)
Matplotlib fill_between 线宽
这里我们将学习如何用 fill_between 方法改变线宽。基本上，线宽参数在曲线之间的填充周围画一个边界。
以下是语法:
matplotlib.fill_between(x, y1, y2, linewidth=None)
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.linspace(-3, 3, 1000)
y = np.sin(x)
**# fill_between with linewidth**
plt.fill_between(x, y, facecolor='orange', linewidth=15,
edgecolor='k')
**# Display**
plt.show()
说明:
- 我们使用
numpy定义数据坐标。 - 为了填充曲线下的区域，我们使用了
fill_between()方法。 - 为了设置绘图的表面颜色和边缘颜色，我们传递表面颜色和边缘颜色参数，并分别设置它们的值橙色和黑色。
- 为了改变线条或边缘的宽度，我们传递线宽参数，并将其值设置为
15。它会在曲线周围创建一个边界。
输出:
fill_between(linewidth=15)
Matplotlib fill _ between no edge
这里，我们将填充曲线之间或之下没有边缘的区域。为此，我们必须将线宽设置为零。
以下是语法:
matplotlib.pyplot.fill_between(x, y, linewidth=0)
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.linspace(-3, 3, 1000)
y = np.cos(x)
**# fill_between no edges**
plt.fill_between(x, y, facecolor='m', linewidth=0)
**# Display**
plt.show()
在上面的例子中，我们将线宽设置为零，并将其传递给 fill_between 方法，以获得没有边缘的曲线。
输出:
fill_between no edges
Matplotlib fill _ between edge
这里我们要用边缘填充曲线之间或之下的区域。为此，我们必须将线宽设置为某个值。
以下是语法:
matplotlib.pyplot.fill_between(x, y, color=None, linewidth=20)
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.linspace(-3, 3, 1000)
y = np.cos(x)
**# Plot**
plt.plot(x, y)
**# fill_between no edges**
plt.fill_between(x, y, color='yellow', linewidth=20)
**# Display**
plt.show()
- 在上面的例子中，我们使用
fill_between()方法来填充曲线之间的区域。这里我们还设置了颜色绕过方法的颜色参数。 - 我们增加了宽度，绕过了该方法的线宽参数，因此我们得到了带有边缘的绘图。
fill_between(linewidth=20)
阅读: Matplotlib 绘图条形图
Matplotlib fill _ between edge color
这里我们看到了一个例子，在 fill_between 方法中的 edgecolor 参数。
举例:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.linspace(-3, 3, 1000)
y = np.cos(x)
**# fill_between edge color**
plt.fill_between(x, y, color='pink', edgecolor='red')
**# Display**
plt.show()
fill_between(edgecolor=None)
阅读: Python 使用 Matplotlib 绘制多条线
Matplotlib fill _ between datetime
这里我们看到了日期时间图中的 fill_between() 方法的一个例子。
源代码:
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
**# Define Data**
N = 500
dates = pd.date_range('2021-5-1', periods=N, freq='D')
x = np.linspace(0, 5, N)
data = pd.DataFrame({'A': np.cos(x), 'B': np.sin(x),
'Date': dates})
**#Plot**
plt.plot_date(data['Date'], data['A'], '-')
plt.plot_date(data['Date'], data['B'], '-')
d = data['Date'].values
**# fill_between**
plt.fill_between(d, data['A'], data['B'],
where=data['A'] <= data['B'],
facecolor='yellow')
**# Rotation of xticks**
plt.xticks(rotation=45)
**# Display**
plt.show()
- 在上面的例子中，我们导入了导入库，比如
matplotlib、numpy和pandas。 - 之后，我们使用 pandas 的
date_range()方法和 numpy 的sin()和cos()方法定义数据坐标。 - 然后我们用
plt.plot_date()方法来绘制日期。 - 为了填充日期图曲线之间的区域，我们使用带有参数的
fill_between()方法。 - 我们还设置了 xtciks 的旋转,以避免 x 轴上的日期重叠。
- 要显示绘图，使用
show()方法。
fill_between()
Matplotlib 填充范围之间
这里我们看到一个使用 python 的 range() 方法定义数据坐标的例子。为了填充曲线下方的区域，我们使用了 fill_between() 方法。
下面是 range()方法的语法:
range(start, stop, step)
源代码:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates**
x = range(3, 20, 2)
y = range(5, 22, 2)
**# Plot**
plt.plot(x, y)
**# fill_between**
plt.fill_between(x, y, facecolor='green')
**# Display**
plt.show()
- 在上面的源代码中，我们导入了
matplotlib.pyplot库。 - 然后我们使用 python 的
range()方法定义数据坐标。 - 要绘制图形，请使用
plot()方法。 - 要填充曲线下方的区域，使用
fill_between()方法。
输出:
range(start, stop, step)
误差线之间的 Matplotlib 填充
我们知道如何使用误差线在图表上显示误差。现在，我们将学习如何使用 fill_between 方法来消除错误。
以下是语法:
matplotlib.pyplot.fill_between(x, y-lower, y-upper)
以下是参数:
- x: 指定绘图的 x 坐标。
- lower: 指定阴影区域的底部。
- 上部:指定阴影区域的顶部。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates**
x = range(8)
y = [10, 12, 13, 13, 20, 22, 23, 29]
**# Define errors**
y_lower_error = [8, 10, 11, 17, 18, 20, 21, 27]
y_upper_error = [12, 14, 15, 15, 17, 24, 25, 31]
**# plot**
plt.plot(x, y)
**# fill_between**
plt.fill_between(x, y_lower_error, y_upper_error,
facecolor='yellow')
**# Display**
plt.show()
在上面的例子中，我们使用 fill_between 方法来对错误进行着色，因此我们将 x 、 y_lower_error 、 y_upper_error、和 facecolor 传递给该方法。
Shade Errors
两条垂直线之间的 Matplotlib 填充
我们将学习填充两条垂直线或曲线之间的区域。为了填充这个区域，我们使用 fill_betweenx()方法。这里，曲线由点(y，x1)和(y，x2)定义。
以下是语法:
matplotlib.pyplot.fill_betweenx(y, x1, x2, where=None, step=None,, interpolate=False, * , data=None, **kwargs)
我们来看一个例子:
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.arange(0, 30, 0.2)
y = np.arange(30, 60, 0.2)
**# Plot**
plt.plot(x,y)
**# Vertical line**
plt.fill_betweenx(y, 15, 20, facecolor='green')
**# Display**
plt.show()
在上面的源代码中，我们使用了 fill_betweenx() 方法来填充两条垂直线之间的区域。
fill_betweenx()
两条水平线之间的 Matplotlib 填充
我们将学习填充两条水平线或曲线之间的区域。为了填充这个区域，我们使用了 fill_between() 方法。这里，曲线由点(x，y1)和(x，y2)定义。
以下是语法:
matplotlib.pyplot.fill_betweenx(x, y1, y2, where=None, step=None,, interpolate=False, * , data=None, **kwargs)
我们来看一个例子:
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.arange(0, 30, 0.2)
y = np.arange(30, 60, 0.2)
**# Plot**
plt.plot(x,y)
**# Horizontal line**
plt.fill_between(x, 30, 35, facecolor='m')
**# Display**
plt.show()
说明:
- 在上面的例子中，我们导入了
matplotlib.pyplot和numpy库。 - 接下来，我们使用 numpy 的
arange()方法定义数据坐标。 - 然后使用
plot()方法绘制直线。 - 要填充两条水平线之间的区域，请使用
fill_between()方法。 - 要显示该图，请使用
show()方法。
fill_between()
Matplotlib 填充在顶部之间
在这里，我们将学习填充曲线上方的颜色。
让我们看看与此相关的例子:
例#1
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.arange(0, 50, 0.5)
y = x**5
**# Plot**
plt.plot(x,y)
**# Top of curve**
plt.fill_between(x, y, np.max(y), facecolor='chocolate')
**# Display**
plt.show()
在上面的例子中，为了填充曲线顶部的颜色，我们使用了带有参数 max(y) 的 fill_between() 方法。
max(y)
例 2
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.arange(0, 50, 0.2)
y = np.cos(30*x)
**# Plot**
plt.plot(x,y)
**# Top of the curve**
plt.fill_between(x, y, 1, facecolor='lime')
**# Display**
plt.show()
在上面的例子中，我们使用 fill_between 方法在绘图中填充颜色。这里，曲线由点 (x，y1) 和 (x，y2) 定义。为了填充曲线上方的区域，我们设置 y2 = 1 。
输出:
y2=1
Matplotlib 填充 _ 熊猫之间
我们将学习填充使用熊猫数据框创建的曲线之间的区域。
源代码:
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
**# Define Data**
N = 100
dates = pd.date_range('2020-5-1', periods=N)
x = np.linspace(0, 10, N)
data = pd.DataFrame({'X': np.exp(x), 'Y': np.sin(x),
'Date': dates})
**# Plot**
plt.plot_date(data['Date'], data['X'], '-')
plt.plot_date(data['Date'], data['Y'], '-')
d = data['Date'].values
**# fill_between**
plt.fill_between(d, data['X'], data['Y'],
where=data['X'] > data['Y'],
facecolor='lightgray')
**# Rotation of xticks**
plt.xticks(rotation=45)
**# Display**
plt.show()
fill_between Pandas
Matplotlib 在 0 之间填充
我们将学习在区域 y1 和 0 之间填充颜色。
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.arange(0, 10, 0.5)
y = np.sin(30*x)
**# Plot**
plt.plot(x,y)
**# Between y1 and 0**
plt.fill_between(x, y, 0, facecolor='lightcoral')
**# Display**
plt.show()
在上面的例子中，我们使用 fill_between() 函数来填充曲线中的颜色。这里我们设置 y1 = y 和 y2 = 0 在 0 之间填充。
输出:
fill between 0
点与点之间的 Matplotlib 填充
我们将学习填充点之间的区域。这里我们用点来定义数据坐标。
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates in ponts**
X=[5, 10, 15, 20, 25, 30, 35]
Y=[35, 20, 10, 8, 6, 12, 15]
**# Plot**
plt.plot(Y,X,'ro-')
**# fill_between points**
plt.fill_betweenx(X, Y, 35, color='wheat')
**# Display**
plt.show()
- 在上面的例子中，我们导入了
matplotlib.pyplot库。 - 在这之后，我们通过定义点来定义数据坐标。
- 为了绘制数据，我们使用了
plot()函数。 - 要填充颜色，使用
fill_between()函数，其中我们设置 x= x，y1 = y，y2 =40。
fill_between()
不同颜色之间的 Matplotlib 填充
在这里，我们将学习根据条件用不同的颜色填充曲线之间的区域。
让我们看一个例子来理解这个概念:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.arange(0, 50, 0.2)
y = np.cos(30*x)
**# Plot**
plt.plot(x,y)
**# Different colors**
plt.fill_between(x, y, 1, where=(x>=20), facecolor='teal')
plt.fill_between(x, y, 1, where=(x<=20), facecolor='plum')
**# Display**
plt.show()
- 在上面的例子中，我们导入了重要的库，如
matplotlib.pyplot和numpy。 - 之后，我们使用 numpy 定义数据坐标。
- 要绘制曲线，使用
plot()方法。 - 然后使用
fill_between()方法填充曲线之间的区域，然后我们将根据条件设置曲线区域的颜色。
Different colors
样式间 Matplotlib 填充
我们将学习根据情况用不同的风格填充一个情节。为了填充样式，我们使用了 fill_between() 方法中的 hatch 和 facecolor 参数。
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.arange(0, 80, 0.2)
y = np.sin(x)
**# Plot**
plt.plot(x,y)
**# fill_between style**
plt.fill_between(x, y, 1, where=(x>10) & (x<=20), hatch='\\\\', facecolor='lightgray')
plt.fill_between(x, y, 1, where=(x>20) & (x<=40), hatch='xx', facecolor='peachpuff')
plt.fill_between(x, y, 1, where=(x>40) & (x<=60), hatch='...', facecolor='honeydew')
plt.fill_between(x, y, 1, where=(x>60) & (x<=80), hatch='*', facecolor='thistle')
plt.fill_between(x, y, 1, where=(x<=10), hatch='o', facecolor='mistyrose')
**# Display**
plt.show()
说明:
- 在上面的例子中，我们导入了重要的库，如
matplotlib.pyplot和numpy。 - 然后我们使用 numpy 的
arange()和sin()方法定义数据坐标。 - 要绘制曲线，使用
plot()方法。 - 要根据条件用不同的样式填充曲线区域，使用
hatch和facecolor参数和fill_between()方法。 - 要在用户的屏幕上可视化绘图，使用
show()方法。
输出:
Different Styles
用于 fill_between 的 Matplotlib 标签
我们将看到一个绘图示例，其中我们使用 fill_between() 函数来填充曲线下的区域，我们还定义了绘图的 x 轴和 y 轴标签。
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.linspace(20, 10, 50)
y = np.cos(45*x)
**# Plot**
plt.plot(x, y)
**# fill_between**
plt.fill_between(x, y, facecolor='pink')
**# Labels**
plt.xlabel('X-Axis')
plt.ylabel('Y-Axis')
**# Display**
plt.show()
- 这里我们使用 numpy 的
linespace()和cos()方法定义数据坐标。 - 然后我们使用
plot()方法绘制曲线。 - 要填充区域之间的区域，请使用
fill_between()方法。 - 然后我们使用
xlabel()和ylabel()方法设置轴标签。
xlabel() and ylabel()
Matplotlib fill_between 插值
这里我们将学习 fill_between() 函数的插值参数。该参数仅在使用参数的处使用。当两条曲线相互交叉时，也使用该参数。
将插值参数设置为真将计算实际交点，并将填充区域延伸到该点。
以下是语法:
matplotlib.pyplot.fill_between(x, y, y1, where=None, interpolate=True)
举例:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data Coordinates**
x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
y = [6, 7.5, 8.3, 8, 9.2, 8.5, 9.4, 8.7, 8.8, 8.9, 7.4, 9.5, 5]
y1 = 8.9
z1 = np.array(y)
z2 = np.array([y1] * 13)
**# Plot**
plt.plot(x, y)
**# Fill between**
plt.fill_between(x, y, y1,
where=(z1 < z2),
color='maroon', interpolate=True)
plt.fill_between(x, y, 8.9,
where=(z1 >= z2),
color='cadetblue', interpolate=True)
**# Display**
plt.show()
fill_between(interpolate=True)
Matplotlib fill_between 置信区间
我们将在 fill_between() 函数中使用置信区间。首先，我们要明白置信区间是什么意思。
置信区间 是对未知参数的一个估计范围，由一个下界和一个上界定义。
以下是语法:
matplotlib.fill_between(x, (y-ci), (y+ci))
这里 ci 是置信区间。
举例:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.arange(0, 20, 0.05)
y = np.cos(x)
**# Define the confidence interval**
ci = 0.05 * np.std(y) / np.mean(y)
**# Plot**
plt.plot(x, y)
**# Plot the confidence interval**
plt.fill_between(x, (y-ci), (y+ci), facecolor='gold',
alpha=0.5)
plt.fill_between(x, (y-2*ci), (y+2*ci),
facecolor='springgreen', alpha=0.5)
plt.fill_between(x, (y-3*ci), (y+3*ci), facecolor='plum',
alpha=0.2)
**# Display**
plt.show()
说明:
- 这里我们导入
matplotlib.pyplot和numpy库。 - 然后我们用 numpy 定义数据坐标 x 和 y。
- 然后我们将
y-ci和y+ci参数传递给fill_between()方法，分别定义函数 y 周围的下区间和上区间。 - 我们还将
facecolor和alpha参数传递给该方法。
输出:
Confidence Interval
Matplotlib 填充间标准差
在这里，我们将绘制置信区间的标准差。要查找标准偏差，请使用 numpy 的 std() 方法。
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates**
x = np.arange(0, 40, 0.05)
y = np.sin(x)
**# Define the standard deviation**
sd = np.std(y)
**# Plot**
plt.plot(x, y)
**# Plot the Standard Deviation**
plt.fill_between(x, (y-sd), (y+sd), facecolor='gold', alpha=0.5)
**# Display**
plt.show()
使用 plt.fill_between(x，(y-sd)，(y+sd)) 函数，在函数值 y 周围绘制一个带有标准差和上下区间边界的填充区间，即 y-sd 和 y+sd 。
Standard Deviation
x 轴之间的 Matplotlib 填充
我们将学习填充曲线和 x 轴之间的区域。
举例:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data Coordinates**
x = np.linspace(-1, 1, 100)
y = np.cos(x)
**# Plot**
plt.plot(x, y)
**# Fill the region with color**
plt.fill_between(x, 0, y, facecolor='olive')
**# Display the plot**
plt.show()
- 这里我们使用 numpy 创建了
x和y数据坐标。 - 使用
plot()方法绘制数据坐标。 - 要填充曲线和 x 轴之间的区域，使用
fill_between()函数 - 要显示绘图，使用
show()方法。
多边形之间的 Matplotlib 填充
这里我们学习创建一个多边形，然后使用 fill_between() 函数填充多边形之间的区域。
举例:
**# Import Library**
from shapely.geometry import Polygon
import matplotlib.pyplot as plt
**# Create Polygon**
pol = Polygon([(0, 7),
(1, 2),
(6, 0),
(4, 8) ])
x, y = pol.exterior.xy
**# PLot**
plt.plot(x, y)
**# Fill between**
plt.fill_between(x, y, facecolor='thistle')
**# Display**
plt.show()
- 使用
x和y数据点创建多边形。 - 使用
polygon.exterior.xy获取 x 和 y、外部数据和数组。 - 要绘制多边形，请使用
plot()方法。 - 要填充多边形之间的区域，使用
fill_between函数。
Polygon
Matplotlib 填充 _ 极坐标间
这里我们将绘制一个极坐标图，并使用 fill_between 方法填充它们之间的区域。
举例:
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
**# Define Data Coordinates**
x = np.arange(0, 2, 1./200)*np.pi
y = abs(6*np.cos(4*x))
y1 = 2 + 0*x
**# Plot Polar Coordinates**
plt.polar(x, y, lw=3)
plt.polar(x, y1, lw=3)
**# Fill Between**
plt.fill_between(x, y, y1, facecolor='purple')
**# Display**
plt.show()
fill_between()
Matplotlib fill_between 动画
在这里，我们将学习如何用动画填充绘图区域之间的区域。
我们来看一个例子:
**# Interactive Mode**
%matplotlib notebook
**# Import Library**
import numpy as np
from matplotlib import pyplot as plt
from matplotlib import animation
**# Define Data**
X = np.arange(0, 40, 0.05)
Y = np.cos(X)
fig = plt.figure(figsize=(8, 4))
ax = plt.axes(xlim=(0,5), ylim=(-1,1.5))
line, = ax.plot([], [])
def init():
line.set_data([], [])
return line,
def animate(i):
x = X[0:(i-1)]
y = Y[0:(i-1)]
line.set_data(x,y)
p = plt.fill_between(x, y, 0, facecolor = 'firebrick', alpha=0.2)
return line, p
**# Animation**
ani = animation.FuncAnimation(fig, animate, init_func=init,
frames = 1000, interval=5)
**# Display**
plt.show()
- 在上面的例子中，我们首先启用交互模式。
- 然后我们导入
numpy、pyplot和动画库。 - 接下来，我们使用 numpy 的
arange()和cos()方法定义数据坐标。 plt.figure()方法用于创建一个图。- 要填充曲线之间的区域，使用
fill_between()方法。 - 通过使用动画。FuncAnimation() 方法我们给剧情添加动画。
- 然后，最后我们使用
save()方法将一个情节保存为gif。
Animation
因此，在这个 Python 教程中，我们已经讨论了“Matplotlib fill _ between”，并且我们也涵盖了一些与之相关的例子。这些是我们在本教程中讨论过的以下主题。
- Matplotlib 填充 _ 之间
- Matplotlib fill_between 示例
- Matplotlib 填充 _ 颜色之间
- Matplotlib 填充 _ 填充线之间
- Matplotlib 填充 _ 步间
- Matplotlib fill_between 阴影颜色
- 面颜色之间的 Matplotlib 填充
- Matplotlib fill_between 图案填充密度
- Matplotlib fill_between where
- 三行之间的 Matplotlib 填充
- 两条曲线之间的 Matplotlib 填充
- 散点之间的 Matplotlib 填充
- 虚线之间的 Matplotlib 填充
- 圆之间的 Matplotlib 填充
- 两行之间的 Matplotlib 填充
- Matplotlib fill_between alpha
- Matplotlib 填充 _ 对数刻度之间
- Matplotlib 填充 _ 图例之间
- Matplotlib fill_between 线条颜色
- Matplotlib fill_between 线条宽度
- Matplotlib fill_between 无边缘
- Matplotlib 填充 _ 边缘之间
- Matplotlib 填充 _ 边缘颜色之间
- Matplotlib fill_between datetime
- 范围之间的 Matplotlib 填充
- 误差线之间的 Matplotlib 填充
- 两条垂直线之间的 Matplotlib 填充
- 两条水平线之间的 Matplotlib 填充
- 顶部之间的 Matplotlib 填充
- 熊猫之间的 Matplotlib 填充
- 0 之间的 Matplotlib 填充
- 点之间的 Matplotlib 填充
- 不同颜色之间的 Matplotlib 填充
- Matplotlib 填充样式间
- fill_between 的 Matplotlib 标签
- Matplotlib fill_between 插值
- Matplotlib fill_between 置信区间
- 标准偏差之间的 Matplotlib 填充
- x 轴之间的 Matplotlib 填充
- 多边形之间的 Matplotlib 填充
- Matplotlib 填充 _ 极坐标间
- Matplotlib fill_between animation
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib 增加地块大小
在本 Python Matplotlib 教程中，我们将讨论 Python 中的 Matplotlib 增加绘图大小。这里我们将介绍与使用 matplotlib 增加地块大小的相关的不同示例。此外，我们还将涵盖以下主题:
- Matplotlib 增加地块大小
- Matplotlib 增加绘图大小 jupyter
- Matplotlib 增加情节大小支线剧情
- matplotlib py plot set _ size _ inches
- 熊猫 matplotlib 增加地块大小
- Matplotlib 更改图形大小和 dpi
- Matplotlib 图变化点大小
- Matplotlib 以像素为单位设置绘图大小
- Matplotlib 更改默认绘图大小
- Matplotlib 更改条形图绘图大小
- Matplotlib 更改散点图大小
- Matplotlib 设置绘图窗口大小
- Matplotlib 更改图形大小 fig ax
- Matplotlib 以厘米为单位设置绘图大小
目录
- Matplotlib 增加地块大小
- Matplotlib 增加地块大小 jupyter
- Matplotlib 增加剧情尺寸支线剧情
- Matplotlib py plot set _ size _ inches
- 熊猫 matplotlib 增加地块大小
- Matplotlib 改变图形尺寸和 dpi
- Matplotlib 图变化点大小
- Matplotlib 以像素为单位设置绘图大小
- Matplotlib 改变默认绘图大小
- Matplotlib 改变柱状图尺寸
- Matplotlib 改变散点图大小
- Matplotlib 改变图尺寸 fig ax
- Matplotlib 以厘米为单位设置绘图尺寸
Matplotlib 增加地块大小
绘图是一种很好的方法，可以图形化地描述数据，并以视觉上吸引人的方式进行总结。然而，如果绘制不当，它似乎是复杂的。
在 matplotlib 中，我们有几个库来表示数据。在 matplotlib 中创建地块时，纠正它们的大小很重要，这样我们就可以正确地显示地块的所有特征。
同样，检查: Matplotlib 绘制一条线
Matplotlib 增加地块大小 jupyter
在本节中，我们将学习在 jupyter 笔记本中使用 matplotlib 来增加绘图的大小。
语法如下:
matplotlib.pyplot.rcParams["figure.figsize"]
以上语法用于以英寸为单位增加绘图的宽度和高度。默认宽度为 6.4 ，高度为 4.8 。
我们来看例子:
例#1
在这里，我们将看到一个增加 jupyter 笔记本中绘图大小的示例。
**# Import Library**
import matplotlib.pyplot as plt
**# Increase size of plot in jupyter**
plt.rcParams["figure.figsize"] = (8,5.5)
**# Define Data**
x = [2, 4, 6, 8]
y = [5, 10, 15, 20]
**# Plot**
plt.plot(x, y, '-.')
**# Display**
plt.show()
- 首先，导入
matplotlib.pyplot库 - 接下来，使用PLT . RC params[" figure . figsize "]方法增加 jupyter 笔记本中的绘图大小，并设置绘图的宽度和高度。
- 然后，定义用于打印的数据坐标。
- 要绘制图表，使用
plot()函数，并将线条样式设置为点划线。 - 要显示图表，在用户屏幕上使用
show()功能。
Width=8, Height=5.5
例 2
下面的源代码阐述了使用 matplotlib 增加 jupyter 笔记本大小的过程。
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Increase size of plot in jupyter**
plt.rcParams["figure.figsize"] = (10,6)
**# Define Data**
x = np.linspace(0, 10, 1000)
y = np.sin(x)
**# Plot**
plt.plot(x, y)
**# Display**
plt.show()
这里我们使用 numpy 模块的 linspace() 函数和 sin() 函数定义数据坐标。
# Increase Size of Plot in Jupyter
Matplotlib 增加剧情尺寸支线剧情
这里我们将学习使用 matplotlib 增加支线剧情的剧情大小。有两种方法可以增加支线剧情的大小。
- 为所有支线剧情设置一个尺寸
- 为支线剧情设置单独的大小
为所有支线剧情设置一个尺寸
在这里，我们将看到为所有支线剧情设置一个尺寸的例子。
以下是语法:
fig, ax = plt.subplots(nrows , ncols , figsize=(width,height))
例#1
在这个例子中，我们为所有的支线剧情增加了相同的尺寸。
**# Import necessary libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Set one size for all subplot**
fig, ax = plt.subplots(2, 2, figsize=(10,8))
**# Preparing the data to subplots**
x = np.linspace(0,10,100)
y1 = x ** 2
y2 = x ** 4
y3 = x ** 6
y4 = x ** 8
**# Plot**
ax[0, 0].plot(x, y1, color='r')
ax[0, 1].plot(x, y2, color='k', linestyle=':')
ax[1, 0].plot(x, y3, color='y', linestyle='-.')
ax[1, 1].plot(x, y4, color='c',linestyle='--')
**# Display**
plt.show()
- 导入必要的库，比如
matplotlib.pyplot和numpy。 - 然后用支线剧情()函数创建 2 行和 2 列的支线剧情。
- 要为所有支线剧情设置一个尺寸，使用带有宽度和高度参数的
figsize()函数。 - 定义用于打印的数据坐标。
- 要绘制支线剧情，请使用带轴的
plot()函数。 - 要设置绘制线的不同线型，使用线型参数。
- 为了可视化支线剧情，使用
show()函数。
Set one size for all subplots
例 2
让我们再看一个例子，为所有的支线剧情设置相同的大小，以便更清楚地理解这个概念。
**# Import necessary libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Change the figure size**
plt.figure(figsize=[15,14])
**# Preparing the data to subplots**
x = np.linspace(0, 10, 1000)
y1 = np.sin(x)
y2 = np.cos(x)
**# Plot the subplots**
**# Plot 1**
plt.subplot(2, 2, 1)
plt.plot(x, y1, color='g')
**# Plot 2**
plt.subplot(2, 2, 2)
plt.plot(x, y2, color='k')
**# Display**
plt.show()
- 为了定义数据坐标，我们使用 numpy 的
linspace()、sin()和cos()函数。 - 这里我们增加所有支线剧情的大小，使用
figure()方法，我们将figsize()作为参数传递，并设置支线剧情的宽度和高度。
Matplotlib increase plot size subplots
为支线剧情 设置单独的大小
在这里，我们将看到不同的例子，我们使用 matplotlib 为子情节设置单独的大小。
以下是语法:
fig, ax = plt.subplots(nrows, ncols, gridspec_kw=
{'width_ratios': [3, 1],
'height_ratios’: [3, 3]})
举例:
下面的源代码详细阐述了增加单个支线剧情大小的过程。
**# Import Library**
import matplotlib.pyplot as plt
**# Define subplots**
fig, ax = plt.subplots(1, 2,
gridspec_kw={'width_ratios': [8,15]})
**# Define data**
x = [1, 2, 3, 4, 5]
y1 = [7, 13, 24, 26, 32]
y2 = [2, 4, 6, 8, 10]
**# Create subplots**
ax[0].plot(x, y1, color='red', linestyle=':')
ax[1].plot(x, y2, color='blue', linestyle='--')
**# Adjust padding**
plt.tight_layout()
**# Display**
plt.show()
- 导入
matplotlib.pyplot库。 - 然后创建带有 1 行 和 2 列 的支线剧情，使用 支线剧情() 功能。
- 要为子情节设置单独的大小，请使用
gridspec_kw()方法。gridpec_kw是一个带有关键字的字典，可以用来改变每个网格的大小。 - 接下来，定义数据坐标以打印数据。
- 要绘制折线图，请使用
plot()函数。 - 要自动调整填充，请使用
tight_layout()函数。 - 为了可视化支线剧情，使用
show()函数。
Matplotlib increase plot size subplots
例 2
下面的源代码解释了增加特定支线剧情大小的过程。
**# Import Library**
import matplotlib.pyplot as plt
**# Define subplots**
fig, ax = plt.subplots(1, 2, gridspec_kw={'width_ratios':
[10,4]})
**# Define data**
x = np.arange(0, 30, 0.2)
y1 = np.cos(x)
y2 = np.sin(x)
**# Create subplots**
ax[0].plot(x, y1, color='red', linestyle=':')
ax[1].plot(x, y2, color='blue', linestyle='--')
**# Adjust padding**
plt.tight_layout()
**# Display**
plt.show()
为了绘制一个数据，我们通过使用 numpy 的 arange() 、 cos() 和 sin() 函数来定义数据坐标。
gridspec_kw={‘width_ratios’: [10,4]}
阅读: Matplotlib 绘图条形图
Matplotlib py plot set _ size _ inches
在 matplotlib 中，要以英寸为单位设置图形大小，请使用图形模块的 set_size_inches() 方法。
以下是语法:
matplotlib.figure.Figure.set_size_inches(w, h)
这里 w 代表宽度， h 代表高度。
让我们看看不同的例子:
例#1
以下是使用 set_size_inches 方法增加地块大小的示例。
**# Import Libraries**
import matplotlib.pyplot as plt
**# Create figure**
fig = plt.figure()
**# Figure size**
fig.set_size_inches(6.5, 6)
**# Define Data Coordinates**
x = [10, 20, 30, 40, 50]
y = [25, 25, 25, 25, 25]
**# Plot**
plt.plot(x, y, '--')
plt.plot(y, x)
**# Display**
plt.show()
- 导入
matplotlib.pyplot库。 - 接下来，使用
figure()函数创建一个新图形。 - 要以英寸为单位设置图形尺寸，使用
set_size_inches()函数，并将宽度和高度作为参数传递，并将它们的值分别设置为6.5和6。 - 然后，定义用于绘图的 x 和 y 数据坐标。
- 要绘制折线图，请使用
plot()函数。
Matplotlib pyplot set_size_inches
例 2
在这里，我们使用 x 和 y 坐标创建一个折线图(由函数 arange 和 sin 定义)。我们使用 set_size_inches 函数将绘图的宽度设置为 12，将高度设置为 10 英寸。
**# Import Libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Create figure**
fig = plt.figure()
**# Figure size**
fig.set_size_inches(12,10)
**# Define Data Coordinates**
x = np.arange(0,4*np.pi,0.1)
y = np.sin(4*x)
**# Plot**
plt.plot(x, y, '--')
**# Display**
plt.show()
这里我们用 numpy 的 arange() 、 pi 、 sin() 函数定义 x、y 数据坐标。
fig.set_size_inches(12,10)
熊猫 matplotlib 增加地块大小
在 Pandas 中，matplotlib 模块的 plot() 方法的 figsize 参数可用于改变地块的大小，绕过所需的尺寸作为元组。它用于计算图形对象的大小。
以下是语法:
figsize=(width, height)
宽度和高度必须是英寸。
让我们看看不同的例子:
例#1
在本例中，我们将使用 pandas dataframe 创建一个饼图，并增加绘图的大小。
**# Import Library**
import pandas as pd
**# Creat pandas dataframe**
df = pd.DataFrame({'Owner': [50, 15, 8, 20, 12]},
index=['Dog', 'Cat', 'Rabbit',
'Parrot','Fish'])
**# Plot**
df.plot.pie(y='Owner', figsize=(8,8))
**# Display**
plt.show()
- 导入熊猫模块。
- 之后，创建一个带有索引的熊猫数据框架。
- 要绘制饼图，请使用
df.plot.pie()函数。 - 要增加绘图的大小，请传递参数
figsize()和尺寸。
Pandas Matplotlib Increase Plot Size
例 2
在本例中，我们将使用熊猫数据框架制作一个折线图，并增加地块大小。
**# Import libraries**
import pandas as pd
import matplotlib.pyplot as plt
**# Data**
data = {'Year': [2021, 2020, 2019, 2018, 2017, 2016, 2015,
2014],
'Birth_Rate': [17.377, 22.807, 26.170, 18.020, 34.532,
18.636, 37.718, 19.252]
}
**# Create DataFrame**
df = pd.DataFrame(data,columns=['Year','Birth_Rate'])
**# Line Plot**
df.plot(x ='Year', y='Birth_Rate', kind = 'line',
figsize=(8,6))
**# Display**
plt.show()
- 使用
DataFrame()方法在 pandas 中创建一个数据帧。 - 接下来，使用
df.plot()函数绘制数据帧。 - 这里我们将种类参数设置为线，以便绘制折线图。
- 要增加绘图的大小，请传递参数
figsize()和尺寸。
figsize=()
Matplotlib 改变图形尺寸和 dpi
在这里，我们将学习使用 matplotlib 模块来改变图形的大小和分辨率。
以下是语法:
matplotlib.pyplot.figure(figsize=(w,h), dpi)
让我们看看与此相关的例子:
例#1
在本例中，我们绘制了一个折线图，并更改了其大小和分辨率。
**# Import Libraries**
import matplotlib.pyplot as plt
from matplotlib.pyplot import figure
**# Set fig size and dpi**
figure(figsize=(8,6), dpi=250)
**# Define Data**
x = range(0,12)
**# Plot**
plt.plot(x)
**# Display**
plt.show()
- 首先使用
matplotlib.pyplot.figure创建一个新图形或激活一个已存在的图形。 - 该方法采用一个
figsize参数，用于指定图形的宽度和高度(以英寸为单位)。 - 然后，输入一个
dpi值，该值对应于以每英寸点数为单位的图形分辨率。
Matplotlib change figure size and dpi
例 2
这里我们将再看一个与图形大小和分辨率变化相关的例子，以便更清楚地理解这个概念。
**# Import Libraries**
import matplotlib.pyplot as plt
from matplotlib.pyplot import figure
import numpy as np
**# Set fig size and dpi**
figure(figsize=(6,4), dpi=150)
**# Define Data**
x = np.random.randint(450,size=(80))
**# Plot**
plt.plot(x)
**# Display**
plt.show()
- 为了定义数据坐标，这里我们使用
numpy的random.randint()方法。 - 这里我们将图的宽度、高度、
dpi分别设置为6、4、150。
figure(figsize=(6,4), dpi=150)
Matplotlib 图变化点大小
这里我们将通过不同的例子学习如何在 matplotlib 中改变标记大小。
以下是语法:
matplotlib.pyplot.scatter(x , y , s)
这里 x 和 y 指定数据坐标， s 指定标记的大小。
例#1
这里我们将看到一个例子，我们为所有的点设置一个单一的大小。
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
A = [6, 7, 2, 5, 4, 8]
B = [12, 14, 17, 20, 22, 27]
**# Scatter Plot and set size**
plt.scatter(A, B, s=80)
**# Display**
plt.show()
- 导入
matplotlib.pyplot库。 - 接下来，定义
A和B数据坐标。 - 要绘制散点图，请使用
scatter()函数。 - 要为所有点设置相同的大小，使用
s作为参数并设置大小。 - 使用
show()函数来可视化底池。
Set Single Size For All Points
例 2
这里我们将看到一个例子，我们为每个点设置不同的大小
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = [6, 7, 2, 5, 4, 8]
y = [12, 14, 17, 20, 22, 27]
**# Define Size**
sizes = [20, 55, 85, 150, 250, 9]
**# Scatter Plot and set size**
plt.scatter(x, y, s=sizes)
**# Display**
plt.show()
- 导入
matplotlib.pyplot库。 - 接下来，定义数据坐标。
- 然后，为每个点定义不同的大小。
- 要绘制散点图，使用
scatter()函数并设置尺寸传递 s 参数。 - 要显示图表，使用
show()功能。
Set Different Size For Each Point
例 3
这里我们将看到一个例子，其中我们为图中的每个点定义了点大小。
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = [2, 4, 6, 8, 10, 12, 14, 16]
y = [4, 8, 12, 16, 20, 24, 28, 32]
**# Define Size**
sizes = [3**n for n in range(len(x))]
**# Scatter Plot and set size**
plt.scatter(x, y, s=sizes, color='red')
**# Display**
plt.show()
- 导入
matplotlib.pyplot库进行数据可视化。 - 定义数据坐标。
- 创建一个函数来定义用于图中每个点的点大小。
- 要绘制散点图，请使用
scatter()函数。
Matplotlib Plot Change Point Size
阅读: Matplotlib 饼图教程
Matplotlib 以像素为单位设置绘图大小
在这里，我们将看到一些例子，其中我们将英寸转换为像素，并使用 matplotlib 模块绘制图形。
例子 #1
在下面的例子中，我们将使用像素转换方法来改变绘图大小。
**# Import Libraries**
import matplotlib.pyplot as plt
from matplotlib.pyplot import figure
import numpy as np
px = 1/plt.rcParams["figure.dpi"]
**# Set fig size in Pixel**
figure(figsize=(600 * px , 450 * px))
**# Define Data**
x = np.random.randint(800,size=(120))
**# Plot**
plt.plot(x)
**# Display**
plt.show()
- 导入必要的库，如
matplotlib.pyplot、figure、numpy。 - 然后使用，默认像素值， rcParams['figure.dpi'] 将值设置为 px。
- 现在，以像素为单位设置 figsize。
- 然后，定义用于打印的数据坐标。
- 要绘制折线图，请使用
plot()函数。 - 要显示图表，使用
show()功能。
Matplotllib set plot size in pixels
例 2
这里我们通过使用 dpi 参数来改变以像素为单位的绘图大小。
**# Import Libraries**
import matplotlib.pyplot as plt
from matplotlib.pyplot import figure
**# Set fig size and dpi**
figure(dpi=100)
**# Define Data Coordinates**
water_quantity = [17, 27, 14, 22, 16, 6]
**# Add labels**
water_uses = ['Shower', 'Toilet', 'Leaks', 'Clothes Wsher',
'Faucet', 'Other']
**# Colors**
colors =['salmon','palegreen','skyblue','plum','pink','silver']
**# Plot**
plt.pie(water_quantity, colors=colors)
**# Add legend**
plt.legend(labels=water_uses, fontsize=18, loc='upper center',
bbox_to_anchor=(0.5, -0.04), ncol=2)
**# Display**
plt.show()
- 在这里，我们使用
dpi参数通过figure()函数以像素为单位设置绘图。 - 接下来，我们为饼图创建定义数据坐标、标签和颜色，
- 为了绘制饼图，我们使用了
pie()函数。 - 为了给绘图添加一个图例，我们使用了
legend()函数。
matplotlib set plot size in pixels(dpi)
阅读: Matplotlib 散点图颜色
Matplotlib 改变默认绘图大小
在 Matplotlib 中，字典对象 rcParams 包含属性。图形大小可以作为 rcParams 中 figsize 的关键图形值，代表图形的大小。
为了改变默认的大小，我们使用 plt.rcParams。当我们把它放在 plt.plot 之前或之后时，这是可以接受的。使用相同脚本制作的任何图形将被分配相同的图形大小。
我们来看例子:
例#1
在这里，我们将设置默认的图形大小为 7 乘 7。
**# Import Library**
import matplotlib.pyplot as plt
**# Default plot size**
plt.rcParams["figure.figsize"] = (7,7)
**# Plot**
plt.plot([[5, 6], [9, 10], [1, 2], [1, 2]])
**# Show**
plt.show()
- 导入
matplotlib.pyplot库。 - 要设置默认绘图尺寸，使用PLT . RC params[" figure . fig size "]。
- 要绘制图表，请使用
plot()函数。
Matplotlib change default plot size
Matplotlib 改变柱状图尺寸
在这里，我们将借助示例学习使用 matplotlib 模块改变条形图大小的不同方法。
例#1
这里我们将使用 figsize() 方法来改变条形图的大小。
**# Import Library**
import matplotlib.pyplot as plt
**# Change size**
plt.figure(figsize=(9,7))
**# Define Data**
pets = ['Rabbit', 'Dog', 'Cat', 'Goldfish', 'Parrot']
no_of_people = [4, 8, 11, 6, 5]
**# Plot bar chart**
plt.bar(pets, no_of_people)
**# Display**
plt.show()
- 导入
matplotlib.pyplot库。 - 要改变图形大小，使用
figsize参数并设置绘图的宽度和高度。 - 接下来，我们定义数据坐标。
- 要绘制条形图，使用
bar()功能。 - 要显示图表，使用
show()功能。
Matplotlib change bar plot size
例 2
在这个例子中，我们将使用 rcParams 来改变条形图的大小。
**# Import Library**
import matplotlib.pyplot as plt
**# Change size**
plt.rcParams['figure.figsize']=(8,6.5)
**# Define Data**
school_suppiles = ['Pencil', 'Scale', 'Pen', 'Sharpner',
'Eraser']
no_of_suppiles = [8, 3, 2, 5, 4]
**# Plot bar chart**
plt.bar(school_suppiles, no_of_suppiles)
**# Display**
plt.show()
这里我们使用默认方法，即通过使用 plt 来更改条形图的大小。RC params[' figure . fig size ']。
plt.rcParams[‘figure.figsize’]
Read: Matplotlib set_xticklabels
Matplotlib 改变散点图大小
在这里，我们将借助示例学习使用 matplotlib 模块改变散点图大小的不同方法。
例#1
这里我们将学习使用 figsize 来改变散点图的大小。
**# Import Library**
import matplotlib.pyplot as plt
**# Set size**
plt.figure(figsize=(8,5))
**# Define Dataset**
x1 = [45, 58, 29, 83, 95, 20,
98, 27]
y1 = [31, 75, 8, 29, 79, 55,
43, 72]
x2 = [23, 41, 25, 64, 3, 15,
39, 66]
y2 = [26, 34, 38,
20, 56, 2, 47, 15]
**# Plot Scatter Graph**
plt.scatter(x1, y1, c ="cyan",
marker ="s",
edgecolor ="black",
s = 50)
plt.scatter(x2, y2, c ="yellow",
linewidths = 2,
marker ="^",
edgecolor ="red",
s = 200)
**# Display**
plt.show()
- 导入
matplotlib.pyplot库。 - 要设置图形尺寸，使用
figsize参数并设置图形的宽度和高度。 - 定义要绘制到散点图的数据集。
- 要绘制散点图，使用散点图方法。
- 为了给绘图添加额外的特性，传递颜色、大小、标记、边缘颜色、标记作为参数。
Matplotlib change scatter plot size
例 2
在这个例子中，我们使用 set_size_inches 方法改变散点图的大小。
**# Import Libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Create figure**
fig = plt.figure()
**# Figure size**
fig.set_size_inches(6,8)
**# Define Data**
x = np.linspace(0, 10, 100)
y = np.sin(x)
**# Plot**
plt.scatter(x, y)
**# Display**
plt.show()
- 导入必要的库，如
matplotlib.pyplot和numpy。 - 然后使用
figure()方法创建一个新的 figure。 - 要设置散点图的大小，使用
set_size_inches()方法并传递宽度和高度。 - 要定义数据坐标，使用
linspace()和sin()方法。 - 要绘制散点图，请使用
scatter()函数。
fig.set_size_inches(6,8)
阅读:Matplotlib tight _ layout–有用教程
Matplotlib 改变图尺寸 fig ax
通过使用 matplotlib 模块的 set_figheight 和 set_figwidth 方法，我们可以很容易地改变绘图的高度和宽度。
让我们看看与这个概念相关的例子:
例#1
这里我们通过使用 set_figwidth 方法来设置绘图的宽度。
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
**# Set width**
fig = plt.figure()
fig.set_figwidth(8)
**# Data Coordinates**
x = np.arange(2, 8)
y = np.array([5, 8, 6, 20, 18, 30])
**# Plot**
plt.plot(x, y, linestyle='--')
**# Display**
plt.show()
- 首先导入必要的库，比如
numpy和matplotlib.pyplot。 - 接下来，使用
set_figwidth()方法来改变绘图的宽度。 - 要定义数据坐标，使用 numpy 的
arange()和array()方法。 - 要用虚线样式绘制线图，使用带有
linestyle参数的plot()函数。
Matplotlib change figure size fig ax
例# 2
这里我们通过使用 set_figheight 方法来设置绘图的高度。
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
**# Set height**
fig = plt.figure()
fig.set_figheight(8)
**# Data Coordinates**
x = np.arange(2, 8)
y = np.array([5, 8, 6, 20, 18, 30])
**# Plot**
plt.plot(x, y, linestyle='--')
**# Display**
plt.show()
- 首先导入必要的库，比如
numpy和matplotlib.pyplot。 - 接下来，使用
set_figheight()方法更改绘图的高度。 - 要定义数据坐标，使用 numpy 的
arange()和array()方法。
Matplotlib change figure size
读取: Matplotlib x 轴标签
Matplotlib 以厘米为单位设置绘图尺寸
默认情况下，在 matplotlib 中，图形大小以英寸为单位。在这里，我们将借助一个例子来学习以厘米为单位设置绘图大小。
举例:
**# Import Library** import numpy as np
import matplotlib.pyplot as plt
**# Set Size**
cm = 1/2.54
plt.figure(figsize=(15*cm, 11*cm))
**# Data Coordinates**
x = np.arange(2, 8)
y = x * 2 + 6
**# Plot**
plt.plot(x, y)
**# Display**
plt.show()
- 导入
numpy库。 - 接下来，导入
matplotlib库。 - 通过将英寸转换为厘米来设置图形大小。
- 定义数据坐标 x 和 y。
- 为了绘制折线图，我们使用了
plot()函数。
Matplotlib set plot size in centimeter
你可能也喜欢阅读下面的 Matplotlib 教程。
在本 Python 教程中，我们已经讨论了" Matplotlib 增加绘图大小"，并且我们还介绍了一些与之相关的例子。这些是我们在本教程中讨论过的以下主题。
- Matplotlib 增加地块大小
- Matplotlib 增加绘图大小 jupyter
- Matplotlib 增加情节大小支线剧情
- matplotlib py plot set _ size _ inches
- 熊猫 matplotlib 增加地块大小
- Matplotlib 更改图形大小和 dpi
- Matplotlib 图变化点大小
- Matplotlib 以像素为单位设置绘图大小
- Matplotlib 更改默认绘图大小
- Matplotlib 更改条形图绘图大小
- Matplotlib 更改散点图大小
- Matplotlib 设置绘图窗口大小
- Matplotlib 更改图形大小 fig ax
- Matplotlib 以厘米为单位设置绘图大小
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib 反转 y 轴
在本 python 教程中，我们将讨论 Python 中的 Matplotlib 反转 y 轴。这里我们将介绍使用 matplotlib 反转 y 轴的不同例子。我们还将讨论以下主题:
- Matplotlib 反转 y 轴
- Matplotlib 反转 y 轴子图
- Matplotlib 反转 x 和 y 轴
- Matplotlib barh 反转 y 轴
- Matplotlib 反转辅助 y 轴
- matplot lib 3d reverse 和 axis
- Matplotlib flip 和 axis label
- matplot lib reverse 和 axis imshow
如果你是 python Matplotlir 的新手，请查看，如何安装 matplotlib python 。
目录
- Matplotlib 反转 y 轴
- Matplotlib 反转 y 轴子图
- Matplotlib 反转 x 和 y 轴
- matplotlib bar 逆变轴
- Matplotlib 反转辅助 y 轴
- Matplotlib 3D 反转 y 轴
- Matplotlib flip 和 axis label
- Matplotlib 逆变 y 轴 im how
Matplotlib 反转 y 轴
在本节中，我们将学习如何在 Python 的 matplotlib 中反转 y 轴。现在在开始这个话题之前，我们先讨论一下反转在这里是什么意思:
反转 表示颠倒或翻转顺序
为了更清楚地理解，让我们举一个常见的例子:
假设 y 轴从 0 到 10 开始，你想从 10 到 0 开始。在这种情况下，我们反转或翻转图的轴。
在 matplotlib 中，我们可以使用不同的方法反转图形的 y 轴。以下是反转 y 轴的不同方法。
- 使用 invert_yaxis()方法
- 使用 ylim()方法
- 使用 axis()方法
通过使用 invert_yaxis()方法
要反转 Y 轴，我们可以使用 invert_yaxis()方法。
该方法的语法如下:
matplotlib.axes.Axes.invert_yaxis(self)
示例:(无反转轴)
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data**
x = np.arange(0, 15, 0.2)
y = np.sin(x)
**# Plot figure**
plt.plot(x, y)
**# Title**
plt.title("Sine Function Normal Plot", fontsize= 15, fontweight='bold')
**# Generate Plot**
plt.show()
- 在上面的例子中，我们导入了
matplotlib.pyplot和numpy库。 - 之后，我们使用
np.arrange()和np.sin()方法定义数据。 - 接下来，我们使用
plt.plot()方法来绘制绘图。 - 通过使用
plt.title()我们定义了绘图的标题。 plt.show()方法用于在用户屏幕上生成绘图。
” Graph without invert method”
看 y 轴:这里从-1.00 开始，到 1.00 结束
示例:(带反转轴)
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data**
x = np.arange(0, 15, 0.2)
y = np.sin(x)
**# Plot figure**
plt.plot(x, y)
**# Invert y-axis**
ax = plt.gca()
ax.invert_yaxis()
**# Title**
plt.title("Sine Function Invert Plot", fontsize= 15, fontweight='bold')
**# Generate Plot**
plt.show()
- 在上面的例子中，我们使用了
plt.gca()方法来获取当前轴。 - 在此之后，我们使用
ax.invert_yaxis()方法来反转或反转绘图的 y 轴。
” Graph with invert method “
看 y 轴:这里从 1.00 开始，到-1.00 结束
结论:通过使用 invert_yaxis()方法，我们可以反转绘图的 y 轴。
通过使用 ylim()方法
ylim() 方法也用于在 Matplotlib 中反转绘图的轴。通常，该方法用于设置轴的限制。
但是，如果我们将最小值设定为上限，将最大值设定为下限，我们就可以恢复坐标轴。
ylim()方法的语法如下:
matplotlib.pyplot.ylim(bottom,top)
这里底部和顶部指定新 y 轴极限的元组。
让我们看一个例子来更清楚地理解它:
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x = np.linspace(5, 15, 35)
y = 2*x+5
**# Create plot**
axes,(p1,p2) = plt.subplots(1, 2)
**# Normal plot**
p1.plot(x, y)
p1.set_title("Normal Plot")
**# Invert plot**
p2.plot(x, y)
p2.set_title("Inverted Plot")
plt.ylim(max(y), min(y))
**# Show**
axes.tight_layout()
plt.show()
- 在上面的例子中，首先我们导入
numpy和matplotlib.pyplot库。 - 接下来，我们定义数据，并通过使用
plt.subplot()方法创建子情节。 - 现在我们用
plot()方法画一个简单的图。 plt.ylim()方法用于反转 y 轴这里我们将max和min作为参数传递。
plt.ylim()
结论:正常图中，y 轴从 1 开始，到 5 结束。在反转图中，y 轴从 5 开始，到 1 结束。
通过使用轴()方法
axis() 方法也用于在 Matplotlib 中恢复轴。基本上，该方法用于设置轴的最小值和最大值。
但是如果我们将最小值设定为上限，将最大值设定为下限就可以得到反轴。
axis()方法的语法如下:
matplotlib.pyplot.axis()
让我们看一个例子:
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x = np.arange(0, 15, 0.2)
y = np.tan(x)
**# Create plot**
axes,(p1,p2) = plt.subplots(1, 2)
**# Normal plot**
p1.plot(x, y)
p1.set_title("Normal Plot")
**# Invert plot**
p2.plot(x, y)
p2.set_title("Inverted Plot")
plt.axis([max(x), min(x), max(y), min(y)])
**# Show**
axes.tight_layout()
plt.show()
- 这里我们导入
matplotlib.pyplot和numpy库，使用np.arrange()和np.tan()方法定义数据。 - plt。支线剧情()方法用于创建支线剧情。
- 然后，我们使用
plot()方法绘制一个图形，并使用set_title()方法为图形添加一个标题。 - 通过使用
plt.axis()方法，我们还原轴，这里我们传递 y 轴和 x 轴的最大值和最小值值。
plt.axis()
Matplotlib 反转 y 轴子图
这里我们将讨论如果我们在 Python matplotlib 中的一个图形区域中绘制多个图，如何反转特定子图的 y 轴。
我们使用 invert_yaxis() 方法翻转子情节的 y 轴。
让我们借助一个例子来理解这个概念:
**# Import Libraries**
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x1= [0.2, 0.4, 0.6, 0.8, 1]
y1= [0.3, 0.6, 0.8, 0.9, 1.5]
x2= [2, 6, 7, 9, 10]
y2= [3, 4, 6, 9, 12]
x3= [5, 8, 12]
y3= [3, 6, 9]
x4= [5, 8, 12]
y4= [3, 6, 9]
fig, ax = plt.subplots(2, 2)
**# Invert y-axis**
ax[1,0].invert_yaxis()
**# Plot graph**
ax[0, 0].plot(x1, y1)
ax[0, 1].plot(x2, y2)
ax[1, 0].plot(x3, y3)
ax[1, 1].plot(x4, y4)
**# Display Graph**
fig.tight_layout()
plt.show()
- 在上面的例子中，我们在一个图形区域中绘制了多个图。我们想要反转特定图的 y 轴。
- 这里我们使用
invert_yaixs()方法翻转绘图的 y 轴。 - 我们将
invert_yaxis()方法与第三图一起使用。
ax.invert_yaxis()
Matplotlib 反转 x 和 y 轴
这里我们将学习如何在 Python matplotlib 中反转绘图的 x 轴和 y 轴。
通过使用 invert_xaxis() 和 invert_yaxis() 方法，我们可以分别翻转 x 轴和 y 轴。
语法如下:
**# Invert x-axis**
matplotlib.axes.Axes.invert_xaxis(self)
**# Invert y-axis**
matplotlib.axes.Axes.invert_yaxis(self)
让我们来看一个与这个概念相关的例子:
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x=[5, 10, 15, 20, 25,30]
y=[0, 1, 2, 3, 4, 5]
**# Create Subplot**
axes,(p1,p2) = plt.subplots(1, 2)
**# Normal plot**
p1.plot(x, y)
p1.set_title("Normal Plot")
**# Invert plot**
p2.plot(x, y)
p2.set_title("Inverted Plot")
**# Invert axes**
ax = plt.gca()
ax.invert_yaxis()
ax.invert_xaxis()
**# Show**
axes.tight_layout()
plt.show()
- 在上面的例子中，我们导入了
numpy和matplotlib库。 - 之后，我们在 x 和 y 坐标上定义数据。
- 通过使用
plt.subplots()方法，我们在图形区域中创建子情节。 - 接下来，我们使用
plot()方法绘制一个图形，使用set_title()方法设置图形的标题。 - 然后，我们使用
plt.gca()方法来获取绘图的当前轴。 - 通过使用
invert_yaxis()和invert_xaxis()方法，我们翻转绘图的轴。 - 最后，我们使用
tight_layout()方法自动设置绘图，使用show()方法在用户屏幕上显示绘图。
” Invert x-axis and y-axis “
另外，读取 Matplotlib savefig 空白图像
matplotlib bar 逆变轴
这里我们将学习如何使用 Python 中的 matplotlib反转水平条形图的 y 轴。首先，我们必须知道如何绘制水平条形图。
绘制水平条形图的语法如下:
matplotlib.pyplot.barh(x,y)
这里 x 表示 x 轴坐标，y 表示条形的高度。
反转 柱状图 y 轴的语法如下:
**# Invert y-axis**
matplotlib.axes.Axes.invert_yaxis(self)
举例:
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x=[1, 2, 3, 4, 5]
y=[20, 15, 12, 6, 5]
**# Simple Bar Chart**
plt.figure()
plt.barh(x,y)
**# Inverted Bar chart**
plt.figure()
plt.barh(x,y)
plt.gca().invert_yaxis()
**# Show**
plt.show()
- 在上面的例子中，我们首先导入了
numpy和matplotlib.pyplot库。 - 接下来，我们定义数据。
- 通过使用
plt.barh()方法，我们创建了一个水平条形图。 - 通过使用
plt.gca()方法，我们得到了绘图的当前轴。 - 然后我们使用
invert_yaxis()方法翻转绘图的 y 轴。
” Invert y-axis of the horizontal bar chart “
Matplotlib 反转辅助 y 轴
在这里，我们将学习如何在 Python 的 matplotlib 中反转辅助 y 轴。首先，我们必须了解辅助 y 轴的含义以及何时需要它。
偶尔，我们需要两个 x 轴或 y 轴来获得对数据的更多洞察。此时，我们需要创建副轴。
在 python 中，matplotlib 提供了创建具有两个 y 轴的绘图的功能，甚至我们可以为两者提供不同的标签。
我们可以通过使用两个不同的轴对象来创建一个具有两个不同 y 轴的图。为了创建不同的轴对象，我们使用了 twinx() 方法。
让我们来看一个反转辅助 y 轴的例子:
**# Import Library** import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x = np.arange(0, 10, 3.5)
y1 = x**2
y2 = x**4
**# Create subplot**
fig, ax = plt.subplots(figsize = (10, 5))
**# twinx() for creating axes object for secondary y-axis**
ax2 = ax.twinx()
**# Plot graph**
ax.plot(x, y1)
ax2.plot(x, y2)
**# Invert secondary y-axis**
ax2.invert_yaxis()
**# Labels to axes**
ax.set_xlabel('x-axis')
ax.set_ylabel('y-axis')
**# Label secondary y-axis**
ax2.set_ylabel('Secondary y-axis', color = 'b')
**# Display layout**
plt.tight_layout()
**# Show plot**
plt.show()
- 在上面的例子中，我们导入了重要的库，如
numpy和matplotlib.pyplot。 - 接下来，我们通过使用
np.arange()方法来创建数据，这里我们定义 0 到 10 之间的数据，在 x 轴上的差值为 3.5。 - 然后通过使用
plt.subplots()方法我们创建支线剧情。 - 通过使用
twinx()我们为辅助 y 轴创建另一个 axes 对象。 set_xlabel()和set_ylabel()方法用于在轴上添加标签。- 通过使用
tight_layout()和show()方法，我们定义了布局并显示了情节。
” Plot without inverting secondary y-axis “
” Plot with inverting secondary y-axis “
Matplotlib 3D 反转 y 轴
在本节中，我们将学习如何在 Python 中的 Matplotlib 中反转 3D 绘图。
创建 3D 图并反转 y 轴的语法:
**# Create 3D plot**
ax.plot3D(x,y,z)
**# Invert y-axis**
matplotlib.pyplot.ylim(max(y),min(y))
这里 x，y 和 z 是坐标点。
我们来看一个与此相关的例子:
**# Import Libraries**
import matplotlib
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
**# Create subplots**
fig = plt.figure(figsize=(12,5), dpi=80)
ax1 = fig.add_subplot(121, projection='3d')
ax2 = fig.add_subplot(122, projection='3d')
**# Simple plot**
x=[1,1,10,10]
y=[1,10,10,10]
z=[1,1,1,10]
ax1.plot(x,y ,z , marker="o")
**# Inverted Plot**
x1=[1,1,10,10]
y1=[1,10,10,10]
z1= [1,1,1,10]
**# Function used for invert y-axis**
plt.ylim(max(y1),min(y1))
ax2.plot(x1,y1 ,z1, marker="o")
**# Show Plot**
plt.show()
- 在上面的例子中，我们导入了重要的库，如
matplotlib.pyplot和mplot3D。 - 接下来，我们使用
plot()方法在图形区域绘制图形。 - 通过使用
ylim()方法，我们反转绘图的 y 轴。在函数中，我们通过 y1 坐标的max和min。
” Invert 3 D y-axis “
阅读在 Python 中添加文本到绘图 matplotlib
Matplotlib flip 和 axis label
这里我们要学习 Python 中 Matplotlib 在 y 轴翻转标签。通过使用 ylabel() 方法，我们可以在 y 轴上添加标签并翻转它。
举例:
**# Import Library**
from matplotlib import pyplot as plt
**# Define Data**
x=[0, 1, 2, 3, 4, 5]
y=[2, 4, 6, 8, 10, 12]
**# Plot graph**
plt.plot(x,y)
**# Flip Y-axis Label**
plt.ylabel('Y-axis',rotation=0)
**# Show**
plt.draw()
- 在上面的例子中，我们导入
matplotlib.pyplot库进行可视化。 - 接下来，我们定义数据并使用
plt.plot()方法绘制一个图。 - 通过使用
plt.ylabel()方法，我们将标签设置在 y 轴上，并通过传递旋转参数将其水平翻转。这里我们将旋转的值设置为0。
” Y-axis label “
” Output of code when we flip Y-axis label “
Matplotlib 逆变 y 轴 im how
这里我们学习在 Python Matplotlib 的 imshow()方法中反转 y 轴。首先，了解 imshow 的作用:
inshow() 方法显示颜色映射或 3D RGB 数组的图像。
inshow()方法的语法如下:
matplotlib.pyplot.imshow(X,
cmap=None,
norm=None,
aspect=None,
interpolation=None,
alpha=None,
vmin=None,
vmax=None,
origin=None,
extent=None,
shape=,
filternorm=1,
filterrad=4.0,
imlim=,
resample=None,
url=None,
data=None,
*kwargs)
上面使用的参数描述如下:
- X: 指定图像的数据。
- cmap: 指定色彩映射表或注册的色彩映射表名称。
- norm: 是用来缩放数据的规范化实例。
- 纵横比:用于控制轴的纵横比。
- 插值:是一种用于显示图像的插值方法。
- alpha: 指定颜色的强度。
- vmin，vmax: 指定颜色条的范围。
- 原点:用于将数组的[0，0]索引放置在坐标轴的左上角或左下角。
- 范围:是数据坐标中的包围盒。
- filternorm: 用于反颗粒图像大小调整滤镜。
- 过滤半径:指定过滤器的过滤半径。
- url: 设置轴图像的 url。
举例:
**# Import Libraries**
import numpy as np
from matplotlib import pyplot as plt
**# Define data**
x = np.array([[0, 1, 2, 3],
[1, 1, 1, 3],
[1, 2, 2, 3],
[2, 2, 3, 3]])
**# Create subplot**
fig, ax = plt.subplots(1,2)
**# Imshow and Invert Y-axis**
for i in range(2):
ax[0].imshow(x, cmap = 'summer', vmin = 1, vmax = 3,)
ax[1].imshow(x, cmap = 'summer', vmin = 1, vmax = 3,
origin='lower')
**# Show**
plt.show()
- 这里，我们使用
np.array()方法定义数据，并使用imshow()方法绘制颜色图的图像。 - 我们通过参数原点来翻转 y 轴，并将其值设置为下限。
imshow(origin=’lower’)
您可能会喜欢以下 Python Matplotlib 教程:
- Matplotlib 移除刻度标签
- modulenotfounderror:没有名为“matplotlib”的模块
- Matplotlib 绘制一条线
- Python 使用 Matplotlib 绘制多条线
- 什么是 matplotlib 内联
- Python Matplotlib tick _ params
在本 Python 教程中，我们已经讨论了 "Matplotlib invert y axis" ，我们还介绍了一些与之相关的例子。这些是我们在本教程中讨论过的以下主题。
- Matplotlib 反转 y 轴
- Matplotlib 反转 y 轴子图
- Matplotlib 反转 x 和 y 轴
- Matplotlib barh 反转 y 轴
- Matplotlib 反转辅助 y 轴
- matplot lib 3d reverse 和 axis
- Matplotlib flip 和 axis label
- matplot lib reverse 和 axis imshow
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib 目前正在使用 agg 这一非 gui 后端
原文：https://pythonguides.com/matplotlib-is-currently-using-agg-a-non-gui-backend/
在本 Python 教程中，我们将讨论属性错误“matplotlib 当前正在 使用 agg 一个非 gui 后端”。在这里，我们将使用 matplotlib 介绍与此错误相关的原因和解决方案。我们还将讨论以下主题:
- 错误:matplotlib 当前正在使用 agg 非 gui 后端
- 解决方案:matplotlib 目前使用 agg 非 gui 后端
Matplotlib is currently using agg a non-gui backend
目录
错误:matplotlib 当前正在使用 agg 非 gui 后端
当我们得到警告:Matplotlib 当前正在使用 agg 非 gui 后端时，我们看不到图形，或者我们可以说图形的可视化是不可能的。
基本上，这个错误意味着我们必须安装 GUI 后端。
GUI 代表图形用户界面。这是一个用户界面，通过它我们可以与设备进行交互，还可以可视化绘图。在 Python 中，我们有多种开发 GUI 的方法，但最常用的方法是 Tkinter 。
非 GUI 用户界面是一种机器，它允许用户在没有任何图形的情况下，只通过文本与机器进行交互。
此外，检查:模块' matplotlib '没有属性' plot'
解决方案:matplotlib 目前正在使用 agg 一个非 gui 后端
解决方案#1
在 matplotlib 中，要解决这个错误，请安装 GUI-backend tk，即 Tkinter。
Linux
- 使用下面提到的命令安装 GUI 后端。
语法:
sudo apt-get install python3-tk
Jupyter 笔记本
- 使用下面提到的命令在 Jupter Notebook 中安装 GUI 后端。
语法:
pip install tk
- 在 jupyter 笔记本中安装 tkinter 后，导入 Tkinter 库。
语法:
from tkinter import *
蟒蛇分布
如果您的系统中有 Anaconda 提示符，您可以从这里使用下面提到的命令轻松安装 Tkinter。如果你不确定你是否有它，你可以很容易地在你的机器 Windows 开始菜单中看到它。
- 使用下面提到的命令安装 Anaconda 支持的 GUI。
语法:
conda install tk
- 在 anaconda 中安装 tkinter 之后，导入 Tkinter 库。
语法:
import tkinter
解决方案#2
使用 matplotlib python 安装任何 GUI 后端来解决此错误。所以这里我们将安装 PyQt5 GUI 工具包。它是 Qt 的 Python 接口，Qt 是一个健壮且广泛使用的跨平台 GUI 框架。PyQt5 是一种结合了 Python 和 Qt 库的编程语言。
Jupyter 笔记本
- 要在 Jupyter 笔记本中安装 PyQt5，请使用以下命令:
语法:
pip install pyqt5
Linux
- 要在 Ubuntu Linux 或 Debian Linux 中安装 PyQt5，使用下面的命令:
语法:
sudo apt-get install python3-pyqt5
厘斯 7
- 要在 CentOs 7 中安装 PyQt5，请使用下面的命令:
语法:
yum install qt5-qtbase-devel
红帽基础系统
- 要在基于 RPM 的系统(即基于 readhat 的系统)中安装 PyQt5，请使用以下命令:
语法:
yum install PyQt5
蟒蛇分布
如果您的系统中有 Anaconda 提示符，您可以从这里使用下面提到的命令轻松安装 PyQt5。
使用下面提到的命令安装 Anaconda 支持的 GUI。
语法:
conda install pyqt
你可能也喜欢阅读下面的 Matplotlib 教程。
- Matplotlib 饼图教程
- Matplotlib 散点图颜色
- Matplotlib Plot NumPy 数组
- Matplotlib 更新循环中的绘图
- Matplotlib 未知投影‘3d’
- Matplotlib 1.3.1 需要未安装的 nose】
在本 Python 教程中，我们已经讨论了 " "matplotlib 当前使用 agg 的 非 gui 后端" " ，我们也讨论了相关的原因和解决方案。这些是我们在本教程中讨论过的以下主题。
- 错误:matplotlib 当前正在使用 agg 非 gui 后端
- 解决方案:matplotlib 目前使用 agg 非 gui 后端
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib 图例字体大小
在本 Python Matplotlib 教程中，我们将讨论 Matplotlib 图例字体大小。在这里，我们将介绍使用 Python 中的 matplotlib 与图例字体大小相关的不同示例。我们还将讨论以下主题:
- Matplotlib 图例字体大小
- Matplotlib 条形图图例字体大小
- Matplotlib 默认图例字体大小
- Matplotlib 图例标题字体大小
目录
- Matplotlib legend font size
- 字体大小作为参数
- 使用 prop 关键字改变字体大小
- rcParams 方法
- Matplotlib 条形图图例字体大小
- Matplotlib 默认图例字体大小
- Matplotlib 图例标题字体大小
Matplotlib legend font size
Matplotlib 是一个 Python 包，允许你创建交互式可视化。Matplotlib 的 legend() 方法描述了情节的元素。在本文中，我们将学习在 Matplotlib 中更改图例字体大小。
以下语法用于向绘图添加图例:
matplotlib.pyplot.legend(*args, **kwa)
我们可以通过以下方式改变图例的字体大小:
- 字体大小将被用作参数。
- 要修改图例中的字体大小，请使用 prop 关键字。
- 使用 rcParams 方法。
整数值或浮点值可用于字体大小选项。但是我们也可以使用' xx-small '，' x-small '，' small '，' medium '，' large '，' x-large '，' xx-large '字符串值作为字体大小。
字体大小作为参数
在这里，我们将学习使用 font size 参数来更改图例的字体大小。
语法如下:
matplotlib.pyplot.legend([labels], fontsize)
让我们看看与此相关的例子:
例#1
在本例中，我们将看到图例的默认大小。
**# Import Libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data**
x = np.linspace(0, 8, 100)
y = np.exp(x/2)
**# Plot**
plt.plot(x, y, color='green', label='Exp(x)')
**# Add legend**
plt.legend()
**# Add title**
plt.title("Default Legend Size")
**# Add labels**
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
**# Display**
plt.show()
- 对于数据可视化，将
matplotlib.pyplot库作为plt导入。 - 对于数据创建，将
numpy库导入为np。 - 我们使用
linspace()和exp()函数来定义数据坐标。 plot()函数用于创建折线图。legend()方法用于将图例添加到绘图中。title()函数用于给图添加标题。- 我们使用
xlabel()和ylabel()分别向 x 轴和 y 轴添加标签。 show()函数用于显示图形。
Matplotlib legend font size
在上面的输出中，我们将看到默认字体大小的图例。
例 2
**# Import Libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data**
x = np.linspace(0, 8, 100)
y = np.exp(x/2)
**# Plot**
plt.plot(x, y, color='green', label='Exp(x)')
**# Add legend**
plt.legend(fontsize=18)
**# Add title**
plt.title("Fontsize Parameter To change Legend Size")
**# Add labels**
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
**# Display**
plt.show()
- 在这里，我们通过将
label参数传递给plot()函数，为绘图设置图例。 - 为了给绘图显示图例，我们使用
legend()函数。 - 为了改变图例的大小，我们将参数
fontsize传递给 legend 方法，并将其大小设置为 18。
Matplotlib legend font size parameter
使用 prop 关键字改变字体大小
在 matplotlib 中，我们可以使用 prop 参数来更改 legend 的字体大小属性。
语法如下:
matplotlib.pyplot.legend([labels], prop={'size':10})
让我们看看与此相关的例子:
例#1
**# Import Libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data**
x = np.linspace(0, 10, 100)
y1 = np.sin(x/2)
y2 = np.cos(x/2)
**# Plot**
plt.plot(x, y1, label='Sin')
plt.plot(x, y2, label='Cos')
**# Add legend**
plt.legend(prop={'size':15})
**# Add title**
plt.title("Prop Parameter To change Legend Size")
**# Add labels**
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
**# Display**
plt.show()
- 首先，我们导入必要的库，如
matplotlib.pyplot和numpy。 - 为了定义数据坐标，我们使用了
linspace()、sin()和cos()函数。 - 要绘制折线图，我们使用
plot()函数。 - 为了给绘图添加一个图例，我们使用
legend()函数。 - 为了修改图例标签文本的大小，我们将
prop参数传递给 legend 方法。我们传递大小作为键，传递15作为值来支持字典。 - 要添加标题，我们使用
title()函数。 - 为了在轴上添加标签，我们使用了
xlabel()和ylabel()函数。 - 为了在用户屏幕上可视化图形，我们使用了
show()函数。
Matplotlib legend font size prop
例 2
**# Import Libraries**
import matplotlib.pyplot as plt
from numpy.random import random
**# Define color data**
colors = ['maroon', 'teal', 'yellow']
**# Plot**
data1 = plt.scatter(random(30), random(30), marker='d',
color=colors[0],label='Label 1')
data2 = plt.scatter(random(50), random(50), marker='d',
color=colors[1],label='Label 2')
data3 = plt.scatter(random(25), random(25), marker='d',
color=colors[1],label='Label 3')
data4 = plt.scatter(random(20), random(20), marker='d',
color=colors[2],label='Label 4')
data5 = plt.scatter(random(10), random(10), marker='d',
color=colors[0],label='Label 5')
**# Add legend**
plt.legend(loc='upper center', prop={'size':13.89},
bbox_to_anchor=(0.5, -0.08), ncol=2)
**# Display**
plt.show()
- 导入
matplotlib.pyplot库进行数据可视化。 - 从号导入随机。
- 接下来，我们定义颜色列表。
- 然后，我们使用
scatter()函数进行绘图。 - 为了改变绘图，我们传递了标记、颜色和标签参数。
- 为了在绘图中显示图例，我们使用了
legend()函数。 - 为了美化这个传说，我们将
loc、bbox_to_anchor和ncol作为参数传递。 - 为了改变图例文本的大小，我们将带有大小键的
propdict 作为参数传递给 legend 函数。
Matplotlib legend font size prop argument
rcParams 方法
matplotlib.rcparams 变量是一个类似于字典的变量，包含了修改默认参数的所有设置。使用关键字参数， matplotlib.rc() 函数可用于调整各种设置。
语法如下:
matplotlib.pyplot.rc(group, **kwargs)
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = [2, 3, 4, 5, 6, 7, 8, 9]
y1 = [4, 9, 16, 25, 36, 49, 64, 81]
y2 = [8, 27, 64, 125, 216, 343, 512, 729]
**# Plot**
plt.plot(x, y1, label='Square')
plt.plot(x, y2, label='Cube')
**# Size**
plt.rc('legend', fontsize=21)
**# Add legend**
plt.legend()
**# Add title**
plt.title("rcParams To change Legend Size")
**# Add labels**
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
**# Display**
plt.show()
- 将
matplotlib.pyplot库作为 plt 导入。 - 接下来，我们定义数据坐标。
- 为了绘制坐标之间的图形，我们使用
plot()函数。 - 为了给图形添加图例，我们使用
legend()函数，图例的标签在 plot 函数中定义。 - 要更改图例文本的默认大小，我们使用
rc()方法并传递一个关键字参数fontsize。 - 为了给绘图添加一个标题，我们使用了
title()函数。 - 为了在 x 轴上添加标签，我们使用了
xlabel()函数。 - 为了在 y 轴上添加标签，我们使用了
ylabel()函数。
Matpotlib legend font size rc
阅读: Matplotlib 散点图图例
Matplotlib 条形图图例字体大小
在这里，我们将学习使用 matplotlib 更改条形图的图例字体大小。
让我们看看与此相关的例子:
例#1
在这个例子中，我们用一个数字来指定字体大小。
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
**# Set figure size**
plt.figure(figsize=(7.5,4))
**# Define Data**
team = ['Team 1','Team 2','Team 3','Team 4','Team 5']
won = [15, 10, 30, 20, 25]
lose = [5, 20, 15, 16, 13]
x_axis = np.arange(len(team))
**# Multi bar Chart**
plt.bar(x_axis -0.2, won, width=0.4, label = 'Match_Won')
plt.bar(x_axis +0.2, lose, width=0.4, label = 'Match_Lose')
**# Xticks**
plt.xticks(x_axis, team)
**# Add labels**
plt.xlabel("Team", fontsize=12, fontweight='bold')
plt.ylabel("Matches", fontsize=12, fontweight='bold')
**# Add legend**
plt.legend(fontsize=18)
**# Display**
plt.show()
- 导入用于数据创建的
numpy库。 - 导入
matplotlib.pyplot进行数据可视化。 - 为了设置图形大小，我们将
figsize参数传递给figure()方法。 - 在这之后，我们定义用于绘图的数据。
- 要生成一系列值，请使用
np.arange()方法。 - 然后使用
plt.bar()函数创建多个条形图。 - 为了避免重叠，我们将杆
-0.2和0.2移动到远离 x 轴的位置。 - 然后将杆的宽度固定为
0.4。 - 为了指定 x 轴上的刻度，我们使用了
xticks()函数。 - 为了在轴上添加标签，我们使用了
xlabel()和ylabel()函数。 - 为了给绘图添加图例，我们使用
legend()函数。 - 要更改图例中文本的字体大小，我们使用一个数字来指定字体大小。
Matplotlib bar chart legend font size
例 2
在这个例子中，我们使用一个字符串来指定字体大小。
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
Class = ["First", "Second", "Third", "Fourth", "Fifth"]
Males = [15, 20, 16, 18, 25]
Females = [10, 12, 5, 9, 15]
**# Define height of stacked chart** h = 0.6
**# Plot stacked bar chart**
plt.barh(Class, Males, h, label='Males')
plt.barh(Class, Females, h, left=Boys, label='Females')
**# Set fontsize of legend**
plt.legend(fontsize='x-small')
**# Display**
plt.show()
- 我们在上面的例子中导入了
matplotlib.pyplot包。 - 然后定义条形的数据和高度。
- 然后，使用
plt.barh()方法，我们创建条形图，然后我们传递left作为参数，将这个简单的条形图转换为堆叠条形图。 - 为了给绘图添加一个图例，我们使用
legend()函数。 - 要改变图例中文本的字体大小，我们使用一个字符串来指定字体大小。
Matplotlib legend font size bar chart
在这里，我们将字体大小设置为超小，即 x-small。
另外，检查:将图例放在绘图 matplotlib 之外
Matplotlib 默认图例字体大小
上面，我们学习了改变图例文本的默认字体大小。所以，在这里，我们会看到更多与此相关的例子。
例#1
**# Import Libraries**
import numpy as np
import matplotlib.pyplot as plt
**# Create subplot**
fig, ax = plt.subplots()
**# Define Data**
x = np.linspace(0, 5, 250)
y1 = np.cos(x)
y2 = np.sin(x)
**# Plot**
ax.plot(x, y1, '--b', label ='Cos')
ax.plot(x, y2, c ='r', label ='Sin')
**# Set axes**
ax.axis('equal')
**# Default legend fontsize**
plt.rc('legend',fontsize='xx-large')
**# Legend**
ax.legend();
**# Show**
plt.show()
- 导入
numpy和matplotlib.pyplotpython 库。 - 为了创建一个支线剧情，我们使用支线剧情()函数。
- 为了定义数据坐标，我们使用了
linspace()、cos()和sin()函数。 - 要绘制折线图，我们使用
plot()函数。 - 然后，我们通过使用
axis()函数将轴设置为相等。 - 为了设置图例的默认字体大小，我们使用
rc()方法并传递字体大小作为关键字参数。 - 为了给绘图添加一个图例，我们使用
legend()函数。
Matplotlib default legend font size
例 2
这里，我们将使用 rc.params.update()函数来指定默认的图例字体大小。
**# Import Libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data**
x = np.linspace(0, 20, 100)
y = np.cos(x)
**# Plot graph**
plt.plot(x, y, label="cos(x)")
**# Default legend fontsize**
plt.rcParams.update({'legend.fontsize': 18})
**# Legend**
plt.legend()
**# Display**
plt.show()
- 导入必要的库，例如，
numpy和matplotlib。 - 然后，定义 x 和 y 数据坐标。
- 为了定义数据坐标，我们使用 numpy 的
linspace()和cos()函数。 - 为了绘制数据坐标之间的图形，我们使用了
plot()函数。 - 接下来，
plt.rcParams.update()使用字典参数来更新 Matplotlib 属性和样式。 - matplotlib 图例字体大小由
legend.fontsize参数指定。 - 为了显示图表的图例，我们使用了
legend()函数。 - 为了显示这个图，我们使用了
show()函数。
matplotlib-default-legend-font-size
例 3
这里，我们通过将键放在括号[]中来更新 rcParams 字典。
**# Import Libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Legend font size**
plt.rcParams['legend.fontsize'] = 'xx-large'
**# Define Data**
x = np.linspace(0, 20, 100)
y = np.tan(x)
**# Plot graph**
plt.plot(x, y, label="tan(x)")
**# Legend**
plt.legend()
**# Display**
plt.show()
- 将
matplotlib.pyplot导入为plt进行数据可视化。 - 导入
numpy作为np进行数据创建。 - 为了设置图例的字体大小，我们使用
rcParams字典并将关键字放在括号[]中。这里的关键是legend.fontsize。 - 为了定义 x 和 y 数据坐标，我们使用了
linspace()和tan()函数。 - 为了绘制图表，我们使用了
plot()函数。 - 为了给绘图添加图例，我们使用了
legend()函数。 - 为了在用户屏幕上可视化绘图，我们使用了
show()函数。
Matplotlib default legend font size rcParams
Matplotlib 图例标题字体大小
我们将使用 matplotlib 来改变图例标题字体的大小。默认没有标题。我们必须向 legend 函数传递一个标题参数来设置标题。
让我们看看与此相关的例子:
例#1
在本例中，我们将学习全局更改 legend 的标题大小。
**# Import Libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Legend Font Size**
plt.rcParams['legend.title_fontsize'] = 'x-large'
**# Define Data**
x = np.random.randint(low = 0, high = 60, size = 50)
y = np.random.randint(low = -15, high = 80, size = 50)
**# Plot**
plt.plot(x, color='slategrey', label='Line 1')
plt.plot(y, color= '#EE1289', linestyle = ':', label='Line 2')
**# Legend**
plt.legend(fontsize='small',title='Legend Title')
**# Display**
plt.show()
- 首先，我们导入必要的库，如
numpy和matplotlib.pyplot，分别用于数据创建和数据可视化。 - 然后，我们通过使用括号中的
plt.rcParams字典和legend.title_fontsize键来全局更改图例标题字体大小。 - 之后，我们使用
numpy的random.randint()函数进行数据定义。 - 为了绘制折线图，我们使用了
plot()函数。 - 为了美化情节，我们通过颜色、线型作为参数来设置线条的颜色和线型。
- 为了在图上设置图例，我们通过
legend()函数。 - 为了改变图例文本的字体大小，我们将
fontsize作为参数传递。 - 为了给图例添加标题，我们将标题作为参数传递。
- 为了在用户屏幕上显示图形，我们使用了
show()函数。
Matplotlib legend title font size
例 2
在本例中，我们将使用 title_fontsize 参数来更改图例标题的大小。
**# Import Library**
import matplotlib.pyplot as plt
**# Set figure size**
plt.figure(figsize=(6,5))
**# Define Data Coordinates**
popularity = [45, 14, 13, 7, 21]
emojis = ['Happy Face', 'Sad Face', 'Hearts', 'Hand Gestures',
'Others']
**# Plot**
plt.pie(popularity)
**# Legend**
plt.legend(labels=emojis,bbox_to_anchor=(0.16,0.96),
ncol=2, title='EMOJIS', title_fontsize=18)
**# Display**
plt.show()
- 导入
matplotlib.pyplot库进行数据可视化。 - 要设置图的大小，我们使用带有 figsize 参数的
figure()方法。 - 之后，我们定义要绘制的数据值。
- 然后，我们定义了一个字符串序列列表，它设置了每个楔形区的标签。
- 为了绘制饼图，我们使用了
pie()函数。 - 为了给绘图添加一个图例，我们使用了
legend()函数，并将标签参数传递给它。 - 我们还将
bbox_to_anchor和ncol参数传递给函数，以设置图例的位置，并在图例框中定义列。 - 为了设置图例的标题，我们将参数
title传递给函数。 - 为了修改图例标题的大小，我们传递参数
title_fontsize并将其设置为 18。 - 要显示图形，使用
show()功能。
Matplotlib font size of legend title
例 3
在本例中，我们将使用 set_fontsize 参数来更改图例标题的字体大小。
**# Import Library**
import matplotlib.pyplot as plt
**# Set axes**
fig = plt.figure()
ax = fig.add_subplot(111)
**# Define Data Coordinates**
popularity = [20, 16, 35, 9]
**# Define Label**
books = ['Story Books','Comic Books', 'Puzzel Books',
'Poem Books']
**# Color**
colors=['rosybrown', 'moccasin', 'lightyellow', 'darkseagreen']
**# Plot with different edgecolor**
plt.pie(popularity, wedgeprops={'edgecolor':'maroon'},
colors=colors)
**# Set title font**
lg = ax.legend(labels=books,title='BOOKS',
bbox_to_anchor=(0.45,-0.1),ncol=2,
loc='center')
title = lg.get_title()
title.set_fontsize('x-large')
**# Add title**
plt.title('Favourite Books',fontweight='bold')
**# Display**
plt.show()
- 首先，我们导入
matplotlib库进行数据可视化。 - 然后，作为子图布局的一部分，matplotlib 包的图形模块用于向图形添加轴。
- 之后，我们定义要绘制的数据值。
- 然后，我们定义了一个字符串序列列表，它设置了每个楔形区的标签。
- 我们还定义了颜色列表。
- 要绘制饼图，请使用
pie()方法。 - 我们还定义了饼图中扇区的边缘颜色和颜色。
- 为了设置带有标题的图例，我们使用带有标签和标题参数的
legend()方法。 - 然后我们通过使用
get_title()函数得到图例标题。 - 要改变图例标题的字体大小，我们使用
set_fontsize()方法，将其设置为x-large。 - 为了给情节添加一个标题，我们使用
title()方法。 - 要显示该图，请使用
show()方法。
Font size of matplotlib legend title
你可能也喜欢阅读下面的 Matplotlib 教程。
- Matplotlib 2d 表面图
- Matplotlib 时间序列图
- Matplotlib 不显示图
- Matplotlib 设定 y 轴范围
- Matplotlib 多个图
- Matplotlib 饼图教程
因此，在本 Python 教程中，我们已经讨论了"Matplotlib legend font-size "，并且我们还涵盖了一些与之相关的例子。这些是我们在本教程中讨论过的以下主题。
- Matplotlib 图例字体大小
- Matplotlib 条形图图例字体大小
- Matplotlib 默认图例字体大小
- Matplotlib 图例标题字体大小
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib log log plot
在本 python 教程中，我们将讨论 Python 中的 Matplotlib log log plot 来绘制具有对数标度的图形，我们还将涵盖以下主题:
- Matplotlib log log plot
- Matplotlib 对数对数标度基数为 2
- Matplotlib 对数对数负标度
- Matplotlib 日志日志散点图
- Matplotlib 日志日志直方图
- Matplotlib 日志日志绘图误差线
- Matplotlib 日志日志网格
- Matplotlib 对数对数标度
- Matplotlib 对数对数刻度刻度
- Matplotlib 对数对数标度 y
- Matplotlib 对数对数对数标度 x
- Matplotlib 对数对数刻度次要刻度
- Matplotlib 对数对数刻度颜色条
目录
- Matplotlib 测井记录图
- Matplotlib 对数对数对数标度基数 2
- Matplotlib 对数对数对数标度负值
- Matplotlib 日志日志散布图
- Matplotlib 测井柱状图
- Matplotlib 测井记录绘图误差线
- Matplotlib 日志日志网格
- Matplotlib 对数对数标度
- Matplotlib 对数对数刻度刻度
- Matplotlib 对数对数 y 标度
- Matplotlib 对数对数对数标度 x
- Matplotlib 对数对数刻度小刻度
- Matplotlib 对数对数对数刻度颜色条
Matplotlib 测井记录图
在 python 中， matplotlib 提供了一个函数 loglog ，该函数可以在两个轴(x 轴和 y 轴)上绘制对数比例图。
matplotlib.pyplot.loglog(x, y[, linewidth, color, basex, basey, ...])
在上面的语法中，
- x 指定要绘制的 x 轴数值。
- y 指定要绘制的 y 轴数值。
- 我们可以指定 matplotlib 中基本绘图所支持的任何参数，如线宽、颜色、线型、标签等。
- 除了基本的绘图参数外，还可以指定以下参数:
- basex 和 basey :我们可以分别使用 basex 和 basey 来指定 x 轴和 y 轴的对数刻度的基数。默认基数是 10。
- subsx 和 subsy :我们可以使用 subsx 和 subsy 在图形上指定次要 x 和 y 刻度的位置。如果没有，将根据地块中的十年数自动选择合理的位置。
- nonposx 和 nonposy :我们可以屏蔽x 和 y 中的非正值为无效，或者将它们削成一个很小的正数。默认情况下，它被屏蔽。
现在，让我们通过一个例子来实现我们的理解:
# Importing necessary libraries
import numpy as np
from matplotlib import pyplot as plt
# Preparing the data for the plot
x = np.arange(0.0, 10.0, 0.005)
y = np.exp(2.3 * x + 3.7)
# Creating figure and axes
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=[7, 11])
# Plotting the graph without using loglog
ax1.plot(x, y, ':b', linewidth=2, label='e ^ (2.3 * x + 3.7)')
ax1.set_title('Exponential plot', fontsize=15)
ax1.set_xlabel('x-axis', fontsize=13)
ax1.set_ylabel('y-axis', fontsize=13)
ax1.legend()
# Plotting the graph with Log ticks at x and y axis using loglog
ax2.loglog(x, y, '--r', linewidth=2, label='e ^ (2.3 * x + 3.7)')
ax2.set_title('loglog exponential plot', fontsize=15)
ax2.set_xlabel('log(x)', fontsize=13)
ax2.set_ylabel('log(y)', fontsize=13)
ax2.legend()
plt.tight_layout()
plt.show()
Matplotlib log log plot
Matplotlib 对数对数对数标度基数 2
我们可以通过在matplotlib . py plot . loglog()函数中分别为 x 轴和 y 轴指定参数 basex 和 basey 来更改图表轴的对数刻度的基数。因此，对于图形的任何轴，将基数更改为 2
让我们通过一个例子来实现这个概念，将 x 轴的基点改为 2:
# Importing necessary libraries
import numpy as np
from matplotlib import pyplot as plt
# Preparing the data for the plot
x = np.arange(0.0, 10.0, 0.005)
y = np.exp(2.3 * x + 3.7)
# Resizing the figure
plt.figure(figsize=[7, 5])
# Plotting the graph with Log ticks at x and y axis using loglog
plt.loglog(x, y, '--r', basex=2, linewidth=2,
label='e ^ (2.3 * x + 3.7)')
plt.title('loglog exponential plot with x-axis log base 2',
fontsize=15)
plt.xlabel('log(x)', fontsize=13)
plt.ylabel('log(y)', fontsize=13)
plt.legend()
plt.show()
Matplotlib loglog log scale base 2
阅读: Matplotlib 绘制一条线
Matplotlib 对数对数对数标度负值
Matplotlib 通过分别为 x 轴和 y 轴指定参数 nonposx 和 nonposy 来处理图表的对数刻度轴的负值。
我们可以将值‘mask’或‘clip’指定给参数 nonposx 和 nonposy 。
‘mask’使图形忽略轴上数据点的负值，并将负值视为无效。并且‘clip’将负值数据点改变为小的正值。
现在，让我们通过一些实际例子来理解这个概念:
# Importing necessary libraries
import numpy as np
from matplotlib import pyplot as plt
# Preparing the data for the plots
x = np.linspace(-2.0, 2.0, 20)
y = 2.1 + 3.1 * (x ** 3)
# Resizing the figure
plt.figure(figsize=[8, 10])
# Plotting the loglog graph with neglecting negative values
plt.subplot(211)
plt.loglog(x, y, 'r', basex=2, basey=2, nonposx='mask', nonposy='mask')
plt.title('loglog neglecting negative values', fontsize=15)
plt.xlabel('log(x)', fontsize=13)
plt.ylabel('log(y)', fontsize=13)
# Plotting the loglog graph with negative values to be changed to
# small positives
plt.subplot(212)
plt.loglog(x, y, 'g', basex=2, basey=2, nonposx='clip', nonposy='clip')
plt.title('loglog with negative values change into small positives', fontsize=15)
plt.xlabel('log(x)', fontsize=13)
plt.ylabel('log(y)', fontsize=13)
plt.tight_layout()
plt.show()
Matplotlib loglog log scale negative
阅读: Python 使用 Matplotlib 绘制多条线
Matplotlib 日志日志散布图
我们可以使用 python 中的matplotlib . py plot . log log()函数将散点图的比例更改为对数比例。
我们可以通过以下两种方法之一做到这一点:
- 上面讨论的方法，直接使用
matplotlib . py plot . log log()函数并指定值'。'到参数线型，用于绘制图形以及将轴刻度改为对数刻度。 - 或者我们可以先创建一个散点图，使用
matplotlib . py plot . scatter()函数来绘制图形，然后指定带有所需参数的matplotlib . py plot . log log()函数来将轴的刻度更改为对数刻度。
让我们通过一个例子来实现第二种方法:
# Importing necessary libraries
import numpy as np
from matplotlib import pyplot as plt
# Preparing the data for the plot
x = np.arange(1, 100, 5)
y = 32 * x
# Resizing the figure
plt.figure(figsize=[7, 5])
# Plotting the scatter plot
plt.scatter(x, y, c='g', alpha=0.6)
plt.title('loglog linear plot with y-axis log base 2', fontsize=15)
plt.xlabel('log(x) base 10', fontsize=13)
plt.ylabel('log(y) base 2', fontsize=13)
# Changing to the log ticks at x and y axis using loglog
plt.loglog(basex=10, basey=2)
plt.show()
Matplotlib log log scatter
Matplotlib 测井柱状图
我们可以通过将值 True 指定给 matplotlib.pyplot.hist() 函数中的参数 log 来改变 python 中直方图坐标轴的刻度。
它会将直方图的 y 轴比例更改为对数比例，默认基数为 10。
让我们通过一个例子来实现这个概念:
# Importing necessary libraries
import numpy as np
from matplotlib import pyplot as plt
# Preparing the data for the plots
np.random.seed(217)
x = np.random.randn(10000)
nbins = 15
# Resizing the figure
plt.figure(figsize=[9, 11])
# Plotting the histogram without log scale
plt.subplot(211)
plt.hist(x, bins=nbins)
plt.title('Histogram', fontsize=15)
plt.xlabel('x-axis (bins)', fontsize=13)
plt.ylabel('y-axis (Heights)', fontsize=13)
# Plotting the histogram on log scale
plt.subplot(212)
plt.hist(x, bins=nbins, log=True, color='g')
plt.title('Histogram on log scale', fontsize=15)
plt.xlabel('x-axis (bins)', fontsize=13)
plt.ylabel('log(y): log(Heights)', fontsize=13)
plt.tight_layout()
plt.show()
Matplotlib log log histogram
阅读: Matplotlib 绘图条形图
Matplotlib 测井记录绘图误差线
我们可以通过使用带有指定的 nonposx 和 nonposy 参数的matplotlib . py plot . log log()函数，将图表上绘制的误差线的刻度更改为对数刻度。
误差线的值可以是负值，因此我们必须将参数 nonposx 和 nonposy 的值指定为【T4’clip’，以将负值更改为较小的正值，并将其绘制到图形中。
让我们以上述概念的实现为例来看看:
# Importing necessary libraries
import numpy as np
from matplotlib import pyplot as plt
# Preparing the data for the plots
x = 10.0**np.linspace(0.0, 2.0, 20)
y = 2.1 * (x ` 3) + 3.1 * (x ` 2)
x_err = 0.1 * x
y_err = 7.0 + 0.35 * y
# Resizing the figure
plt.figure(figsize=[8, 10])
# Plotting the errorbars without log scale
plt.subplot(211)
plt.errorbar(x, y, xerr=x_err, yerr=y_err)
plt.title('Errorbars', fontsize=15)
plt.xlabel('x-axis', fontsize=13)
plt.ylabel('y-axis', fontsize=13)
# Plotting the errorbars with log scale
plt.subplot(212)
plt.errorbar(x, y, xerr=x_err, yerr=y_err, color='g')
plt.loglog(nonposx='clip', nonposy='clip')
plt.title('Errorbars on log scale', fontsize=15)
plt.xlabel('log(x)', fontsize=13)
plt.ylabel('log(y)', fontsize=13)
plt.tight_layout()
plt.show()
Matplotlib log log plot error bars
Matplotlib 日志日志网格
我们可以通过在图形语句中添加语句 matplotlib.pyplot.grid() 来指定对数标度图形中的网格线。
我们来练习一个例子，让概念更清晰。在下面给出的例子中，我们用不同类型的图形创建了 4 个子图，每个图形都有网格线:
# Importing necessary libraries
import numpy as np
from matplotlib import pyplot as plt
# Resizing the figure
plt.figure(figsize=[11, 10])
# Preparing the data for the plot
x1 = np.arange(0.0, 10.0, 0.005)
y1 = np.exp(2.3 * x1 + 3.7)
# Plotting the graph with Log ticks at x and y axis using loglog
plt.subplot(221)
plt.loglog(x1, y1, '--r', basex=2, linewidth=3)
plt.title('loglog exponential plot', fontsize=15)
plt.xlabel('log(x) base 2', fontsize=13)
plt.ylabel('log(y) base 10', fontsize=13)
plt.grid()
# Preparing the data for the plot
x2 = np.arange(1, 100, 5)
y2 = 32 * x2
# Plotting the scatter plot
plt.subplot(222)
plt.scatter(x2, y2, c='y', alpha=0.6)
plt.title('loglog linear plot', fontsize=15)
plt.xlabel('log(x) base 10', fontsize=13)
plt.ylabel('log(y) base 2', fontsize=13)
# Changing to the log ticks at x and y axis using loglog
plt.loglog(basex=10, basey=2)
plt.grid()
# Preparing the data for the plots
np.random.seed(217)
x3 = np.random.randn(10000)
nbins = 15
# Plotting the histogram on log scale
plt.subplot(223)
plt.hist(x3, bins=nbins, log=True, color='g')
plt.title('Histogram on log scale', fontsize=15)
plt.xlabel('x-axis (bins)', fontsize=13)
plt.ylabel('log(y): log(Heights)', fontsize=13)
plt.grid()
# Preparing the data for the plots
x4 = 10.0**np.linspace(0.0, 2.0, 20)
y4 = 2.1 * (x4 ` 3) + 3.1 * (x4 ` 2)
x_err = 0.1 * x4
y_err = 7.0 + 0.35 * y4
# Plotting the errorbars with log scale
plt.subplot(224)
plt.errorbar(x4, y4, xerr=x_err, yerr=y_err, color='c')
plt.loglog(basex=2, nonposx='clip', nonposy='clip')
plt.title('Errorbars on log scale', fontsize=15)
plt.xlabel('log(x) base 2', fontsize=13)
plt.ylabel('log(y) base 10', fontsize=13)
plt.grid()
plt.tight_layout()
plt.show()
Matplotlib log log grid
阅读: Matplotlib 最佳拟合线
Matplotlib 对数对数标度
我们可以通过将对数刻度的基数更改为所需的值(最小值可以是 2)来放大和缩小图表上的对数刻度。
- 我们可以通过在
matplotlib . py plot . loglog()函数中指定参数basex和basey来更改对数标度的基数。 - 或者我们可以使用函数
matplotlib . py plot . xscale()和matplotlib . py plot . yscale()以及位置参数‘log’将轴的刻度更改为对数刻度。并且还指定参数basex和basey来分别指定 x 轴和 y 轴的对数刻度的基数。语法如下:
matplotlib.pyplot.xscale('log', [basex, subsx, nonposx])
matplotlib.pyplot.yscale('log', [basey, subsy, nonposy])
在上面的语法中，这里的位置论元是‘log’，我们可以将其指定为‘linear’，‘symlog’，‘logit’等。，它指定我们需要的缩放类型。其余的论点已经在第一个主题中讨论过了。
让我们通过一个示例实现第二种方法来更改图表轴的比例:
# Importing necessary libraries
import numpy as np
from matplotlib import pyplot as plt
# Preparing the data for the plots
x = np.linspace(-2.0, 2.0, 20)
y = 2.1 + 3.1 * (x ** 3)
# Resizing the figure
plt.figure(figsize=[8, 10])
plt.plot(x, y, 'g', linewidth=3)
plt.xscale('log', basex=2, nonposx='clip')
plt.yscale('log', basey=2, nonposy='clip')
plt.title('Matplotlib log scale using xscale and yscale', fontsize=15)
plt.xlabel('log(x) base 2', fontsize=13)
plt.ylabel('log(y) base 2', fontsize=13)
plt.grid()
plt.show()
Matplotlib log scale using xscale and yscale
Matplotlib 对数对数刻度刻度
通过改变对数刻度轴的底部，我们也可以改变刻度。我们已经讨论了改变对数刻度轴的底部的方法。
因此，让我们通过一个示例来实现这个概念并进行一些实际操作:
# Importing necessary libraries
import numpy as np
from matplotlib import pyplot as plt
# Preparing the data for the plots
x = np.linspace(-2.0, 2.0, 20)
y = 3.1 * (x ` 4) + 0.3 * (x ` 2) + 0.7 * x
# Resizing the figure
plt.figure(figsize=[7, 11])
plt.subplot(311)
plt.plot(x, y, 'r', linewidth=3)
plt.loglog(basex=10, basey=10, nonposx='clip', nonposy='clip')
plt.title('Matplotlib loglog scale tick plot 1', fontsize=15)
plt.xlabel('log(x) base 10', fontsize=13)
plt.ylabel('log(y) base 10', fontsize=13)
plt.grid(linewidth=2)
plt.subplot(312)
plt.plot(x, y, 'g', linewidth=3)
plt.loglog(basex=5, basey=5, nonposx='clip', nonposy='clip')
plt.title('Matplotlib loglog scale tick plot 2', fontsize=15)
plt.xlabel('log(x) base 5', fontsize=13)
plt.ylabel('log(y) base 5', fontsize=13)
plt.grid(linewidth=2)
plt.subplot(313)
plt.plot(x, y, 'c', linewidth=3)
plt.loglog(basex=2, basey=2, nonposx='clip', nonposy='clip')
plt.title('Matplotlib loglog scale tick plot 3', fontsize=15)
plt.xlabel('log(x) base 2', fontsize=13)
plt.ylabel('log(y) base 2', fontsize=13)
plt.grid(linewidth=2)
plt.tight_layout()
plt.show()
Matplotlib loglog log scale ticks
Matplotlib 对数对数 y 标度
通过使用matplotlib . py plot . semi logy()函数，我们可以仅将 y 轴的刻度更改为对数刻度。它的工作原理与matplotlib . py plot . loglog()函数相同，但只提供 y 轴刻度参数(basey、subsy 和 nonposy)。语法如下:
matplotlib.pyplot.semilogy(x, y, [, color, linestyle, basex, subsx, nonposx, ...])
在上面的语法中，所有的参数已经在第一个主题中讨论过了。
让我们通过一个例子来实现上面的概念:
# Importing necessary libraries
import numpy as np
from matplotlib import pyplot as plt
# Preparing the data for the plots
x = np.linspace(0.01, 100, 1000)
y = 7.1 * np.exp(-x) + 2.5 * x
# Resizing the figure
plt.figure(figsize=[9, 7])
# log y axis in the plot
plt.semilogy(x, y, basey=2)
plt.title('Matplotlib log scale y', fontsize=15)
plt.xlabel('x-axis', fontsize=13)
plt.ylabel('log(y) base 2', fontsize=13)
plt.grid()
plt.show()
Matplotlib log scale y-axis using semilogy
阅读在 Python 中添加文本到绘图 matplotlib
Matplotlib 对数对数对数标度 x
通过使用matplotlib . py plot . semi logx()函数，我们可以只将 x 轴的刻度更改为对数刻度。它的工作原理与matplotlib . py plot . loglog()函数相同，但只提供 x 轴比例参数(basex、subsx 和 nonposx)。语法如下:
matplotlib.pyplot.semilogx(x, y, [, color, linestyle, basex, subsx, nonposx, ...])
在上面的语法中，所有的参数已经在第一个主题中讨论过了。
让我们通过一个例子来实现上面的概念:
# Importing necessary libraries
import numpy as np
from matplotlib import pyplot as plt
# Preparing the data for the plots
x = np.linspace(0.01, 100, 1000)
y = np.cos(np.pi * x)
# Resizing the figure
plt.figure(figsize=[9, 7])
# log x axis in the plot
plt.semilogx(x, y, basex=10)
plt.title('Matplotlib log scale x for cos function', fontsize=15)
plt.xlabel('log(x) base 10', fontsize=13)
plt.ylabel('y-axis', fontsize=13)
plt.grid()
plt.show()
Matplotlib log scale x-axis using semilogx
Matplotlib 对数对数刻度小刻度
我们可以通过在matplotlib . py plot . log log()函数中分别为 x 轴次要刻度和 y 轴次要刻度指定参数 subsx 和 subsy 的值来缩放对数刻度轴的次要刻度。
例如，对于基数为 10 的对数标度轴，我们可以将 subsx/subsy 的值指定为[2，3，4，5，6，7，8，9]，这将使这些列表值位于主要刻度[10⁰，10¹，10²，…]的值之间。类似地，对于基数为 5 的对数标度轴，我们可以给出[2，3，4]或[1.5，2，2.5，3，3.5，4，4.5]。
让我们举一个例子来实现上述概念:
# Importing necessary libraries
import numpy as np
from matplotlib import pyplot as plt
# Preparing the data for the plots
x = np.linspace(-2.0, 2.0, 20)
y = 3.1 * (x ` 3) + 0.3 * (x ` 2) + 0.7 * x
# Resizing the figure
plt.figure(figsize=[7, 11])
plt.subplot(211)
plt.plot(x, y, 'g', linewidth=3)
plt.loglog(basex=2, basey=10, nonposx='clip', nonposy='clip',
subsx=[0.5, 1.0, 1.5])
plt.title('Matplotlib log scale scale minor ticks Plot 1', fontsize=15)
plt.xlabel('log(x) base 2', fontsize=13)
plt.ylabel('log(y) base 10', fontsize=13)
plt.grid(b=True, which='major', linewidth=2, linestyle='-')
plt.grid(b=True, which='minor', linewidth=1, linestyle='--')
plt.subplot(212)
plt.plot(x, y, 'g', linewidth=3)
plt.loglog(basex=2, basey=10, nonposx='clip', nonposy='clip',
subsx=[0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
suby=[2, 3, 4, 5, 6, 7, 8, 9])
plt.title('Matplotlib log scale scale minor ticks Plot 2', fontsize=15)
plt.xlabel('log(x) base 2', fontsize=13)
plt.ylabel('log(y) base 10', fontsize=13)
plt.grid(b=True, which='major', linewidth=2, linestyle='-')
plt.grid(b=True, which='minor', linewidth=1, linestyle='--')
plt.tight_layout()
plt.show()
Matplotlib loglog log scale minor ticks
阅读: Matplotlib 虚线
Matplotlib 对数对数对数刻度颜色条
我们还可以使用 matplotlib 在 python 中将颜色条的比例更改为对数比例。我们可以使用 python 的 matplotlib 模块/库的颜色子模块来指定对数标度的颜色值。
我们可以在定义(或创建)的图像(或 colorgrid 或 colormesh)中将 norm 参数的值指定为颜色。LogNorm() 将标准化的颜色值换算成对数标度。
让我们通过一个例子来说明上面的概念。在本例中，我们将使用 pcolormesh() 创建一个 colorgrid，然后为创建的 colorgrid 定义对数标度的 colorbar:
# Importing necessary libraries
import numpy as np
from matplotlib import pyplot as plt
from matplotlib import colors as colors
# Preparing the data for the pcolormesh
np.random.seed(20000)
Z = np.random.rand(7, 15)
x = np.arange(-0.75, 15.0, 1)
y = np.arange(5.0, 15.0, 1.5)
# Resizing the figure
plt.figure(figsize=[7, 11])
# Plotting the pcolormesh with colorbar
plt.subplot(211)
plt.pcolormesh(x, y, Z)
plt.title('Matplotlib pcolormesh with colorbar', fontsize=15)
plt.xlabel('x-axis', fontsize=13)
plt.ylabel('y-axis', fontsize=13)
plt.colorbar()
# Plotting the pcolormesh with log scale colorbar
plt.subplot(212)
plt.pcolormesh(x, y, Z, norm=colors.LogNorm())
plt.title('Matplotlib pcolormesh with log scale colorbar', fontsize=15)
plt.xlabel('x-axis', fontsize=13)
plt.ylabel('y-axis', fontsize=13)
plt.colorbar()
plt.tight_layout()
plt.show()
Matplotlib log scale colorbar using LogNorm()
另外，请查看以下关于 Matplotlib 的文章。
在本 python 教程中，我们讨论了 Python 中的 Matplotlib log log plot 来绘制具有对数标度的图形，我们还讨论了以下主题:
- Matplotlib log log plot
- Matplotlib 日志日志散点图
- Matplotlib 日志日志直方图
- Matplotlib 日志日志绘图误差线
- Matplotlib 日志日志网格
- Matplotlib 对数对数标度
- Matplotlib 对数对数刻度刻度
- Matplotlib 对数对数标度 y
- Matplotlib 对数对数对数标度 x
- Matplotlib 对数对数刻度次要刻度
- Matplotlib 对数对数刻度颜色条
- Matplotlib 对数对数标度基数为 2
- Matplotlib 对数对数负标度
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib 多条形图
在本 Matplotlib 教程中，我们将讨论 python 中的 Matplotlib 多条形图。在这里，我们将使用 matplotlib 介绍与多条形图相关的不同示例。我们还将讨论以下主题:
- Matplotlib 多条形图
- Matplotlib 多条形图示例
- 并排的多个条形图
- Matplotlib 多水平条形图
- matplotlib 多条形图熊猫
- Matplotlib 条形图多列
- Matplotlib 条形图多种颜色
- Matplotlib 覆盖两个条形图
- Matplotlib 多重堆积条形图
- Matplotlib 条形图多组
- Matplotlib 多个条形图标签
- Matplotlib 多条形图标题
目录
- Matplotlib 多条形图
- Matplotlib 多个条形图示例
- Matplotlib 多个条形图并排
- Matplotlib 多个水平条形图
- Matplotlib 多条形图熊猫
- Matplotlib 条形图多列
- Matplotlib 条形图多色
- Matplotlib 叠加两个条形图
- Matplotlib 多重堆积条形图
- Matplotlib 条形图多组
- Matplotlib 多个条形图标签
- Matplotlib 多个条形图标题
Matplotlib 多条形图
在本节中，我们将学习如何在 Python 的 matplotlib 中绘制多条形图。在开始这个话题之前，我们首先要了解多条形图是什么意思:
多条形图 表示多个条形图。它也被称为分组条形图。
多重条形图用于描述各种数据变量之间的关系。图中的列表示每个数据值。基本上，多个条形图用于比较不同的实体。
用于绘制多条形图的以下步骤概述如下:
- 定义库:导入绘制多条形图和数据可视化所需的库
pyplot，还导入其他数据创建和操作所需的库numpy和pandas。 - 定义数据:定义用于绘图的 x 轴和 y 轴的数据坐标值。
- 绘制多条形图:通过使用 matplotlib 库的
bar()方法我们可以绘制多个条形图。 - 可视化绘图:通过使用
show()方法，用户可以在他们的屏幕上生成一个绘图。
多条形图绘图的语法如下:
matplotlib.pyplot.bar(x, height, width=None, bottom=None, align='center', data=None, **kwargs)
参数定义如下:
- x: 指定条形的 x 坐标。
- height: y 坐标指定条形的高度。
- 宽度:指定条形的宽度。
- 底部:指定条形底部的 y 坐标。
- 对齐:条的对齐。
Matplotlib 多个条形图示例
让我们看不同的例子来更清楚地理解 的概念:
例#1
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
team = ['Team 1','Team 2','Team 3','Team 4','Team 5']
female = [5, 10, 15, 20, 25]
male = [15, 20, 30, 16, 13]
x_axis = np.arange(len(team))
**# Multi bar Chart**
plt.bar(x_axis -0.2, female, width=0.4, label = 'Female')
plt.bar(x_axis +0.2, male, width=0.4, label = 'Male')
**# Xticks**
plt.xticks(x_axis, team)
**# Add legend**
plt.legend()
**# Display**
plt.show()
- 在上面的例子中，我们导入了库，如
numpy和matplotlib.pyplot。 - 在这之后，我们定义用于绘图的数据。
np.arange()方法用于创建一个数值范围。- 然后用
plt.bar()函数绘制多个条形图。 - 然后我们从 x 轴移动杆
-0.2和0.2单位以避免重叠。 - 然后我们将横条的宽度设置为
0.4。
plt.bar()
例 2
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
team = ['Team 1','Team 2','Team 3']
Python = [5, 10, 15]
Java = [15, 20, 30]
Php = [ 5, 9, 12]
x_axis = np.arange(len(team))
**# Multi bar Chart**
plt.bar(x_axis +0.20, Python, width=0.2, label = 'Python')
plt.bar(x_axis +0.20*2, Java, width=0.2, label = 'Java')
plt.bar(x_axis +0.20*3, Php, width=0.2, label = 'Php')
**# Xticks**
plt.xticks(x_axis,team)
**# Add legend**
plt.legend()
**# Display**
plt.show()
- 在上面的例子中，我们导入了所需的库，如
numpy、pyplot。 - 然后我们定义用于绘图的数据。
- 之后，我们使用 numpy 的
arange()方法得到 x 轴的长度。 plt.bar()方法用于绘制多个条形图。plt.xticks()函数定义 x 个刻度，使用plt.legend()方法添加图例。
” Multiple Bar Chart ”
阅读: Matplotlib 散点图图例
Matplotlib 多个条形图并排
这里我们将并排绘制多个条形图。为了并排绘制，我们必须绘制支线剧情。
让我们来看一个并排多个条形图的例子:
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x1 = [2.5, 3.5, 4.5, 5.5, 6.5, 7.5]
y1 = [3, 6, 9, 12, 15, 18]
x2 = [5, 10, 15, 20, 25, 30]
y2 = [2.6, 9.5, 14, 12, 8.3, 12]
r = np.arange(6)
width = 0.4
**# Draw first subplot**
plt.subplot(1, 2, 1)
plt.bar(r, x1, width=width)
plt.bar(r + width, y1, width=width)
**# Draw second subplot**
plt.subplot(1, 2, 2)
plt.bar(r, x2, width=width)
plt.bar(r + width, y2, width=width)
**# Display**
plt.show()
- 在上面的例子中，我们导入了
numpy和matplotlib.pyplot库。 - 之后，我们定义用于绘图的数据。
- 然后我们使用
np.arange()函数来创建一系列值。 - 通过使用
plt.subplot()方法，我们创建了两个并排的支线剧情。 plt.bar()方法用于创建多个条形图图形。
“Multiple Bar Graphs Side By Side”
Matplotlib 多个水平条形图
在这里，我们将学习如何绘制成组的条形图，或者我们可以说是水平方向上的多个条形图。
首先，我们必须知道创建水平条形图的语法:
matplotlib.pyplot.barh(y, width, height=0.8, left=none, align='center', **kwargs)
使用的参数描述如下:
- y: 指定 y 轴的坐标。
- 宽度:指定条形的宽度。
- 高度:指定条形的高度。
- left: 指定条形左侧的 x 坐标。
- 对齐:基座与 y 坐标对齐。
让我们看一个绘制多个水平条形图的例子:
**# Import Library**
import matplotlib.pyplot as plt
import pandas as pd
**# Define Data**
data = {'Girls': [15, 20, 25, 30, 35],
'Boys': [25, 30, 28, 19, 40] }
df = pd.DataFrame(data,columns=['Girls','Boys'], index = ['Team-1','Team-2','Team-3','Team-4','Team-5'])
**# Multiple horizontal bar chart**
df.plot.barh()
**# Display**
plt.show()
- 在上面的例子中，我们通过使用熊猫数据帧来定义数据。
- 然后我们用一个
plot.barh()的方法画出多个水平条形图。 plt.show()方法用于在用户屏幕上可视化绘图。
” Horizontal Multiple Bar Chart “
Matplotlib 多条形图熊猫
在这里，我们将学习如何使用 pandas DataFrame 绘制多个条形图。
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
import pandas as pd
**# Define Data**
data = {'Girls': [15, 20, 25, 30, 35],
'Boys': [25, 30, 28, 19, 40] }
df = pd.DataFrame(data,columns=['Girls','Boys'], index = ['MCA','BCA','MCOM','BCOM','BA'])
**# Multiple bar chart**
df.plot.bar()
**# Display**
plt.show()
- 在上面的例子中，我们导入了重要的库，如熊猫和
pyplot。 - 接下来，我们使用 Pandas
DataFrame定义数据。 plot.bar()方法用于创建多个条形图。
” Multiple Bar Chart Using Pandas “
Matplotlib 条形图多列
在这里，我们正在学习如何绘制一个有多列的条形图。我们使用 plot() 方法来绘制条形图并定义多个列，我们使用 DataFrame 对象。
举例:
这里我们将使用熊猫的 DataFrame 对象创建多个条形图。我们创建一个有 5 多个列的条形图。
**# Import Library**
import pandas as pd
import matplotlib.pyplot as plt
**# Define Data**
data=[["A",40, 36, 38, 35, 40],
["B",39, 37, 33, 38, 32],
["C",28, 30, 33, 39, 24],
["D",40, 40, 35, 29, 35],
["E", 28, 25, 16, 27, 30]
]
**# Plot multiple columns bar chart**
df=pd.DataFrame(data,columns=["Name","English","Hindi","Maths", "Science", "Computer"])
df.plot(x="Name", y=["English","Hindi","Maths", "Science", "Computer"], kind="bar",figsize=(9,8))
**# Show**
plt.show()
- 在上面的例子中，我们导入了熊猫和
pyplot库。 - 之后，我们定义数据并创建数据帧。
- 然后我们使用
plot()函数绘制一个带有5多列的条形图。这里我们通过类作为参数来提及类栏类的剧情。
” Bar Chart with 5 multiple columns “
Matplotlib 条形图多色
在这里，我们将创建不同颜色的条形图分组。
要改变条的颜色，我们必须将颜色作为参数传递，并将不同颜色的列表作为值传递。
改变颜色的语法如下:
matplotlib.pyplot.bar(x, height, color=None ...)
这里的颜色参数用于根据我们的选择来设置条形的颜色。
我们来看一些例子:
举例:
**# Import Library**
import pandas as pd
import matplotlib.pyplot as plt
**# Define Data**
data=[["Team A",10, 5, 3],
["Team B",6, 3, 8],
["Team C",4, 12, 5],
["Team D",8, 9, 5]
]
**# Colors**
my_color =['yellow', 'cyan','m','blue']
**# Plot multiple bar chart with color of your choice**
df=pd.DataFrame(data,columns=["Team","Web Development", "Andriod", "IoT"])
df.plot(x="Team", y=["Web Development", "Andriod", "IoT"],
kind="bar",figsize=(8,4), color=my_color)
**# Show**
plt.show()
在上面的例子中，我们创建了一个颜色的列表，并将其传递给 plot() 方法的颜色参数，这样我们就可以根据自己的选择设置条形的颜色。
plot(kind=bar, color=my_color)
举例:
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
team = ['Team 1','Team 2','Team 3','Team 4','Team 5']
female = [5, 10, 15, 20, 25]
male = [15, 20, 30, 16, 13]
x_axis = np.arange(len(team))
**# Multiple colors of bars**
plt.bar(x_axis -0.2, female, width=0.4,
label = 'Female', color='k')
plt.bar(x_axis +0.2, male, width=0.4,
label = 'Male', color='g')
**# Xticks**
plt.xticks(x_axis, team)
**# Add legend**
plt.legend()
**# Display**
plt.show()
在上面的例子中，我们使用两个 plt.bar() 方法来创建多个条形，并向每个函数传递一个颜色参数来根据我们的选择设置条形的值。
plt.bar(color=None)
阅读: Matplotlib 条形图标签
Matplotlib 叠加两个条形图
在这里，我们将学习如何将条形图中的一个条形叠加到另一个条形中。
让我们来看一个叠加两个条形图的例子:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data**
x = [0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5, 11.5, 12.5, 14.5]
y = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
ind = np.arange(14)
**# Create figure**
fig = plt.figure()
ax = fig.add_subplot(111)
**# Multiple bar chart**
ax.bar(x=ind, height=x, width=0.55,align='center')
ax.bar(x=ind, height=y, width=0.55/3, align='center')
**# Define x-ticks**
plt.xticks(ind, x)
**# Layout and Display**
plt.tight_layout()
plt.show()
- 在上面的例子中，我们导入了
numpy和matplotlib库。 - 之后，我们定义用于绘制多个条形图的数据。
- 然后我们创建一个人物并使用
add_figure()方法创建支线剧情。 ax.bar()方法用于创建多个条形图，其中一个条形图覆盖另一个条形图。这里，我们划分位于另一个条内的条的宽度。
” Overlay two bar chart “
读取: Matplotlib 绘图误差线
Matplotlib 多重堆积条形图
在这里，我们将学习如何创建分组堆积条形图。首先，我们了解了堆叠条形图的含义:
堆积条形图 是一种用来比较部分整体的图形。当我们在一个类别中有多组数据时，我们可以针对每组数据建立联系，并将条形一个放在另一个之上。”
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
import pandas as pd
**# Define Data**
df = pd.DataFrame(dict(
x1=[3, 4, 5, 6],
x2=[5, 9, 11.2, 14],
x3=[1.6, 3, 4, 6.5],
x4=[4.5, 5.5, 8.9, 12]))
**# Stacked grouped bar chart**
plt.bar([0, 1, 2, 3], df.x2, align='edge', width= 0.4,color='g')
plt.bar([0, 1, 2, 3], df.x1, align='edge', width= 0.4,color='c')
plt.bar([0, 1, 2, 3], df.x4, align='edge',width= -0.4, color='r')
plt.bar([0, 1, 2, 3], df.x3, align='edge',width= -0.4,color='y')
**# Show**
plt.show()
- 在上面的例子中，我们使用 DataFrame 定义数据。
- 然后，我们通过以创建堆叠条形图的方式提及数据点来绘制堆叠多条形图。
“Stacked Multiple Bar Chart”
Matplotlib 条形图多组
在这里，我们将创建一个包含多个组的条形图。多组多列意思相同。
让我们看一个例子，我们用多个组绘制一个条形图。
这里，我们创建了一个包含 6 个组的条形图。
**# Import Library**
import pandas as pd
import matplotlib.pyplot as plt
**# Define Data**
data=[["Team A", 500, 100, 350, 250, 400, 600],
["Team B", 130, 536, 402, 500, 350, 250],
["Team C", 230, 330, 500, 450, 600, 298],
["Team D", 150, 398, 468, 444, 897, 300]
]
**# Plot multiple groups**
df=pd.DataFrame(data,columns=["Team","January", "March", "May", "July", "September", "November"])
df.plot(x="Team", y=["January", "March", "May", "July", "September", "November"], kind="bar",
figsize=(8,4))
**# Show**
plt.show()
- 在上面的例子中，我们导入了熊猫和
matplotlib.pyplot库。 - 接下来，我们创建数据帧。
- 然后我们用
plot()的方法画出一个有6个多组的条形图。
” Multiple Groups Bar Chart “
阅读: Matplotlib 散点图标记
Matplotlib 多个条形图标签
在这里，我们将学习如何向多个条形图添加标签。
添加标签的语法:
**# X-axis label**
matplotlib.pyplot.xlabel()
**# Y-axis label**
matplotlib.pyplot.ylabel()
举例:
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
team = ['Team 1','Team 2','Team 3','Team 4','Team 5']
female = [5, 10, 15, 20, 25]
male = [15, 20, 30, 16, 13]
x_axis = np.arange(len(team))
**# Multi bar Chart**
plt.bar(x_axis -0.2, female, width=0.4, label = 'Female')
plt.bar(x_axis +0.2, male, width=0.4, label = 'Male')
**# Xticks**
plt.xticks(x_axis, team)
**# Add labels**
plt.xlabel("Team", fontsize=12, fontweight='bold')
plt.ylabel("No.of Persons", fontsize=12, fontweight='bold')
# Add legend
plt.legend()
**# Display**
plt.show()
- 在上面的例子中，我们分别使用
plt.xlabel()和plt.ylabel()在 x 轴和 y 轴定义了标签。 - 要创建多个条形图我们使用
plt.bar()方法。
” Multiple Bar Chart with Labels “
阅读: Matplotlib 虚线
Matplotlib 多个条形图标题
这里我们将创建多个带有标题的条形图。要添加标题，我们使用 title() 函数。
添加标题的语法如下:
matplotlib.pyplot.title()
举例:
**# Import Library**
import pandas as pd
import matplotlib.pyplot as plt
**# Define Data**
data=[["Team A",10, 5, 3],
["Team B",6, 3, 8],
["Team C",4, 12, 5],
["Team D",8, 9, 5]
]
**# Colors**
my_color =['yellow', 'cyan','m','blue']
**# Plot multiple bar chart**
df=pd.DataFrame(data,columns=["Team","Web Development", "Andriod", "IoT"])
df.plot(x="Team", y=["Web Development", "Andriod", "IoT"], kind="bar",
figsize=(8,4), color=my_color)
**# Add title**
plt.title("Studenr vs Courses")
**# Show**
plt.show()
在上面的例子中，我们使用 plt.title() 方法给多个条形图添加一个标题。
“Multiple Bar Chart with Title”
你可能也喜欢阅读下面的 Matplotlib 教程。
- Matplotlib plot_date
- Matplotlib 散点图颜色
- Matplotlib 子情节 _adjust
- Matplotlib 设定轴范围
- Matplotlib 时间序列图
- Matplotlib 绘图条形图
在本 Python 教程中，我们已经讨论了" Matplotlib multiple bar chart ",我们还介绍了一些与之相关的例子。这些是我们在本教程中讨论过的以下主题。
- Matplotlib 多条形图
- Matplotlib 多条形图示例
- 并排的多个条形图
- Matplotlib 多水平条形图
- matplotlib 多条形图熊猫
- Matplotlib 条形图多列
- Matplotlib 条形图多种颜色
- Matplotlib 覆盖两个条形图
- Matplotlib 多重堆积条形图
- Matplotlib 条形图多组
- Matplotlib 多个条形图标签
- Matplotlib 多条形图标题
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib 多图
在本 Python Matplotlib 教程中，我们将讨论 Python 中的 Matplotlib 多重绘图。在这里，我们将介绍与使用 matplotlib 的多个绘图相关的不同示例。此外，我们还将涵盖以下主题:
- Matplotlib 多图
- Matplotlib 多图示例
- Matplotlib 多个图一个标题
- Matplotlib 多个图一个图例
- Matplotlib 绘制多个矩形
- Matplotlib 多个图一个颜色条
- Matplotlib 多极坐标图
- Matplotlib 多盒图
- 多个小提琴情节
- Matplotlib 多重圆形图
- Matplotlib 多重等高线图
- Matplotlib 多图直方图
- Matplotlib 多图 seaborn
目录
- Matplotlib 多个图
- Matplotlib 多图示例
- Matplotlib 多个地块一个标题
- Matplotlib 多个图一个图例
- Matplotlib 绘制多个矩形
- Matplotlib 多个图一个颜色条
- Matplotlib 多极坐标图
- Matplotlib 多盒图
- Matplotlib 多个小提琴情节
- Matplotlib 多圆图
- Matplotlib 多重等高线图
- Matplotlib 多图直方图
- Matplotlib 多个地块 seaborn
Matplotlib 多个图
Matplotlib 的子情节() 和子情节()函数便于在单个图形内创建多个情节的网格。制造多个罐，并从图的左上开始排成一行。
支线剧情()函数
【subplot()函数的语法如下:
matplotlib.pyplot.subplot(nrows, ncols, index, **kwargs)
**#OR**
matplotlib.pyplotsubplot(pos, **kwargs)
参数如下:
- nrows: 指定行数。
- ncols: 指定列数。
- 索引:指定当前图的索引。
- kwargs: 指定美化情节的额外功能。
- 位置:指定当前绘图的位置。
在的第一个语法中，我们传递三个独立的整数参数来描述多个绘图的位置。
在的第二个语法中，我们传递一个三位数的整数来指定位置参数，以定义 nrows、ncols 和 index。
支线剧情()功能
【subplots()函数的语法如下:
matplotlib.pyplot.subplots(nrows, ncols, sharex=False,
sharey=False, squeeze=True,
subplot_kw=None, gridspec_kw=None,
**kwargs)
参数如下:
- nrows，ncols: 指定行数和列数。
- sharex，sharey: 指定 x 轴和 y 轴之间的共享属性。
- squeeze: 该可选参数的默认值为 True，通常包含布尔值。
- subplot_kw: 提供给 add subplot 方法的带有关键字的 dict，用于创建每个 subplot。
- gridspec_kw: 用于创建多个地块所在的网格。
支线剧情()vs 支线剧情()
使用 subplots() 函数时，你可以只用一行代码生成一个有多个图的图形。另一方面，子图()函数只在给定的网格位置构造一个子图 ax。
另外，检查Matplotlib subplots _ adjust
Matplotlib 多图示例
这里我们将看到一个使用 matplotlib 函数 subplot() 和subplot()的多重绘图的例子。
我们来看例子:
例#1
在这个例子中，我们将使用 subplot()函数来创建多个绘图。
**# Import library**
import matplotlib.pyplot as plt
**# Create figure**
fig = plt.figure()
**# Create each subplot individually**
ax1 = plt.subplot(131)
ax2 = plt.subplot(132)
ax3 = plt.subplot(133)
**# Auto adjust**
plt.tight_layout()
**# Display**
plt.show()
- 首先，我们导入
matplotlib.pyplot库来创建图。 - 然后，我们使用
figure()函数创建一个图形。 - 之后，我们使用子图()函数分别创建多个图。
- 然后，我们使用
tight_layout()函数自动调整多个地块的布局。 - 为了显示该图，我们使用了
show()函数。
Matplotlib multiple plots example
例# 2
在这个例子中，我们将使用 subplots()函数创建多个情节。
**# Import library**
import matplotlib.pyplot as plt
**# Create figure and multiple plots**
fig, axes = plt.subplots(nrows=2, ncols=2)
**# Auto adjust**
plt.tight_layout()
**# Display**
plt.show()
- 导入
matplotlib.pyplot作为plt用于图形创建。 - 然后，我们调用
subplots()函数，将图形和 subplots 一起存储在轴数组中。 - 这里我们创建了多个图，有 2 行和 2 列。
- 为了调整多个图的布局，我们使用了
tight_layout()函数。 - 为了显示该图，我们使用了
show()函数。
Example of matplotlib multiple plots
Matplotlib 多个地块一个标题
在这里，我们将学习添加一个标题，或者我们可以使用 matplotlib 在多个地块上添加公共标题。 suptitle() 函数用于给图形添加居中的标题。
让我们看看与此相关的例子:
例#1
在这个例子中，我们使用子情节()函数绘制多个情节，并使用 suptitle() 函数添加一个标题。
**# Import library**
import matplotlib.pyplot as plt
**# Create figure**
fig = plt.figure()
**# Define Data Coordinates**
x = range(5)
y = range(5)
**# Create each subplot individually**
plt.subplot(2, 2, 1)
plt.plot(x, y, linestyle='dashed', color='r')
plt.subplot(2, 2, 2)
plt.plot(x, y, linestyle='dashdot', color='green')
plt.subplot(2, 2, 4)
plt.plot(x, y, linestyle='dotted', color='m')
**# One Title**
plt.suptitle('Different Line Plots')
**# Auto adjust**
plt.tight_layout()
**# Display**
plt.show()
- 导入
matplotlib.pyplot库进行数据绘制。 - 然后，我们使用
figure()方法创建一个图形。 - 要定义 x 和 y 数据坐标，使用 python 的
range()函数。 - 然后，我们使用子图()函数分别创建多个图。
- 要在数据坐标之间绘制折线图，使用带有线型和颜色参数的
plot()函数。 - 要在多个图中添加一个标题，使用
suptitle()函数。 - 要调整多个图之间的间距，使用
tight_layout()功能。 - 要显示图形，使用
show()功能。
Matplotlib multiple plots one title
例 2
在这个例子中，我们使用支线剧情()函数绘制多个剧情，并使用 suptitle() 函数添加一个标题。
**# Import library**
import matplotlib.pyplot as plt
**# Create figure and multiple plots**
fig, ax = plt.subplots(nrows=2, ncols=1)
**# Define Data**
x = range(15)
y = range(15)
**# Plot**
ax[0].plot(x, y, color='r')
ax[1].bar(x, y, color='green')
**# Title**
plt.suptitle('Multiple Plots With One Title',
fontweight='bold')
**# Auto adjust**
plt.tight_layout()
**# Display**
plt.show()
- 导入必要的库
matplotlib.pyplot。 - 之后，使用
subplots()函数创建一个具有多个情节的图形。 - 要定义数据坐标，使用 python 的
range()方法。 - 为了绘制第一个图，我们使用了
plot()函数。 - 为了绘制第二个图，我们使用了
bar()函数。 - 要添加一个标题，我们使用 matplotlib 的
suptitle()函数。 - 为了显示一个图形，我们使用了
show()函数。
Matplotlib multiple plots with one title
Matplotlib 多个图一个图例
在 matplotlib 中，图例用于表示图形元素。我们可以在图中的任何地方设置和调整图例。有时，需要创建一个包含多个地块的图例。
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Create figure**
fig = plt.figure(figsize=(10, 9))
**# Multiple Plots**
axes = fig.subplots(nrows=1, ncols=2)
**# Define Data**
year = [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
2009, 2010]
birth_rate = [26.635, 26.170, 25.704, 25.238, 24.752, 24.266,
23.779, 23.293, 22.807, 22.158, 21.508]
death_rate = [8.804, 8.661, 8.518, 8.375, 8.261, 8.147, 8.034,
7.920, 7.806, 7.697, 7.589]
**# Plot**
axes[0].plot(year,birth_rate, label='Birth Rate', marker='o')
axes[1].plot(year,death_rate ,label='Death Rate', marker='o')
**# Legend**
handels = []
labels = []
for ax in fig.axes:
Handel, Label = ax.get_legend_handles_labels()
handels.extend(Handel)
labels.extend(Label)
fig.legend(handels, labels, loc = 'upper center')
**# Display**
plt.show()
- 导入
matplotlib.pyplot库进行数据可视化。 - 然后，我们使用
figure()方法创建一个 figure。 - 为了创建多个情节，我们使用
subplots()函数。 - 接下来，我们定义数据坐标。
- 然后，我们用
plot()函数绘制一个线图。 - 在这之后，我们创建两个空列表，定义
handels和标签。 - 如果在一个子图中有更多的行和标签，list
extend函数用于将它们全部添加到行和标签列表中。 - 为了显示图例，我们使用
legend()函数。 - 为了显示这个图，我们使用了
show()函数。
Matplotlib multiple plots one legend
推荐: Matplotlib 散点图图例
Matplotlib 绘制多个矩形
在 matplotlib 中， patches 模块允许我们在绘图顶部覆盖矩形等形状。补丁模块中的 Rectangle() 函数可用于添加一个矩形。
矩形函数取你需要的矩形的宽和高，以及左和底位置。矩形根据我们的需要突出显示了绘图的特定部分。
绘制矩形的语法如下:
matplotlib.patches.Rectangle(xy, width, height,
angle=0.0,**kwargs)
以上使用的 参数定义如下:
- xy: 指定锚点，即矩形开始的左下点。
- 宽度:指定矩形的宽度。
- 高度:指定矩形的高度。
- 角度:指定矩形旋转的角度。
让我们看看与此相关的例子:
例#1
在这个例子中，我们绘制了多个矩形来突出显示最高和最低的重量和高度。
**# Import Libraries**
import matplotlib.pyplot as plt
import pandas as pd
import matplotlib.patches as mpatches
- 首先，我们导入必要的库，如
matplotlib.pyplot用于数据可视化。- 熊猫进行数据创作。
matplotlib.patches在绘图顶部添加矩形等形状。
**# Load Dataset**
df = pd.read_csv('weight-height.csv')
我们将使用体重-身高数据集，并直接从 CSV 文件中加载它。
点击此处下载数据集:
**# Print Top 10 Rows**
df.head(10)
**# Print Last 10 Rows**
df.tail(10)
df.head()
df.tail()
**# Set figure size**
plt.figure(figsize=(10,7))
**# Plot scatter graph**
plt.scatter(x=df.Height, y=df.Weight)
**# Add Labels**
plt.xlabel("Height",fontweight ='bold', size=14)
plt.ylabel("Weight", fontweight ='bold',size=14)
- 为了设置绘图的大小，我们使用
figure()方法来传递figsize参数，并设置其宽度和高度。 - 为了绘制散点图，我们使用了
scatter()方法。 - 为了在 x 轴上添加标签，我们使用了
xlabel()函数。 - 为了在 y 轴上添加标签，我们使用了
ylabel()函数。 - 为了美化轴上的标签，我们将字体重量和大小作为参数传递。
**# Define coordinates of rectangle 1**
left, bottom, width, height = (73, 225, 8, 55)
**# Plot Rectangle 1**
rect=mpatches.Rectangle((left,bottom),width,height,
alpha=0.1,
facecolor="green")
**# Add Rectangle 1**
plt.gca().add_patch(rect)
**# Define coordinates of rectangle 2**
left, bottom, width, height = (52, 50, 8, 48)
**# Plot Rectangle 2**
rect=mpatches.Rectangle((left,bottom),width,height,
alpha=0.3,
facecolor="yellow")
**# Add Rectangle 2**
plt.gca().add_patch(rect)
**# Display**
plt.show()
- 我们定义矩形的坐标
x、y、宽度、高度。 - 通过使用
Rectangle()函数，我们可以添加一个矩形。 - 矩形函数以位置、大小、面颜色和阿尔法为参数。
- 为了将这个矩形对象添加到一个已经存在的绘图中，我们使用
gca()函数来获取当前轴。 - 使用
add_patch()函数，将矩形放置在绘图顶部。 - 为了显示该图，我们使用了
show()函数。
Plot multiple rectangles using matplotlib
例 2
在本例中，我们绘制了多个矩形，根据最小和最大身体质量指数指数突出显示体重和身高范围。
**# Import Libraries**
import matplotlib.pyplot as plt
import pandas as pd
import matplotlib.patches as mpatches
导入定义数据坐标和绘制图形和矩形补丁所需的库。
**# Load Dataset**
df = pd.read_csv('bmi.csv')
接下来，我们使用 read_csv() 函数加载数据集。
点击此处下载数据集:
**# Print Top 10 Rows**
df.head(10)
**# Print Last 10 Rows**
df.tail(10)
df.head()
df.tail()
**# Set figure size**
plt.figure(figsize=(10,7))
**# Plot scatter graph**
plt.scatter(x=df.Index, y=df.Height)
plt.scatter(x=df.Index, y=df.Weight)
**# Add Labels**
plt.xlabel("BMI INDEX",fontweight ='bold', size=14)
plt.ylabel("WEIGHT(kg) / HEIGHT(cm)",
fontweight ='bold',size=14)
- 为了增加图形的大小，我们使用 figure()方法，并将 figsize 参数和绘图的宽度和高度传递给它。
- 为了绘制图表，我们使用 scatter()函数。
- 为了在轴上设置标签，我们使用 xlabel()和 ylabel()函数。
**# Define coordinates of rectangle 1**
left, bottom, width, height = (-0.09, 45, 0.2, 20)
**# Plot Rectangle 1**
rect=mpatches.Rectangle((left,bottom),width,height,
alpha=0.1,
facecolor="c")
**# Add Rectangle 1**
plt.gca().add_patch(rect)
**# Define coordinates of rectangle 2**
left, bottom, width, height = (-0.09, 161, 0.2, 40)
**# Plot Rectangle 2**
rect=mpatches.Rectangle((left,bottom),width,height,
alpha=0.3,
facecolor="yellow")
**# Add Rectangle 2**
plt.gca().add_patch(rect)
**# Define coordinates of rectangle 3**
left, bottom, width, height = (4.91, 76, 0.2, 86)
**# Plot Rectangle 3**
rect=mpatches.Rectangle((left,bottom),width,height,
alpha=0.1,
facecolor="red")
**# Add Rectangle 3**
plt.gca().add_patch(rect)
**# Define coordinates of rectangle 4**
left, bottom, width, height = (4.91, 160, 0.2, 40)
**# Plot Rectangle 4**
rect=mpatches.Rectangle((left,bottom),width,height,
alpha=0.1,
facecolor="green")
**# Add Rectangle 4**
plt.gca().add_patch(rect)
**# Display**
plt.show()
- 定义矩形的
x、y、宽度和高度坐标。 - 我们可以通过使用
Rectangle()函数来添加一个矩形。 - 位置、大小、面色和阿尔法都是矩形函数的参数。
- 我们调用
gca()函数来获取当前轴，以便将这个矩形对象添加到一个已经存在的绘图中。 - 使用
add_patch()函数将矩形放置在图的顶部。 show()函数用于显示图形。
Plot multiple rect using matplotlib
这里我们用矩形来突出体重和身高的范围，分别对应身体质量指数指数的最小值和最大值。
阅读: Matplotlib 时间序列图
Matplotlib 多个图一个颜色条
在这里，我们将学习使用 matplotlib 为图中的多个图添加一个颜色条。
我们来看例子:
例#1
在本例中，我们使用不同的数据集用一个颜色条绘制多个图表。
**# Import Libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data**
data_x = np.linspace(-20, 30, 3000)
data_y = np.linspace(-50, 20, 3000)
**# Meshgrid**
X, Y = np.meshgrid(data_x, data_y)
Z1 = 5*X + 2*Y
Z2 = X - Y
Z3 = X*Y + 2
Z4 = X`5+Y`5
**# Create a figure object**
fig, axes = plt.subplots(2, 2,
figsize=(8,8),constrained_layout=True)
**# Plot**
im_1 = axes[0,0].imshow(Z1, cmap='seismic')
im_2 = axes[0,1].imshow(Z2, cmap='seismic')
im_3 = axes[1,0].imshow(Z3, cmap='seismic')
im_4 = axes[1,1].imshow(Z4, cmap='seismic')
**# Colorbar**
color_bar = fig.colorbar(im_1, ax=axes[:, 1], shrink=0.5)
**# Display**
plt.show()
- 导入必要的库，如
matplotlib.pyplot和numpy。 - 然后，我们使用
linspace()函数定义数据坐标。 - 在这之后，我们还使用
meshgrid()函数来定义 meshgrid。 - 为了创建一个支线剧情，我们使用支线剧情()函数。
- 然后，我们使用
imshow()函数绘制一个图表。 - 为了给绘图添加一个颜色条，我们使用了
colorbar()函数。 - 为了显示这个图，我们使用了
show()函数。
Matplotlib multiple plots one colorbar
例 2
**# Import Libraries**
import numpy as np
import matplotlib.pyplot as plt
**# Define Subplots**
fig, axes = plt.subplots(3, 2,
figsize=(8,8),constrained_layout=True)
**# Define Plots**
for ax in axes.flat:
im = ax.imshow(np.random.random((30,30)),cmap='BrBG')
**# Define Colorbar Coordinates**
color_bar = fig.add_axes([1, 0.15, 0.05, 0.7])
**# Colorbar plot**
fig.colorbar(im, cax=color_bar)
**# Display**
plt.show()
- 导入
matplotlib.pyplot库进行数据可视化。 - 导入
numpy进行数据创建。 - 为了创建多个情节，我们使用了子情节()函数。
- 为了迭代所有的轴，我们使用
axes.flat。 - 要定义数据坐标，使用 numpy 的
random.random()函数。 - 为了绘制图表，我们使用了
imshow()函数。 - 之后，我们使用
add_axes()函数设置颜色条的轴。 - 要将颜色条添加到绘图中，使用
colorbar()函数。
Matplotlib multiple plots single colorbar
这里我们用一个颜色条创建了 6 个 3 行 2 列的多重图。
另外，检查: Matplotlib 散点图颜色
Matplotlib 多极坐标图
在这里，我们将学习使用 matplotlib 创建多个极坐标图。为了将轴添加到图形中作为多个绘图的一部分，我们使用 matplotlib 库的图形模块的 add_subplot() 方法。
我们来举个例子:
**# Import Libraries**
import numpy as np
import matplotlib.pyplot as plt
import math
**# Create new figure**
fig = plt.figure(figsize=(6, 6))
**# Set the title of the polar plot**
plt.suptitle('Multiple Polar Plots')
**# Create first subplot**
fig.add_subplot(221, projection='polar')
**# Define Data**
radius = np.arange(0, (5*np.pi), 0.05)
r = 4
**# Plot**
for radian in radius:
plot.polar(radian, r,'o')
**# Create second subplot**
fig.add_subplot(222, projection='polar')
**# Define Data**
a = 4
b = 3
**# Plot**
for radian in radius:
r = (a*b)/math.sqrt((a*np.cos(radian))**2 +
(b*np.tan(radian))**2)
plt.polar(radian,r,'o')
**# Create third subplot**
fig.add_subplot(223, projection='polar')
**# Define Data**
a = 8
**# Plot**
for radian in radius:
r = a + (a*np.sin(radian))
plt.polar(radian,r,'o')
**# Create fourth subplot**
fig.add_subplot(224, projection='polar')
**# Define Data**
a = 1
n = 10
**# Plot**
for radian in radius:
r = a * np.cos(n*radian)
plt.polar(radian,r,'o')
**# Auto adjust layout**
plt.tight_layout()
**# Display the Polar plot**
plt.show()
- 导入必要的库，比如
matplotlib.pyplot、numpy、math。 - 要增加图形的大小，使用
figure()方法，并将带有宽度和高度的figsize参数传递给它。 - 要在多个图中添加单个标题，使用
suptitle()功能。 - 要创建多个图，使用
add_subplot()函数。 - 为了将投影设置为极坐标，我们将投影参数传递给
add_subplot()函数。 - 接下来，我们定义数据坐标。
- 为了绘制极坐标图，我们使用
polar()函数。 - 为了自动调整图的布局，我们使用了
tight_layout()函数。 - 为了显示该图，我们使用
show()函数。
Matplotlib multiple polar plots
阅读:Matplotlib tight _ layout–有用教程
Matplotlib 多盒图
在这里，我们将借助一个使用 matplotlib 的示例来学习绘制多个箱线图。
我们来看一个例子:
**# Import Libraries**
import matplotlib.pyplot as plt
import pandas as pd
import random
- 首先，导入所有必需的库，例如:
matplotlib.pyplot用于数据可视化。- 熊猫进行数据创作。
random用于访问随机数。
**# Create figure and axes**
fig, ax = plt.subplots(2,2, figsize=(8,6))
plt.subplots()是一个函数，它返回一个包含图形和轴对象的元组。- 我们定义 2 行和 2 列。
- 为了增加图形的大小，我们将
figsize参数传递给该方法。 - 我们将绘图的宽度设置为 8，将绘图的高度设置为 6。
**# Define Data**
data_frame = pd.DataFrame(data={
'Group 1': random.sample(range(60, 200), 10),
'Group 2': random.sample(range(20, 80), 10),
'Group 3': random.sample(range(2000, 3060), 10),
'Category':list(2*'A')+list(4*'B')+list(4*'C')
})
- 然后，我们使用
DataFrame()函数创建一个数据帧。 - 我们使用
random.sample()和range()函数来定义数据。 - 我们还使用
list()函数创建一个列表对象来定义类别。
**# Plot boxplot**
for i,elist in enumerate(list(df.columns.values)[:-1]):
box_plot = df.boxplot(elist, by="Category",
ax=axes.flatten()[i])
- 方法
enumerate()向 iterable 添加一个计数器，并将其作为枚举对象返回。 - 然后这个枚举对象可以直接在循环中使用，或者用
list()方法转换成元组列表。 - 为了绘制箱线图，我们使用
boxplot()函数。 axes.flatten()是 numpy 数组的方法。它返回数组的扁平版本，而不是迭代器。
**# Remove Empty Subplot**
fig.delaxes(axes[1,1])
**# Auto adjust multiple plots**
plt.tight_layout()
**# Display figure**
plt.show()
- 为了删除空图，我们使用了
delaxes()函数。 - 为了自动调整图的布局，我们使用了
tight_layout()函数。 - 为了显示该图，我们使用了
show()函数。
Matplotlib multiple boxplot
Matplotlib 多个小提琴情节
Violin 图结合了箱形图和直方图的特征。数据分布使用 violin plots 可视化，它显示了数据的范围、中位数和分布。
以下是语法:
matplotlib.axes.Axes.violinplot(dataset, positions=None,
vert=True, width=0.5,
showmeans=False,
showextrema=True,
showmedians=False,
quantiles=None, points=100,
bw_method=None, *, data=None)
这里我们将看到一个多小提琴情节的例子:
**# Import Libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Create figure and multiple plots**
fig, ax = plt.subplots(2,3, figsize=(8,6))
**# Define Data**
np.random.seed(30)
data_1 = np.random.normal(100, 10, 200)
data_2 = np.random.normal(80, 30, 200)
data_3 = np.random.normal(90, 20, 1200)
data_4 = np.random.normal(70, 25, 2000)
data_5 = np.random.normal(270, 325, 400)
**# Create the boxplot**
ax[0,0].violinplot(data_1)
ax[0,1].violinplot(data_2)
ax[0,2].violinplot(data_3)
ax[1,0].violinplot(data_4)
ax[1,2].violinplot(data_5)
**# Remove empty plot**
fig.delaxes(ax[1,1])
**# Auto layout**
plt.tight_layout()
**# Display**
plt.show()
- 首先，我们导入
matpltlib.pyplot模块进行数据可视化。 - 接下来，我们导入
numpy库作为数据定义或创建的 np。 - 然后，我们使用
subplots()方法创建一个新的图形和多个情节。 - 我们创建了 2 行，每行有 3 个地块。
- 通过使用
figsize参数，我们修改了图形大小。 - 接下来，我们使用
random.seed()函数在代码的多次执行中生成具有相同种子值的随机数。 - 然后，我们使用
random.normal()函数来生成从正态分布中抽取的数字样本。 - 绘制 violin plot，我们调用
violinplot()不同轴的函数。 - 为了删除第一行和第一列的空白图，我们使用了
delaxes()函数。 - 为了自动调整绘图的布局，我们使用了
tight_layout()函数。 - 为了在用户屏幕上可视化绘图，我们使用了
show()方法。
Matplotlib multiple violin plots
阅读: Matplotlib 饼图教程
Matplotlib 多圆图
在 matplotlib 中， patches 模块允许我们在绘图顶部覆盖圆形等形状。补丁模块中的 Circle() 函数可用于添加一个圆。
Circle 函数取你需要的圆的圆心，以及半径。圆形补丁也用来突出我们需要的情节的特定部分。
以下是语法:
matplotlib.patches.Circle(xy, radius ,**kwargs)
让我们看一个与多个圆形图相关的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Create subplot and figure**
fig, ax = plt.subplots(2,2, figsize=(8,8))
**# Plot circles**
circle_1 = plt.Circle(( 0.4 , 0.4),0.35, color='r')
circle_2 = plt.Circle(( 0.5 , 0.5 ), 0.4 , color='yellow',
alpha=0.2)
circle_3 = plt.Circle(( 0.45 , 0.5 ), 0.2 , fill=False)
**# Add Circle Patch**
ax[0,0].add_artist( circle_1 )
ax[0,1].add_artist( circle_2 )
ax[1,1].add_artist( circle_3 )
**# Add title on each plot**
ax[0,0].set_title('Colored Circle')
ax[0,1].set_title('Transparent Circle')
ax[1,1].set_title('Outlined Circle')
**# Main Title**
plt.suptitle( 'Multiple Circle Plots',fontweight='bold',fontsize=18 )
**# Remove empty plot**
fig.delaxes(ax[1,0])
**# Display**
plt.show()
- 导入
matplotlib.pyplot库进行数据可视化。 - 这里我们使用
subplots()函数创建了 2 行 2 列的多个图。 - 为了设置图形的大小，我们将
figsize参数传递给该方法。 - 为了画一个圆，我们使用
Circle()函数。 - 使用
add_patch()函数将圆放置在图的顶部。 - 为了给每个图添加标题，我们使用
set_title()方法。 - 为了给图添加一个主标题，我们使用了
suptitle()函数。 - 为了移除一个 emoty 图，我们使用
delaxes()函数。 - 为了显示一个绘图，我们使用
show()函数。
Matplotlib multiple circle plots
Matplotlib 多重等高线图
等值线图，也称为水平图，是一种多元分析工具，允许您在二维空间中可视化三维图。等高线图通常用于气象部门来说明密度、海拔或山的高度。
matplotlib contour() 函数用于绘制等高线图。
以下是语法:
matplotlib.pyplot.contour([X, Y, ] Z, [levels], **kwargs)
我们来看一个例子:
**# Import Libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Create a figure object` **and multiple plots`
fig, ax = plt.subplots(2,2, figsize=(6,6))
**# Define Data**
data_x = np.linspace(-20, 30, 3000)
data_y = np.linspace(-50, 20, 3000)
**# Meshgrid**
X, Y = np.meshgrid(data_x, data_y)
Z1 = np.cos(X/2) + np.sin(Y/4)
Z2 = X*Y + 2
Z3 = X - Y
Z4 = np.cos(X/2) + np.tan(Y/4)
**# Countor Plot**
ax[0,0].contour(X, Y, Z1)
ax[0,1].contour(X, Y, Z2)
ax[1,0].contour(X, Y, Z3)
ax[1,1].contour(X, Y, Z4)
**# Display**
plt.show()
- 导入
matplotlib.pyplot和numpy库。 - 为了创建多个情节，我们使用
subplots()函数。 - 为了定义数据坐标，我们使用了
linspace()，meshgrid()，cos()，sin()，tan()函数。 - 为了绘制 countor 图，我们使用
contour()函数。 - 为了显示该图，我们使用
show()函数。
Matplotlib multiple contour plots
例 2
这里我们将使用 contourf() 函数来绘制填充轮廓。我们使用上例中定义的相同数据集。
**# Import Libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Create a figure object**
fig, ax = plt.subplots(2,2, figsize=(6,6))
**# Define Data**
data_x = np.linspace(-20, 30, 3000)
data_y = np.linspace(-50, 20, 3000)
**# Meshgrid**
X, Y = np.meshgrid(data_x, data_y)
Z1 = np.cos(X/2) + np.sin(Y/4)
Z2 = X*Y + 2
Z3 = X - Y
Z4 = np.cos(X/2) + np.tan(Y/4)
**# Countor Plot**
ax[0,0].contourf(X, Y, Z1)
ax[0,1].contourf(X, Y, Z2)
ax[1,0].contourf(X, Y, Z3)
ax[1,1].contourf(X, Y, Z4)
**# Display**
plt.show()
这个例子和第一个例子的唯一区别是我们调用了 contourf() 方法。
Matplotlib multiple plots contour
阅读: Matplotlib 多条形图
Matplotlib 多图直方图
在这里，我们将学习使用 matplotlib 在示例的帮助下绘制多个直方图。
举例:
**# Import library**
import matplotlib.pyplot as plt
import numpy as np
**# Create figure and multiple plots**
fig, ax = plt.subplots(2,2,figsize=(8,6))
**# Define Data**
x = np.random.normal(loc=1, size=50000)
y = np.random.normal(loc=-1, size=10000)
z = np.random.randn(10000, 3)
**# Plot**
ax[0,0].hist(x, bins=80, color='r')
ax[0,1].hist(y, bins=50, alpha=0.5,
color='green',histtype='step')
ax[1,1].hist(z, bins=20, alpha=0.5, color=
['green','yellow','orange'],histtype='bar')
**# Remove empty plot**
fig.delaxes(ax[1,0])
**# Auto adjust**
plt.tight_layout()
**# Display**
plt.show()
- 导入
matplotlib.pyplot库。 - 为了创建多个情节，我们使用
subplots()函数。 - 为了定义绘图数据，我们使用了
random.normal()和random.randn()函数。 - 为了绘制直方图，我们使用
hist()函数。 - 我们还使用
histtype参数定义了不同类型的直方图类型。 - 为了删除空的绘图，我们使用
delaxes()函数。
Matplotlib multiple plots histogram
Matplotlib 多个地块 seaborn
在这里，我们将学习使用 matplotlib 绘制多个 seaborn 图。
我们来看一个例子:
**# Import Libraries**
import seaborn as sns
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
**# Seaborn Style**
sns.set()
**# Create new figure and plots**
fig, ax = plt.subplots(1,2)
**# Define Data**
x = range(15)
y = range(15)
**# Plot**
ax[0].plot(x, y, color='r')
ax[1].bar(x, y, color='green')
**# Auto layout**
plt.tight_layout()
**# Display**
plt.show()
- 导入必要的库，如
matplotlib.pyplot用于数据可视化。seaborn进行数据可视化。numpy用于数据创建。
- 然后我们使用
sns.set()函数设置 seaborn 的默认样式。 - 为了创建支线剧情，我们使用 1 行 2 列的支线剧情()函数。
- 为了定义数据坐标，我们使用
range()函数。 - 为了绘制一个图形，我们使用
plot()和bar()函数。 - 为了自动调整多个地块的布局，我们使用了
tight_layout()函数。 - 为了显示该图，我们使用
show()函数。
Matplotlib multiple plots seaborn
还有，看看 Matplotlib 上的一些教程。
在本 Python 教程中，我们已经讨论了" Matplotlib multiple plots" ，并且我们还介绍了一些与之相关的例子。这些是我们在本教程中讨论过的以下主题。
- Matplotlib 多图
- Matplotlib 多图示例
- Matplotlib 多个图一个标题
- Matplotlib 多个图一个图例
- Matplotlib 绘制多个矩形
- Matplotlib 多个图一个颜色条
- Matplotlib 多极坐标图
- Matplotlib 多盒图
- 多个小提琴情节
- Matplotlib 多重圆形图
- Matplotlib 多重等高线图
- Matplotlib 多图直方图
- Matplotlib 多图 seaborn
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib 不显示绘图
在这个 Python Matplotlib 教程中，我们将讨论 Matplotlib 不显示 plot。在这里，我们将涵盖与使用 matplotlib 无法显示的绘图相关的不同示例。我们还将讨论以下主题:
- Matplotlib 不显示绘图 jupyter
- Matplotlib 不显示绘图 vscode
目录
Matplotlib 不显示绘图 Jupyter
Jupyter Notebook 是一个基于 Python 的用户界面，允许用户通过使用有序的输入/输出单元阵列来完成 Python web 服务器作业和存放代码解决方案。
jupyter 笔记本有两种展现剧情的方式:
- 通过使用显示
- 通过使用内嵌
显示()功能
在 matplotlib 库中，pyplot 模块的 show() 函数用于显示所有的图形或绘图。
使用内嵌
我们已经有一个与 matplotlib 内联相关的帖子。要深入了解 matplotlib 内联，请阅读文章:什么是 matplotlib 内联。
此外，检查:模块' matplotlib '没有属性' plot'
Matplotlib 不显示曲线图 vscode
在这一节中，我们将讨论 show 函数。matplotlib 库的 pyplot 模块中的 show() 函数用于显示图形。
语法为:
matplotlib.pyplot.show(*args , **kwargs)
这些参数如下:
- args: 指定多个参数。
- kwargs: 指定多个关键字参数。
通常，我们将使用不带参数的 show()函数。
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
**# Plot**
plt.plot(x, y)
**# Display**
plt.show()
- 首先，我们用 pyplot 子模块导入 matplotlib 库进行数据可视化。
- 接下来，我们定义
x和y数据坐标。 - 为了绘制一个简单的线图，我们使用 pyplot 模块的
plot()函数。 - 最后，为了显示这个图，我们使用了
show()函数。我们正在使用这个函数，没有任何参数。
当我执行这段代码时，输出是:
Matplotlib not showing plot
如果我们不使用这个函数就意味着 show()函数看看会发生什么。
代码:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
**# Plot**
plt.plot(x, y)
如果我现在执行这段代码，输出如下:
Matplotlib plot not showing
这意味着如果我们不使用 show()函数，它就不会显示任何图形。
当我们在非交互模式下使用 show() 功能时。
这意味着当我们在文件中编写代码时，它将显示所有的图形或图和块，直到图被关闭。
我们用一个例子来理解这个概念:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
**# Plot**
plt.plot(x, y)
**# Display**
plt.show()
**# Print Statement**
print('My First Matplotlib Program')
- 对于数据可视化，我们首先用
pyplot子模块导入matplotlib库。 - 然后定义
x和y数据坐标。 - pyplot 包的
plot()函数用于创建一个简单的线图。 - 在此之后，我们使用不带任何参数的
show()函数来显示绘图。 - 接下来，我们使用
print()函数来打印语句。
现在，我执行这段代码，看看输出是什么:
Matplotlib not showing plot vscode
Terminal Output
从上面的输出中，您可以看到 plot 正在显示，并且在终端 shell 中，我们可以看到它没有打印打印消息。
现在，要打印消息，我们必须关闭图形。并且关闭后，该图消息将打印在终端外壳中。
下面是输出:
Message Print
基本上，它会阻止语句的执行，直到图形被关闭。
如果你想改变它，那么你必须在 show()方法中取一个块作为参数。
块是一个布尔值，可以设置为真或假。并且该块的默认值为真。
以下是语法:
matplotlib.pyplot.show(block = True | False)
Block 什么都不是，但是它会阻止代码的执行，直到我们关闭所有的情节。
如果你把一个阻塞参数当作假，那么它不会阻塞执行。这意味着它用开放图显示打印信息。
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
**# Plot**
plt.plot(x, y, color='green', linewidth=3, linestyle='dotted')
**# Display**
plt.show(block=False)
**# Print Statement**
print('My First Matplotlib Program')
**# Hold the plot**
plt.pause(1000)
输出如下:
plt.show(block=False)
如果将 block 参数设置为 False 时绘图闪烁并关闭。不要担心使用 plt.pause() 函数来保持绘图。
show() 函数用于所有编辑器和操作系统，如【colab，pycharm，mac，ubuntu，spyder，Linux，terminal，jupyter lab】来显示绘图。
你可能也喜欢阅读下面的 Matplotlib 教程。
- Matplotlib 增加地块大小
- 什么是 add_axes matplotlib
- Matplotlib 饼图教程
- Python Matplotlib tick _ params
- Matplotlib 未知投影‘3d’
因此，在这个 Python 教程中，我们已经讨论了“Matplotlib 不显示 plot”，并且我们还涵盖了一些与使用 plot 不显示 matplotlib 相关的示例。这些是我们在本教程中讨论过的以下主题。
- Matplotlib 不显示绘图 jupyter
- Matplotlib 不显示绘图 vscode
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Matplotlib 饼图教程
在本 Python Matplotlib 教程中，我们将讨论 Matplotlib 中的 Matplotlib 饼状图。在这里，我们将使用 matplotlib 介绍与饼状图相关的不同示例。我们还将讨论以下主题:
- python 中的 Matplotlib 饼图
- Matplotlib 饼图示例
- Matplotlib pie chart title
- Matplotlib 饼图标题位置
- Matplotlib 饼图标题字体大小
- Matplotlib 饼图颜色
- 带标签的 Matplotlib 饼图
- Matplotlib 饼图背景色
- Matplotlib 饼图十六进制颜色
- 带图例的 Matplotlib 饼图
- matplot lib pie chart label fontsize
- matplot lib pie chart legend fontsize
- Matplotlib 饼图自动压缩
- Matplotlib 饼图自动压缩位置
- Matplotlib 饼图楔形图
- Matplotlib 饼图边缘颜色
- Matplotlib 饼图增加大小
- Matplotlib 饼图标签在内部
- Matplotlib 饼图粗体文本
- Matplotlib 饼图放大
- Matplotlib 饼图文本属性
- Matplotlib 饼图文本颜色
- Matplotlib 饼图阴影
- Matplotlib pie chart alpha
- Matplotlib 饼图爆炸图
- Matplotlib 饼图阴影
- Matplotlib 饼图框架
- Numpy matplotlib pie chart(数字打印图表)
- Matplotlib pie chart label header
- Matplotlib 多重饼图
- Matplotlib 饼图移动图例
- Matplotlib 饼图移动标签
- Matplotlib 饼图不是圆形
- 并排的 Matplotlib 饼图
- Matplotlib 饼图保存
- Matplotlib 饼图关闭标签
- 来自数据框架的 Matplotlib 饼图
- 带标签的 Matplotlib 嵌套饼图
- Matplotlib 饼图删除标签
- Matplotlib 饼图半径
- Matplotlib 饼图旋转标签
- Matplotlib 饼图子情节
- Matplotlib 饼图开始角度
- Matplotlib 饼图词典
- Matplotlib 半饼图
- Matplotlib 饼图绝对值
- Matplotlib pie chart 甜甜圈
- Matplotlib 饼图批注
- Matplotlib 饼图分类数据
目录
- python 中的 Matplotlib 饼图
- Matplotlib 饼图示例
- Matplotlib 饼图标题
- Matplotlib 饼图标题位置
- Matplotlib 饼图标题字体大小
- Matplotlib 饼图颜色
- 带标签的 Matplotlib 饼图
- Matplotlib 饼图背景色
- Matplotlib 饼图十六进制颜色
- 带图例的 Matplotlib 饼图
- matplotlib pie chart label fontsize
- Matplotlib 饼图图例字体大小
- matplot lib pie chart autopsy
- Matplotlib 饼状图自动选取位置
- Matplotlib 饼图楔形图
- Matplotlib 饼图边缘颜色
- Matplotlib 饼图增加尺寸
- Matplotlib 饼图标签内
- Matplotlib 饼图粗体文本
- Matplotlib 饼图变大
- Matplotlib 饼图 textprops
- Matplotlib 饼图文本颜色
- Matplotlib 饼图阴影
- Matplotlib pie chart alpha
- Matplotlib 饼图展开图
- Matplotlib 饼图阴影
- Matplotlib 饼图框架
- Numpy matplotlib pie chart
- Matplotlib 饼图标签标题
- Matplotlib 多个饼图
- Matplotlib 饼图移动图例
- Matplotlib 饼图移动标签
- Matplotlib 饼图不圆
- Matplotlib 并排饼图
- Matplotlib 饼图顺时针方向
- Matplotlib 饼图保存
- Matplotlib 饼图关闭标签
- 来自数据帧的 Matplotlib 饼图
- 带标签的 Matplotlib 嵌套饼图
- Matplotlib 饼图移除标签
- Matplotlib 饼图半径
- Matplotlib 饼图旋转标签
- Matplotlib 饼状图支线剧情
- Matplotlib 饼图开始角度
- Matplotlib 饼图字典
- Matplotlib 半饼图
- Matplotlib 饼图绝对值
- Matplotlib 饼图甜甜圈
- Matplotlib 饼图注释
- Matplotlib 饼图分类数据
python 中的 Matplotlib 饼图
在本节中，我们将学习什么是饼图以及如何创建饼图。此外，如何使用 python matplotlib 工具创建一个饼图来表示您的数据。在开始这个话题之前，我们首先要明白派图图是什么意思:
饼图是一种特殊类型的图表，它使用圆形图来表示数据。这是最常用的表示数据的图表之一，它使用圆、球体和角度数据的属性来表示真实世界的数据。
- 饼状图用于只显示一个系列的数据。
- 整圆图代表整数据，切片代表数据
- 馅饼的切片被称为楔形。
- 完整饼图的面积等于占
- 切片的面积等于数据部分的百分比。
在 matplotlib 中， pie() 函数用于创建饼图。语法如下所示:
matplotlib.pyplot.pie(x, explode=None, labels=None,
colors=None, autopct=None,
pctdistance=0.6, shadow=False,
labeldistance=1.1, startangle=None,
radius=None, counterclock=True,
wedgeprops=None, textprops=None,
center=(0,0), frame=False,
rotatelabels=False, * , data=None)
以下是参数:
| 参数 | 价值 | 描述 |
|---|---|---|
| x | 排列 | 指定楔形的大小。 |
| 激增 | 数组 | |
| 默认值:无 | 如果不是 None，则是一个 len(x)数组，它指示每个楔形应该移动的半径的分数。 | |
| 标签 | 列表 | |
| 默认:无 | 每个楔形区的标签由一个字符串序列指定。 | |
| 颜色；色彩；色调 | 数组 | |
| 默认值:无 | 饼图将在 matplotlib 颜色参数序列中循环。如果没有，将使用当前活动周期中的颜色。 | |
| 自动 ct | 字符串或函数 | |
| 默认值:无 | 如果不是 None，则使用一个字符串或函数来标记楔形区的数值。标签将被放置在楔形物内。如果是格式字符串，标签将是 fmt% pct。如果它是一个函数，它将被调用。 | |
| 百分比距离 | 浮动 | |
| 默认值:0.6 | 每个饼图扇区的中心与自动执行生成的文本的开头之间的距离。如果 autopct 为 None，则忽略它。 | |
| 阴影 | bool | |
| Default: False | 就在饼的下面，画一个阴影。 | |
| 使标准化 | bool | |
| Default: False | 通过将 x 归一化为 sum(x) == 1，始终在 True 时创建完整的饼图。如果 sum(x) = 1，False 会创建一个部分饼图，如果 sum(x) > 1，则会引发 ValueError。 | |
| 标签距离 | 浮动或无 | |
| 默认值:1.1 | 饼图标签以径向距离绘制。如果选择了“无”，则不会绘制标签，但会保存它们以供在图例中使用()。 | |
| 起始角度 | 浮动 | |
| 默认值:0 度 | 饼图起点从 x 轴旋转的逆时针角度。 | |
| 半径 | 浮点 | |
| 默认值:1 | 指定饼图的半径。 | |
| 反锁 | bool | |
| Default: True | 指定分数应该顺时针还是逆时针旋转。 | |
| 楔形夹 | 默认:无 | 饼图由提供给组成饼图的楔形对象的参数字典组成。例如，wedgeprops =' linewidth': 3 可用于将楔形边框线的宽度设置为 3。 |
| textprops | 默认:无 | 传递给 dict 中文本对象的参数。 |
| 中心 | (float，float) | |
| 默认值:(0，0) | 图表中心的坐标。 | |
| 设计 | bool | |
| Default: False | 如果为真，用图表绘制坐标轴框架。 | |
| 旋转标签 | bool | |
| Default: False | 如果为真，则将每个标签旋转到相应切片的角度。 | |
| 数据 | 可转位对象 | 以下参数采用一个字符串 s，如果给定的话，它被解释为 datas: |
| x，explode，labels，colors |
另外，检查: Matplotlib 默认图形尺寸
Matplotlib 饼图示例
这里，我们将讨论一个与 Matplotlib 饼图相关的示例。
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
data = [20, 16, 8, 9.8]
**# Plot**
plt.pie(data)
**# Display**
plt.show()
- 首先导入
matplotlib.pyplot库进行数据可视化。 - 接下来，定义用于打印的数据坐标。
- 为了创建一个饼图，我们使用了
pie()函数。 - 要显示图表，使用
show()功能。
输出:
plt.pie()
Matplotlib 饼图标题
在这里，我们将学习向饼图添加标题。要添加标题，我们使用 matplotlib pyplot 模块的 title() 方法。
下面是添加标题的语法:
matplotlib.pyplot.title()
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
subjects= ['English', 'Hindi', 'Science', 'Maths']
like = [18, 9, 16, 7]
**# Plot**
plt.pie(like, labels=subjects)
**# Title**
plt.title('Subject like by students')
**# Display**
plt.show()
- 这里我们定义数据坐标和标签。
- 接下来，我们使用
pie()函数创建一个饼图。 - 要向饼图添加标题，请使用
title()函数。
plt.title()
Matplotlib 饼图标题位置
这里我们将看到一个标题位于不同位置的饼图示例。
需要的语法是:
matplotlib.pyplot.pie(label, loc= 'center' | 'left' | 'right' )
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
age_group = ['Infancy', 'Childhood', 'Adolescence',
'Adulthood', 'Old Age']
persons = [10, 15, 25, 50, 35]
**# Plot**
plt.pie(persons, labels=age_group)
**# Title**
plt.title('Survey',loc='right',color='r')
**#OR**
plt.title('Survey',loc='left',color='r')
**# Display**
plt.show()
这里我们将 loc 作为参数传递给 title() 函数，并将其值设置为右和左。
plt.title(loc=’right’)
plt.left(loc=’left’)
阅读: Matplotlib 条形图标签
Matplotlib 饼图标题字体大小
在这里，我们将看到一个带有标题的饼图示例，在这里，我们还更改了标题的字体大小。
以下是语法:
matplotlib.pyplot.title(label, fontsize=None)
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
pet = ['Dog', 'Cat', 'Rabbit', 'Parrot', 'Fish']
owner = [50, 15, 8, 20, 12]
**# Plot**
plt.pie(owner, labels=pet)
**# Title fontsize**
plt.title('Pet Ownership',fontsize=20)
**# Display**
plt.show()
这里我们将 fontsize 参数传递给 title() 函数来改变标题字体的大小。
输出:
plt.title(fontsize=None)
读取: Matplotlib 绘图误差线
Matplotlib 饼图颜色
这里我们将看到一个例子，我们将在 matplotlib 中改变饼图的颜色。为了改变饼图的颜色，我们将把一个颜色数组传递给 colors 参数。
以下是语法:
matplotlib.pyplot.pie(x, labels=None, colors=None)
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
movie = ['Comedy','Drama','Action']
popularity = [60, 40, 25]
**# Colors**
pie_colors = ['tab:orange', 'tab:cyan', 'tab:gray']
**# Plot**
plt.pie(popularity, labels=movie, colors=pie_colors)
**# Display**
plt.show()
- 在上面的例子中，首先我们导入
matplotlib.pyplot库。 - 之后，我们定义用于绘图的数据坐标和标签。
- 接下来，我们创建一个颜色列表。
- 为了用您选择的颜色绘制饼图，我们使用带有颜色参数的
pie()方法。
plt.pie(colors=None)
阅读: Matplotlib 散点图标记
带标签的 Matplotlib 饼图
为了创建一个带有标签的饼图，我们需要向 pie() 方法传递一个标签参数。
以下是语法:
matplotlib.pyplot.pie(x, labels=None)
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
icecream = ['Chocolate','Vanilla','Straberry']
**# Labels**
popularity = [55, 30, 15]
**# Plot**
plt.pie(popularity, labels=icecream)
**# Display**
plt.show()
- 在这里，我们还定义了绘图和标签的数据。
- 为了绘制饼图，我们使用了
pie()方法。 - 为了添加标签，我们传递了标签参数。
plt.pie(labels=None)
Matplotlib 饼图背景色
为了设置饼图的背景颜色，我们使用带有 facecolor 参数的 figure() 方法。
语法如下:
matplotlib.pyplot.figure(facecolor=None)
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
emojis = ['Happy Face', 'Sad Face', 'Hearts', 'Hand Gestures',
'Others']
popularity = [45, 14, 13, 7, 21]
**# Background Color**
plt.figure(facecolor='salmon')
**# Plot**
plt.pie(popularity, labels=emojis)
**# Display**
plt.show()
在这里，我们通过使用 pie() 方法创建了一个饼状图来表示最常用的表情符号。为了改变图像的背景颜色，我们使用了带有参数 facecolor 的 figure() 函数。
plt.figure(facecolor=None)
Matplotlib 饼图十六进制颜色
这里我们将创建一个饼图，并使用十六进制颜色设置切片的颜色。为了得到好看的图表，我们最好选择浅色。
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates` **and labels`
languages = ['Python', 'Ruby', 'Java', 'Php']
popularity = [40, 20, 10, 30]
**# Add colors**
colors = ['#ff9999','#66b3ff','#99ff99','#ffcc99']
**# Plot**
plt.pie(popularity, labels=languages, colors=colors)
**# Display**
plt.show()
这里我们使用十六进制颜色代码设置切片的颜色。为了改变颜色，我们使用了 colors 参数。
Hex Color
带图例的 Matplotlib 饼图
这里我们将看到一个带有图例的饼图示例。为了给绘图添加图例，我们使用 matplotlib 的 pyplot 模块的 legend() 函数。
以下是语法:
matplotlib.pyplot.legend(labels, loc=None)
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
diet = ['Fruit', 'Protein', 'Vegetables', 'Dairy', 'Grains',
'Other']
quantity = [30, 23, 18, 15, 9, 5]
**# Plot**
plt.pie(quantity)
**# Add legend**
plt.legend(labels=diet, loc='upper center',
bbox_to_anchor=(0.5, -0.04), ncol=2)
**# Display**
plt.show()
- 导入 matplotlib 库的
pyplot函数。 - 定义要绘制的数据。
- 接下来，定义一个标签为的数组。
- 要绘制饼图，请使用
pie()函数。 - 要添加图例，使用
legend()函数。
plt.legend()
matplotlib pie chart label fontsize
这里我们将看到一个饼图的例子，我们将改变标签的字体大小。为了改变字体大小，我们使用了 textprops 参数。基本上这个参数是用来修改 pe 图的文本属性的。
以下是改变标签字体大小的语法:
matplotlib.pyplot.pie(x, labels=[], textprops={"fontsize":10})
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
languages = ['Python', 'Ruby', 'Java', 'Php']
popularity = [40, 20, 10, 30]
**# Change label fontsize**
textprops = {"fontsize":15}
**# Plot**
plt.pie(popularity, labels=languages, textprops =textprops)
**# Display**
plt.show()
- 首先，我们导入
matplotlib.pyplot库进行数据可视化。 - 接下来，我们定义坐标数据来绘制饼图。
- 之后，我们创建一个要添加的标签列表。
- 然后我们创建一个字典，在这里我们设置字体大小和它的值作为键和值来改变标签的大小。
- 为了创建一个饼图，我们使用了
pie()方法，为了改变标签的字体大小，我们向它传递了textprops参数。 - 为了显示饼图，我们使用了
show()方法。
textprops{‘fontsize’:15}
Matplotlib 饼图图例字体大小
这里我们将看到一个饼图示例，我们将在其中更改图例的字体大小。为了改变字体大小，我们使用带有图例()方法的字体大小参数。
以下是语法:
matplotlib.pyplot.legend(labels, fontsize=None)
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
water_quantity = [17, 27, 14, 22, 16, 6]
**# Add labels**
water_uses = ['Shower', 'Toilet', 'Leaks', 'Clothes Wsher',
'Faucet', 'Other']
**# Color**s
colors =
['salmon','palegreen','skyblue','plum','pink','silver']
**# Plot**
plt.pie(water_quantity, colors=colors)
**# Add legend**
plt.legend(labels=water_uses, fontsize=18, loc='upper center',
bbox_to_anchor=(0.5, -0.04), ncol=2)
**# Display**
plt.show()
- 首先，定义数据坐标来绘制饼图。
- 然后创建一个标签列表来定义饼图上的标签。
- 之后，我们创建一个颜色列表来改变切片的颜色。
- 为了绘制饼图，我们使用了
pie()方法。 - 为了向饼图添加图例，我们使用了
legend()方法，并且为了改变图例的字体大小，我们使用了fontsize参数。
plt.legend(fontsize=18)
matplot lib pie chart autopsy
在这里，我们将看到一个带有自动执行参数的饼图示例。自动压缩参数用于显示相应楔形的百分比。默认情况下，百分比标签放在内部。格式字符串将是 fmt%pct。
以下是语法:
matplotlib.pyplot.pie(x, labels=[], autopct=fmt%pct)
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
cost = [10, 15, 15, 15, 20, 25]
**# Define Label**
work = ['Timber', 'Supervision', 'Steel', 'Bricks', 'Cement',
'Labour']
**# Plot with autopct**
plt.pie(cost, labels=work, autopct='%.1f%%')
**# Display**
plt.show()
- 我们将成本定义为绘制饼图的数据坐标。
- 为了在饼图中定义标签，我们创建一个工作列表。
- 为了绘制饼图，我们使用了
pie()函数。 - 为了在楔形区内添加一个百分比，我们将
autopct参数传递给pie()方法。
plt.pie(autopct= fmt%pct )
阅读: Matplotlib 散点图颜色
Matplotlib 饼状图自动选取位置
这里我们将看到一个饼图的例子，我们手动设置百分比标签的位置。要更改自动投影的位置，我们使用 pctdistance 和 labeldistance 参数。
语法如下:
matplotlib.pyplot.pie(x, labels, autopct, pctdistance,
labeldistance)
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
cost = [10, 15, 15, 15, 20, 25]
**# Define Label**
work = ['Timber', 'Supervision', 'Steel', 'Bricks', 'Cement',
'Labour']
**# Plot with autopct** `position`
plt.pie(cost, labels=work, autopct='%.1f%%',pctdistance=1.7,
labeldistance=1.2)
**# Display**
plt.show()
为了设置楔形区外百分比标签的位置，我们将百分比距离和标签距离参数传递给 pie() 方法。
plt.pie(pctdistance=1.7, labeldistance=1.2)
Matplotlib 饼图楔形图
这里我们将看到一个饼图楔形图参数的例子。基本上，该参数用于修改饼图中扇区的属性。
语法如下:
matplotlib.pyplot.pie(x, wedgeprops={}
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
popularity = [20, 15, 35, 26, 16]
**# Define Label**
beverages = ['Tea','Coffee', 'Cola', 'Water', 'Other']
**# color**
colors=['gold', 'springgreen', 'powderblue', 'orchid',
'slategray']
**# Plot with wedgeprops**
plt.pie(popularity, labels=beverages,
wedgeprops={'edgecolor':'k', 'linestyle': 'dashdot',
'antialiased':True}
,colors=colors)
**# Add title**
plt.title('Favourite Beverages',fontweight='bold')
**# Display**
plt.show()
- 首先导入
matplotlib.pyplot库。 - 接下来，定义 x 数据坐标来创建一个饼图。
- 要添加标签，请创建标签列表。
- 要改变切片的颜色，使用
colors参数并向其传递一个颜色列表。 - 要绘制饼图，请使用
pie()方法。 - 要改变楔形的属性，使用
wedgeprops参数。这里我们改变楔形的线型。 - 要给绘图添加标题，使用
title()方法。
plt.pie(wedgeprops={})
Read: Matplotlib set_xticklabels
Matplotlib 饼图边缘颜色
这里我们将看到一个带有不同边缘颜色的饼图示例。为了改变边缘的颜色，我们使用 wedgeprops 参数并创建一个字典，以 edgecolor 作为键，color 作为值。
以下是语法:
matplotlib.pyplot.pie(x, wedgeprops={'edgecolor':None})
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
popularity = [20, 16, 35, 9]
**# Define Label**
books = ['Story Books','Comic Books', 'Puzzel Books', 'Poem Books']
**# color**
colors=['rosybrown', 'moccasin', 'lightyellow', 'darkseagreen']
**# Plot with different edgecolor**
plt.pie(popularity, labels=books, wedgeprops=
{'edgecolor':'maroon'}, colors=colors)
**# Add title**
plt.title('Favourite Books',fontweight='bold')
**# Display**
plt.show()
- 在这里，我们创建了一个饼图，显示了儿童书籍的受欢迎程度。为了改变饼图的边缘颜色，wedgeprops 参数被传递给
pie()方法。 - Wedgeprops 参数接受
dict中的值，因此，我们创建了一个定义edgecolor的字典。这里我们设置边缘颜色为栗色。
wedgeprops={‘edgecolor’:’maroon’}
Matplotlib 饼图增加尺寸
我们将通过增加图形的大小来增加饼图的大小。
以下是语法:
matplotlib.pyplot.figure(figsize=(x,y))
这里 x 和 y 分别代表宽度和高度。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Figure Size**
plt.figure(figsize=(8,10))
**# Define Data Coordinates**
popularity = [30, 20, 13, 27, 10]
**# Define Label**
fruits = ['Banana','Pineapple', 'Orange', 'Grapes', 'Peach']
**# Color**
colors=['rosybrown', 'moccasin', 'lightyellow', 'darkseagreen',
'lavender']
**# Plot**
plt.pie(popularity, labels=fruits, colors=colors)
**# Add title**
plt.title('Favourite Fruits',fontweight='bold')
**# Display**
plt.show()
为了增加饼图的大小，我们将 figsize 参数传递给 pyplot 的 figure() 方法。
figsize=(8,10)
阅读:Matplotlib fill _ between–完整指南
Matplotlib 饼图标签内
在这里，我们将看到一个饼图的例子，在切片内有标签。为了在内部添加标签，我们将 labeldistance 参数传递给 pie() 方法，并相应地设置其值。
以下是语法:
matplotlib.pyplot.pie(x, labeldistnce=0.5)
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
popularity = [25, 34, 25, 8, 8]
**# Define Label**
activities = ['Sleeping', 'School', 'Playing', 'Tv', 'Music']
**# color**
colors=['lightcoral', 'sandybrown', 'gold', 'darkseagreen',
'lavender']
**# Plot**
plt.pie(popularity, labels=activities, colors=colors,
labeldistance=0.5)
**# Add title**
plt.title('Activities',fontweight='bold')
**# Display**
plt.show()
plt.pie(labeldistance=0.5)
阅读:Matplotlib set _ yticklabels–实用指南
Matplotlib 饼图粗体文本
我们将看到一个饼图示例，其中我们将标签文本加粗。为了加粗文本，我们将 textprops 参数传递给 pie() 方法。
以下是语法:
matplotlib.pyplot.pie(x, textprops={'fontweight':'bold'})
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Figsize**
plt.figure(figsize=(6,8))
**# Define Data Coordinates**
owner = [10, 45, 15, 30]
**# Define Label**
transport = ['Bicycle', 'Walking', 'Bus', 'Car']
**# Plot**
plt.pie(owner, labels=transport, textprops=
{'fontweight':'bold'})
**# Add title**
plt.title('Types of Transport',fontweight='bold')
**# Display**
plt.show()
plt.pie(textprops={fontweight:bold})
阅读:Matplotlib tight _ layout–有用教程
Matplotlib 饼图变大
我们将看到一个如何创建更大的饼图的例子。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Figsize**
fig = plt.figure()
fig.set_figheight(10)
**# Define Data Coordinates**
population = [29, 29, 42]
**# Define Label**
wildlife = ['Whales', 'Bears', 'Dolphins']
**# Plot**
plt.pie(population, labels=wildlife)
**# Add title**
plt.title('Wildlife Population',fontweight='bold')
**# Display**
plt.show()
这里我们只增加饼图的高度。为了增加高度，我们使用 set_figheight() 方法中的fig()方法。
set_figheight()
阅读:Python Matplotlib tick _ params
Matplotlib 饼图 textprops
这里我们将了解饼图的 textprops 参数。我们将使用 textprops 参数来分别设置文本的样式。
以下是语法:
matplotlib.pyplot.pie(x, textprops={})
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
sales = [22, 33, 13, 15, 17]
**# Define Label**
laptops = ['HP', 'Dell', 'Lenovo', 'Asus', 'Acer']
**# Text Properties**
text_prop = {'family':'sans-serif', 'fontsize':'x-large',
'fontstyle':'italic', 'fontweight':'heavy'}
**# Plot**
plt.pie(sales, labels=laptops, textprops=text_prop)
**# Add title**
plt.title('Sales',fontweight='bold')
**# Display**
plt.show()
- 首先导入
matplotlib.pyplot库。 - 然后定义用于制作饼图的数据坐标。
- 我们还创建了一个标签列表。
- 之后，我们创建一个定义文本属性的字典。
- 为了创建一个饼图，我们使用了
pyplot模块的pie()方法。我们还通过textprops参数来改变文本的文本属性。 - 我们还使用
title()方法为一个情节添加一个标题。
plt.pie(textprops={})
读取: Matplotlib x 轴标签
Matplotlib 饼图文本颜色
这里我们将看到一个带有标签的饼图示例，在这个示例中，我们将更改标签的颜色。
改变颜色的语法:
matplotlib.pyplot.pie(x, textprops={'color':None})
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
popularity = [25, 16, 23, 12, 35]
**# Define Label**
sports = ['Football', 'Basketball', 'Badminton', 'Hockey', '
'Cricket']
**# Color**
colors = ['orchid','mediumpurple', 'powderblue',
'mediumaquamarine', 'sandybrown']
**# Plot**
plt.pie(popularity, labels=sports, colors=colors,
textprops={'color':'darkblue'})
**# Add title**
plt.title('Favourite Sports',fontweight='bold')
**# Display**
plt.show()
为了改变文本的颜色，我们创建了一个字典，将颜色定义为键，将深蓝定义为值，并将这个字典，即 textprops 参数传递给 pie() 方法。
textprops={‘color’:’darkblue’}
阅读: Matplotlib 多条形图
Matplotlib 饼图阴影
在本节中，我们将了解饼图阴影。我们已经在上面的题目中学习了关于饼状图的内容。现在是时候学习新的东西了，也就是说孵化。
在每种情况下，我们都使用颜色来填充饼图，但现在我们学习在饼图的每个部分中填充图案。
为了用图案填充图，我们分配一个新的参数影线，其值为一个字符串。部分字符串值有: / 、 \ 、 | 、–、 + 、 x 、 o 、。， *
源代码:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data Coordinates**
data = np.random.rand(4)
**# Hatch**
hatches = ['..' for value in data]
**# Plot pie chart**
pie_chart = plt.pie(data)
**# Fill hatch**
for i in range(len(pie_chart[0])):
pie_chart[0][i].set(hatch = hatches[i], fill=False)
**# Display**
plt.show()
- 首先，我们导入
matplotlib.pyplot和numpy库。 - 接下来，我们使用 numpy
random.rand()函数定义数据来绘制饼图。 - 之后，我们定义阴影图案。
- 为了绘制饼图，我们使用了
pie()方法。 - 为了用阴影图案填充饼图，我们使用 for 循环，同时传递
fill参数，并将其值设置为False以获得空白背景。
hatch=[‘..’]
阅读:Matplotlib plot _ date–完整教程
Matplotlib pie chart alpha
在本节中，我们将看到一个带有 alpha 参数的饼图示例。 alpha 参数用于设置颜色的透明度。其值范围从 0 到 1 。
要使用 alpha 参数，我们必须调用 wedgeprops 参数并创建一个字典，并将 alpha 参数设置为键，将 alpha 的值设置为值。
语法如下:
matplotlib.pyplot.pie(x, wedgeprops={'alpha':1})
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
loss = [14, 32, 15, 11, 28]
**# Define Label**
reasons = ['Competition', 'Not qualified', 'Salesperson',
'Price', 'Timing']
**# Plot**
plt.pie(loss, labels=reasons, wedgeprops={'alpha':0.5})
**# Add title**
plt.title('Loss Reasons',fontweight='bold')
**# Display**
plt.show()
plt.pie(wedgeprops={‘alpha’:0.5})
Matplotlib 饼图展开图
在这里，我们将了解饼图展开的论点。使用爆炸参数，我们可以弹出饼图的一个或多个部分。
让我们从声明一个包含爆炸值的数组开始。每个切片偏移爆炸阵列中指定半径的一部分。
语法如下:
matplotlib.pyplot.pie(x, explode=())
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
cost = [18, 13, 11, 9, 6, 21, 25]
**# Define Label**
project = ['Labor','Licenses','Taxes','Legal','Insurance',
'Facilities','Production']
**# Explosion Value**
explode = (0.2, 0, 0, 0, 0, 0, 0)
**# Plot**
plt.pie(cost, labels=project, explode=explode)
**# Add title**
plt.title('Project Cost Breakdown',fontweight='bold')
**# Display**
plt.show()
- 定义数据坐标和标签以创建饼图。
- 在此之后，我们定义爆炸值。
- 要创建一个饼图，使用
pie()方法并向其传递explode参数。
plt.pie(explode=())
Matplotlib 饼图阴影
在本节中，我们将使用 shadow 参数向饼图添加阴影。默认情况下，阴影参数的值为假。
以下是语法:
matplotlib.pyplot.pie(x, shadow=True)
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data Coordinates**
defects = [14, 11, 15, 35, 25]
**# Define Label**
parts = ['Rimcut', 'Bulge', 'Other', 'Dented Rim', 'Dented
Body']
**# Explosion Value**
explode = (0.1, 0.1, 0.1, 0.1, 0.1)
**# Plot**
plt.pie(defects, labels=parts, explode=explode, shadow=True)
**# Add title**
plt.title('Project Cost Breakdown',fontweight='bold')
**# Display**
plt.show()
plt.pie(shadow=True)
另外，检查:模块“matplotlib”没有属性“artist”
Matplotlib 饼图框架
通过将帧参数设置为真，我们可以在饼图周围绘制一个帧。
以下是语法:
matplotlib.pyplot.pie(x, frame=True)
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Create subplot**
figure , ax = plt.subplots()
**# Define Data Coordinates**
sales = [35, 12, 20, 22, 32 ]
**# Define Label**
company = ['Redmi', 'Apple', 'Samsung', 'Oppo', 'Vivo']
**# Plot**
plt.pie(sales, labels=company, frame=True)
ax.axis('equal')
**# Add title**
plt.title('Sales of different company',fontweight='bold')
**# Display**
plt.show()
- 导入
matplotlib.pyplot库。 - 创建支线剧情，使用支线剧情()方法。
- 定义数据坐标和标签。
- 为了绘制饼图，我们使用了
pie()方法。 - 为了在图表周围设置一个框架，我们将
frameargument 传递给方法，并将其值设置为 True 。 - 将轴设置为等于。
- 要添加标题，我们使用
title()方法。
plt.pie(frame=True)
Numpy matplotlib pie chart
这里我们将看到一个使用 NumPy 的饼图示例。
举例:
**# Import Libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data Coordinate**
x = np.array([20, 12, 9, 3])
**# Plot pie chart**
plt.pie(x)
**# Display**
plt.show()
- 这里我们导入
matplotlib.pyplot和numpy库。 - 接下来，我们使用
array()方法定义数据坐标来创建 numpy。 - 为了绘制饼图，我们使用 pyplot 模块的
plot()方法。
输出:
np.array([])
Matplotlib 饼图标签标题
在本节中，我们将看到一个带有标题标签的饼图示例。为了给图例添加标题，我们使用带有参数 title 的 legend()函数。
以下是语法:
matplotlib.pyplot.legend(title)
我们来看一个例子:
**# Import Libraries**
import matplotlib.pyplot as plt
import numpy as np
**# Define data coordinates and labels**
quantity = np.array([1, 4, 3, 2])
material = ['Butter', 'Egg', 'Flour', 'Sugar']
**# Plot pie chart**
plt.pie(quantity, labels = material)
**# Legend with header**
plt.legend(title = "Butter Cake:", loc='upper center',
bbox_to_anchor=(0.5, -0.04))
**# Display**
plt.show()
- 这里我们使用 pie()方法创建一个饼图来表示奶油蛋糕配方材料数量。
- 要添加带有标题的图例，我们使用带有标题参数的
legend()方法。
plt.legend(title=)
Matplotlib 多个饼图
这里我们将使用 pyplot 模块的 figure() 方法创建多个饼图。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Create first chart.**
plt.figure(0)
x = [30, 30, 15, 11, 12]
reasons = ['Health','Less Pollution', 'No parking Ptoblem', 'No costs', 'Faster than driving']
plt.pie(x, labels = reasons, explode=(0.1, 0.1, 0.1, 0.1, 0.1),
autopct='%.1f%%')
plt.title('Reasons for cycling', color='r')
**# Create second chart.**
plt.figure(1)
x = [40, 21, 14, 14, 11]
reasons = ['Comfort','Distance', 'Faster than cycling', 'Need to carry things to work', 'Safer than cycling']
plt.pie(x, labels = reasons, explode=(0.1, 0.1, 0.1, 0.1, 0.1),
autopct='%.1f%%')
plt.title('Reasons for driving', color='r')
**# Show all figures**
plt.show()
创建多个饼图的步骤:
- 导入
matplotlib.pyplot库。 - 创建第一个饼图，使用
figure()方法。 - 定义坐标 x 以创建第一个饼图。
- 接下来定义第一个饼图的标签。
- 为了绘制饼图，我们使用了
pie()方法。 - 我们还将
explode和autopct参数传递给pie()方法，分别获取切片的切割和显示切片的百分比。 - 要添加标题，我们使用
title()方法。 - 同样，我们使用
figure()方法创建第二个饼图。
Multiple Pie Chart
Matplotlib 饼图移动图例
在这里，我们将学习在饼图中移动图例。为了改变图例的位置，我们将 loc 参数传递给 legend() 方法。
语法如下:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates and labels**
teachers = [15, 24, 13, 15, 10]
subjects = ['Science', 'Mathematics', 'Social Studies',
'English', 'Spanish']
**# Plot pie chart**
plt.pie(teachers)
**# Move Legend**
plt.legend(subjects, title = "Subjects Alloted To Teachers:", loc='lower right',bbox_to_anchor=(0.3, -0.08))
**# Display**
plt.show()
说明:
要移动图例，我们将 loc 和 bbox_to_anchor 参数传递给 legend 方法，以设置图例的位置和手动位置。
plt.legend(loc=’lower right’, bbox_to_anchor=(0.03, -0.08))
Matplotlib 饼图移动标签
在这里，我们将学习在饼图中移动标签。为了改变标签的位置，我们将 labeldistance 参数传递给 pie()方法。默认情况下，其位置距离径向距离为 1.1。
以下是语法:
matplotlib.pyplot.pie(x, labeldistance=1.1)
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates and labels**
winner = [19, 27, 13, 41]
superhero = ['Captain America', 'Iron Man', 'Superman',
'Batman']
**# Plot pie chart**
plt.pie(winner, labels = superhero, labeldistance=1.35)
**# Title**
plt.title('Superhero Battle Winner', color='r')
**# Display**
plt.show()
在本例中，我们通过将 labeldistance 参数传递给方法，将 labeldistance 设置为距离半径 1.35。
plt.pie(labeldistance=1.35)
Matplotlib 饼图不圆
默认情况下，饼图的形状是圆形，但是如果要改变饼图的形状，必须将 explode 参数传递给 pie() 方法，并设置不同的爆炸值。
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates**
x = np.random.rand(3)
**# Plot pie chart**
plt.pie(x, explode=(0.5, 0.65, 0.5))
**# Display**
plt.show()
Pie but not circle
Matplotlib 并排饼图
为了并排创建饼图，我们使用 Matplotlib 中 pyplot 模块的 subplot 函数。
以下是语法:
matplotlib.pyplot.subplot(nrows, ncolumns, index)
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates and labels**
energy = ['Coal','Other','Nuclear','Petro','Gas']
production_1995 = [30, 5, 7, 30, 30]
production_2005 = [31, 10, 11, 20, 31]
**# using subplot function and creating plot one
# row 1, column 2, count 1 subplot**
plt.subplot(1, 2, 1)
plt.pie(production_1995,labels=energy)
plt.title('1995',color='b')
**# using subplot function and creating plot two
# row 1, column 2, count 2**
plt.subplot(1, 2, 2)
plt.pie(production_2005,labels=energy)
plt.title('2005',color='b')
**# space between the plots**
plt.tight_layout()
**# show plot**
plt.show()
- 在上面的例子中，我们定义了用于绘制饼图的数据坐标和标签。
- 使用
subplot()函数并将其行、列和计数设置为 1，2，1，我们创建第一个 subplot。 - 使用
subplot()函数并将其行、列和计数设置为 1、2、2，我们在第一个 subplot 的旁边创建第二个 subplot。 - 为了绘制饼图，我们使用
pie()函数。 - 为了给饼图添加标题，我们使用了
title()函数。 - 为了在图之间添加一个空间，我们使用了
tight_layout()函数。 - 为了显示一个图表，我们使用
show()函数。
plt.subplot()
Matplotlib 饼图顺时针方向
在这里，我们将了解饼图的顺时针模式。为此，必须将反锁参数设置为假。默认情况下，其值为 True。
语法如下:
matplotlib.pyplot.pie(x, counterclock=False)
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates and labels**
ratio = [20, 12, 4, 18, 16]
responses = ['Likely','Very Likely','Very Unlikely',
'Unlikely', 'Unsure']
**# Plot pie chart**
plt.pie(ratio, labels = responses,counterclock=False, autopct='%1.1f%%')
**# Title**
plt.title('Survey Responses', color='r')
**# Display**
plt.show()
plt.pie(counterclock=False)
Matplotlib 饼图保存
在这里，我们将学习将饼图保存为 png 图像。要保存一个绘图，我们必须使用 savefig() 方法。
举例:
**# Import Library** import matplotlib.pyplot as plt
**# Create subplot**
figure , ax = plt.subplots()
**# Define Data Coordinates**
sales = [35, 12, 20, 22, 32 ]
**# Define Label**
company = ['Toyota','General Motors', 'Honda', 'Ford', 'Fiat']
**# Plot**
plt.pie(sales, labels=company, frame=True)
ax.axis('equal')
**# Add title**
plt.title('Sales of different company',fontweight='bold')
**# Save pie chart**
plt.savefig('Save Pie Chart.png')
**# Display**
plt.show()
plt.savefig()
Matplotlib 饼图关闭标签
在这里，我们将看到一个示例，其中我们根据某些条件关闭了饼图的标签。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates and labels**
hours = [6, 8, 4, 3, 3]
activities = ['School', 'Sleep', 'Homework', 'Others', 'Play']
**# Plot pie chart**
plt.pie(hours,labels=activities, autopct=lambda p: format(p,
'.2f') if p > 15 else None)
**# Title**
plt.title('Time', color='r')
**# Display**
plt.show()
- 导入
matplotlib.pyplot库。 - 定义数据坐标和标签以创建饼图。
- 为了绘制饼图，我们使用
pie()方法。 - 要添加标题，我们使用
title()方法。 - 我们应用标签的有条件移除，例如，如果%age 值大于 15，则仅保留标签，否则移除它们。
plt.pie()
来自数据帧的 Matplotlib 饼图
在这里，我们将学习从熊猫数据帧创建一个饼图。列中数字数据的比例表示是饼图。
从数据帧创建饼图需要以下步骤:
- 导入所需的库，如熊猫和
matplotlib.pyplot。 - 使用 pandas 的
DataFrame()方法创建 pandas dataframe。 - 使用
pie()方法为“金额”列和“费用”列绘制一个饼图。
pd.DataFrame()
带标签的 Matplotlib 嵌套饼图
这里我们将看到一个带有标签的嵌套饼图示例。我们可以使用嵌套饼图或多级饼图在您的饼图中包含多个级别或层。嵌套饼图是饼图的一种形式，是普通饼图的模块变体。
我们来看一个例子:
**# Import Libraries**
import matplotlib.pyplot as plt
**# Define data coordinates and labels**
labels = ['Vitamin B12', 'Vitamin A', 'Vitamin E']
sizes = [600, 600, 600]
labels_vitamins = ['meat','poultry','fish','carrots','sweet potatoes','spinach','kale','nuts','seeds','vegetable oils']
sizes_vitamins = [120, 120, 120, 120, 120, 120, 120, 120, 120, 120]
**# Define colors**
colors = ['#8B8378', '#53868B','#2E8B57']
colors_vitamins = ['#EEDFCC', '#FFEFDB', '#FAEBD7', '#7AC5CD',
'#8EE5EE','#98F5FF',
'#5F9EA0','#43CD80','#4EEE94','#54FF9F']
**# Plot pie chart**
bigger = plt.pie(sizes, labels=labels, colors=colors,startangle=90)
smaller = plt.pie(sizes_vitamins, labels=labels_vitamins,radius=0.7,startangle=90,labeldistance=0.8,colors=colors_vitamins)
**# Add space**
plt.axis('equal')
plt.tight_layout()
**# Display**
plt.show()
- 首先导入
matplotlib.pyplot库。 - 接下来定义饼图扇区的外部标签、内部标签、外部大小、内部大小、内部颜色和外部颜色。
- 通过使用
plt.pie()方法，我们创建了一个内部和外部饼图。
Nested Pie Chart
Matplotlib 饼图移除标签
在这里，我们将学习从饼图中删除轴标签。为了移除标签，我们向 axes 函数传递一个空字符串。
让我们先看一个添加标签的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates and labels**
hours = [6, 8, 4, 3, 3]
activities = ['School', 'Sleep', 'Homework', 'Others', 'Play']
**# Plot pie chart**
plt.pie(hours,labels=activities, autopct=lambda p: format(p, '.2f') if p > 15 else None)
**# Labels**
plt.xlabel("Activities", color='g')
plt.ylabel("Hours", color='g')
**# Title**
plt.title('Time', color='r')
**# Display**
plt.show()
为了在 x 轴和 y 轴添加标签，我们使用了， xlabel ()和 ylabel ()函数。
plt.xlabel() and plt.ylabel()
让我们看一个移除标签的例子:
要删除轴上的标签，我们传递一个空白字符串。
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates and labels**
hours = [6, 8, 4, 3, 3]
activities = ['School', 'Sleep', 'Homework', 'Others', 'Play']
**# Plot pie chart**
plt.pie(hours,labels=activities, autopct=lambda p: format(p, '.2f') if p > 15 else None)
**# Remove Labels**
plt.xlabel(" ")
plt.ylabel(" ")
**# Title**
plt.title('Time', color='r')
**# Display**
plt.show()
plt.xlabel(” “) and plt.ylabel(” “)
Matplotlib 饼图半径
这里我们将看到一个例子，我们创建了一个不同半径的饼。通过将 radius 作为参数传递给 pie()方法，我们可以增大和减小饼图的大小。
以下是语法:
matplotlib.pyplot.pie(x, labels, radius)
举例:
**# Import Library**
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
**# Define data coordinates and labels**
monthly_sales = [8, 30, 10, 27, 25]
stores = ['B2B Channels', 'Discounts Sales', 'Others', 'Digital
Stores', 'Off-line Stores']
**# Plot pie chart**
plt.pie(monthly_sales, labels=stores, radius=1.6)
**# OR**
plt.pie(monthly_sales, labels=stores, radius=0.5)
**# Display**
plt.show()
- 首先创建支线剧情，使用支线剧情()函数。
- 接下来，我们定义数据坐标和标签。
- 为了绘制饼图，我们使用了
pie()函数。 - 为了设置半径，我们将半径参数传递给函数。这里我们分别将半径设置为 1.6 和 0.5。
plt.pie(radius=1.6)
plt.pie(radius=0.5)
Matplotlib 饼图旋转标签
在这里，我们将学习旋转饼图中绘制的标签。为了旋转标签，我们将 rotatelabels 传递给 pie() 函数。
以下是语法:
matplotlib.pyplot.pie(x, labels, rotatelabels)
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates and labels**
popularity = [2, 3, 6, 35, 54]
devices = ['iPod Touch', 'Samsung SGH-1747M', 'RIM Playbook',
'iPhone', 'iPad']
**# Plot pie chart**
plt.pie(popularity, labels=devices, rotatelabels=180)
**# Display**
plt.show()
- 我们导入
matplotlib.pyplot库。 - 接下来，我们定义数据坐标和标签。
- 为了绘制饼图，我们使用
pie()函数。 - 为了旋转标签，我们将
rotatelabels参数传递给该方法。我们将标签旋转 180 度。
plt.pie(rotatelabels=180)
Matplotlib 饼状图支线剧情
在这里，我们将看到一个数字区域中多个饼图的示例。为了创建支线剧情，我们使用 axes 模块的 subplots()函数。
举例:
**# Importing Library**
import matplotlib.pyplot as plt
import numpy as np
**# Create subplots**
fig, ax = plt.subplots(2, 2)
**# Define Data**
data1 = [10, 60, 30]
data2 = np.array([50])
data3 = np.random.rand(8)
data4 = [10, 10, 10, 10, 10, 10]
**# Plot graph**
ax[0, 0].pie(data1)
ax[0, 1].pie(data2)
ax[1, 0].pie(data3)
ax[1, 1].pie(data4)
**# Add Title**
ax[0, 0].set_title('Pie Chart 1')
ax[0, 1].set_title('Pie Chart 2')
ax[1, 0].set_title('Pie Chart 3')
ax[1, 1].set_title('Pie Chart 4')
**# Display Graph**
fig.tight_layout()
plt.show()
- 为了创建 2 行 2 列的支线剧情，我们使用支线剧情()函数。
- 接下来，我们定义数据坐标。
- 为了绘制饼图，我们使用 axes 模块的
pie()函数。 - 要设置标题，我们使用
set_title()函数。 - 为了增加图之间的空间，我们使用了
tight_layout()函数。 - 为了显示图表，我们使用
show()函数。
plt.subplots()
Matplotlib 饼图开始角度
默认情况下，起始角度设置为 x 轴，但是您可以通过给定一个 startangle 参数来更改它。
startangle 参数以度角作为输入；默认角度为 0:
给定的语法是:
matplotlib.pyplot.pie(x, labels, startangle)
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates and labels**
visitors = [40, 25, 15, 10, 10]
sources = ['Searches', 'Social Media', 'Links', 'Direct',
'Advertising']
**# Plot pie chart**
plt.pie(visitors, labels=sources, startangle=90)
# OR
plt.pie(visitors, labels=sources, startangle=270)
**# Display**
plt.show()
这里，我们将 startangel 参数传递给 pie() 函数，并将其值分别设置为 90 度和 270 度。
plt.pie(startangle=90)
plt.pie(startangle=270)
Matplotlib 饼图字典
这里我们将看到一个使用字典数据类型创建饼图的例子。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Data**
pie_data = {'Chocolate': 65,
'Tart': 30,
'Fruit': 45,
'Mint': 18, }
**# Data to plot**
flavors = []
popularity = []
for x, y in pie_data.items():
flavors.append(x)
popularity.append(y)
**# Plot**
plt.pie(popularity, labels=flavors)
**# Display**
plt.axis('equal')
plt.show()
在上面的例子中，我们通过使用字典数据类型来定义数据坐标。在这里，我们将关键字定义为口味，将值定义为流行度。
Matplotlib 半饼图
在这里，我们将看到一个饼图示例，其中我们制作了一个半饼图。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Create Subplot**
fig = plt.figure(figsize=(8,6),dpi=100)
ax = fig.add_subplot(1,1,1)
**# Data Coordinates**
pie_labels = ["Label 1", "Label 2", "Label 3"]
pie_values = [1,2,3]
**# Colors**
pie_labels.append("")
pie_values.append(sum(val))
colors = ['red', 'blue', 'green', 'white']
**# Plot**
ax.pie(val, labels=label, colors=colors)
**# Add artist**
ax.add_artist(plt.Circle((0, 0), 0.6, color='white'))
**# Display**
plt.show()
- 我们导入
matplotlib.pyplot库。 - 接下来，我们使用
figure()函数来设置 fig 大小。 - 然后我们用
add_subplot()函数添加支线剧情。 - 定义数据坐标和标签。
- 然后我们添加数据并分配颜色。
- 为了绘制饼图，我们使用了
pie()函数。 - 然后我们使用
add_artist()函数和circle()函数添加艺术家。
Half Pie Chart
Matplotlib 饼图绝对值
这里我们将学习用绝对值替换自动标记的值。要将百分比转换为原始值，我们必须将饼图的总大小乘以 100。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data coordinates and labels**
money_utilised = [48, 19, 9, 9, 10, 5]
resources = ['Rent', 'Food', 'Utilities', 'Fun', 'Clothes',
'Phone']
**# Total**
total = sum(money_utilised)
**# Plot pie chart**
plt.pie(money_utilised, labels=resources,
autopct=lambda p: '{:.0f}'.format(p * total / 100))
**# Display**
plt.show()
输出:
Absolute Value
Matplotlib 饼图甜甜圈
饼图的修改版本是圆环图。中心区域被切掉的环形图。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Data coordinates and labels**
languages = ["Python", "Android", "Php", "JavaScript"]
popular = [50, 15, 45, 30]
colors = ['#FF0000', '#0000FF', '#FFFF00', '#ADFF2F']
**# Plot pie chart**
plt.pie(popular, labels=languages, colors=colors)
**# Draw circle**
centre_circle = plt.Circle((0, 0), 0.70, fc='white')
fig = plt.gcf()
**# Adding Circle in Pie chart**
fig.gca().add_artist(centre_circle)
**# Display**
plt.show()
- 首先，我们导入库
matplotlib.pyplot。 - 接下来，我们定义数据坐标、标签和颜色。
- 之后，我们使用
pie()函数绘制饼图。 - 然后我们用
circle()函数画圆。 - 要在饼图中添加一个圆，我们使用
add_artist()函数。
Donut
Matplotlib 饼图注释
在这里，我们将学习创建一个带有注释标签的饼图。
举例:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Subplot**
fig, ax= plt.subplots(figsize=(4,4))
plt.subplots_adjust(bottom=0.3)
**# Coordinates and labels**
usage = [19, 36, 39, 5, 3]
browser = ['Internet Explorer', 'Firefox', 'Chrome', 'Safari',
'Opera']
**# Title**
plt.title('Browser Usage')
plt.gca().axis("equal")
**# Plot pie**
patches, texts = pie = plt.pie(usage)
**# Annotate**
bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=0.72)
arrowprops=dict(arrowstyle="-",connectionstyle="angle,angleA=0,angleB=90")
kw = dict(xycoords='data',textcoords='data',arrowprops=arrowprops,
bbox=bbox_props, zorder=0, va="center")
for i, p in enumerate(patches):
ang = (p.theta2 - p.theta1)/2.+p.theta1
y = np.sin(ang/180.*np.pi)
x = 1.35*np.sign(np.cos(ang/180.*np.pi))
plt.gca().annotate(str(1+i), xy=(0, 0), xytext=( x, y), **kw )
**# Legend**
plt.legend(pie[0],browser, loc="center", bbox_to_anchor=(0.5,-0.2))
**# Display**
plt.show()
Matplotlib 饼图分类数据
这里我们将学习使用 groupby() 函数绘制分类数据的饼图。
举例:
**# Import Library**
import pandas as pd
import numpy as np
from matplotlib import pyplot as plt
**# function**
def label_function(val):
return f'{val / 100 * len(df):.0f}\n{val:.0f}%'
**# Data Frame**
N = 50
df = pd.DataFrame({'vegetable': np.random.choice(['Tomato','Carrot', 'Peas'], N),
'fruit': np.random.choice(['Apple',
'Orange', 'Cherry'], N)})
**# create subplot**
fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(10, 5))
**# Categorial data pie chart**
df.groupby('vegetable').size().plot(kind='pie', colors='
['tomato', 'gold', 'skyblue'], ax=ax1)
df.groupby('fruit').size().plot(kind='pie', colors=
['violet','pink', 'lime'], ax=ax2)
**# Labels**
ax1.set_ylabel('Vegetables', size=15)
ax2.set_ylabel('Fruits', size=15)
**# Auto space**
plt.tight_layout()
**# Display**
plt.show()
df.groupby()
另外，看看 matplotlib 上的更多教程。
所以，在这个 Python 教程中，我们已经讨论了“Matplotlib 饼状图”，我们也涵盖了一些与之相关的例子。这些是我们在本教程中讨论过的以下主题。
- python 中的 Matplotlib 饼图
- Matplotlib 饼图示例
- Matplotlib pie chart title
- Matplotlib 饼图标题位置
- Matplotlib 饼图标题字体大小
- Matplotlib 饼图颜色
- 带标签的 Matplotlib 饼图
- Matplotlib 饼图背景色
- Matplotlib 饼图十六进制颜色
- 带图例的 Matplotlib 饼图
- matplot lib pie chart label fontsize
- matplot lib pie chart legend fontsize
- Matplotlib 饼图自动压缩
- Matplotlib 饼图自动压缩位置
- Matplotlib 饼图楔形图
- Matplotlib 饼图边缘颜色
- Matplotlib 饼图增加大小
- Matplotlib 饼图标签在内部
- Matplotlib 饼图粗体文本
- Matplotlib 饼图放大
- Matplotlib 饼图文本属性
- Matplotlib 饼图文本颜色
- Matplotlib 饼图阴影
- Matplotlib pie chart alpha
- Matplotlib 饼图爆炸图
- Matplotlib 饼图阴影
- Matplotlib 饼图框架
- Numpy matplotlib pie chart(数字打印图表)
- Matplotlib pie chart label header
- Matplotlib 多重饼图
- Matplotlib 饼图移动图例
- Matplotlib 饼图移动标签
- Matplotlib 饼图不是圆形
- 并排的 Matplotlib 饼图
- Matplotlib 饼图保存
- Matplotlib 饼图关闭标签
- 来自数据框架的 Matplotlib 饼图
- 带标签的 Matplotlib 嵌套饼图
- Matplotlib 饼图删除标签
- Matplotlib 饼图半径
- Matplotlib 饼图旋转标签
- Matplotlib 饼图子情节
- Matplotlib 饼图开始角度
- Matplotlib 饼图词典
- Matplotlib 半饼图
- Matplotlib 饼图绝对值
- Matplotlib pie chart 甜甜圈
- Matplotlib 饼图批注
- Matplotlib 饼图分类数据
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
