Python 赋值语句

说明

《Python 教程》持续更新中，提供建议、纠错、催更等加作者微信: gairuo123（备注：pandas教程）和关注公众号「盖若」ID: gairuo。跟作者学习，请进入 Python学习课程。欢迎关注作者出版的书籍：《深入浅出Pandas》和《Python之光》。

Python 中的赋值语句的基本形式是在等号左边写赋值语句的目标。要赋值的对象位于右侧。左侧的目标可以是变量名或者元素。右侧的对象可以是任何会计算得到的对象表达式。

综述

Python中的赋值语句用于将值赋给变量。主要有以下几种形式:

a = 'hello'  # 基本形式
a, b = 'hello', 'world'  # 元组赋值运算（位置性）
a, b = b, a # 交换对象
[a, b] = ['hello', 'world']  # 列表赋值运算（按位置）
(a, b) = 'hello', 'world'  # 元组赋值运算（位置性）
a, b, c, d = 'good'  # 序列赋值运算，通用性
a, b, c = [1, 2, 3]  # 按顺序解包
a, *b = 'hello'  # 扩展的序列解包（Python3.0）
a = b = 'hello'  # 多目标赋值运算（链式赋值）
a += 1  # 增强赋值运算（相当于 a = a + 1）
a:int = 1 # 带标注的赋值语句
a = 1 + 1 # 计算结果赋值
# 对象相关
obj.a = 123 # 属性赋值
obj['name'] = 'Tom' # 抽取赋值
obj[1] = 'hello' # 索引赋值
obj[1:3] = 'hello', 'world' # 切片赋值
# 生成器
a = yield b
a = yield from b

注意，以下是错误的：

a, b, c = 3 # 3 不能解包
a = (b = 1 + 2) # 赋值语句不能再赋值
a + b = 10 # 标识符号相加不能赋值
a = 2b # 没有这个语法，应该 2*b
2a = b + 1 # 同上

基本赋值

最简单的赋值形式是直接为变量赋一个值:

x = 5

这会将数字5赋给变量x。

多重赋值

可以同时为多个变量赋值:

x, y, z = 1, 2, 3

这会将1赋给x,2赋给y,3赋给z。

链式赋值

可以将一个变量赋值给另一个变量:

x = y = z = 1

这等同于:

y = 1
z = 1
x = 1

解包赋值

可以将序列或集合中的元素依次赋值给变量:

x, y, z = [1, 2, 3]

这会将[1, 2, 3]中的每个元素依次赋给 x, y, z。

增强赋值

可以使用一些增强的运算符进行赋值操作:

x += 1 # 等同于 x = x + 1
x -= 1 # 等同于 x = x - 1 
x *= 2 # 等同于 x = x * 2
# 等等

这就完成了Python中最主要的赋值语句。充分利用它们可以使代码更简洁。

语法介绍

赋值语句用于将名称（重）绑定到特定值，以及修改属性或可变对象的成员项。赋值语句会对指定的表达式列表进行求值（注意这可能为单一表达式或是由逗号分隔的列表，后者将产生一个元组）并将单一结果对象从左至右逐个赋值给目标列表。

赋值是根据目标（列表）的格式递归地定义的。当目标为一个可变对象（属性引用、抽取或切片）的组成部分时，该可变对象必须最终执行赋值并决定其有效性，如果赋值操作不可接受也可能引发异常。各种类型可用的规则和引发的异常通过对象类型的定义给出。

对象赋值的目标对象可以包含于圆括号或方括号内，具体操作按以下方式递归地定义。

如果目标列表为后面不带逗号、可以包含于圆括号内的单一目标，则将对象赋值给该目标。
否则:
- 如果目标列表包含一个带有星号前缀的目标，这称为“加星”目标：则该对象至少必须为与目标列表项数减一相同项数的可迭代对象。该可迭代对象前面的项将按从左至右的顺序被赋值给加星目标之前的目标。该可迭代对象末尾的项将被赋值给加星目标之后的目标。然后该可迭代对象中剩余项的列表将被赋值给加星目标（该列表可以为空）。
- 否则：该对象必须为具有与目标列表相同项数的可迭代对象，这些项将按从左至右的顺序被赋值给对应的目标。

对象赋值给单个目标的操作按以下方式递归地定义。

如果目标为标识符（名称）:
- 如果该名称未出现于当前代码块的 global 或 nonlocal 语句中：该名称将被绑定到当前局部命名空间的对象。
- 否则：该名称将被分别绑定到全局命名空间或由 nonlocal 所确定的外层命名空间的对象。
  如果该名称已经被绑定则将被重新绑定。这可能导致之前被绑定到该名称的对象的引用计数变为零，造成该对象进入释放过程并调用其析构器（如果存在）。
如果该对象为属性引用：引用中的原型表达式会被求值。它应该产生一个具有可赋值属性的对象；否则将引发 TypeError。该对象会被要求将可赋值对象赋值给指定的属性；如果它无法执行赋值，则会引发异常 (通常应为 AttributeError 但并不强制要求)。
注意：如果该对象为类实例并且属性引用在赋值运算符的两侧都出现，则右侧表达式 a.x 可以访问实例属性或（如果实例属性不存在）类属性。左侧目标 a.x 将总是设定为实例属性，并在必要时创建该实例属性。因此 a.x 的两次出现不一定指向相同的属性：如果右侧表达式指向一个类属性，则左侧会创建一个新的实例属性作为赋值的目标:

class Cls:
    x = 3             # class variable
inst = Cls()
inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

此描述不一定作用于描述器属性，例如通过 property() 创建的特征属性。

如果目标为一个抽取项：引用中的原型表达式会被求值。它应当产生一个可变序列对象（例如列表）或一个映射对象（例如字典）。接下来，该抽取表达式会被求值。

如果原型为一个可变序列对象（例如列表），抽取应产生一个整数。如其为负值，则再加上序列长度。结果值必须为一个小于序列长度的非负整数，序列将把被赋值对象赋值给该整数指定索引号的项。如果索引超出范围，将会引发 IndexError (给被抽取序列赋值不能向列表添加新项)。

如果主对象是映射对象（如字典），则下标的类型必须与映射的键类型兼容，然后要求映射创建一个键/值对，将下标映射到指定的对象。这可以用相同的键值替换现有的键值对，也可以插入新的键值对（如果不存在具有相同值的键）。

对于用户定义对象，会调用 __setitem__() 方法并附带适当的参数。
如果目标为一个切片：引用中的原型表达式会被求值。它应当产生一个可变序列对象（例如列表）。被赋值对象应当是一个相同类型的序列对象。接下来，下界与上界表达式如果存在的话将被求值；默认值分别为零和序列长度。上下边界值应当为整数。如果某一边界为负值，则会加上序列长度。求出的边界会被裁剪至介于零和序列长度的开区间中。最后，将要求序列对象以被赋值序列的项替换该切片。切片的长度可能与被赋值序列的长度不同，这会在目标序列允许的情况下改变目标序列的长度。

CPython 实现细节：在当前实现中，目标的句法被当作与表达式的句法相同，无效的句法会在代码生成阶段被拒绝，导致不太详细的错误信息。

虽然赋值的定义意味着左手边与右手边的重叠是“同时”进行的（例如 a, b = b, a 会交换两个变量的值），但在赋值给变量的多项集之内的重叠是从左至右进行的，这有时会令人混淆。例如，以下程序将会打印出 [0, 2]:

x = [0, 1]
i = 0
i, x[i] = 1, 2         # i is updated, then x[i] is updated
print(x)

增强赋值语句

增强赋值语句将对目标和表达式列表求值（与普通赋值语句不同的是，前者不能为可迭代对象拆包），对两个操作数相应类型的赋值执行指定的二元运算，并将结果赋值给原始目标。目标仅会被求值一次。

增强赋值语句例如 x += 1 可以改写为 x = x + 1 获得类似但并非完全等价的效果。在增强赋值的版本中，x 仅会被求值一次。而且，在可能的情况下，实际的运算是原地执行的，也就是说并不是创建一个新对象并将其赋值给目标，而是直接修改原对象。

不同于普通赋值，增强赋值会在对右手边求值之前对左手边求值。例如，a[i] += f(x) 首先查找 a[i]，然后对 f(x) 求值并执行加法操作，最后将结果写回到 a[i]。

除了在单个语句中赋值给元组和多个目标的例外情况，增强赋值语句的赋值操作处理方式与普通赋值相同。类似地，除了可能存在原地操作行为的例外情况，增强赋值语句执行的二元运算也与普通二元运算相同。

对于属性引用类目标，针对常规赋值的关于类和实例属性的警告也同样适用。

带标注的赋值语句

标注赋值就是在单个语句中将变量或属性标注和可选的赋值语句合为一体。与正常情况的赋值语句不同，它只允许一个目标。

对于将简单名称作为赋值目标的情况，如果是在类或模块作用域中，标注会被求值并存入一个特殊的类或模块属性 __annotations__ 中，这是一个将变量名称（如为私有会被移除）映射到被求值标注的字典。此属性为可写并且在类或模块体开始执行时如果静态地发现标注就会自动创建。

对于将表达式作为赋值目标的情况，如果是在类或模块作用域中，标注会被求值，但不会保存。

如果一个名称在函数作用域内被标注，则该名称为该作用域的局部变量。标注绝不会在函数作用域内被求值和保存。

如果存在右手边，带标注的赋值会在对标注求值之前（如果适用）执行实际的赋值。如果用作表达式目标的右手边不存在，则解释器会对目标求值，但最后的 __setitem__() 或 setattr() 调用除外。

原理机制

Python中的赋值语句在底层实现上涉及一些比较有趣的机制。我们来看一下它的具体工作原理:

变量名是指针。Python中的变量名本质上是一个指针,指向变量的值所在的内存地址。当我们执行x = 5时,解释器会先在内存中分配一个整数对象5,然后让x指向这个对象。
对象的引用计数。Python使用引用计数机制来管理内存。当一个对象被指向时,它的引用计数加1;当失去指向时,引用计数减1。当引用计数为0时,对象将被垃圾回收。所以x = 5会使整数对象5的引用计数加1,而del x会使其引用计数减1。
名称绑定。赋值语句会将一个变量名绑定到一个对象上,这个绑定关系被保存在一个字典中。比如x = 5会在当前命名空间绑定"x"和整数对象5。后续对x的访问会通过该字典找到对应的整数对象。这也是多个变量名可以指向一个对象的原理。
浅拷贝与深拷贝。当我们进行赋值如y = x时,实际上是将y指向了和x相同的对象,这叫浅拷贝。而深拷贝会重新创建一个一模一样的对象,完全断开与原对象的绑定关系。
变量的不可变性。简单对象如整数、字符串在Python中是不可变对象。这意味着对一个变量的任何操作都不会改变对象自身,而是重新绑定变量名到一个新的对象,这会带来一些副作用。

这就是Python赋值语句的一些关键实现机制。正确理解它们会有助于更好地运用Python。

拷贝类型

在 Python 中，x, y = y, x 这种交换两个变量的值的写法是浅拷贝，不是深拷贝。

这种写法实现起来非常简单，就是将 x 的值赋给 y，将 y 的值赋给 x，两者的内存地址不变，只是值进行了交换。

举个例子:

x = [1, 2, 3]
y = [4, 5, 6]

x, y = y, x
print(x) # [4, 5, 6]
print(y) # [1, 2, 3]

这里 x 和 y 只是交换了对列表的引用,并没有创建任何新的列表或复制内容。因此这属于浅拷贝，x 和 y 指向的内存地址保持不变。

而深拷贝通常需要使用 copy 模块或 [:] 切片操作来实现对对象的递归复制，这样新的变量将指向一个完全不同的内存空间。

所以简单地交换两个变量的值只能实现浅拷贝。如果需要深拷贝，还需要额外的操作。

避坑

注意，解包赋值有时不能分开编写，如：

a, b = b, a + b
# vs
a = b
b = a + b

这两种方法不是等价的，我们测试下：

a, b = 0, 1
a, b = b, a + b
a, b
# (1, 1)

# vs
a, b = 0, 1
a = b
b = a + b
a, b
# (1, 2)

它们所赋值的结果是不一样的。因为后者中的 a + b 时的 a 的对象已经发生了变化。

总结

Python中的赋值语句的基本形式是在等号左边写赋值语句的目标。要赋值的对象位于右侧。左侧的目标可以是变量名或者元素。右侧的对象可以是任何会计算得到的对象表达式。
赋值语句建立对象的引用，而不是赋值对象。
Python会在首次将对象引用值赋给变量时创建其变量名。一旦赋值后，每当这个变量名出现在表达式时，就会被其所引用的值取代
变量名在引用前必须先赋值，禁止未进行赋值就的变量
隐式赋值应用于模块导入、函数、类定义、for循环变量以及函数参数

参考

https://docs.python.org/zh-cn/3/reference/simple_stmts.html#augmented-assignment-statements
https://realpython.com/python-assignment-operator/