Comment obtenir tous les objets dans un module en python?

J'ai besoin d'obtenir une liste de tous les objets à l'intérieur d'un module, et non pas une liste de leurs noms. Ainsi, par exemple, j'ai:

class myClass:  
    def __init__(self):  
        # here be code
        pass

class thing1(myClass):  
    def __init__(self):  
        self.x = 1

class thing2(myClass):  
    def __init__(self):
        self.x = 2

et ainsi de suite.

Ce que je veux, c'est quelque chose qui va me donner une liste des objets dans myClass (thing1thing2) à partir de laquelle je peux appeler des méthodes /obtenir les attributs. Je suis en train de faire quelque chose comme ceci:

for myThing in dir(myClass):  
    print myThing.x

Mais la dir fonction ne donne qu'une liste des noms des classes, et je ne peux pas obtenir l'attribut.

Comment puis-je faire cela?

source d'informationauteur NSP

  1. 17

    Si vous avez le nom d'un attribut dans une chaîne, vous devez utiliser getattr pour aller la chercher.

    Donné un module de X, vous pouvez obtenir une liste de tous les attributs et (par exemple) leurs types avec quelque chose comme ça.

    for i in dir(X):
   print i,"  ",type(getattr(X,i))
  2. 6

    Si vous voulez vraiment le membres d'une classe, d'une instance ou d'un module, il suffit d'utiliser la vars() builtin: http://docs.python.org/library/functions.html#vars (il fonctionne comme annoncé)

    Si vous voulez que les membres de la actuel module à partir de l'intérieur d'une fonction ou d'une classe (où vars() va faire la mauvaise chose), alors vous devriez utiliser globals() à la place.

    Toutefois, le code et les mots dans votre question ne correspondent pas. Vous dire vous souhaitez accéder aux objets "à l'intérieur" myClassmais alors vous poste le code qui est apparemment à la recherche pour les sous-classes de myClass plutôt que de son contenu.

    Pour compléter Astérisque réponses avec quelques exemples de plus de jouer avec cela à l'invite de commandes:

    >>> class Example:
...   def method(): pass
...
>>> class SubExample(Example):
...   pass
...
>>> class OverrideExample(Example):
...   def method():
...     pass
...
>>> globals()
{'OverrideExample': <class '__main__.OverrideExample'>, '__builtins__': <module
'builtins' (built-in)>, 'Example': <class '__main__.Example'>, '__name__': '__ma
in__', '__package__': None, '__doc__': None, 'SubExample': <class '__main__.SubE
xample'>}
>>> Example.__subclasses__()
[<class '__main__.SubExample'>, <class '__main__.OverrideExample'>]
>>> vars(Example)
dict_proxy({'__dict__': <attribute '__dict__' of 'Example' objects>, '__module__
': '__main__', '__weakref__': <attribute '__weakref__' of 'Example' objects>, 'm
ethod': <function method at 0x00BF6F18>, '__doc__': None})
>>> vars(SubExample)
dict_proxy({'__module__': '__main__', '__doc__': None})
>>> vars(OverrideExample)
dict_proxy({'__module__': '__main__', 'method': <function method at 0x00C10030>,
 '__doc__': None})
>>> vars(Example())
{}
>>> vars(SubExample())
{}
>>> vars(OverrideExample())
{}

    Noter les différences entre ce qui est visible au niveau du module, sur chaque objet de classe et sur chaque instance de classe.

    Notez également que, pour une définition de classe, vars() ne vous parler de toute les méthodes héritées. Elle aussi ne vais pas vous parler des méthodes qui sont disponibles par l'intermédiaire d'une instance de classe. Afin de voir correctement les deux de ceux-ci, votre meilleur pari est de faire comme Noufal suggère et à pied dir()appelant getattr() pour chaque attribut.

  3. 1

    Je crois locals() vous donne un dictionnaire de toutes les variables locales et les objets qu'ils désignent.

    Vous pouvez également essayer d'utiliser le eval() ou exec() fonctions pour évaluer les noms de la crue du code python. Ensuite, vous pouvez utiliser directement les résultats de dir().

  4. 0

    Ne sais pas si cela aide:

    class myClass(object):

    def init(self):
        pass


class thing1(myClass):
    def init(self):
        self.x = 1

class thing2(myClass):
    def init(self):
        self.x = 2

myClass.__subclasses__()
[<class '__main__.thing1'>, <class '__main__.thing2'>]
  5. 0
    class myClass(object):

    def init(self):
        pass


class thing1(myClass):
    def __init__(self):
        self.x = 1

class thing2(myClass):
    def __init__(self):
        self.x = 2

print myClass.__subclasses__()
print vars(thing1())
print vars(thing2())
    [<class '__main__.thing1'>, <class '__main__.thing2'>]
{'x': 1}
{'x': 2}