为什么命名元组使用的内存比字典少？

我问这个是因为我觉得这很令人惊讶——我想namedtuple会有更多的开销。

（背景是我在内存中缓存了一个大型 Django 查询，发现 Django 对象的大小是.values()。然后我想知道什么开销namedtuple对象的版本将是，允许我仍然使用.访问作为属性的项目。更小不是我所期望的。）

#!/usr/bin/env python                                                           

from pympler.asizeof import asizeof                                             
from collections import namedtuple                                              

import random                                                                   
import string                                                                   

QTY = 100000                                                                    


class Foz(object):                                                              
    pass                                                                        

dicts = [{'foo': random.randint(0, 10000),                                      
          'bar': ''.join([random.choice(string.ascii_letters + string.digits) for n in xrange(32)]),
          'baz': random.randrange(10000),                                       
          'faz': random.choice([True, False]),                                  
          'foz': Foz()} for _ in range(QTY)]                                    

print "%d dicts: %d" % (len(dicts), asizeof(dicts))                             

# https://stackoverflow.com/questions/43921240/pythonic-way-to-convert-dictionary-to-namedtuple-or-another-hashable-dict-like

MyTuple = namedtuple('MyTuple', sorted(dicts[0]))                               

tuples = [MyTuple(**d) for d in dicts]                                          

print "%d namedtuples: %d" % (len(tuples), asizeof(tuples))                     

print "Ratio: %.01f" % (float(asizeof(tuples)) / float(asizeof(dicts))) 

Running,

$ ./foo.py    
100000 dicts: 75107672
100000 namedtuples: 56707472
Ratio: 0.8

单个元组甚至更少，可能是由于list:

$ ./foo.py    
1 dicts: 1072
1 namedtuples: 688
Ratio: 0.6

是哈希表数组的开销吗？但不会是namedtuple还需要属性的哈希表吗？是pympler不准确吗？

基本答案很简单：“是”：普通对象有一个内部字典来存储实例的属性：

class Foo:
    pass

f = Foo()
print(f.__dict__)
# {}

它必须是一个字典，因为在 Python 中，您可以在类未定义的实例上分配新属性：

f.a = 1
print(f.__dict__)
# {'a': 1}

使用字典可以快速进行属性查找，但由于数据结构本身存在内存开销。另外，由于不同的实例Foo可能定义了不同的属性，每个实例可能需要自己的字典：

g = Foo()
print(g.__dict__)
# {}
print(f.__dict_ == g.__dict__)
# False

A namedtuple不允许在运行时添加属性。一个具体实例namedtuple因此，可以将其所有属性存储在由所有实例共享的单个实例中。

Given a namedtuple和一个实例：

Foo = collections.namedtuple("Foo", 'a,b')
f = Foo(1,2)

The namedtuple-构造函数产生 https://github.com/python/cpython/blob/12083284c54be25abadd85781d36b63731dc1f0c/Lib/collections/__init__.py#L458 a 描述符 https://stackoverflow.com/a/3798882/2722968对于每个字段并将其存储在类中；这里是存储命名属性和元组索引之间的转换的位置。当您访问属性时a实例f，属性访问通过此描述符进行路由：

type(Foo.a)
#<class 'property'>