Python: Faire de la classe objet iterable

J'ai hérité d'un projet avec de nombreuses grandes classes de constituants de rien, mais les objets de la classe (entiers, chaînes de caractères, etc). Je voudrais être en mesure de vérifier si un attribut est présent, sans le besoin de définir une liste d'attributs manuellement.

Est-il possible de faire un python classe itérable lui-même en utilisant la syntaxe standard? C'est, je voudrais être en mesure de parcourir toutes d'une classe d'attributs à l'aide for attr in Foo: (ou même if attr in Foo) sans avoir besoin de créer une instance de la classe de première. Je pense que je peux le faire en définissant __iter__, mais jusqu'à présent, je n'ai pas vraiment réussi ce que je suis à la recherche d'.

J'ai réalisé certains de ce que je veux en ajoutant un __iter__ méthode comme suit:

class Foo:
    bar = "bar"
    baz = 1
    @staticmethod
    def __iter__():
        return iter([attr for attr in dir(Foo) if attr[:2] != "__"])

Cependant, ce n'est pas tout à fait accomplir ce que je suis à la recherche de:

>>> for x in Foo:
...     print(x)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'classobj' object is not iterable

Même si, cela fonctionne:

>>> for x in Foo.__iter__():
...     print(x)
bar
baz

OriginalL'auteur multipleinterfaces | 2011-03-25

54

Ajouter le __iter__ à la métaclasse au lieu de la classe elle-même (en supposant que Python 2.x):
```
class Foo(object):
    bar = "bar"
    baz = 1
    class __metaclass__(type):
        def __iter__(self):
            for attr in dir(self):
                if not attr.startswith("__"):
                    yield attr
```
Pour Python 3.x, utilisez
```
class MetaFoo(type):
    def __iter__(self):
        for attr in dir(self):
            if not attr.startswith("__"):
                yield attr

class Foo(metaclass=MetaFoo):
    bar = "bar"
    baz = 1
```
Nice. S'il vous plaît pourriez-vous expliquer pourquoi les OP approche ne fonctionne pas? Merci.
La raison OP approche ne fonctionne pas, c'est que le __iter__ méthode ne fonctionne que pour les cas de la classe. Cela heurte la __iter__ méthode pour les instances de la métaclasse, c'est à dire la classe.
Cela a un sens, merci pour l'explication.
Comme d'autres méthodes magiques, __iter__ est recherché dans l'espace de nom du type de l'objet plutôt que dans l'objet le nom de l'espace lui-même. Je n'ai pas vraiment trouver ce expliqué dans le Python docs, mais il peut être facilement vu dans le code source (recherche de la définition de PyObject_GetIter()).
href="https://docs.python.org/2.7/reference/datamodel.html#new-style-special-lookup" >méthodes Spéciales sont penchés sur le type de l'instance, et non pas sur l'instance elle-même. Si l'instance est une classe, cela signifie que la méthode particulière est-elle leva les yeux sur la métaclasse, pas la classe elle-même.

OriginalL'auteur Sven Marnach
8

Vous pouvez parcourir la classe est visible attributs avec for attr in (elem for elem in dir(Foo) if elem[:2] != '__').

Moins horrible façon de sort qui est:
```
def class_iter(Class):
    return (elem for elem in dir(Class) if elem[:2] != '__')
```
puis
```
for attr in class_iter(Foo):
    pass
```
Je dois avouer que je préfère cette solution qui semble plus pythonic que celui de l'OP. Mais a c'est pas de résoudre son problème, je n'ai pas de +1

OriginalL'auteur nmichaels
7

c'est comment nous faisons un objet de classe itératif. fournir de la classe avec un iter et une méthode next (), vous pouvez effectuer une itération sur les attributs de classe ou de leurs valeurs.vous pouvez laisser la méthode next() si vous le souhaitez, ou vous pouvez définir next() et soulever StopIteration sur une condition.

e.g:
```
class Book(object):
      def __init__(self,title,author):
          self.title = title
          self.author = author

      def __iter__(self):
          for each in self.__dict__.keys():
              yield self.__getattribute__(each)

>>> book  = Book('The Mill on the Floss','George Eliot')
>>> for each in book: each
...
'George Eliot'
'The Mill on the Floss'
```
cette classe effectue une itération sur la valeur de l'attribut de la classe Livre.
Un objet de classe peut être faite itérable en lui fournissant un getitem méthode de trop.
e.g:
```
class BenTen(object):
    def __init__(self, bentenlist):
        self.bentenlist = bentenlist

    def __getitem__(self,index):
        if index <5:
            return self.bentenlist[index]
        else:
            raise IndexError('this is high enough')

>>> bt_obj = BenTen([x for x in range(15)])
>>>for each in bt_obj:each
...
0
1
2
3
4
```
maintenant, lorsque l'objet de BenTen de classe est utilisé dans un dans la boucle, getitem est appelée successivement plus élevés de l'indice de valeur, jusqu'à ce qu'il soulève IndexError.

Cette itère sur les attributs d'un exemple d'une classe (c'est à dire la book dans book = Book(...)); la question est à propos de l'itération sur le de la classe attributs directement (c'est à dire la Book dans class Book(object):).
Bien que ce n'est pas la réponse à l'OP de la question, il m'a aidé parce que j'étais à la recherche de ce lors de la recherche pour objet iterable classe.

OriginalL'auteur vijay shanker

De Python 3.4+, rendre une classe itérable est un peu plus facile en utilisant enum.Enum.

from enum import Enum

class Foo(Enum):
    bar = "qux"
    baz = 123

>>> print(*Foo)
Foo.bar Foo.baz

names = [m.name for m in Foo]
>>> print(*names)
bar baz

values = [m.value for m in Foo]
print(*values)
>>> qux 123

OriginalL'auteur A-B-B

class MetaItetaror(type):
    def __iter__(cls):
        return iter(
            filter(
                lambda k: not k[0].startswith('__'),
                cls.__dict__.iteritems()
            )
        )


class Klass:
    __metaclass__ = MetaItetaror

    iterable_attr_names = {'x', 'y', 'z'}
    x = 5
    y = 6
    z = 7


for v in Klass:
    print v

OriginalL'auteur sanit

Vous devez vous connecter pour publier un commentaire.