Wie bekomme ich Instanzvariablen in Python?

Gibt es in Python eine integrierte Methode, um ein Array aller Instanzvariablen einer Klasse abzurufen? Zum Beispiel, wenn ich diesen Code habe:

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

Gibt es eine Möglichkeit für mich, dies zu tun:

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

Bearbeiten: Ich hatte ursprünglich fälschlicherweise nach Klassenvariablen gefragt.

Jedes Objekt enthält eine __dict__Variable, die alle Variablen und ihre Werte enthält.

Versuche dies

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

Verwenden Sie vars ()

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

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

Normalerweise können Sie Instanzattribute nicht nur für eine Klasse erhalten, zumindest nicht, ohne die Klasse zu instanziieren. Sie können jedoch Instanzattribute für eine Instanz oder Klassenattribute für eine Klasse abrufen. Siehe das 'Inspect'-Modul. Sie können keine Liste der Instanzattribute abrufen, da Instanzen wirklich alles als Attribut haben können. Wie in Ihrem Beispiel besteht die normale Methode zum Erstellen darin, sie einfach mit der Methode __init__ zuzuweisen.

Eine Ausnahme ist, wenn Ihre Klasse Slots verwendet. Hierbei handelt es sich um eine feste Liste von Attributen, die die Klasse für Instanzen zulässt. Slots werden unter http://www.python.org/2.2.3/descrintro.html erläutert , es gibt jedoch verschiedene Fallstricke bei Slots. Sie wirken sich auf das Speicherlayout aus, sodass Mehrfachvererbung problematisch sein kann und die Vererbung im Allgemeinen auch Slots berücksichtigen muss.

Sowohl die Vars () - als auch die dict-Methode funktionieren für das Beispiel, das das OP veröffentlicht hat, aber sie funktionieren nicht für "lose" definierte Objekte wie:

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

Um alle nicht aufrufbaren Attribute zu drucken, können Sie die folgende Funktion verwenden:

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

Sie können auch testen, ob ein Objekt eine bestimmte Variable hat:

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

Ihr Beispiel zeigt "Instanzvariablen", nicht wirklich Klassenvariablen.

Suchen Sie hi_obj.__class__.__dict__.items()nach den Klassenvariablen zusammen mit anderen Klassenmitgliedern wie Elementfunktionen und dem enthaltenen Modul.

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

Klassenvariablen werden von allen Instanzen der Klasse gemeinsam genutzt.

Vorschlagen

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

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

Mit anderen Worten, es wird im Wesentlichen nur __dict__ umbrochen

Obwohl dies keine direkte Antwort auf die OP-Frage ist, gibt es eine ziemlich gute Möglichkeit, herauszufinden, welche Variablen in einer Funktion enthalten sind. Schauen Sie sich diesen Code an:

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

Das Attribut func_code enthält alle möglichen interessanten Dinge. Es erlaubt dir, ein paar coole Sachen zu machen. Hier ist ein Beispiel, wie ich dies verwendet habe:

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'

Aufbauend auf der Antwort von dmark, um Folgendes zu erhalten. Dies ist nützlich, wenn Sie das Äquivalent von sprintf möchten und hoffentlich jemandem helfen möchten ...

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

Manchmal möchten Sie die Liste basierend auf öffentlichen / privaten Variablen filtern. Z.B

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