PythonForBeginners-中文系列教程-五-
PythonForBeginners 中文系列教程（五）
为什么我们需要 Python 中的注释
原文：https://www.pythonforbeginners.com/comments/why-we-need-comments-in-python
注释是包含在源代码中但对程序逻辑没有贡献的语句。一个 python 注释不是由解释器执行的，只有当我们可以访问源代码时才能访问它。现在的问题是，尽管它们对程序逻辑没有贡献，但是为什么注释会包含在源代码中。在这篇文章中，我们将尝试了解为什么我们需要 python 中的注释。让我们开始吧。
我们使用注释来指定源代码的元数据。
当我们出于商业目的编写任何计算机程序时，我们通常会包括程序员的姓名、源代码创建的日期和时间。一般来说，当根据合同开发程序时，源代码的使用条件、源代码的许可和版权以及程序的一般描述也包含在源文件中。为了在源代码中包含这些信息，我们使用 python 注释。元数据包含在源代码文件开头的头注释中。下面是一个标题注释的例子。
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Mar 27 19:59:11 2021
@author: aditya1117
This code has been written to demonstrate the use of comments in python to specify metadata of the sorce code
"""
当任何人访问源代码文件时，他们可以读取文件的元数据，然后他们可以知道他们是否被允许重用或修改源代码。如果对源代码进行了任何更改，也应该在元数据中提及，以便其他人可以获得相关信息。
我们使用注释来记录源代码。
对于源代码文档，我们使用注释来描述程序中使用的每个函数和方法的规范。我们包括输入参数、预期输出和方法或函数的一般描述，这样当有人试图使用程序中的函数和方法时，他可以从文档中得到想法。当用任何编程语言引入一个框架或库时，必须提供适当的源代码文档。下面是一个文档示例，描述了一个将数字及其平方作为键值对添加到 python 字典的函数。
#The function adds a number and its square to a python dictionary as key value pair.
def add_square_to_dict(x,mydict):
a=x*x
mydict[str(x)]=a
return mydict
我们使用注释来阐明为什么在源代码中写了一个特定的语句。
一般来说，程序中使用的函数和语句对于它们在程序中的使用应该是不言自明的，但是每当看起来不清楚为什么要在源代码中编写语句时，我们就需要注释来说明为什么要在源代码中编写语句。
我们使用注释来指定有助于调试代码和改进程序功能的指令。
当编写程序时，根据代码中需要的功能，对代码进行许多修改。为了能够重构和修改代码进行改进，程序员必须知道源代码中包含的函数、方法、类等的所有属性。程序员必须清楚地理解代码中包含的每个语句，以便能够修改它。为了向程序员提供所有这些信息，我们需要注释来指定源代码中函数和方法的所有属性。
我们使用注释来指定对源代码所做的更改。
无论何时对程序的源代码进行任何更改，都必须在源代码中使用注释来指定，并且应该包括关于为什么进行更改以及谁进行了更改的信息。
结论
在本文中，我们已经看到了为什么我们需要 python 中的注释的各种原因。请继续关注更多内容丰富的文章。
Python 中的 With Open 语句
原文：https://www.pythonforbeginners.com/files/with-statement-in-python
在 Python 中，可以使用 open()方法访问文件。但是，直接使用 open()方法需要使用 close()方法显式关闭文件。相反，您可以使用 python 中的 with Open 语句创建上下文。它返回一个 file 对象，该对象具有获取信息和操作打开的文件的方法和属性。
Python 中的 With 语句
使用“With”语句，可以获得更好的语法和异常处理。
" with 语句通过封装常见的准备和清理任务简化了异常处理."
此外，它会自动关闭文件。with 语句提供了一种确保始终使用清理的方法。
如果没有 with 语句，我们将编写如下内容:
file = open("welcome.txt")
data = file.read()
print data
file.close() # It's important to close the file when you're done with it
在上面的代码中，我们需要使用 close()方法显式关闭文件。
Python 中 Open()函数的 With 语句用法
使用 with 打开文件非常简单:with open(filename) as file:
with open("welcome.txt") as file: # Use file to refer to the file object
data = file.read()
do something with data
以写入模式打开 output.txt
with open('output.txt', 'w') as file: # Use file to refer to the file object
file.write('Hi there!')
在上面的代码中，您可以看到我们已经使用 with open 语句打开了 output.txt 文件。该语句返回一个分配给变量“file”的文件指针。现在，我们可以在 with 语句的上下文中对 file 对象执行任何操作。一旦执行完所有语句，并且执行到达 with context 块的末尾，python 解释器将自动关闭该文件。此外，如果程序在 with 块中遇到任何异常，python 中的 with open 上下文会在终止程序之前关闭文件。这样，即使程序突然终止，文件中的数据也保持安全。
请注意，我们不必编写“file.close()”。会被自动调用。
结论
在本文中，我们讨论了如何使用 with open 语句而不是 open()
方法在 python 中打开文件。要了解更多关于 python 编程的知识，你可以阅读这篇关于 Python 中的字符串操作的文章。你可能也会喜欢这篇关于 python 的文章，如果是简写。
使用 Python 超级函数
原文：https://www.pythonforbeginners.com/super/working-python-super-function
Python 2.2 引入了一个名为“super”的内置函数，该函数返回一个代理对象，将方法调用委托给一个类——本质上可以是父类或兄弟类。
除非您有使用 Python 的经验，否则这种描述可能没有意义，所以我们将对其进行分解。
本质上，super 函数可以用来访问继承的方法——从父类或兄弟类——在类对象中被覆盖。
或者，正如官方 Python 文档所说的那样:
"[Super 用于] 返回一个代理对象，该对象将方法调用委托给类型的父类或同级类。这对于访问在类中被重写的继承方法很有用。搜索顺序与 getattr()使用的顺序相同，只是跳过了类型本身。
超级功能是怎么用的？
超级函数有点多才多艺，可以以多种方式使用。
用例 1:可以在单个继承中调用 Super，以便引用父类或多个类，而无需显式命名它们。这在某种程度上是一种捷径，但更重要的是，它有助于在可预见的未来保持代码的可维护性。
用例 2:可以在动态执行环境中调用 Super 来实现多重或协作继承。这种用法被认为是 Python 独有的，因为对于只支持单一继承或静态编译的语言来说是不可能的。
当超级功能被引入时，它引发了一些争议。许多开发人员发现文档不清楚，而且函数本身很难实现。它甚至获得了有害的名声。但是重要的是要记住，Python 自 2.2 以来已经有了很大的发展，其中许多问题不再适用。
super 的伟大之处在于它可以用来增强任何模块方法。另外，不需要知道被用作扩展器的基类的细节。超级函数为您处理所有这些。
因此，对于所有意图和目的来说，super 是访问基类的快捷方式，而不必知道它的类型或名称。
在 Python 3 和更高版本中，super 的语法是:
super().methoName(args)
而调用 super 的正常方式(在 Python 的旧版本中)是:
super(subClass, instance).method(args)
如您所见，Python 的新版本使语法稍微简单了一些。
如何在 Python 2 和 Python 3 中调用 Super？
首先，我们将获取一个常规的类定义，并通过添加超级函数来修改它。最初的代码看起来会像这样:
class MyParentClass(object):
def __init__(self):
pass
class SubClass(MyParentClass):
def __init__(self):
MyParentClass.__init__(self)
如您所见，这是一个通常用于单一继承的设置。我们可以看到有一个基类或父类(有时也称为超类)，以及一个指定的子类。
但是我们仍然需要在子类中初始化父类。为了使这个过程更容易，Python 的核心开发团队创建了 super 函数。目标是为初始化类提供一个更加抽象和可移植的解决方案。
如果我们使用的是 Python 2，我们会像这样编写子类(使用 super 函数):
class SubClass(MyParentClass):
def __init__(self):
super(SubClass, self).__init__()
然而，用 Python 3 编写时，相同的代码略有不同。
class MyParentClass():
def __init__(self):
pass
class SubClass(MyParentClass):
def __init__(self):
super()
注意父类不再直接基于对象基类了吗？此外，由于这个超级函数，我们不需要从父类传递任何东西给它。你不认为这要容易得多吗？
现在，记住大多数类也会有参数传递给它们。当这种情况发生时，超能力会发生更大的变化。
它将如下所示:
class MyParentClass():
def __init__(self, x, y):
pass
class SubClass(MyParentClass):
def __init__(self, x, y):
super().__init__(x, y)
同样，这个过程比传统方法简单得多。在这种情况下，我们必须调用超级函数的 init 方法来传递我们的参数。
超能力又是干什么用的？
当你关心向前兼容性时，超级函数是非常有用的。通过将它添加到您的代码中，您可以确保您的工作在未来保持可操作性，只需进行一些全面的更改。
最终，它消除了声明一个类的某些特征的需要，只要你正确地使用它。
为了正确使用该功能，必须满足以下条件:
- 被 super() 调用的方法必须存在
- 调用者和被调用者函数都需要有匹配的参数签名
- 使用该方法后，该方法的每次出现都必须包含 super()
您可能从单个继承类开始，但是后来，如果您决定添加另一个基类——或者更多——这个过程会顺利得多。你只需要做一些改变，而不是很多。
一直在谈论使用 super 函数进行依赖注入，但是我们还没有看到这方面的任何可靠的例子——至少没有实际的例子。目前，我们只是坚持我们给出的描述。
不管怎样，现在你会明白 super 并不像其他开发者声称的那样糟糕。
了解更多关于超级功能的信息
我们知道很多关于超级函数和 Python 语言的知识，但是我们并不知道所有的事情！你可以去很多其他地方了解更多！
我们建议查看的网站有:
Raymond Hettinger 对 Super 和 Python 的探索
在 Python 中使用 JSON 文件
原文：https://www.pythonforbeginners.com/basics/working-with-json-files-in-python
JSON 文件是两个 web 应用程序之间通信最常用的数据格式之一。在本文中，我们将讨论什么是 JSON 对象，以及如何在 Python 中处理 JSON 文件。
JSON 对象是什么？
JSON 是 JavaScript 对象符号的首字母缩写。它是一种基于文本的标准格式，使用键值对以结构化的方式表示数据。它最常用于在 web 应用程序之间传输数据。JSON 文件的扩展名为.json。
下面是一个 JSON 对象的例子。
{"Name": "Aditya", "Age":23, "Height":181}
什么是嵌套的 JSON 对象？
嵌套的 JSON 对象是包含另一个 JSON 对象作为一个或多个键的关联值的 JSON 对象。我们还可以使用嵌套的 JSON 对象来传输数据。例如，考虑下面的 JSON 对象。
{
"coffee": {
"region": [
{"id":1, "name": "John Doe"},
{"id":2, "name": "Don Josh"}
],
"country": {"id":2, "company": "ACME"}
},
"brewing": {
"region": [
{"id":1, "name": "John Doe"},
{"id":2, "name": "Don Josh"}
],
"country": {"id":2, "company": "ACME"}
}
}
上面的 JSON 对象是嵌套的 JSON 对象。您可以观察以下内容。
- 在外部对象中，我们有两个键，即
“coffee”和“brewing”. “coffee”和“brewing”键包含其他 JSON 对象作为它们的值。因此，给定的 JSON 对象是一个嵌套的 JSON 对象。- 在
“coffee”和“brewing”里面，我们有两个按键，分别是“region”和“country”。“country”包含另一个 JSON 对象作为它的键，而“region”包含一个 JSON 对象列表。
因此，一个嵌套的 JSON 对象可以包含另一个 JSON 对象或一组 JSON 对象。
定义 JSON 对象的语法
正如您在上面两个例子中看到的，JSON 对象具有以下语法。
- 数据以类似于 python 字典的方式呈现在键值对中。
- JSON 字符串中的键和值由冒号
(:)分隔。 - JSON 对象中的每个键值对由逗号
(,)分隔。 - JSON 对象中的所有数据都用花括号
({ })括起来。 - 字符串值和键用双引号
(“ ”)括起来。 - 数组用方括号
([ ])括起来。 - 数组中的值用逗号分隔。数组中的值可以是 JSON 对象、数组或任何允许的数据类型的文字。
- JSON 对象中的键是字符串数据类型。另一方面，关联值可以是允许的数据类型之一。允许的数据类型有字符串、数字、对象、数组、布尔值或空值。
在 Python 中使用 JSON 文件
Python 为我们提供了 JSON 模块来处理 Python 中的 JSON 字符串和文件。现在让我们讨论如何将 python 对象转换成 JSON 对象，反之亦然。
Python 对象到 JSON 文件
我们可以使用 dump()方法将 python 对象转换成 JSON 文件。
dump()方法
dump()方法的语法如下。
json.dump(python_obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
这里，
python_obj参数接受一个需要转换成 JSON 文件的 python 对象。该对象可以是数字、字符串、字典、列表或自定义 python 对象。fp参数将一个文件指针作为它的输入参数。在写模式下打开一个扩展名为.json的文件后，可以将它传递给fp参数。执行后，python_obj的内容以 JSON 格式保存到fp指向的文件中。- python 对象中的键可以是任何数据类型。但是，并非所有的数据类型都可以转换成 JSON 格式。当我们试图从一个 python 对象或字典创建一个 JSON 文件，其键的数据类型不是
str、int、float、bool和None时，dump()方法会引发一个类型错误异常。skipkeys参数帮助我们在这种情况下处理数据。当我们将skipkeys设置为True时，dump()方法会跳过具有不兼容数据类型的键，而不是遇到 TypeError 异常。 ensure_ascii参数用于确保输出 JSON 文件中的所有字符都是 ASCII 字符。当ensure_ascii设置为True时，跳过python_obj中所有非 ASCII 字符。如果设置为False，非 ASCII 字符将按原样保存到 JSON 文件中。check_circular参数用于确保dump()方法对容器类型执行循环引用检查。如果check_circular被设置为False，循环参考检查被跳过。在这种情况下，循环引用将导致程序运行到 RecursionError 异常。allow_nan参数用于将NaN和 infinity 值转换为 JSON 格式。当allow_nan设置为True时，dump()方法将NaN、+inf和-inf分别转换为 JavaScriptNaN、Infinity、-Infinity。当allow_nan设置为False时，dump()方法在python_obj中找到NaN、+inf或-inf时，会引发 ValueError 异常。- 当我们想要将定制的 python 对象转换成 JSON 时，使用
cls参数。为了将自定义对象转换成 JSON，我们需要定义一个自定义的JSONEncoder子类，并将其传递给cls参数。 indent参数用于指定 JSON 对象中的缩进。当indent参数被设置为None或负整数时，JSON 对象是最紧凑的表示。当indent参数被设置为一个正整数值时，它在从dump()方法创建的 JSON 对象中每层缩进那么多空格。当indent被设置为字符串时，该字符串被用作缩进字符。当indent设置为 0 或空字符串时，每缩进一级引入一个新行。- 默认情况下，JSON 对象的键值对由逗号分隔，键和值用冒号分隔。要为键和项指定新的分隔符，可以将包含两个字符的元组传递给
separators参数。元组的第一个字符成为键和值的分隔符。元组的第二个元素成为不同项目的分隔符。当indent参数设置为None时，separators参数的默认值为(', ', ': ')。否则，separators参数的默认值为(',', ': ')。为了获得最紧凑的 JSON 对象，您应该从分隔符中删除空格，并使用(',', ':')作为separators参数的输入参数。 - 当
dump()方法在python_obj参数中获得一个不可序列化的对象时，它会引发一个 TypeError 异常。您可以使用default参数来处理这种情况。default参数将一个函数作为其输入参数。该函数应该返回对象的 JSON 可编码版本，或者引发 TypeError。 - 如果您希望 JSON 对象的键以一种排序的方式排序，那么在
dump()方法中使用sort_keys参数。如果sort_keys参数被设置为True，则输出 JSON 对象的键以词典的方式排序。
执行后，dump()方法将 JSON 文件保存到给定的文件指针。您可以在下面的示例中观察到这一点。
import json
myStr="Aditya Raj"
fp=open("fromstring.json","w")
json.dump(myStr, fp)
fp.close()
输出:
在上面的例子中，我们已经将字符串"Aditya Raj" 转换为名为fromstring.json的 JSON 文件。为此，我们首先使用open()函数以写模式打开fromstring.json文件。open()函数将文件名和文字"w"作为它的输入参数。执行后，它以写模式打开文件并返回一个文件指针。我们将文件指针和输入字符串传递给dump()方法。执行后，dump()方法将 JSON 对象保存在文件中。
最后，我们使用close()方法关闭文件。如果不关闭文件，写入文件的任何数据都不会被保存。因此，这是重要的一步。
您还可以使用 Python 中的dumps()方法将列表和字典等对象转换成 JSON 文件，如下所示。
import json
myDict={"Name": "Aditya", "Age": 23}
fp=open("fromdict.json","w")
json.dump(myDict, fp)
fp.close()
输出:
在本文中，我们已经用 python 将一个 python 字典转换成了一个 JSON 文件。类似地，您也可以使用dump() 方法将列表转换成 JSON 文件。
要将定制 python 对象转换成 JSON，可以阅读这篇关于 Python 中的定制 JSON 编码器的文章。
Python 对象到 JSON 字符串
dumps()方法
dumps()方法用于将 python 对象转换为 JSON 格式的字符串。它具有以下语法。
json.dumps(python_obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
dumps()方法中的所有参数与 dump() 方法中的各个参数含义相同。唯一的区别是，dump()方法将 JSON 对象保存到一个文件中，而dumps()方法在执行后返回一个 JSON 格式的字符串。您可以在下面的示例中观察到这一点。
import json
myStr="Aditya Raj"
print("The input string is:")
print(myStr)
jsonStr=json.dumps(myStr)
print("The JSON string is:")
print(jsonStr)
输出:
The input string is:
Aditya Raj
The JSON string is:
"Aditya Raj"
您还可以使用 Python 中的dumps()方法将列表和字典等对象转换为 JSON 字符串，如下所示。
import json
myDict={"Name": "Aditya", "Age": 23}
print("The dictionary is:")
print(myDict)
jsonStr=json.dumps(myDict)
print("The JSON string is:")
print(jsonStr)
输出
The dictionary is:
{'Name': 'Aditya', 'Age': 23}
The JSON string is:
{"Name": "Aditya", "Age": 23}
使用 JSONEncoder 类将 Python 对象转换为 JSON 字符串
JSONEncoder 类用于创建默认和定制的 JSON 编码器，以便将 python 对象转换为 JSON 格式。执行时，JSONEncoder()构造函数返回一个 JSONEncoder 对象。
我们可以调用 JSONEncoder 对象上的encode()方法来从 python 对象创建 JSON 字符串。当在 JSONEncoder 对象上调用encode() 方法时，该方法将 python 对象作为其输入参数，并返回 python 对象的 JSON 表示。您可以在下面的示例中观察到这一点。
import json
myStr="Aditya Raj"
print("The input string is:")
print(myStr)
jsonStr=json.JSONEncoder().encode(myStr)
print("The JSON string is:")
print(jsonStr)
输出:
The input string is:
Aditya Raj
The JSON string is:
"Aditya Raj"
在这个例子中，我们首先使用JSONEncoder()构造函数创建了一个 JSONEncoder 对象。然后，我们使用encode() 方法将 python 字符串转换成 JSON 字符串。
除了原始数据类型，还可以将列表和字典等容器对象转换成 JSON 格式，如下所示。
import json
myDict={"Name": "Aditya", "Age": 23}
print("The dictionary is:")
print(myDict)
jsonStr=json.JSONEncoder().encode(myDict)
print("The JSON string is:")
print(jsonStr)
输出:
The dictionary is:
{'Name': 'Aditya', 'Age': 23}
The JSON string is:
{"Name": "Aditya", "Age": 23}
建议阅读:如果你对机器学习感兴趣，你可以在 mlops for 初学者上阅读这篇文章。您可能还会喜欢这篇关于用 Python 对混合数据类型进行聚类的的文章。
将 JSON 文件加载到 Python 对象
我们可以使用load()方法将 JSON 文件加载到 python 对象中。
load()方法
load()方法的语法如下。
json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
fp参数是指向包含 JSON 文件的 file 对象的文件指针。- 当我们想要将 JSON 转换成一个定制的 python 对象时，就要用到
cls参数。为了将 JSON 转换成自定义对象，我们需要定义一个自定义 JSONDecoder 子类，并将其传递给cls参数。 object_hook参数用于创建定制的 JSON 解码器。object_hook参数将一个函数作为其输入参数。使用从 JSON 解码的对象文字来调用该函数。在输出中，函数的返回值被用来代替字典。parse_float参数用于将 JSON 中的任何浮点数转换成另一种数据类型。默认情况下，使用 JSON 中包含浮点数的字符串调用float()函数。如果我们在parse_float参数中指定一个函数，load()方法将包含一个浮点数的字符串传递给该函数，该函数的输出在 python 对象中使用。如果您希望在加载 JSON 本身时将浮点转换为 int 或其他数据类型，可以使用这个参数。parse_int参数用于将 JSON 中的任何整数转换成另一种数据类型。默认情况下，使用 JSON 中包含整数的字符串调用int()函数。如果我们在parse_int参数中指定一个函数，load()方法将包含整数的字符串传递给该函数，函数的输出在 python 对象中使用。如果您想在加载 JSON 本身时将整数转换成浮点数或其他数据类型，可以使用这个参数。int()的默认parse_int现在通过解释器的整数字符串转换长度限制来限制整数字符串的最大长度，以帮助避免拒绝服务攻击。parse_constant参数用于将NaN、-Infinity和+Infinity从 JSON 加载到自定义 python 值中。parse_constant参数将一个函数作为它的输入参数。而load()函数的执行，NaN、-Infinity、+Infinity被传递给函数，返回值在 python 对象中使用。object_pairs_hook是一个可选参数，它将一个函数作为其输入参数。调用该函数时，任何对象文字的解码结果都带有一个有序的对列表。使用了object_pairs_hook的返回值来代替字典。此功能可用于实现自定义解码器。如果object_hook也被定义，则object_pairs_hook优先。
执行后，load()方法返回一个 python 对象。例如，考虑下面的 JSON 文件。
当我们使用load()方法将上面的 JSON 文件转换成 python 对象时，我们将得到一个 python 字典。
您可以使用如下所示的load()方法将 JSON 文件转换成 python 对象。
import json
fp=open("simplestudent.json","r")
myDict=json.load(fp)
print("The python object is:")
print(myDict)
fp.close()
输出:
The python object is:
{'Name': 'Aditya', 'Age': 23}
将 JSON 字符串转换为 Python 对象
要将 JSON 字符串转换成 python 对象，我们可以使用 loads()方法或 JSONDecoder 类。
loads()方法
loads()方法用于将 JSON 字符串加载到 python 对象中。它具有以下语法。
json.loads(json_string, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
这里，json_string参数表示必须转换成 python 对象的 JSON 字符串。loads()方法中的所有其他参数与load() 方法中的参数相同。执行后，loads()方法返回一个 python 对象，如下所示。
import json
jsonStr='{"Name": "Aditya", "Age": 23}'
print("The JSON string is:")
print(jsonStr)
myDict=json.loads(jsonStr)
print("The python object is:")
print(myDict)
输出:
The JSON string is:
{"Name": "Aditya", "Age": 23}
The python object is:
{'Name': 'Aditya', 'Age': 23}
在这个例子中，您可以观察到我们已经使用loads()方法将 JSON 字符串转换为 python 字典。
使用 JSONDecoder 类将 JSON 字符串转换为 Python 字典
JSONDecoder 类用于在 Python 中创建定制的 JSON 解码器。为了使用 JSONDecoder 类将 JSON 字符串转换成 python 对象，我们将首先执行JSONDecoder() 构造函数。JSONDecoder 构造函数在执行后返回一个 JSONDecoder 对象。
我们将调用 JSONDecoder 对象上的decode()方法，从 JSON 字符串创建一个 python 对象。decode()方法接受一个 JSON 字符串并返回一个 python 对象，如下例所示。
import json
jsonStr='{"Name": "Aditya", "Age": 23}'
print("The JSON string is:")
print(jsonStr)
myDict=json.JSONDecoder().decode(jsonStr)
print("The python object is:")
print(myDict)
输出:
The JSON string is:
{"Name": "Aditya", "Age": 23}
The python object is:
{'Name': 'Aditya', 'Age': 23}
默认情况下，load()方法、loads()方法和decode()函数返回一个 python 字典。要将 JSON 对象直接转换成定制 python 对象，可以阅读这篇关于 Python 中定制 JSON 解码器的文章。
为什么要用 JSON 文件配合 Python 进行数据传输？
- JSON 格式在语法上类似于原始的 python 对象。因此，很容易将 python 对象转换成 JSON 并通过网络发送。为了发送定制的 python 对象，我们可以定义编码器和解码器，并轻松地以 JSON 格式传输数据。
- JSON 数据是文本格式的。因此，我们可以将它发送到任何应用程序。此外，它可以由任何编程语言处理，因为所有编程语言都支持文本数据。
- JSON 格式是非常轻量级的。由于它很小，可以很容易地通过 HTTP 和 HTTPS 发送。
- JSON 易于阅读，使用键值对进行结构化，不像 XML 等其他格式那样有很多结束或开始标记。
- 几乎每种主要语言都有处理 JSON 数据的专用库。因此，即使您在不同的团队中使用不同的编程语言，您的软件模块也可以使用 JSON 轻松地相互通信。
结论
在本文中，我们讨论了在 Python 中使用 JSON 文件。要了解更多关于 python 编程的知识，你可以阅读这篇关于如何用 Python 创建聊天应用的文章。您可能也会喜欢这篇关于使用 Python 中的 sklearn 模块进行线性回归的文章。
请继续关注更多内容丰富的文章。
快乐学习！
str 与 repr
原文：https://www.pythonforbeginners.com/basics/__str__-vs-__repr
根据 Python 官方文档，repr 是一个内置函数，用于计算对象的“正式”字符串信誉，而 str 是一个内置函数，用于计算对象的“非正式”字符串表示。所以 repr 和 str 都用来表示对象，只是方式不同。理解这两种功能区别的最佳方式是看它们的实际应用:
对于 int x，repr()和 str()的返回值是相同的，但是 str y 的返回值是不同的——一个是正式的，另一个是非正式的。正式表示和非正式表示之间最重要的区别之一是，str 值的 repr 的默认实现可以作为 eval 的参数调用，返回值将是一个有效的 string 对象，如下所示:
如果尝试调用 str 的返回值作为 eval 的参数，结果将无效。
浙公网安备 33010602011771号