阅读Python 3.1 中的更改 ，我发现了一些...... 意外的：
sys.version_info 元组现在是一个命名元组 ：
我之前从未听说过命名元组，我认为元素可以用数字（如元组和列表）或键（如 dicts）索引。我从没想过他们可以两种方式编入索引。
因此，我的问题是：
命名元组基本上是易于创建的轻量级对象类型。可以使用类似对象的变量解引用或标准元组语法来引用命名的元组实例。它们可以类似于struct或其他常见记录类型使用，除了它们是不可变的。它们是在 Python 2.6 和 Python 3.0 中添加的，尽管在 Python 2.4 中有一个实现的配方 。
例如，通常将点表示为元组(x, y) 。这导致代码如下：
pt1 = (1.0, 5.0)
pt2 = (2.5, 1.5)
from math import sqrt
line_length = sqrt((pt1[0]-pt2[0])**2 + (pt1[1]-pt2[1])**2)使用命名元组它变得更具可读性：
from collections import namedtuple
Point = namedtuple('Point', 'x y')
pt1 = Point(1.0, 5.0)
pt2 = Point(2.5, 1.5)
from math import sqrt
line_length = sqrt((pt1.x-pt2.x)**2 + (pt1.y-pt2.y)**2)但是，命名元组仍然向后兼容正常元组，因此以下内容仍然有效：
Point = namedtuple('Point', 'x y')
pt1 = Point(1.0, 5.0)
pt2 = Point(2.5, 1.5)
from math import sqrt
# use index referencing
line_length = sqrt((pt1[0]-pt2[0])**2 + (pt1[1]-pt2[1])**2)
# use tuple unpacking
x1, y1 = pt1因此， 您应该使用命名元组而不是元组，只要您认为对象符号会使您的代码更加 pythonic 并且更易于阅读 。我个人已经开始使用它们来表示非常简单的值类型，特别是在将它们作为参数传递给函数时。它使函数更具可读性，而无需查看元组打包的上下文。
此外， 您还可以替换没有函数的普通不可变类 ，只替换具有它们的字段。您甚至可以使用命名元组类型作为基类：
class Point(namedtuple('Point', 'x y')):
[...]但是，与元组一样，命名元组中的属性是不可变的：
>>> Point = namedtuple('Point', 'x y')
>>> pt1 = Point(1.0, 5.0)
>>> pt1.x = 2.0
AttributeError: can't set attribute如果您希望能够更改值，则需要其他类型。 可变记录类型有一个方便的配方，允许您为属性设置新值。
>>> from rcdtype import *
>>> Point = recordtype('Point', 'x y')
>>> pt1 = Point(1.0, 5.0)
>>> pt1 = Point(1.0, 5.0)
>>> pt1.x = 2.0
>>> print(pt1[0])
2.0但是，我不知道任何形式的 “命名列表” 允许您添加新字段。在这种情况下，您可能只想使用字典。命名元组可以使用pt1._asdict()转换为字典，它返回{'x': 1.0, 'y': 5.0}并且可以使用所有常用的字典函数进行操作。
如前所述，您应该查看文档以获取构建这些示例的更多信息。
namedtuple是一个用于创建元组类的工厂函数 。使用该类，我们可以创建可按名称调用的元组。
import collections
#Create a namedtuple class with names "a" "b" "c"
Row = collections.namedtuple("Row", ["a", "b", "c"], verbose=False, rename=False)
row = Row(a=1,b=2,c=3) #Make a namedtuple from the Row class we created
print row #Prints: Row(a=1, b=2, c=3)
print row.a #Prints: 1
print row[0] #Prints: 1
row = Row._make([2, 3, 4]) #Make a namedtuple from a list of values
print row #Prints: Row(a=2, b=3, c=4)什么叫元组？
命名元组是一个元组。
它完成了元组所能做的一切。
但它不仅仅是一个元组。
它是元组的特定子类，以编程方式为您的规范创建，具有命名字段和固定长度。
例如，这创建了一个元组的子类，除了具有固定长度（在这种情况下为三个）之外，它可以在使用元组的任何地方使用而不会破坏。这被称为 Liskov 可替代性：
>>> from collections import namedtuple
>>> class_name = 'ANamedTuple'
>>> fields = 'foo bar baz'
>>> ANamedTuple = namedtuple(class_name, fields)这实例化它：
>>> ant = ANamedTuple(1, 'bar', [])我们可以检查它并使用它的属性：
>>> ant
ANamedTuple(foo=1, bar='bar', baz=[])
>>> ant.foo
1
>>> ant.bar
'bar'
>>> ant.baz.append('anything')
>>> ant.baz
['anything']要了解命名元组，首先需要知道元组是什么。元组本质上是一个不可变的（不能在内存中就地更改）列表。
以下是使用常规元组的方法：
>>> student_tuple = 'Lisa', 'Simpson', 'A'
>>> student_tuple
('Lisa', 'Simpson', 'A')
>>> student_tuple[0]
'Lisa'
>>> student_tuple[1]
'Simpson'
>>> student_tuple[2]
'A'您可以使用 iterable unpacking 扩展元组：
>>> first, last, grade = student_tuple
>>> first
'Lisa'
>>> last
'Simpson'
>>> grade
'A'命名元组是元组，允许通过名称而不是索引来访问它们的元素！
你创建一个像这样的命名元组：
>>> from collections import namedtuple
>>> Student = namedtuple('Student', ['first', 'last', 'grade'])您还可以使用单个字符串，其名称用空格分隔，API 的使用稍微更具可读性：
>>> Student = namedtuple('Student', 'first last grade')怎么用？
您可以执行元组可以执行的所有操作（请参见上文）以及执行以下操作：
>>> named_student_tuple = Student('Lisa', 'Simpson', 'A')
>>> named_student_tuple.first
'Lisa'
>>> named_student_tuple.last
'Simpson'
>>> named_student_tuple.grade
'A'
>>> named_student_tuple._asdict()
OrderedDict([('first', 'Lisa'), ('last', 'Simpson'), ('grade', 'A')])
>>> vars(named_student_tuple)
OrderedDict([('first', 'Lisa'), ('last', 'Simpson'), ('grade', 'A')])
>>> new_named_student_tuple = named_student_tuple._replace(first='Bart', grade='C')
>>> new_named_student_tuple
Student(first='Bart', last='Simpson', grade='C')一位评论者问：
在大型脚本或程序中，通常在哪里定义一个命名元组？
使用namedtuple创建的类型基本上是您可以使用简单的速记创建的类。像对待课一样对待他们在模块级别定义它们，以便 pickle 和其他用户可以找到它们。
全局模块级别的工作示例：
>>> from collections import namedtuple
>>> NT = namedtuple('NT', 'foo bar')
>>> nt = NT('foo', 'bar')
>>> import pickle
>>> pickle.loads(pickle.dumps(nt))
NT(foo='foo', bar='bar')这表明无法查找定义：
>>> def foo():
... LocalNT = namedtuple('LocalNT', 'foo bar')
... return LocalNT('foo', 'bar')
...
>>> pickle.loads(pickle.dumps(foo()))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
_pickle.PicklingError: Can't pickle <class '__main__.LocalNT'>: attribute lookup LocalNT on __main__ failed为什么 / 何时应该使用命名元组而不是普通元组？
在改进代码时使用它们，以便在代码中表达元组元素的语义。如果您使用具有不变数据属性且没有功能的对象，则可以使用它们而不是对象。您还可以将它们子类化以添加功能，例如 ：
class Point(namedtuple('Point', 'x y')):
"""adding functionality to a named tuple"""
__slots__ = ()
@property
def hypot(self):
return (self.x ** 2 + self.y ** 2) ** 0.5
def __str__(self):
return 'Point: x=%6.3f y=%6.3f hypot=%6.3f' % (self.x, self.y, self.hypot)为什么 / 何时应该使用普通元组而不是命名元组？
从使用命名元组切换到元组可能是一种回归。前期设计决策的核心是，在使用元组时，所涉及的额外代码的成本是否值得提高可读性。
命名元组与元组没有使用额外的内存。
是否有任何类型的 “命名列表”（命名元组的可变版本）？
您正在寻找实现静态大小列表的所有功能的时隙对象或者像命名元组一样工作的子类列表（并且以某种方式阻止列表更改大小。）
一个现在扩展的，甚至可能是 Liskov 可替代的第一个例子：
from collections import Sequence
class MutableTuple(Sequence):
"""Abstract Base Class for objects that work like mutable
namedtuples. Subclass and define your named fields with
__slots__ and away you go.
"""
__slots__ = ()
def __init__(self, *args):
for slot, arg in zip(self.__slots__, args):
setattr(self, slot, arg)
def __repr__(self):
return type(self).__name__ + repr(tuple(self))
# more direct __iter__ than Sequence's
def __iter__(self):
for name in self.__slots__:
yield getattr(self, name)
# Sequence requires __getitem__ & __len__:
def __getitem__(self, index):
return getattr(self, self.__slots__[index])
def __len__(self):
return len(self.__slots__)要使用，只需子类并定义__slots__ ：
class Student(MutableTuple):
__slots__ = 'first', 'last', 'grade' # customize
>>> student = Student('Lisa', 'Simpson', 'A')
>>> student
Student('Lisa', 'Simpson', 'A')
>>> first, last, grade = student
>>> first
'Lisa'
>>> last
'Simpson'
>>> grade
'A'
>>> student[0]
'Lisa'
>>> student[2]
'A'
>>> len(student)
3
>>> 'Lisa' in student
True
>>> 'Bart' in student
False
>>> student.first = 'Bart'
>>> for i in student: print(i)
...
Bart
Simpson
A