Pourquoi ma classe n'a-t-elle pas de fonction 'touches'?

Question

class a(object): 
    w='www' 
    def __init__(self): 
     for i in self.keys(): 
      print i 
    def __iter__(self): 
      for k in self.keys(): 
       yield k 

a() # why is there an error here? 

Merci.

---

Édition: La classe suivante n'élargit aucune classe; Pourquoi peut-il utiliser keys?

class DictMixin: 
    # Mixin defining all dictionary methods for classes that already have 
    # a minimum dictionary interface including getitem, setitem, delitem, 
    # and keys. Without knowledge of the subclass constructor, the mixin 
    # does not define __init__() or copy(). In addition to the four base 
    # methods, progressively more efficiency comes with defining 
    # __contains__(), __iter__(), and iteritems(). 

    # second level definitions support higher levels 
    def __iter__(self): 
     for k in self.keys(): 
      yield k 
    def has_key(self, key): 
     try: 
      value = self[key] 
     except KeyError: 
      return False 
     return True 
    def __contains__(self, key): 
     return self.has_key(key) 

    # third level takes advantage of second level definitions 
    def iteritems(self): 
     for k in self: 
      yield (k, self[k]) 
    def iterkeys(self): 
     return self.__iter__() 

    # fourth level uses definitions from lower levels 
    def itervalues(self): 
     for _, v in self.iteritems(): 
      yield v 
    def values(self): 
     return [v for _, v in self.iteritems()] 
    def items(self): 
     return list(self.iteritems()) 
    def clear(self): 
     for key in self.keys(): 
      del self[key] 
    def setdefault(self, key, default=None): 
     try: 
      return self[key] 
     except KeyError: 
      self[key] = default 
     return default 
    def pop(self, key, *args): 
     if len(args) > 1: 
      raise TypeError, "pop expected at most 2 arguments, got "\ 
           + repr(1 + len(args)) 
     try: 
      value = self[key] 
     except KeyError: 
      if args: 
       return args[0] 
      raise 
     del self[key] 
     return value 
    def popitem(self): 
     try: 
      k, v = self.iteritems().next() 
     except StopIteration: 
      raise KeyError, 'container is empty' 
     del self[k] 
     return (k, v) 
    def update(self, other=None, **kwargs): 
     # Make progressively weaker assumptions about "other" 
     if other is None: 
      pass 
     elif hasattr(other, 'iteritems'): # iteritems saves memory and lookups 
      for k, v in other.iteritems(): 
       self[k] = v 
     elif hasattr(other, 'keys'): 
      for k in other.keys(): 
       self[k] = other[k] 
     else: 
      for k, v in other: 
       self[k] = v 
     if kwargs: 
      self.update(kwargs) 
    def get(self, key, default=None): 
     try: 
      return self[key] 
     except KeyError: 
      return default 
    def __repr__(self): 
     return repr(dict(self.iteritems())) 
    def __cmp__(self, other): 
     if other is None: 
      return 1 
     if isinstance(other, DictMixin): 
      other = dict(other.iteritems()) 
     return cmp(dict(self.iteritems()), other) 
    def __len__(self): 
     return len(self.keys()) 

Answer 1

Pourquoi voudriez-vous qu'il ait keys? Vous n'avez pas défini une telle méthode dans votre classe. Aviez-vous l'intention d'hériter d'un dictionnaire?

Pour faire cette classe annoncez a(dict)

Ou peut-être que vous vouliez dire a.__dict__.keys()?

En ce qui concerne le grand extrait que vous avez posté dans la mise à jour, lire le commentaire ci-dessus de la classe à nouveau:

# Mixin defining all dictionary methods for classes that already have 
# a minimum dictionary interface including getitem, setitem, delitem, 
# and keys 

Notez que partie « ont déjà ... touches ».

La classe DictMixin vient du module UserDict, qui dit:

classe UserDict.DictMixin mixin définir toutes les méthodes dictionnaire pour classes qui ont déjà une interface minimale dictionnaire comprenant getitem() , setitem(), delitem(), et les clés(). Ce mélange doit être utilisé comme . L'ajout de chacune des méthodes ci-dessus ajoute de plus en plus de fonctionnalités . Par exemple, la définition de sauf delitem() exclura uniquement pop() et popitem() de l'interface complète .

En plus des quatre méthodes de base, efficacité vient progressivement plus avec la définition contient(), iter() et iteritems().

Depuis le mixin n'a pas connaissance de le constructeur de sous-classe, il n'a pas définir initialisation() ou une copie().

partir de la version Python 2.6, il est recommandé d'utiliser collections.MutableMapping au lieu de DictMixin.

Notez la recommandation dans la dernière partie - utilisez plutôt collections.MutableMapping.

pour itérer sur les attributs d'un objet:

class A(object): 
    def __init__(self): 
     self.myinstatt1 = 'one' 
     self.myinstatt2 = 'two' 
    def mymethod(self): 
     pass 

a = A() 
for attr, value in a.__dict__.iteritems(): 
    print attr, value