¿Cómo obtener variables de instancia en Python?

¿Existe un método incorporado en Python para obtener una matriz de todas las variables de instancia de una clase? Por ejemplo, si tengo este código:

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

¿Hay alguna manera de hacer esto?

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

Editar: originalmente había pedido variables de clase por error.

Cada objeto tiene una __dict__variable que contiene todas las variables y sus valores.

Prueba esto

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

Utilice vars ()

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

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

Normalmente no puede obtener atributos de instancia dada solo una clase, al menos no sin instanciar la clase. Sin embargo, puede obtener atributos de instancia dada una instancia, o atributos de clase dada una clase. Consulte el módulo "inspeccionar". No puede obtener una lista de atributos de instancia porque las instancias realmente pueden tener cualquier cosa como atributo y, como en su ejemplo, la forma normal de crearlas es simplemente asignándolas en el método __init__.

Una excepción es si su clase usa ranuras, que es una lista fija de atributos que la clase permite que tengan las instancias. Las ranuras se explican en http://www.python.org/2.2.3/descrintro.html , pero existen varias dificultades con las ranuras; afectan el diseño de la memoria, por lo que la herencia múltiple puede ser problemática, y la herencia en general también debe tener en cuenta las ranuras.

Tanto el método Vars () como el dict funcionarán para el ejemplo que publicó el OP, pero no funcionarán para objetos definidos "libremente" como:

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

Para imprimir todos los atributos no invocables, puede utilizar la siguiente función:

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

También puede probar si un objeto tiene una variable específica con:

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

Su ejemplo muestra "variables de instancia", no realmente variables de clase.

Busque hi_obj.__class__.__dict__.items()las variables de clase, junto con otros miembros de la clase, como funciones miembro y el módulo contenedor.

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

Las variables de clase son compartidas por todas las instancias de la clase.

Sugerir

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

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

En otras palabras, básicamente envuelve __dict__

Aunque no es una respuesta directa a la pregunta de OP, hay una manera bastante agradable de averiguar qué variables están dentro del alcance de una función. echa un vistazo a este código:

>>> 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')
>>> 

El atributo func_code tiene todo tipo de cosas interesantes. Te permite hacer algunas cosas interesantes. Aquí hay un ejemplo de cómo lo he usado:

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'

construido sobre la respuesta de dmark para obtener lo siguiente, que es útil si desea el equivalente de sprintf y, con suerte, ayudará a alguien ...

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

A veces, desea filtrar la lista según las variables públicas / privadas. P.ej

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('_')]