Python快速入门专业版（十七）：赋值运算符：简单赋值与复合赋值（+=/*=等用法详解）

本文链接：https://blog.csdn.net/Pocker_Spades_A/article/details/151327168

在这里插入图片描述

一.简单赋值：= 基本用法
2.复合赋值运算符：简洁高效的操作
- 2.1 复合赋值的基本用法
- 2.2 复合赋值的注意事项
3.复合赋值的优势：简洁性与效率
- 3.1 代码更简洁
- 3.2 执行效率更高
4.复合赋值的注意事项
- 4.1 与普通赋值的细微差别
- 4.2 复合赋值的运算顺序
5.实战案例：复合赋值的典型应用
总结

Python提供了多种赋值运算符，不仅包括基本的 =赋值，还有一系列复合赋值运算符（如 +=、 *=等），这些运算符能使代码更加简洁高效。本文将详细介绍这些运算符的使用方法、特性以及实际应用场景。

一.简单赋值：= 基本用法

简单赋值运算符=是最基础的赋值方式，它的核心作用是将右边表达式的计算结果存储到左边变量所代表的内存位置中。这是所有编程语言中最基本且最常用的操作之一。

基本语法：

变量 = 表达式

其中：

变量：必须是有效的变量名（如a、score等），不能是常量或表达式
表达式：可以是常量、变量、运算式或函数调用等任何能产生值的表达式
=：赋值符号，表示将右边的值存入左边变量

代码示例：

# 1. 基本数据类型赋值
a = 10       # 整数赋值
b = 3.14     # 浮点数赋值
c = "hello"  # 字符串赋值
d = True     # 布尔值赋值

# 2. 表达式赋值（先计算右边，再赋值给左边）
x = 5 + 3    # 先计算5+3=8，再将8赋给x
y = x * 2    # 先计算x*2=16，再将16赋给y
z = (x + y) // 3  # 先计算括号内8+16=24，再24//3=8，最后将8赋给z

# 3. 容器类型赋值
list1 = [1, 2, 3]       # 列表赋值
dict1 = {"name": "Tom"} # 字典赋值
set1 = {1, 2, 3}        # 集合赋值

# 4. 多变量同时赋值
# 链式赋值：多个变量赋相同值
m = n = p = 0  # m、n、p都赋值为0

# 元组解包赋值：按位置对应赋值
name, age = "Alice", 25  # name="Alice", age=25
x, y = y, x  # 经典的两值交换技巧

# 5. 函数返回值赋值
import math
pi_value = math.pi  # 将math.pi的值赋给pi_value

注意点：

赋值号=不是数学中的"等于"符号，它是"赋值"操作，表示将右边的值存入左边变量的内存地址
赋值操作有方向性：左边必须是可赋值的变量（不能是常量或表达式）
- 正确：a = 10
- 错误：10 = a（会报SyntaxError）
多变量赋值时，右边的值会按顺序赋给左边的变量：
- a, b = 1, 2 → a=1, b=2
- 如果左右数量不匹配会报ValueError

赋值操作会覆盖变量原有的值：

x = 5
x = 10  # 原来的5被覆盖，x现在为10

Python是动态类型语言，变量可以随时被赋值为不同类型的值：

var = 10    # 现在是整数
var = "hi"  # 现在是字符串
var = [1,2] # 现在是列表

2.复合赋值运算符：简洁高效的操作

复合赋值运算符是将"运算"和"赋值"两个操作合并的简写形式，它不仅能减少代码量，还能提高执行效率（因为解释器可以优化这种常见操作）。这类运算符在循环累加、计数器更新等场景中特别常用。

Python支持的所有复合赋值运算符如下：

运算符	等价表达式	描述	典型应用场景
`+=`	`a = a + b`	加法赋值	累加计算、字符串拼接
`-=`	`a = a - b`	减法赋值	递减计数、余额扣除
`*=`	`a = a * b`	乘法赋值	连乘运算、字符串重复
`/=`	`a = a / b`	除法赋值（结果为float）	平均值计算
`//=`	`a = a // b`	整除赋值（结果为int）	整数除法运算
`%=`	`a = a % b`	取余赋值	周期计算、判断奇偶
`**=`	`a = a ** b`	幂运算赋值	指数增长计算
`&=`	`a = a & b`	按位与赋值	位操作
`	=`	`a = a	b`
`^=`	`a = a ^ b`	按位异或赋值	位操作
`<<=`	`a = a << b`	左移位赋值	位操作
`>>=`	`a = a >> b`	右移位赋值	位操作

2.1 复合赋值的基本用法

# 初始化变量
a = 10
b = 3

# += 加法赋值（常用于累加）
a += b  # 等价于 a = a + b → a = 13
print(f"a += b 后：a = {a}")  # 输出：a += b 后：a = 13

# -= 减法赋值（常用于递减）
a -= 5  # 等价于 a = a - 5 → a = 8
print(f"a -= 5 后：a = {a}")  # 输出：a -= 5 后：a = 8

# *= 乘法赋值（常用于连乘）
a *= b  # 等价于 a = a * b → a = 24
print(f"a *= b 后：a = {a}")  # 输出：a *= b 后：a = 24

# /= 除法赋值（结果总是浮点数）
a /= 4  # 等价于 a = a / 4 → a = 6.0
print(f"a /= 4 后：a = {a}")  # 输出：a /= 4 后：a = 6.0

# //= 整除赋值（结果向下取整）
a = 24  # 重置a的值
a //= b  # 等价于 a = a // b → a = 8（24 // 3 = 8）
print(f"a //= b 后：a = {a}")  # 输出：a //= b 后：a = 8

# %= 取余赋值（常用于周期计算）
a %= 5  # 等价于 a = a % 5 → a = 3（8 % 5 = 3）
print(f"a %= 5 后：a = {a}")  # 输出：a %= 5 后：a = 3

# **= 幂运算赋值（指数计算）
a **= 2  # 等价于 a = a ** 2 → a = 9（3的平方）
print(f"a **= 2 后：a = {a}")  # 输出：a **= 2 后：a = 9

# 字符串操作示例
text = "Hello"
text += " World"  # 字符串拼接
print(text)  # 输出：Hello World

# 列表操作示例
nums = [1, 2]
nums += [3, 4]  # 列表扩展
print(nums)  # 输出：[1, 2, 3, 4]

2.2 复合赋值的注意事项

复合赋值不是原子操作，在多线程环境下仍需加锁保护

对于可变对象（如列表），a += b和a = a + b可能表现不同：

lst1 = [1,2]
lst2 = lst1
lst1 += [3]  # 原地修改，lst1和lst2都变为[1,2,3]

lst1 = [1,2]
lst2 = lst1
lst1 = lst1 + [3]  # 创建新对象，lst1变为[1,2,3]，lst2仍为[1,2]

复合赋值的右边表达式会先求值：

x = 2
x *= 3 + 2  # 等价于 x = x * (3 + 2) = 10，不是 x = x * 3 + 2

3.复合赋值的优势：简洁性与效率

3.1 代码更简洁

对比普通赋值和复合赋值的写法：

# 普通赋值写法
count = count + 1
total = total * 2
remainder = remainder % 5

# 复合赋值写法（更简洁）
count += 1
total *= 2
remainder %= 5

复合赋值减少了变量的重复书写，尤其在以下场景优势更明显：

长变量名场景：

# 普通赋值
database_connection_retry_count = database_connection_retry_count + 1  
# 复合赋值（减少重复）
database_connection_retry_count += 1

嵌套属性访问：

class User:
    def __init__(self):
        self.stats = {'login_count': 0}

# 普通赋值
user.stats['login_count'] = user.stats['login_count'] + 1
# 复合赋值（更易读）
user.stats['login_count'] += 1

链式操作场景：

# 需要修改多个变量时
x = x * 2 + 5
y = y - x // 3
# 用复合赋值可以更紧凑地表达
x *= 2
x += 5
y -= x // 3

3.2 执行效率更高

在底层实现中，复合赋值通常比普通赋值更高效，原因如下：

普通赋值a = a + b的执行过程：

查找变量a的当前值（内存读取）
创建临时变量存储a + b的结果
查找a的内存地址
将结果写入a的内存地址

复合赋值a += b的执行优势：

对于可变对象（如列表），直接原地修改而不创建新对象
减少一次变量查找过程
更少的临时对象创建

性能对比测试（扩展版）：

import timeit

# 准备测试函数
def test_regular():
    a = 0
    for _ in range(1000):
        a = a + 1

def test_compound():
    a = 0
    for _ in range(1000):
        a += 1

# 执行时间测试
regular_time = timeit.timeit(test_regular, number=10000)
compound_time = timeit.timeit(test_compound, number=10000)

print(f"普通赋值平均耗时：{regular_time:.6f}秒")
print(f"复合赋值平均耗时：{compound_time:.6f}秒")
print(f"性能提升：{(regular_time - compound_time)/regular_time:.1%}")

典型输出结果：

普通赋值平均耗时：0.782415秒
复合赋值平均耗时：0.632187秒
性能提升：19.2%

实际应用场景中的效率优势：

数值计算密集型循环（如科学计算）
高频更新的计数器（如web请求统计）
游戏开发中的实时状态更新
大规模数据处理时的累加操作

注意：对于不可变对象（如整数、字符串），Python会创建新对象，但复合赋值仍然通过减少中间步骤来保持效率优势。

4.复合赋值的注意事项

4.1 与普通赋值的细微差别

对于不可变对象（如整数、字符串、元组），a += b与a = a + b功能完全等价；但对于可变对象（如列表），两者可能存在差异：

# 列表的普通赋值
lst1 = [1, 2, 3]
lst2 = lst1  # lst2与lst1指向同一列表
lst1 = lst1 + [4, 5]  # 创建新列表并赋值给lst1
print(lst1)  # [1, 2, 3, 4, 5]
print(lst2)  # [1, 2, 3]（lst2仍指向原列表）

# 列表的复合赋值
lst1 = [1, 2, 3]
lst2 = lst1
lst1 += [4, 5]  # 直接修改原列表（不创建新对象）
print(lst1)  # [1, 2, 3, 4, 5]
print(lst2)  # [1, 2, 3, 4, 5]（lst2也受影响）

深入分析：

对于不可变对象（如整数），两种写法都会创建新对象：

x = 5
y = x
x += 1  # 创建新整数6
print(x, y)  # 6 5（y不受影响）

对于可变对象（如列表）：
- +操作会调用__add__方法，总是返回新对象
- +=操作会调用__iadd__方法，就地修改对象（如果支持）
- 如果对象不支持__iadd__，则会退化为__add__+赋值

实际应用建议：

当需要保留原对象时，使用普通赋值+
当需要修改原对象时，使用复合赋值+=
在函数参数默认值等场景要特别注意这个区别

4.2 复合赋值的运算顺序

复合赋值表达式中，右边的表达式会先计算，再与左边变量进行运算：

a = 5
b = 3
a += b * 2  # 等价于 a = a + (b * 2) → 5 + 6 = 11
print(a)  # 输出：11

运算顺序详解：

复合赋值的优先级低于算术运算符：
- a *= b + c 等价于 a = a * (b + c)
- 不是 (a * b) + c

多个复合赋值的执行顺序：

x = y = 0
x += (y += 1)  # 报错！Python不允许这样链式赋值

与函数调用的结合：

def get_value():
    print("Calculating...")
    return 3

x = 5
x *= get_value()  # 先调用get_value()得到3，再计算5*3

实际编程建议：

复杂的表达式建议使用括号明确优先级
避免在复合赋值中嵌套其他赋值操作
多步运算建议拆分成多个语句提高可读性

5.实战案例：复合赋值的典型应用

案例1：计数器与累加器

在循环中统计次数或累加总和时，复合赋值是最常用的写法：

# 统计列表中偶数的个数并计算总和
numbers = [12, 5, 8, 23, 42, 17, 9, 36]
count = 0  # 计数器
total = 0  # 累加器

for num in numbers:
    if num % 2 == 0:
        count += 1  # 计数+1
        total += num  # 累加偶数

print(f"偶数个数：{count}")  # 输出：4
print(f"偶数总和：{total}")  # 输出：12 + 8 + 42 + 36 = 98

扩展应用场景：

计算移动平均值：

data = [2.5, 3.7, 4.2, 5.1, 3.9]
moving_avg = 0
for i, value in enumerate(data, 1):
    moving_avg += (value - moving_avg) / i

统计多个指标：

scores = [85, 92, 78, 90, 88]
sum_scores = sum_squares = 0
for score in scores:
    sum_scores += score
    sum_squares += score ** 2

多条件计数：

ages = [23, 17, 35, 42, 19, 28]
young = middle = senior = 0
for age in ages:
    if age < 20: young += 1
    elif age < 40: middle += 1
    else: senior += 1

案例2：实现倒计时功能

import time

# 实现10秒倒计时
seconds = 10
print("倒计时开始：")
while seconds > 0:
    print(seconds)
    seconds -= 1  # 每秒减1
    time.sleep(1)  # 暂停1秒
print("时间到！")

扩展应用：

进度指示器：

total = 100
current = 0
while current < total:
    current += 5  # 模拟进度更新
    print(f"进度: {current}%")
    time.sleep(0.5)

游戏生命值系统：

health = 100
damage = 10
while health > 0:
    print(f"生命值: {health}")
    health -= damage  # 受到伤害
    if health <= 0:
        print("游戏结束")

倒计时时钟：

minutes = 1
seconds = 30
while minutes >= 0 and seconds >= 0:
    print(f"{minutes:02d}:{seconds:02d}")
    if seconds == 0:
        minutes -= 1
        seconds = 59
    else:
        seconds -= 1
    time.sleep(1)

案例3：计算阶乘（使用*=）

# 计算n的阶乘（n! = 1×2×3×...×n）
n = 5
result = 1
for i in range(1, n+1):
    result *= i  # 等价于 result = result * i

print(f"{n}的阶乘是：{result}")  # 输出：5的阶乘是：120

扩展应用：

计算组合数：

def combination(n, k):
    numerator = 1
    for i in range(n, n-k, -1):
        numerator *= i
    denominator = 1
    for i in range(1, k+1):
        denominator *= i
    return numerator // denominator

计算指数泰勒展开：

def exp_taylor(x, terms=10):
    result = 1.0
    factorial = 1.0
    for n in range(1, terms):
        factorial *= n  # 计算n!
        result += x**n / factorial
    return result

累积计算：

# 计算1×3×5×...×(2n+1)
odd_product = 1
for i in range(1, 10, 2):  # 步长为2
    odd_product *= i

总结

赋值运算符是Python编程的基础工具，掌握简单赋值和复合赋值的用法能显著提升代码质量：

简单赋值=：基础的变量赋值方式，用于将表达式结果存储到变量中。
- 支持多重赋值：x = y = z = 0
- 支持序列解包：a, b = b, a（交换变量值）
复合赋值：+=、-=、*=等运算符将运算和赋值合并，使代码更简洁。
- 支持所有基本算术运算：+= -= *= /= //= %= **=
- 支持位运算：&= |= ^= <<= >>=
性能考量：
- 对于不可变对象，两种写法性能相当
- 对于可变对象，复合赋值通常更高效（避免创建临时对象）
- 在CPython中，复合赋值对应专门的字节码指令（如INPLACE_ADD）
最佳实践：
- 循环计数器必须使用复合赋值
- 数学运算优先使用复合赋值形式
- 复杂的表达式考虑可读性优先
- 注意共享引用问题（特别是列表等可变对象）
Pythonic风格：
- 避免i = i + 1这样的冗余写法
- 在列表操作中明确使用extend()或+=表达意图
- 利用复合赋值简化数学表达式