Перебирать атрибуты объекта в python


162

У меня есть объект Python с несколькими атрибутами и методами. Я хочу перебрать атрибуты объекта.

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

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

Я хочу создать словарь, содержащий все атрибуты объектов и их текущие значения, но я хочу сделать это динамически (поэтому, если позже я добавлю другой атрибут, мне не придется также обновлять свою функцию).

В php переменные могут использоваться как ключи, но объекты в python неприемлемы, и если я использую для этого точечную нотацию, он создает новый атрибут с именем моего var, который не является моим намерением.

Просто чтобы прояснить ситуацию:

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

Обновление: под атрибутами я подразумеваю только переменные этого объекта, а не методы.


3
stackoverflow.com/questions/1251692/… Может быть, вам поможет.
Шон

@sean В частности, можно использовать stackoverflow.com/a/1251789/4203 ; вы бы использовали необязательный predicateаргумент для передачи вызываемого объекта, который отфильтровывал бы (связывал?) функции (который избавлялся от методов).
Хэнк Гей

Ответы:


227

Предполагая, что у вас есть такой класс, как

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

вызов dirобъекта возвращает все атрибуты этого объекта, включая специальные атрибуты python. Хотя некоторые атрибуты объекта могут вызываться, например методы.

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

Вы всегда можете отфильтровать специальные методы, используя понимание списка.

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

или если вы предпочитаете карту / фильтры.

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

Если вы хотите отфильтровать методы, вы можете использовать встроенный callableв качестве проверки.

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

Вы также можете проверить разницу между вашим классом и его экземпляром объекта с помощью.

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

1
Это плохая идея, я бы даже не предложил ее, но если вы собираетесь, по крайней мере, предоставьте оговорку.
Джулиан

2
@ Meitham @Pablo Что плохого, в основном то, что вам не нужно этого делать. Какие атрибуты вас интересуют, должны быть включающими, а не исключительными . Как вы уже видели, вы включаете методы, и любая попытка исключить их будет ошибочной, потому что они будут связаны с такими неприятными вещами, как callableили types.MethodType. Что произойдет, если я добавлю атрибут «_foo», в котором будет сохранен какой-то промежуточный результат или внутренняя структура данных? Что произойдет, если я просто добавлю атрибут в класс name, скажем, и теперь он вдруг включается.
Джулиан

3
@Julian приведенный выше код выберет оба, _fooи nameпотому что они теперь являются атрибутами объекта. Если вы не хотите включать их, вы можете исключить их из условия понимания списка. Приведенный выше код является распространенной идиомой Python и популярным способом анализа объектов Python.
Мейтам

30
На самом деле obj .__ dict__ (вероятно) лучше для этой цели.
Дейв

5
@Julian dir()только "лежит", когда переданы метаклассы (крайний крайний случай) или классы с атрибутами, украшенными @DynamicClassAttribute(другой крайний крайний случай). В обоих случаях вызов dirs()обертки inspect.getmembers()решает эту проблему. Однако для стандартных объектов этого подхода к пониманию списков для фильтрации не подлежащих вызову абсолютно достаточно. То, что некоторые питонисты назвали бы это «плохой идеей», сбивает меня с толку, но ... каждому, я полагаю, свое собственное?
Сесил Карри

57

в общем, поместите __iter__метод в ваш класс и итерируйте атрибуты объекта или поместите этот класс mixin в свой класс.

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

Твой класс:

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

это работает только когда oneи twoопределено после yc = YourClass(). Вопрос спрашивает о перекручивание через существующие attris в YourClass(). Кроме того, наследование IterMixinкласса не всегда доступно в качестве решения.
Сяо

4
vars(yc)дает тот же результат без необходимости наследования от другого класса.
Натан,

1
Мой вышеупомянутый комментарий не совсем прав; vars(yc)почти такой же, но словарь, который он вам возвращает, является собственным экземпляром __dict__, поэтому изменение его будет отражено в экземпляре. Это может привести к проблемам, если вы не будете осторожны, поэтому вышеописанный метод иногда может быть лучше (хотя копирование словаря, вероятно, проще). Кроме того, обратите внимание, что хотя приведенный выше словарь не является экземпляром экземпляра __dict__, значения одинаковы, поэтому изменение любых изменяемых значений все равно будет отражено в атрибутах экземпляра.
Натан,

25

Как уже упоминалось в некоторых ответах / комментариях, объекты Python уже хранят словарь своих атрибутов (методы не включены). Это может быть доступно как __dict__, но лучший способ - использовать vars(хотя вывод тот же). Обратите внимание, что изменение этого словаря изменит атрибуты экземпляра! Это может быть полезно, но также означает, что вы должны быть осторожны с тем, как вы используете этот словарь. Вот быстрый пример:

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}

Использование dir(a)- странный, если не откровенный, плохой подход к этой проблеме. Хорошо, если вам действительно нужно перебрать все атрибуты и методы класса (включая специальные методы, например __init__). Тем не менее, это не то, что вам нужно, и даже принятый ответ идет плохо, применяя хрупкую фильтрацию, чтобы попытаться удалить методы и оставить только атрибуты; Вы можете увидеть, как это не получится для класса, Aопределенного выше.

(Использование __dict__было сделано в нескольких ответах, но все они определяют ненужные методы вместо того, чтобы использовать его напрямую. Только комментарий предлагает использовать vars).


1
Что-то, чего я не понял с помощью подхода vars (), - как справиться с ситуацией, когда класс A имеет член, который является другим объектом, тип которого является определяемым пользователем классом B. vars (a), кажется, вызывает __repr __ () на его член типа B. __repr __ (), как я понимаю, должен возвращать строку. Но когда я вызываю vars (a), кажется, что для этого вызова имеет смысл вернуть вложенный dict вместо dict со строковым представлением B.
plafratt

1
Если у вас есть a.bкакой-то пользовательский класс, Bто vars(a)["b"] is a.b, как и следовало ожидать; ничто иное не имело бы смысла (считалось a.bсинтаксическим сахаром a.__dict__["b"]). Если у вас есть d = vars(a)и call, repr(d)то он будет вызывать repr(d["b"])как часть возврата своей собственной строки repr, так как только класс Bдействительно знает, как она должна быть представлена ​​в виде строки.
Натан

2

Объекты в python хранят свои атрибуты (в том числе функции) в вызываемом слове __dict__. Вы можете (но обычно не должны) использовать это для прямого доступа к атрибутам. Если вы просто хотите получить список, вы также можете вызвать dir(obj), который возвращает итерацию со всеми именами атрибутов, которые вы можете затем передать getattr.

Однако необходимость что-либо делать с именами переменных, как правило, плохой дизайн. Почему бы не хранить их в коллекции?

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

Затем вы можете перебирать ключи с помощью for key in obj.special_values:


Не могли бы вы объяснить немного больше, как бы я использовал коллекцию для достижения того, чего я хочу?
Пабло Мешер

1
Я не добавляю атрибуты к объекту динамически. Переменные, которые у меня есть, будут оставаться неизменными в течение длительного времени, однако я думаю, что было бы неплохо иметь возможность делать что-то вроде того, что я намерен.
Пабло Мешер

1
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

тогда просто назовите это как итеративный

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

Это кажется слишком сложным. Если у меня нет выбора, я бы предпочел придерживаться того, что я делаю сейчас.
Пабло Мешер

0

Правильный ответ на это, что вы не должны. Если вам нужен этот тип вещей, либо просто используйте dict, либо вам нужно явно добавить атрибуты в некоторый контейнер. Вы можете автоматизировать это, узнав о декораторах.

В частности, кстати, method1 в вашем примере так же хорош как атрибут.


2
Да, я знаю, что не должен .. но это помогает мне понять, как все работает. Я пришел из php-фона и обычно делал такие вещи ежедневно
Пабло Мешер,

Вы убедили меня. Обновление метода to_dict () гораздо проще, чем любой ответ.
Пабло Мешер

1
Остались ли люди, которые воздержатся от догматических советов? Динамическое программирование обожжет вас, если вы не будете осторожны, но функции на языке, который вы будете использовать.
Хенрик Вендельбо

0

Для питона 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

6
Можете ли вы добавить некоторые пояснения к своим сообщениям, чтобы и непрофессиональные питонисты могли получить пользу от ваших ответов?
not2qubit

-3

Я уверен, что для всех питонских фанатиков Йохан Клиз одобрит ваш догматизм;). Я оставляю этот ответ, продолжайте его унизлять. Это на самом деле делает меня более доверенным. Оставьте комментарий вам, цыплята!

Для питона 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

Есть ли причина, по которой у вас есть два ответа на этот вопрос?
Натан,

@ Натан, потому что один более многословный, а другой более питонский. Я также не знал, что работает быстрее, поэтому я решил позволить читателю выбрать.
Резиновая утка

@nathan ты питон или полиция переполнения стека? Существуют разные стили кодирования. Я предпочитаю не питонический, потому что я работаю на многих языках и технологиях, и я думаю, что это имеет тенденцию быть своеобразным. Тем не менее, Iist понимание это круто и кратко. Так почему бы не позволить и просвещенному читателю оба?
Резиновая утка

Я уверен, что для всех питонских фанатиков Йохан Клиз одобрит ваш догматизм;). Я оставляю этот ответ, продолжайте его унизлять. Это на самом деле делает меня более доверенным. Оставьте комментарий вам, цыплята!
резиновая утка
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.