Comment obtenir des variables d'instance en Python?

Existe-t-il une méthode intégrée en Python pour obtenir un tableau de toutes les variables d'instance d'une classe? Par exemple, si j'ai ce code:

class hi:
  def __init__(self):
    self.ii = "foo"
    self.kk = "bar"

Y a-t-il un moyen pour moi de faire ceci:

>>> mystery_method(hi)
["ii", "kk"]

Edit: j'avais initialement demandé des variables de classe par erreur.

Chaque objet a une __dict__variable contenant toutes les variables et ses valeurs.

Essaye ça

>>> hi_obj = hi()
>>> hi_obj.__dict__.keys()

Utilisez vars ()

class Foo(object):
    def __init__(self):
        self.a = 1
        self.b = 2

vars(Foo()) #==> {'a': 1, 'b': 2}
vars(Foo()).keys() #==> ['a', 'b']

Vous ne pouvez normalement pas obtenir d'attributs d'instance uniquement pour une classe, du moins pas sans instancier la classe. Vous pouvez cependant obtenir des attributs d'instance pour une instance ou des attributs de classe pour une classe. Voir le module «inspecter». Vous ne pouvez pas obtenir une liste d'attributs d'instance car les instances peuvent vraiment avoir n'importe quoi comme attribut, et - comme dans votre exemple - la manière normale de les créer est de simplement leur attribuer dans la méthode __init__.

Une exception est si votre classe utilise des emplacements, qui est une liste fixe d'attributs que la classe permet aux instances d'avoir. Les slots sont expliqués dans http://www.python.org/2.2.3/descrintro.html , mais il y a plusieurs pièges avec les slots; ils affectent la disposition de la mémoire, donc l'héritage multiple peut être problématique, et l'héritage en général doit également prendre en compte les emplacements.

Les méthodes Vars () et dict fonctionneront toutes les deux pour l'exemple publié par l'OP, mais elles ne fonctionneront pas pour des objets définis "vaguement" comme:

class foo:
  a = 'foo'
  b = 'bar'

Pour imprimer tous les attributs non appelables, vous pouvez utiliser la fonction suivante:

def printVars(object):
    for i in [v for v in dir(object) if not callable(getattr(object,v))]:
        print '\n%s:' % i
        exec('print object.%s\n\n') % i

Vous pouvez également tester si un objet a une variable spécifique avec:

>>> hi_obj = hi()
>>> hasattr(hi_obj, "some attribute")

Votre exemple montre des "variables d'instance", pas vraiment des variables de classe.

Recherchez hi_obj.__class__.__dict__.items()les variables de classe, ainsi que d'autres membres de la classe comme les fonctions membres et le module conteneur.

class Hi( object ):
    class_var = ( 23, 'skidoo' ) # class variable
    def __init__( self ):
        self.ii = "foo" # instance variable
        self.jj = "bar"

Les variables de classe sont partagées par toutes les instances de la classe.

Suggérer

>>> print vars.__doc__
vars([object]) -> dictionary

Without arguments, equivalent to locals().
With an argument, equivalent to object.__dict__.

En d'autres termes, il encapsule essentiellement __dict__

Bien que ce ne soit pas directement une réponse à la question OP, il existe une manière assez douce de savoir quelles variables sont dans la portée d'une fonction. jetez un œil à ce code:

>>> def f(x, y):
    z = x**2 + y**2
    sqrt_z = z**.5
    return sqrt_z

>>> f.func_code.co_varnames
('x', 'y', 'z', 'sqrt_z')
>>> 

L'attribut func_code contient toutes sortes de choses intéressantes. Cela vous permet de faire des trucs sympas. Voici un exemple de la façon dont j'ai utilisé ceci:

def exec_command(self, cmd, msg, sig):

    def message(msg):
        a = self.link.process(self.link.recieved_message(msg))
        self.exec_command(*a)

    def error(msg):
        self.printer.printInfo(msg)

    def set_usrlist(msg):
        self.client.connected_users = msg

    def chatmessage(msg):
        self.printer.printInfo(msg)

    if not locals().has_key(cmd): return
    cmd = locals()[cmd]

    try:
        if 'sig' in cmd.func_code.co_varnames and \
                       'msg' in cmd.func_code.co_varnames: 
            cmd(msg, sig)
        elif 'msg' in cmd.func_code.co_varnames: 
            cmd(msg)
        else:
            cmd()
    except Exception, e:
        print '\n-----------ERROR-----------'
        print 'error: ', e
        print 'Error proccessing: ', cmd.__name__
        print 'Message: ', msg
        print 'Sig: ', sig
        print '-----------ERROR-----------\n'

construit sur la réponse de dmark pour obtenir ce qui suit, ce qui est utile si vous voulez l'équivalent de sprintf et, espérons-le, aidera quelqu'un ...

def sprint(object):
    result = ''
    for i in [v for v in dir(object) if not callable(getattr(object, v)) and v[0] != '_']:
        result += '\n%s:' % i + str(getattr(object, i, ''))
    return result

Parfois, vous souhaitez filtrer la liste en fonction des variables publiques / privées. Par exemple

def pub_vars(self):
    """Gives the variable names of our instance we want to expose
    """
    return [k for k in vars(self) if not k.startswith('_')]