Iterieren Sie über Objektattribute in Python

Ich habe ein Python-Objekt mit mehreren Attributen und Methoden. Ich möchte über Objektattribute iterieren.

class my_python_obj(object):
    attr1='a'
    attr2='b'
    attr3='c'

    def method1(self, etc, etc):
        #Statements

Ich möchte ein Wörterbuch generieren, das alle Objektattribute und ihre aktuellen Werte enthält, aber ich möchte dies auf dynamische Weise tun (wenn ich später ein weiteres Attribut hinzufüge, muss ich nicht daran denken, auch meine Funktion zu aktualisieren).

In PHP können Variablen als Schlüssel verwendet werden, aber Objekte in Python sind nicht beschreibbar. Wenn ich hierfür die Punktnotation verwende, wird ein neues Attribut mit dem Namen meiner Variable erstellt, was nicht meine Absicht ist.

Nur um die Dinge klarer zu machen:

def to_dict(self):
    '''this is what I already have'''
    d={}
    d["attr1"]= self.attr1
    d["attr2"]= self.attr2
    d["attr3"]= self.attr3
    return d

· ·

def to_dict(self):
    '''this is what I want to do'''
    d={}
    for v in my_python_obj.attributes:
        d[v] = self.v
    return d

Update: Mit Attributen meine ich nur die Variablen dieses Objekts, nicht die Methoden.

Angenommen, Sie haben eine Klasse wie

>>> class Cls(object):
...     foo = 1
...     bar = 'hello'
...     def func(self):
...         return 'call me'
...
>>> obj = Cls()

Wenn Sie dirdas Objekt aufrufen, erhalten Sie alle Attribute dieses Objekts zurück, einschließlich der speziellen Python-Attribute. Obwohl einige Objektattribute aufrufbar sind, wie z. B. Methoden.

>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar', 'foo', 'func']

Sie können die speziellen Methoden jederzeit mithilfe eines Listenverständnisses herausfiltern.

>>> [a for a in dir(obj) if not a.startswith('__')]
['bar', 'foo', 'func']

oder wenn Sie Karte / Filter bevorzugen.

>>> filter(lambda a: not a.startswith('__'), dir(obj))
['bar', 'foo', 'func']

Wenn Sie die Methoden herausfiltern möchten, können Sie die integrierte Methode callableals Prüfung verwenden.

>>> [a for a in dir(obj) if not a.startswith('__') and not callable(getattr(obj, a))]
['bar', 'foo']

Sie können auch den Unterschied zwischen Ihrer Klasse und ihrem Instanzobjekt mithilfe von untersuchen.

>>> set(dir(Cls)) - set(dir(object))
set(['__module__', 'bar', 'func', '__dict__', 'foo', '__weakref__'])

Fügen Sie im Allgemeinen eine __iter__Methode in Ihre Klasse ein und durchlaufen Sie die Objektattribute oder fügen Sie diese Mixin-Klasse in Ihre Klasse ein.

class IterMixin(object):
    def __iter__(self):
        for attr, value in self.__dict__.iteritems():
            yield attr, value

Deine Klasse:

>>> class YourClass(IterMixin): pass
...
>>> yc = YourClass()
>>> yc.one = range(15)
>>> yc.two = 'test'
>>> dict(yc)
{'one': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 'two': 'test'}

Wie bereits in einigen Antworten / Kommentaren erwähnt, speichern Python-Objekte bereits ein Wörterbuch ihrer Attribute (Methoden sind nicht enthalten). Auf diese kann zugegriffen werden __dict__, aber der bessere Weg ist die Verwendung vars(die Ausgabe ist jedoch dieselbe). Beachten Sie, dass durch Ändern dieses Wörterbuchs die Attribute der Instanz geändert werden! Dies kann nützlich sein, bedeutet aber auch, dass Sie bei der Verwendung dieses Wörterbuchs vorsichtig sein sollten. Hier ist ein kurzes Beispiel:

class A():
    def __init__(self, x=3, y=2, z=5):
        self.x = x
        self._y = y
        self.__z__ = z

    def f(self):
        pass

a = A()
print(vars(a))
# {'x': 3, '_y': 2, '__z__': 5}
# all of the attributes of `a` but no methods!

# note how the dictionary is always up-to-date
a.x = 10
print(vars(a))
# {'x': 10, '_y': 2, '__z__': 5}

# modifying the dictionary modifies the instance attribute
vars(a)["_y"] = 20
print(vars(a))
# {'x': 10, '_y': 20, '__z__': 5}

Die Verwendung dir(a)ist eine seltsame, wenn nicht geradezu schlechte Herangehensweise an dieses Problem. Es ist gut, wenn Sie wirklich alle Attribute und Methoden der Klasse durchlaufen müssen (einschließlich der speziellen Methoden wie __init__). Dies scheint jedoch nicht das zu sein, was Sie wollen, und selbst die akzeptierte Antwort geht schlecht dahin, indem Sie eine spröde Filterung anwenden, um zu versuchen, Methoden zu entfernen und nur die Attribute zu belassen. Sie können sehen, wie dies für die Klasse fehlschlagen würdeA oben definierte .

(Die Verwendung __dict__wurde in einigen Antworten durchgeführt, aber alle definieren unnötige Methoden, anstatt sie direkt zu verwenden. Nur ein Kommentar schlägt die Verwendung vor. vars)

Objekte in Python speichern ihre Attribute (einschließlich Funktionen) in einem Diktat namens __dict__. Sie können (sollten dies aber im Allgemeinen nicht) verwenden, um direkt auf die Attribute zuzugreifen. Wenn Sie nur eine Liste möchten, können Sie auch anrufendir(obj) , die eine Iterable mit allen Attributnamen zurückgibt, an die Sie dann übergeben können getattr.

Es ist jedoch normalerweise ein schlechtes Design, irgendetwas mit den Namen der Variablen tun zu müssen. Warum sie nicht in einer Sammlung aufbewahren?

class Foo(object):
    def __init__(self, **values):
        self.special_values = values

Sie können dann mit über die Tasten iterieren for key in obj.special_values:

class someclass:
        x=1
        y=2
        z=3
        def __init__(self):
           self.current_idx = 0
           self.items = ["x","y","z"]
        def next(self):
            if self.current_idx < len(self.items):
                self.current_idx += 1
                k = self.items[self.current_idx-1]
                return (k,getattr(self,k))
            else:
                raise StopIteration
        def __iter__(self):
           return self

dann nenne es einfach als iterable

s=someclass()
for k,v in s:
    print k,"=",v

Die richtige Antwort darauf ist, dass Sie nicht sollten. Wenn Sie diese Art von Dingen möchten, verwenden Sie entweder nur ein Diktat oder Sie müssen einem Container explizit Attribute hinzufügen. Sie können dies automatisieren, indem Sie sich mit Dekorateuren vertraut machen.

Insbesondere Methode1 in Ihrem Beispiel ist übrigens genauso gut für ein Attribut.

Für Python 3.6

class SomeClass:

    def attr_list(self, should_print=False):

        items = self.__dict__.items()
        if should_print:
            [print(f"attribute: {k}    value: {v}") for k, v in items]

        return items

Für alle pythonischen Eiferer da draußen bin ich sicher, dass Johan Cleeze Ihren Dogmatismus gutheißen würde;). Ich lasse diese Antwort immer wieder herabsetzen. Das macht mich selbstbewusster. Hinterlasse einen Kommentar du Hühner!

Für Python 3.6

class SomeClass:

    def attr_list1(self, should_print=False):

        for k in self.__dict__.keys():
            v = self.__dict__.__getitem__(k)
            if should_print:
                print(f"attr: {k}    value: {v}")

    def attr_list(self, should_print=False):

        b = [(k, v) for k, v in self.__dict__.items()]
        if should_print:
            [print(f"attr: {a[0]}    value: {a[1]}") for a in b]
        return b