In che modo le tuple nominate sono implementate internamente in python?

Question

Le tuple con nome sono facili da creare, tipi di oggetti leggeri. Le istanze namedtuple possono essere referenziate utilizzando il deferencing variabile ad oggetti o la sintassi standard della tupla. Se è possibile accedere a queste strutture dati mediante gli indici di differimento degli oggetti &, come vengono implementate internamente? È tramite tabelle hash?

Answer 1

In realtà, è molto facile per scoprire come un dato namedtuple è implementato: se si passa la parola argomento verbose=True durante la creazione, la sua definizione di classe viene stampato:

>>> Point = namedtuple('Point', "x y", verbose=True) 
from builtins import property as _property, tuple as _tuple 
from operator import itemgetter as _itemgetter 
from collections import OrderedDict 

class Point(tuple): 
    'Point(x, y)' 

    __slots__ =() 

    _fields = ('x', 'y') 

    def __new__(_cls, x, y): 
     'Create new instance of Point(x, y)' 
     return _tuple.__new__(_cls, (x, y)) 

    @classmethod 
    def _make(cls, iterable, new=tuple.__new__, len=len): 
     'Make a new Point object from a sequence or iterable' 
     result = new(cls, iterable) 
     if len(result) != 2: 
      raise TypeError('Expected 2 arguments, got %d' % len(result)) 
     return result 

    def _replace(_self, **kwds): 
     'Return a new Point object replacing specified fields with new values' 
     result = _self._make(map(kwds.pop, ('x', 'y'), _self)) 
     if kwds: 
      raise ValueError('Got unexpected field names: %r' % list(kwds)) 
     return result 

    def __repr__(self): 
     'Return a nicely formatted representation string' 
     return self.__class__.__name__ + '(x=%r, y=%r)' % self 

    @property 
    def __dict__(self): 
     'A new OrderedDict mapping field names to their values' 
     return OrderedDict(zip(self._fields, self)) 

    def _asdict(self): 
     '''Return a new OrderedDict which maps field names to their values. 
      This method is obsolete. Use vars(nt) or nt.__dict__ instead. 
     ''' 
     return self.__dict__ 

    def __getnewargs__(self): 
     'Return self as a plain tuple. Used by copy and pickle.' 
     return tuple(self) 

    def __getstate__(self): 
     'Exclude the OrderedDict from pickling' 
     return None 

    x = _property(_itemgetter(0), doc='Alias for field number 0') 

    y = _property(_itemgetter(1), doc='Alias for field number 1') 

Quindi, è una sottoclasse di tuple con alcuni metodi aggiuntivi per dargli il comportamento richiesto, una costante di livello di classe _fields contenente i nomi dei campi e i metodi property per l'accesso agli attributi ai membri della tupla.

Per quanto riguarda il codice alla base della creazione di questa definizione di classe, è deep magic.