Iterasi atribut objek dalam python

Saya memiliki objek python dengan beberapa atribut dan metode. Saya ingin beralih pada atribut objek.

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

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

Saya ingin membuat kamus yang berisi semua atribut objek dan nilai-nilai mereka saat ini, tetapi saya ingin melakukannya dengan cara yang dinamis (jadi jika nanti saya menambahkan atribut lain saya tidak harus ingat untuk memperbarui fungsi saya juga).

Dalam variabel php dapat digunakan sebagai kunci, tetapi objek dalam python tidak dapat ditulis dan jika saya menggunakan notasi titik untuk ini, ia menciptakan atribut baru dengan nama var saya, yang bukan maksud saya.

Hanya untuk memperjelas:

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

Pembaruan: Dengan atribut yang saya maksud hanya variabel objek ini, bukan metode.

Dengan asumsi Anda memiliki kelas seperti

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

memanggil dirobjek memberi Anda kembali semua atribut objek itu, termasuk atribut khusus python. Meskipun beberapa atribut objek dapat dipanggil, seperti metode.

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

Anda selalu dapat memfilter metode khusus dengan menggunakan pemahaman daftar.

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

atau jika Anda lebih suka peta / filter.

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

Jika Anda ingin menyaring metode, Anda dapat menggunakan builtin callablesebagai tanda centang.

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

Anda juga bisa memeriksa perbedaan antara kelas Anda dan objek instansinya menggunakan.

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

secara umum letakkan __iter__metode di kelas Anda dan beralih melalui atribut objek atau letakkan kelas mixin ini di kelas Anda.

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

Kelas Anda:

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

Seperti yang disebutkan dalam beberapa jawaban / komentar sudah, objek Python sudah menyimpan kamus atribut mereka (metode tidak termasuk). Ini dapat diakses sebagai __dict__, tetapi cara yang lebih baik adalah dengan menggunakan vars(outputnya sama, meskipun). Perhatikan bahwa memodifikasi kamus ini akan mengubah atribut pada instance! Ini bisa bermanfaat, tetapi juga berarti Anda harus berhati-hati dengan cara Anda menggunakan kamus ini. Ini contoh singkatnya:

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}

Menggunakan dir(a)adalah pendekatan yang aneh, jika tidak langsung buruk, untuk masalah ini. Baik jika Anda benar-benar perlu untuk mengulangi semua atribut dan metode kelas (termasuk metode khusus seperti __init__). Namun, ini sepertinya bukan yang Anda inginkan, dan bahkan jawaban yang diterima mengenai hal ini buruk dengan menerapkan beberapa penyaringan getas untuk mencoba menghapus metode dan hanya meninggalkan atribut; Anda dapat melihat bagaimana ini akan gagal untuk kelas yang Aditentukan di atas.

(menggunakan __dict__telah dilakukan dalam beberapa jawaban, tetapi mereka semua mendefinisikan metode yang tidak perlu daripada menggunakannya secara langsung. Hanya komentar yang menyarankan untuk menggunakan vars).

Objek dalam python menyimpan atribut mereka (termasuk fungsi) dalam sebuah dict yang disebut __dict__. Anda dapat (tetapi umumnya tidak boleh) menggunakan ini untuk mengakses atribut secara langsung. Jika Anda hanya ingin daftar, Anda juga bisa menelepon dir(obj), yang mengembalikan iterable dengan semua nama atribut, yang kemudian bisa Anda sampaikan kegetattr .

Namun, perlu melakukan apa pun dengan nama-nama variabel biasanya desain yang buruk. Mengapa tidak menyimpannya di koleksi?

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

Anda kemudian dapat beralih di atas tombol dengan 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

maka sebut saja itu sebagai iterable

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

Jawaban yang benar untuk ini adalah bahwa Anda seharusnya tidak melakukannya. Jika Anda menginginkan hal semacam ini, gunakan saja dict, atau Anda harus menambahkan atribut secara eksplisit ke suatu wadah. Anda dapat mengotomatiskannya dengan mempelajari tentang dekorator.

Secara khusus, metode1 pada contoh Anda sama baiknya dengan atribut.

Untuk 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

Untuk semua fanatik pythonian di luar sana, saya yakin Johan Cleeze akan menyetujui dogmatisme Anda;). Saya meninggalkan jawaban ini terus-menerus meremehkannya. Itu sebenarnya membuat saya lebih percaya diri. Tinggalkan komentar kamu ayam!

Untuk 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