Python obj.count=8或setattr（obj，count，8）

在python中。使用

setattr（object'var'，value

和

object.var=value

方法之间有什么区别。它们似乎都做同样的事情

class Something(object):
    pass

x = Something()

setattr(x, 'count', 2) #sets count to be 2
x.count = 3            #sets count to be 3

---

它们确实做了同样的事情，但是不能使用属性设置语法的变量，而可以使用

setattr（）

换句话说，这是有效的：

foo = 'count'
setattr(x, foo, 2)

但这并不是：

foo = 'count'
x.foo = 2

对于动态属性设置，使用

setattr（）

，其中属性的名称取自变量。对于静态属性，使用

object.attributename=value

，其中您事先知道名称

此外，属性访问语法仅限于正确的Python标识符，而

setattr（）

可以使用任何字符串。这意味着您可以使用：

setattr(x, '3 little piggies', 42)

---

因为Python标识符不允许空格，并且不能以数字开头，所以尝试使用静态属性将不起作用。

它们确实做了同样的事情，但是您不能使用属性设置语法的变量，而您可以使用

setattr（）

换句话说，这是有效的：

foo = 'count'
setattr(x, foo, 2)

但这并不是：

foo = 'count'
x.foo = 2

对于动态属性设置，使用

setattr（）

，其中属性的名称取自变量。对于静态属性，使用

object.attributename=value

，其中您事先知道名称

此外，属性访问语法仅限于正确的Python标识符，而

setattr（）

可以使用任何字符串。这意味着您可以使用：

setattr(x, '3 little piggies', 42)

---

因为Python标识符不允许空格，并且不能以数字开头，所以尝试使用静态属性将不起作用。

正如其他人所提到的，它们本质上是相同的。但是，

setattr（obj，'attr'，value）

更为通用，因为它允许您通过语法结构执行无法执行的操作

obj.attr=value

：

>>> class A(object):
...    pass
>>> a = A()
>>> setattr(a, 'foo bar', 5)  # space in the attribute name???
>>> print getattr(a, 'foo bar')
5
>>> a.'foo bar' = 7
  File "<stdin>", line 1
    a.'foo bar' = 7
          ^

>>A类（对象）：
…通过
>>>a=a（）
>>>setattr（一个'foo-bar'，5）#属性名称中的空格？？？
>>>打印getattr（一个“foo-bar”）
5.
>>>a.“富吧”=7
文件“”，第1行
a、 ‘富吧’=7
^

SyntaxError:无效语法

---

您是否应该利用Python的这个“特性”（提示：您可能不应该）是另一个问题。

正如其他人所提到的，它们本质上是相同的。但是，

setattr（obj，'attr'，value）

更为通用，因为它允许您通过语法结构执行无法执行的操作

obj.attr=value

：

>>> class A(object):
...    pass
>>> a = A()
>>> setattr(a, 'foo bar', 5)  # space in the attribute name???
>>> print getattr(a, 'foo bar')
5
>>> a.'foo bar' = 7
  File "<stdin>", line 1
    a.'foo bar' = 7
          ^

>>A类（对象）：
…通过
>>>a=a（）
>>>setattr（一个'foo-bar'，5）#属性名称中的空格？？？
>>>打印getattr（一个“foo-bar”）
5.
>>>a.“富吧”=7
文件“”，第1行
a、 ‘富吧’=7
^

SyntaxError:无效语法

---

您是否应该利用Python的这个“特性”（提示：您可能不应该）是另一个问题。

访问

x.count

直接生成更高效的代码，我怀疑这是因为属性访问可以在解析/字节编译时解决。这在循环中可能特别明显

给定

下面是Python 2.7上的说明：

>>> dis.dis(f)
  1           0 LOAD_GLOBAL              0 (setattr)
              3 LOAD_GLOBAL              1 (x)
              6 LOAD_CONST               1 ('count')
              9 LOAD_CONST               2 (2)
             12 CALL_FUNCTION            3
             15 POP_TOP
             16 LOAD_CONST               0 (None)
             19 RETURN_VALUE
>>> dis.dis(g)
  1           0 LOAD_CONST               1 (3)
              3 LOAD_GLOBAL              0 (x)
              6 STORE_ATTR               1 (count)
              9 LOAD_CONST               0 (None)
             12 RETURN_VALUE

---

因此

g

产生的字节码更少，我怀疑它也更快。

访问

x.count

直接产生更高效的代码，我怀疑这是因为可以在解析/字节编译时解析属性访问。这在循环中可能特别明显

给定

下面是Python 2.7上的说明：

>>> dis.dis(f)
  1           0 LOAD_GLOBAL              0 (setattr)
              3 LOAD_GLOBAL              1 (x)
              6 LOAD_CONST               1 ('count')
              9 LOAD_CONST               2 (2)
             12 CALL_FUNCTION            3
             15 POP_TOP
             16 LOAD_CONST               0 (None)
             19 RETURN_VALUE
>>> dis.dis(g)
  1           0 LOAD_CONST               1 (3)
              3 LOAD_GLOBAL              0 (x)
              6 STORE_ATTR               1 (count)
              9 LOAD_CONST               0 (None)
             12 RETURN_VALUE

所以

g

产生的字节码更少，我怀疑它也更快