使用namedtuple编写Python的代码

Pythonnamedtuple()是一个工厂函数，可在collections. 它允许您创建tuple具有命名字段的子类。您可以使用点表示法和字段名称访问给定命名元组中的值，例如 in obj.attr。

Python 的namedtuple创建是为了通过提供一种使用描述性字段名称而不是整数索引来访问值的方法来提高代码可读性，大多数情况下，整数索引不提供有关值的任何上下文。此功能还使代码更简洁，更易于维护。

相比之下，对常规元组中的值使用索引可能很烦人、难以阅读且容易出错。如果元组有很多字段并且构建的位置远离您使用它的地方，则尤其如此。

除了命名元组的这一主要功能外，您还会发现它们：

• 是不可变的数据结构
• 具有一致的哈希值
• 可以用作字典键
• 可以成套存储
• 有一个基于类型和字段名称的有用文档字符串
• 提供有用的字符串表示形式，以某种name=value格式打印元组内容
• 支持索引
• 提供其他方法和属性，例如._make()、_asdict()、._fields等
• 是向后兼容与普通的元组
• 具有与常规元组相似的内存消耗

通常，您可以namedtuple在需要类似元组的对象的任何地方使用实例。命名元组的优势在于它们提供了一种使用字段名称和点表示法访问其值的方法。这将使您的代码更加 Pythonic。

通过namedtuple对它的简要介绍及其一般特性，您可以更深入地了解如何在代码中创建和使用它们。

创建类似元组的类 namedtuple()

您可以使用 anamedtuple()创建具有字段名称的不可变且类似于元组的数据结构。您可以在教程中找到的一个流行示例namedtuple是创建一个类来表示一个数学点。

根据问题的不同，您可能希望使用不可变的数据结构来表示给定的点。以下是使用常规元组创建二维点的方法：

>>> # Create a 2D point as a tuple
>>> point = (2, 4)
>>> point
(2, 4)

>>> # Access coordinate x
>>> point[0]
2
>>> # Access coordinate y
>>> point[1]
4

>>> # Try to update a coordinate value
>>> point[0] = 3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

在这里，您point使用常规tuple. 此代码有效：您有point两个坐标，并且不能修改任何这些坐标。但是，这段代码可读吗？你能预先说出0和1指数的含义吗？为了防止这些歧义，你可以使用namedtuple这样的：

>>> from collections import namedtuple

>>> # Create a namedtuple type, Point
>>> Point = namedtuple("Point", "x y")
>>> issubclass(Point, tuple)
True

>>> # Instantiate the new type
>>> point = Point(2, 4)
>>> point
Point(x=2, y=4)

>>> # Dot notation to access coordinates
>>> point.x
2
>>> point.y
4

>>> # Indexing to access coordinates
>>> point[0]
2
>>> point[1]
4

>>> # Named tuples are immutable
>>> point.x = 100
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: can't set attribute

现在你有point两个适当命名的字段，x和y. 默认情况下，您point提供了用户友好且描述性的字符串表示形式 ( Point(x=2, y=4))。它允许您使用点表示法访问坐标，该表示法方便、易读且明确。您还可以使用索引来访问每个坐标的值。

>>> from collections import namedtuple

>>> Person = namedtuple("Person", "name children")
>>> john = Person("John Doe", ["Timmy", "Jimmy"])
>>> john
Person(name='John Doe', children=['Timmy', 'Jimmy'])
>>> id(john.children)
139695902374144

>>> john.children.append("Tina")
>>> john
Person(name='John Doe', children=['Timmy', 'Jimmy', 'Tina'])
>>> id(john.children)
139695902374144

>>> hash(john)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

最后，由于namedtuple类是 的子类tuple，它们也是不可变的。因此，如果您尝试更改坐标的值，则会得到AttributeError.

namedtuple从可迭代对象创建实例

您可以使用._make()来创建命名元组实例。该方法接受一个可迭代的值并返回一个新的命名元组：

>>> from collections import namedtuple

>>> Person = namedtuple("Person", "name age height")
>>> Person._make(["Jane", 25, 1.75])
Person(name='Jane', age=25, height=1.75)

在这里，您首先Person使用namedtuple(). 然后，您._make()使用 .csv 文件中每个字段的值列表进行调用namedtuple。请注意，这._make()是一个用作替代类构造函数并返回一个新命名元组实例的类方法。

最后，._make()期望一个可迭代对象作为参数，list在上面的例子中是 a 。另一方面，namedtuple构造函数可以采用位置参数或关键字参数，正如您已经了解的那样。

将namedtuple实例转换为字典

您可以使用 将现有的命名元组实例转换为字典._asdict()。此方法返回一个使用字段名称作为键的新字典。结果字典的键与原始字典中的字段顺序相同namedtuple：

>>> from collections import namedtuple

>>> Person = namedtuple("Person", "name age height")
>>> jane = Person("Jane", 25, 1.75)
>>> jane._asdict()
{'name': 'Jane', 'age': 25, 'height': 1.75}

当您调用._asdict()命名元组时，您将获得一个新dict对象，该对象将字段名称映射到原始命名元组中的相应值。

从Python 3.8 开始，._asdict()返回了一个普通字典。在此之前，它返回了一个OrderedDict对象：

Python 3.7.9 (default, Jan 14 2021, 11:41:20)
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from collections import namedtuple

>>> Person = namedtuple("Person", "name age height")
>>> jane = Person("Jane", 25, 1.75)
>>> jane._asdict()
OrderedDict([('name', 'Jane'), ('age', 25), ('height', 1.75)])

Python 3.8 更新._asdict()为返回常规字典，因为字典会记住其键在 Python 3.6 及更高版本中的插入顺序。请注意，结果字典中键的顺序等同于原始命名元组中字段的顺序。

替换现有namedtuple实例中的字段

您将学习的最后一种方法是._replace(). 此方法采用表单的关键字参数field=value并返回一个namedtuple更新所选字段值的新实例：

>>> from collections import namedtuple

>>> Person = namedtuple("Person", "name age height")
>>> jane = Person("Jane", 25, 1.75)

>>> # After Jane's birthday
>>> jane = jane._replace(age=26)
>>> jane
Person(name='Jane', age=26, height=1.75)

在此示例中，您在 Jane 生日后更新她的年龄。尽管 的名称._replace()可能暗示该方法修改了现有的命名元组，但实际情况并非如此。这是因为namedtuple实例是不可变的，所以._replace()不会jane 就地更新。

探索附加namedtuple属性

命名元组还有两个额外的属性：._fields和._field_defaults. 第一个属性包含一个列出字段名称的字符串元组。第二个属性包含一个字典，该字典将字段名称映射到它们各自的默认值（如果有）。

在 的情况下._fields，您可以使用它来内省您的namedtuple类和实例。您还可以从现有类创建新类：

>>> from collections import namedtuple

>>> Person = namedtuple("Person", "name age height")

>>> ExtendedPerson = namedtuple(
...     "ExtendedPerson",
...     [*Person._fields, "weight"]
... )

>>> jane = ExtendedPerson("Jane", 26, 1.75, 67)
>>> jane
ExtendedPerson(name='Jane', age=26, height=1.75, weight=67)
>>> jane.weight
67

在此示例中，您将创建一个具有新字段的新namedtuple调用ExtendedPerson，weight。这种新类型扩展了您的旧Person. 为此，您可以访问._fieldsonPerson并将其解压缩到一个新列表以及一个附加字段weight.

您还可以使用 Python._fields来迭代给定namedtuple实例中的字段和值zip()：

>>> from collections import namedtuple

>>> Person = namedtuple("Person", "name age height weight")
>>> jane = Person("Jane", 26, 1.75, 67)
>>> for field, value in zip(jane._fields, jane):
...     print(field, "->", value)
...
name -> Jane
age -> 26
height -> 1.75
weight -> 67

在这个例子中，zip()产生形式为 的元组(field, value)。这样，您就可以访问底层命名元组中的字段-值对的两个元素。另一种同时迭代字段和值的方法是使用._asdict().items(). 来试试看吧！

使用._field_defaults，您可以内省namedtuple类和实例以找出哪些字段提供默认值。具有默认值使您的字段可选。例如，假设您的Person类应该包含一个额外的字段来保存此人居住的国家/地区。由于您主要与来自加拿大的人一起工作，因此您可以为该country字段设置适当的默认值，如下所示：

>>> from collections import namedtuple

>>> Person = namedtuple(
...     "Person",
...     "name age height weight country",
...     defaults=["Canada"]
... )

>>> Person._field_defaults
{'country': 'Canada'}

通过对 的快速查询._field_defaults，您可以找出给定的哪些字段namedtuple提供默认值。在此示例中，您团队中的任何其他程序员都可以看到您的Person类"Canada"为country.

如果您namedtuple不提供默认值，则.field_defaults保存一个空字典：

>>> from collections import namedtuple

>>> Person = namedtuple("Person", "name age height weight country")
>>> Person._field_defaults
{}

如果您没有向 提供默认值列表namedtuple()，则它依赖于 的默认值defaults，即None。在这种情况下，._field_defaults持有一个空字典。

使用字段名称而不是索引

假设您正在创建一个绘画应用程序，并且您需要根据用户的选择定义要使用的笔属性。您已经在元组中对笔的属性进行了编码：

>>> pen = (2, "Solid", True)

>>> if pen[0] == 2 and pen[1] == "Solid" and pen[2]:
...     print("Standard pen selected")
...
Standard pen selected

这行代码定义了一个具有三个值的元组。你能说出每个值的含义吗？也许你能猜到第二个值和线型有关，但是2and是什么意思True呢？

您可以添加一个很好的注释来为 提供一些上下文pen，在这种情况下，您最终会得到如下内容：

>>> # Tuple containing: line weight, line style, and beveled edges
>>> pen = (2, "Solid", True)

凉爽的！现在您知道元组中每个值的含义。但是，如果您或其他程序员使用的pen远离此定义怎么办？他们必须回到定义来记住每个值的含义。

这是pen使用 a的另一种实现namedtuple：

>>> from collections import namedtuple

>>> Pen = namedtuple("Pen", "width style beveled")
>>> pen = Pen(2, "Solid", True)

>>> if pen.width == 2 and pen.style == "Solid" and pen.beveled:
...     print("Standard pen selected")
...
Standard pen selected

现在，您的代码清楚地表明2表示笔的宽度、"Solid"线条样式等。任何阅读您代码的人都可以看到并理解这一点。您的新实现pen有两行额外的代码。这是在可读性和可维护性方面取得巨大胜利的少量工作。

从函数返回多个命名值

可以使用命名元组的另一种情况是需要从给定函数返回多个值。在这种情况下，使用命名元组可以使您的代码更具可读性，因为返回的值还将为其内容提供一些上下文。

例如，Python 提供了一个内置函数divmod()，该函数接受两个数字作为参数，并返回一个元组，其中包含输入数字的整数除法的商和余数：

>>> divmod(8, 4)
(2, 0)

要记住每个数字的含义，您可能需要阅读 的文档，divmod()因为数字本身并没有提供有关其各自含义的太多信息。该函数的名称也没有太大帮助。

这是一个函数，它使用 anamedtuple来阐明每个divmod()返回数字的含义：

>>> from collections import namedtuple

>>> def custom_divmod(a, b):
...     DivMod = namedtuple("DivMod", "quotient remainder")
...     return DivMod(*divmod(a, b))
...

>>> custom_divmod(8, 4)
DivMod(quotient=2, remainder=0)

在此示例中，您为每个返回值添加了上下文，因此任何阅读您代码的程序员都可以立即理解每个数字的含义。

使用namedtuplevs 其他数据结构

到目前为止，您已经学习了如何创建命名元组以使您的代码更具可读性、明确性和 Pythonic。您还编写了一些示例，帮助您发现在代码中使用命名元组的机会。

在本节中，您将大致了解namedtuple类与其他 Python 数据结构（例如字典、数据类和类型化命名元组）之间的异同。您将就以下特征将命名元组与其他数据结构进行比较：

• 可读性
• 可变性
• 内存使用情况
• 表现

这样，您将更好地准备为您的特定用例选择正确的数据结构。

子namedtuple类化

由于namedtuple类是常规 Python 类，如果您需要提供附加功能、文档字符串、用户友好的字符串表示等，您可以将它们子类化。

例如，在对象中存储一个人的年龄不被认为是最佳实践。因此，您可能希望存储出生日期并在需要时计算年龄：

>>> from collections import namedtuple
>>> from datetime import date

>>> BasePerson = namedtuple(
...     "BasePerson",
...     "name birthdate country",
...     defaults=["Canada"]
... )

>>> class Person(BasePerson):
...     """A namedtuple subclass to hold a person's data."""
...     __slots__ = ()
...     def __repr__(self):
...         return f"Name: {self.name}, age: {self.age} years old."
...     @property
...     def age(self):
...         return (date.today() - self.birthdate).days // 365
...

>>> Person.__doc__
"A namedtuple subclass to hold a person's data."

>>> jane = Person("Jane", date(1996, 3, 5))
>>> jane.age
25
>>> jane
Name: Jane, age: 25 years old.

Person继承自BasePerson，这是一个namedtuple类。在子类定义中，您首先添加一个文档字符串来描述该类的作用。然后您设置__slots__为一个空元组，这会阻止自动创建 per-instance .__dict__。这使您的BasePerson子类内存保持高效。

您还添加了一个自定义.__repr__()来为类提供一个很好的字符串表示。最后，您添加一个属性来使用 计算此人的年龄datetime。

测量创建时间：tuplevsnamedtuple

到目前为止，您已经namedtuple根据几个特性将类与其他数据结构进行了比较。在本节中，您将大致了解常规元组和命名元组在创建时间方面的比较。

假设您有一个动态创建大量元组的应用程序。您决定使用命名元组使您的代码更加 Pythonic 和可维护。一旦您更新了所有代码库以使用命名元组，您就可以运行应用程序并注意到一些性能问题。经过一些测试，您得出结论，问题可能与动态创建命名元组有关。

这是一个测量动态创建多个元组和命名元组所需的平均时间的脚本：

# tuple_namedtuple_time.py

from collections import namedtuple
from time import perf_counter

def average_time(test_func):
    time_measurements = []
    for _ in range(1_000):
        start = perf_counter()
        test_func()
        end = perf_counter()
        time_measurements.append(end - start)
    return sum(time_measurements) / len(time_measurements) * int(1e9)

def time_tuple():
    tuple([1] * 1000)

fields = [f"a{n}" for n in range(1000)]
TestNamedTuple = namedtuple("TestNamedTuple", fields)

def time_namedtuple():
    TestNamedTuple(*([1] * 1000))

namedtuple_time = average_time(time_namedtuple)
tuple_time = average_time(time_tuple)
gain = namedtuple_time / tuple_time

print(f"tuple:      {tuple_time:.2f} ns ({gain:.2f}x faster)")
print(f"namedtuple: {namedtuple_time:.2f} ns")

在此脚本中，您计算​​创建多个元组及其等效命名元组所需的平均时间。如果您从命令行运行该脚本，您将获得类似于以下内容的输出：

$ python tuple_namedtuple_time.py
tuple:      7075.82 ns (3.36x faster)
namedtuple: 23773.67 ns

当您查看此输出时，您会发现tuple动态创建对象比创建类似命名的元组快得多。在某些情况下，例如使用大型数据库，创建命名元组所需的额外时间会严重影响应用程序的性能，因此如果您的代码动态创建大量元组，请注意这一点。

结论

编写Pythonic代码是 Python 开发领域的一项急需技能。Pythonic 代码可读、明确、干净、可维护，并利用 Python 习语和最佳实践。在本教程中，您学习了创建namedtuple类和实例以及它们如何帮助您提高 Python 代码的质量。

在本教程中，您学习了：

• 如何创建和使用namedtuple类和实例
• 如何利用很酷的namedtuple功能
• 何时使用namedtuple实例编写Pythonic 代码
• 何时使用 namedtuple而不是类似的数据结构
• 如何子类化 namedtuple以添加新功能

有了这些知识，您可以深入提高现有和未来代码的质量。如果您经常使用元组，请考虑在有意义的时候将它们转换为命名元组。这样做将使您的代码更具可读性和 Pythonic。