Je veux obtenir les attributs d'une classe, disons:

class MyClass():
  a = "12"
  b = "34"

  def myfunc(self):
    return self.a

using MyClass.__dict__me donne une liste d'attributs et de fonctions, et même des fonctions comme __module__et __doc__. While MyClass().__dict__me donne un dict vide à moins que je ne définisse explicitement une valeur d'attribut de cette instance.

Je veux juste les attributs, dans l'exemple ci-dessus, ceux-ci seraient: aetb

Essayez le module d' inspection . getmemberset les divers tests devraient être utiles.

ÉDITER:

Par exemple,

class MyClass(object):
    a = '12'
    b = '34'
    def myfunc(self):
        return self.a

>>> import inspect
>>> inspect.getmembers(MyClass, lambda a:not(inspect.isroutine(a)))
[('__class__', type),
 ('__dict__',
  <dictproxy {'__dict__': <attribute '__dict__' of 'MyClass' objects>,
   '__doc__': None,
   '__module__': '__main__',
   '__weakref__': <attribute '__weakref__' of 'MyClass' objects>,
   'a': '34',
   'b': '12',
   'myfunc': <function __main__.myfunc>}>),
 ('__doc__', None),
 ('__module__', '__main__'),
 ('__weakref__', <attribute '__weakref__' of 'MyClass' objects>),
 ('a', '34'),
 ('b', '12')]

Maintenant, les méthodes et attributs spéciaux m'énervent - ils peuvent être traités de plusieurs façons, la plus simple étant simplement de filtrer en fonction du nom.

>>> attributes = inspect.getmembers(MyClass, lambda a:not(inspect.isroutine(a)))
>>> [a for a in attributes if not(a[0].startswith('__') and a[0].endswith('__'))]
[('a', '34'), ('b', '12')]

... et dont le plus compliqué peut inclure des vérifications de noms d'attributs spéciaux ou même des métaclasses;)

def props(cls):   
  return [i for i in cls.__dict__.keys() if i[:1] != '_']

properties = props(MyClass)

myfunc est un attribut de MyClass. C'est comme ça que ça se trouve lorsque vous exécutez:

myinstance = MyClass()
myinstance.myfunc()

Il recherche un attribut sur myinstancenamed myfunc, n'en trouve pas, voit qu'il myinstances'agit d'une instance de MyClasset le recherche là-haut.

La liste complète des attributs pour MyClassest donc:

>>> dir(MyClass)
['__doc__', '__module__', 'a', 'b', 'myfunc']

(Notez que j'utilise dir simplement comme un moyen rapide et facile de lister les membres de la classe: il ne doit être utilisé que de manière exploratoire, pas dans le code de production)

Si vous ne souhaitez attributs particuliers, vous aurez besoin de filtrer cette liste en utilisant certains critères, parce que __doc__, __module__et myfuncne sont pas particulièrement en aucune façon, ils sont les attributs exactement de la même manière aet bsont.

Je n'ai jamais utilisé le module d'inspection mentionné par Matt et Borealid, mais à partir d'un bref lien, il semble qu'il y ait des tests pour vous aider à le faire, mais vous devrez écrire votre propre fonction de prédicat, car cela semble ce que vous voulez est à peu près les attributs qui ne passent pas le isroutinetest et qui ne commencent et ne se terminent pas par deux traits de soulignement.

Remarquez également: en utilisant class MyClass():Python 2.7, vous utilisez les classes à l'ancienne très obsolètes. À moins que vous ne le fassiez délibérément pour la compatibilité avec des bibliothèques extrêmement anciennes, vous devriez plutôt définir votre classe comme class MyClass(object):. Dans Python 3, il n'y a pas de classes «à l'ancienne», et ce comportement est le comportement par défaut. Cependant, l'utilisation de classes newstyle vous donnera beaucoup plus d'attributs définis automatiquement:

>>> class MyClass(object):
        a = "12"
        b = "34"
        def myfunc(self):
            return self.a
>>> dir(MyClass)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'a', 'b', 'myfunc']

Obtenir uniquement les attributs de l' instance est facile.
Mais obtenir également les attributs de classe sans les fonctions est un peu plus délicat.

Attributs d'instance uniquement

Si vous n'avez qu'à lister les attributs d'instance, utilisez simplement
for attribute, value in my_instance. __dict__.items()

>>> from __future__ import (absolute_import, division, print_function)
>>> class MyClass(object):
...   def __init__(self):
...     self.a = 2
...     self.b = 3
...   def print_instance_attributes(self):
...     for attribute, value in self.__dict__.items():
...       print(attribute, '=', value)
...
>>> my_instance = MyClass()
>>> my_instance.print_instance_attributes()
a = 2
b = 3
>>> for attribute, value in my_instance.__dict__.items():
...   print(attribute, '=', value)
...
a = 2
b = 3

Attributs d'instance et de classe

Pour obtenir également les attributs de classe sans les fonctions, l'astuce est d'utiliser callable().

Mais les méthodes statiques ne le sont pas toujourscallable !

Par conséquent, au lieu d'utiliser, callable(value)utilisez
callable( getattr(MyClass, attribute))

Exemple

from __future__ import (absolute_import, division, print_function)

class MyClass(object):
   a = "12"
   b = "34"               # class attributes

   def __init__(self, c, d):
     self.c = c
     self.d = d           # instance attributes

   @staticmethod
   def mystatic():        # static method
       return MyClass.b

   def myfunc(self):      # non-static method
     return self.a

   def print_instance_attributes(self):
     print('[instance attributes]')
     for attribute, value in self.__dict__.items():
        print(attribute, '=', value)

   def print_class_attributes(self):
     print('[class attributes]')
     for attribute in self.__dict__.keys():
       if attribute[:2] != '__':
         value = getattr(self, attribute)
         if not callable(value):
           print(attribute, '=', value)

v = MyClass(4,2)
v.print_class_attributes()
v.print_instance_attributes()

Remarque: print_class_attributes() devrait être       mais pas dans cet exemple stupide et simple .@staticmethod

Résultat pour python2

$ python2 ./print_attributes.py
[class attributes]
a = 12
b = 34
[instance attributes]
c = 4
d = 2

Même résultat pour python3

$ python3 ./print_attributes.py
[class attributes]
b = 34
a = 12
[instance attributes]
c = 4
d = 2

MyClass().__class__.__dict__

Cependant, le "droit" était de le faire via le module d'inspection .

import re

class MyClass:
    a = "12"
    b = "34"

    def myfunc(self):
        return self.a

attributes = [a for a, v in MyClass.__dict__.items()
              if not re.match('<function.*?>', str(v))
              and not (a.startswith('__') and a.endswith('__'))]

Pour une instance de MyClass, telle que

mc = MyClass()

utiliser type(mc)à la place de MyClassdans la compréhension de la liste. Cependant, si l'on ajoute dynamiquement un attribut à mc, tel que mc.c = "42", l'attribut n'apparaîtra pas lors de l'utilisation type(mc)dans cette stratégie. Il ne donne que les attributs de la classe d'origine.

Pour obtenir le dictionnaire complet d'une instance de classe, vous devez COMBINER les dictionnaires de type(mc).__dict__et mc.__dict__.

mc = MyClass()
mc.c = "42"

# Python 3.5
combined_dict = {**type(mc).__dict__, **mc.__dict__}

# Or Python < 3.5
def dict_union(d1, d2):
    z = d1.copy()
    z.update(d2)
    return z

combined_dict = dict_union(type(mc).__dict__, mc.__dict__)

attributes = [a for a, v in combined_dict.items()
              if not re.match('<function.*?>', str(v))
              and not (a.startswith('__') and a.endswith('__'))]

Je ne sais pas si quelque chose de similaire a déjà été fait ou non, mais j'ai créé une fonction de recherche d'attribut intéressante en utilisant vars (). vars () crée un dictionnaire des attributs d'une classe que vous lui passez.

class Player():
    def __init__(self):
        self.name = 'Bob'
        self.age = 36
        self.gender = 'Male'

s = vars(Player())
#From this point if you want to print all the attributes, just do print(s)

#If the class has a lot of attributes and you want to be able to pick 1 to see
#run this function
def play():
    ask = input("What Attribute?>: ")
    for key, value in s.items():
        if key == ask:
            print("self.{} = {}".format(key, value))
            break
    else:
        print("Couldn't find an attribute for self.{}".format(ask))

Je développe une aventure textuelle assez massive en Python, ma classe Player a jusqu'à présent plus de 100 attributs. J'utilise ceci pour rechercher des attributs spécifiques que j'ai besoin de voir.

Cela peut être fait sans inspecter, je suppose.

Suivez le cours suivant:

 class Test:
   a = 1
   b = 2

   def __init__(self):
     self.c = 42

   @staticmethod
   def toto():
     return "toto"

   def test(self):
     return "test"

En regardant les membres avec leurs types:

t = Test()
l = [ (x, eval('type(x.%s).__name__' % x)) for x in dir(a) ]

... donne:

[('__doc__', 'NoneType'),
 ('__init__', 'instancemethod'),
 ('__module__', 'str'),
 ('a', 'int'),
 ('b', 'int'),
 ('c', 'int'),
 ('test', 'instancemethod'),
 ('toto', 'function')]

Donc, pour ne sortir que les variables, il vous suffit de filtrer les résultats par type et les noms ne commençant pas par «__». Par exemple

filter(lambda x: x[1] not in ['instancemethod', 'function'] and not x[0].startswith('__'), l)

[('a', 'int'), ('b', 'int'), ('c', 'int')] # actual result

C'est tout.

Remarque: si vous utilisez Python 3, convertissez les itérateurs en listes.

Si vous voulez une manière plus robuste de le faire, utilisez inspect .

Python 2 & 3, sans importations, filtrage des objets par leur adresse

Solutions en bref:

Renvoie dict {nom_attribut: valeur_attribut} , objets filtrés. c'est à dire{'a': 1, 'b': (2, 2), 'c': [3, 3]}

{k: val for k, val in self.__dict__.items() if not str(hex(id(val))) in str(val)}

Liste de retour [nom_attribut] , objets filtrés. c'est à dire['a', 'b', 'c', 'd']

[k for k, val in self.__dict__.items() if not str(hex(id(val))) in str(val)]

Liste de retour [valeur_attribut] , objets filtrés. c'est à dire[1, (2, 2), [3, 3], {4: 4}]

[val for k, val in self.__dict__.items() if not str(hex(id(val))) in str(val)]

Ne pas filtrer les objets

Suppression de la ifcondition. Revenir{'a': 1, 'c': [3, 3], 'b': (2, 2), 'e': <function <lambda> at 0x7fc8a870fd70>, 'd': {4: 4}, 'f': <object object at 0x7fc8abe130e0>}

{k: val for k, val in self.__dict__.items()}

Solution en long

Tant que l'implémentation par défaut de __repr__n'est pas remplacée, l' ifinstruction retournera Truesi la représentation hexadécimale de l'emplacement en mémoire de valest dans la __repr__chaîne de retour.

Concernant l'implémentation par défaut de, __repr__vous pourriez trouver utile cette réponse . En bref:

def __repr__(self):
    return '<{0}.{1} object at {2}>'.format(
      self.__module__, type(self).__name__, hex(id(self)))

Qui renvoie une chaîne comme:

<__main__.Bar object at 0x7f3373be5998>

L'emplacement en mémoire de chaque élément est obtenu via la id()méthode.

Python Docs dit à propos de id ():

Renvoie «l'identité» d'un objet. Il s'agit d'un entier garanti unique et constant pour cet objet pendant sa durée de vie. Deux objets dont les durées de vie ne se chevauchent pas peuvent avoir la même valeur id ().

Détail de l'implémentation CPython: il s'agit de l'adresse de l'objet en mémoire.

Essayez par vous-même

class Bar:

    def __init__(self):

        self.a = 1
        self.b = (2, 2)
        self.c = [3, 3]
        self.d = {4: 4}
        self.e = lambda: "5"
        self.f = object()

    #__str__ or __repr__ as you prefer
    def __str__(self):
        return "{}".format(

            # Solution in Short Number 1
            {k: val for k, val in self.__dict__.items() if not str(hex(id(val))) in str(val)}

        )

# Main
print(Bar())

Production:

{'a': 1, 'c': [3, 3], 'b': (2, 2), 'd': {4: 4}}

Remarque :

• Testé avec Python 2.7.13et Python3.5.3

• En Python 2.x .iteritems()est préférable à.items()

J'ai récemment eu besoin de trouver quelque chose de similaire à cette question, donc je voulais publier des informations de base qui pourraient être utiles à d'autres personnes confrontées à la même chose à l'avenir.

Voici comment cela fonctionne en Python (à partir de https://docs.python.org/3.5/reference/datamodel.html#the-standard-type-hierarchy ):

MyClassest un objet de classe, MyClass()est une instance de l'objet de classe. Une instance __dict__contient uniquement des attributs et des méthodes spécifiques à cette instance (par exemple self.somethings). Si un attribut ou une méthode fait partie d'une classe, il est dans la classe __dict__. Lorsque vous le faites MyClass().__dict__, une instance de MyClassest créée sans attribut ni méthode en plus des attributs de classe, donc le vide__dict__

Donc, si vous dites print(MyClass().b), Python vérifie d'abord le dict de la nouvelle instance MyClass().__dict__['b']et ne parvient pas à le trouver b. Il vérifie ensuite la classe MyClass.__dict__['b']et trouve b.

C'est pourquoi vous avez besoin du inspectmodule pour émuler ce même processus de recherche.

Vous pouvez utiliser dir()dans une compréhension de liste pour obtenir les noms d'attributs:

names = [p for p in dir(myobj) if not p.startswith('_')]

Utilisation getattr() pour obtenir les attributs eux-mêmes:

attrs = [getattr(myobj, p) for p in dir(myobj) if not p.startswith('_')]

Ma solution pour obtenir tous les attributs (et non les méthodes) d'une classe (si la classe a une docstring correctement écrite avec les attributs clairement énoncés):

def get_class_attrs(cls):
    return re.findall(r'\w+(?=[,\)])', cls.__dict__['__doc__'])

Cette pièce cls.__dict__['__doc__']extrait la docstring de la classe.

Pourquoi avez-vous besoin de lister les attributs? Il semble que sémantiquement votre classe est une collection. Dans ce cas, je recommande d'utiliser enum:

import enum

class myClass(enum.Enum):
     a = "12"
     b = "34"

Listez vos attributs? Rien de plus simple que ça:

for attr in myClass:
    print("Name / Value:", attr.name, attr.value)

Si vous voulez "obtenir" un attribut, il y a une réponse très simple , qui devrait être évidente: getattr

class MyClass(object):
a = '12'
b = '34'
def myfunc(self):
    return self.a

>>> getattr(MyClass, 'a')
'12'

>>> getattr(MyClass, 'myfunc')
<function MyClass.myfunc at 0x10de45378>

Cela fonctionne dandy à la fois en Python 2.7 et Python 3.x.

Si vous voulez une liste de ces éléments, vous devrez toujours utiliser inspect.

deux fonctions:

def get_class_attr(Cls) -> []:
    import re
    return [a for a, v in Cls.__dict__.items()
              if not re.match('<function.*?>', str(v))
              and not (a.startswith('__') and a.endswith('__'))]

def get_class_attr_val(cls):
    attr = get_class_attr(type(cls))
    attr_dict = {}
    for a in attr:
        attr_dict[a] = getattr(cls, a)
    return attr_dict

utilisation:

>>> class MyClass:
    a = "12"
    b = "34"
    def myfunc(self):
        return self.a

>>> m = MyClass()
>>> get_class_attr_val(m)
{'a': '12', 'b': '34'}

Voici ce que je veux.

Données de test

class Base:
    b = 'b'


class MyClass(Base):
    a = '12'

    def __init__(self, name):
        self.name = name

    @classmethod
    def c(cls):
        ...

    @property
    def p(self):
        return self.a

    def my_fun(self):
        return self.name

print([name for name, val in inspect.getmembers(MyClass) if not name.startswith('_') and not callable(val)])  # need `import inspect`
print([_ for _ in dir(MyClass) if not _.startswith('_') and not callable(getattr(MyClass, _))])
# both are equ: ['a', 'b', 'p']

my_instance = MyClass('c')
print([_ for _ in dir(my_instance) if not _.startswith('_') and not callable(getattr(my_instance, _))])
# ['a', 'b', 'name', 'p']

Je sais que c'était il y a trois ans, mais pour ceux qui viendront se poser cette question à l'avenir, pour moi:

class_name.attribute 

fonctionne très bien.

Vous pouvez utiliser MyClass.__attrs__. Il donne juste tous les attributs de cette classe. Rien de plus.