关于oop:python中的对象属性迭代

Iterate over object attributes in python

我有一个具有几个属性和方法的python对象。我想迭代对象属性。

1
2
3
4
5
6
7

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

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

我希望生成一个包含所有对象属性及其当前值的字典，但我希望以动态方式进行(因此，如果以后添加另一个属性，我也不必记住更新我的函数)。

在PHP中，变量可以用作键，但python中的对象是不可脚本化的，如果为此使用点表示法，它将创建一个新的属性，其名称为my var，这不是我的意图。

只是为了让事情更清楚：

1
2
3
4
5
6
7

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

1
2
3
4
5
6

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

更新：对于属性，我的意思是只有这个对象的变量，而不是方法。

相关讨论

假设你有一个类，比如

1
2
3
4
5
6
7

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

在对象上调用dir将返回该对象的所有属性，包括python特殊属性。尽管有些对象属性是可调用的，例如方法。

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

您总是可以使用列表理解来筛选出特殊的方法。

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

或者如果你喜欢地图/过滤器。

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

如果要筛选出这些方法，可以使用内置的callable作为检查。

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

您还可以使用检查类与其父类之间的差异。

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

相关讨论

这是个坏主意，我甚至不建议你这么做，但如果你打算这么做，至少要提出警告。
这似乎很简单。你说的警告是什么意思？什么会出错？
dir()还将列出方法。我只想列出变量
@pablo方法也是对象，但它们是可调用的，因此可以排除任何可调用对象。我将更新示例。
@Meitham@Pablo出了什么问题，主要是你不需要这么做。您感兴趣的属性应该是包含的，而不是独占的。正如您已经看到的，您包括了方法，任何排除方法的尝试都将是有缺陷的，因为它们将涉及诸如callable或types.MethodType之类的讨厌的事情。如果我添加一个名为"foo"的属性来存储一些中间结果或内部数据结构，会发生什么？如果我只是在类中无害地添加一个属性，比如name，然后突然将其包含进来，会发生什么呢？
@朱利安上面的代码将同时选择_foo和name，因为它们现在是对象的属性。如果不想包含它们，可以在列表理解条件中排除它们。上面的代码是一个常见的python习惯用法，也是一种常见的内省python对象的方法。
不可调用不起作用。也许@julian是对的，我不应该这样做。
@梅瑟姆，这就是重点，它会包括他们，你特别需要走出你的方式排除他们：)。不管怎样，我可以把这归因于哲学上的差异，但是我知道优秀的Python代码永远不需要这样做。使用容器，并显式声明要包含的内容。@巴勃罗，我没有说它似乎不起作用：)正如所说，什么@meitham贴的(包括callable当然应该起作用)。
实际上，obj.uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
是的，__dict__是一个实现细节。有些对象甚至没有一个对象，比如带有__slots__的对象，但仍然可以响应dir。但这两种情况都不理想，因为dir也可以撒谎。
我不知道为什么不让我编辑最后一条评论，但是现在你已经把你的评论改成建议使用obj.__dict__，我的评论让人气馁。
@Pablo Callable不工作，因为我弄错了。道歉。我在尝试可调用(k)，其中k只是字符串。我应该说callable(the_method)，即getattr(obj，k)，我已经在我的答案中解决了这个问题。如果我把你弄糊涂了，再次道歉。
@Julian dir()只在传递元类(一个极端边缘情况)或具有由@DynamicClassAttribute修饰的属性的类(另一个极端边缘情况)时"说谎"。在这两种情况下，调用dirs()包装器inspect.getmembers()可以解决这个问题。然而，对于标准对象，这个解决方案的列表理解方法过滤掉不可调用的内容就完全足够了。一些Python会把它贴上"坏主意"的标签，这让我很困惑，但是…我想是他们各自的吧？
您也可以使用返回__dict__的vars(obj)，而不是返回dir(obj)：stackoverflow.com/a/27181165/911945

通常，在类中放入一个__iter__方法，并迭代对象属性，或者将这个mixin类放入类中。

1
2
3
4

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

你们班：

1
2
3
4
5
6
7

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

相关讨论

python中的对象将其属性(包括函数)存储在名为__dict__的dict中。您可以(但一般不应该)使用它直接访问属性。如果只需要一个列表，还可以调用dir(obj)，它返回一个包含所有属性名的iterable，然后可以将其传递给getattr。

然而，需要对变量名做任何事情通常是不好的设计。为什么不把它们收藏起来呢？

1
2
3

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

然后可以使用for key in obj.special_values:迭代键。

相关讨论

正如已经在一些答案/注释中提到的，python对象已经存储了其属性的字典(不包括方法)。这可以作为__dict__访问，但更好的方法是使用vars(尽管输出是相同的)。请注意，修改此字典将修改实例上的属性！这可能很有用，但也意味着你应该小心使用这本词典。下面是一个简单的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

那就称之为无可辩驳

1
2
3

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

相关讨论

对此的正确答案是您不应该这样做。如果您想要这种类型的东西，要么使用dict，要么您需要显式地向某个容器添加属性。你可以通过学习装饰师来实现自动化。

顺便说一句，在您的示例中，method1和属性一样好。

相关讨论

对于Python 3.6

1
2
3
4
5
6
7
8
9

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

相关讨论

对于Python 3.6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

相关讨论