python关于+=的陷阱

最新推荐文章于 2024-03-15 23:40:22 发布
原创 最新推荐文章于 2024-03-15 23:40:22 发布 · 391 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#1024程序员节

本文探讨了为何在Python中，尽管元组被视为不可变，但尝试修改其内部可变元素仍可能导致异常。通过实例和Python Tutor可视化，揭示了可变对象与元组结合的复杂性，以及增量赋值操作在元组中的非原子性。关键教训是避免在元组中包含可变元素。

看下面代码

t = (1, 2, [30, 40])
t[2] += [50, 60]

我们知道tuple元组是个不可变元素，所以更改元组的元素道理上是不行的，但是我改变的元素是个列表，它本身是可变的，这样可行吗？？

先别去控制台运行，猜是下面哪一种：

  1. t 变成 (1, 2, [30, 40, 50, 60])。
  2. 因为 tuple 不支持对它的元素赋值，所以会抛出 TypeError 异常。
  3. 以上两个都不是。
  4. a 和 b 都是对的。

\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\

\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
答案是第四种情况

我们使用Python Tutor（http://www.pythontutor.com）对执行代码进行可视化
在这里插入图片描述在这里插入图片描述
最后我们看看背后的字节码是怎么执行s[a] += b这种操作的
在这里插入图片描述到1是将 s[a] 的值存入 TOS（Top Of Stack，栈的顶端）
到2是计算 TOS += b。这一步能够完成，是因为 TOS 指向的是一个可变对象
到3是s[a] = TOS 赋值。这一步失败，是因为 s 是不可变的元组

所以才会出现即操作成功又报异常的现象

教训：

  1. 不要把可变对象放在元组里面
  2. 增量赋值不是一个原子操作（从字节码可以看出经过了若干步）
Python 3.8+ 海象运算符详解
The @MMiL algoDves & programming space
08-01 194
本文介绍了Python 3.8引入的海象运算符(:=)的使用方法和技巧。主要内容包括：基础概念和语法，在条件语句、循环、表达式复用中的基础用法；进阶应用如列表推导式过滤、避免重复调用函数、正则匹配复用等；使用时需注意的作用域规则、优先级陷阱等注意事项。海象运算符能有效减少冗余代码、简化嵌套逻辑，但需合理使用以保持代码可读性。典型应用场景包括条件检查、循环读取、推导式过滤和链式操作等。
整理了 Python新手 最容易犯错的 10个坑！
lsxxx2011的专栏
10-01 394
相比于其他语言，Python 的语法比较简单易学，但一旦不注意细节，刚入门的新手就会掉进语法错误的坑里。今天给大家讲几个平常比较容易掉的“坑”。1、忘记写冒号在if、elif、else...
python弱点-python易错盲点排查之+=与+的区别分析以及一些赋值运算踩过的坑
weixin_39616071的博客
11-11 133
问题1. int和list是不一样的>>> a=1>>> b=a>>> a+=1>>>a,b(2, 1)>>> a=[1,2,3,4]>>> b=a>>> a+=[5]>>>a,b([1, 2, 3, 4, 5], [1, 2, 3, 4, 5])通俗地讲，类型为int时，a和b是“不一样的”；类型为list时，a和b是“一样的”。术语叫做immutable和mutable，具体原理在这个节点不必...
python易错盲点排查之+=与+的区别分析以及一些赋值运算踩过的坑
weixin_34161083的博客
03-08 94
问题1. int和list是不一样的 >>> a=1 >>> b=a >>> a+=1 >>> a,b (2, 1) >>> a=[1,2,3,4] >>> b=a >>> a+=[5] >>> a,b (...
踩过的python坑
wonengguwozai的博客
06-02 1090
1、python中一些内置函数是没有返回值的，所以不能return 函数调用。如 return list_a.append（a）,函数返回值为None而不是append 后的list_a！ 2、对list删除元素时，如果时连续删除元素不能用pop(index)函数（考虑使用remove(val)）！原因是pop(i)函数执行完后，索引 i 后面的元素均依次前移，对应地索引值均依次减一，所以在程序...
Python中的+=问题
Yuudachi的博客
07-28 1521
面试题 — += += 运算符相对于整型或者字符串类型都是先相加再赋值（修改引用） 在python中，列表变量调用 += 本质上是在执行列表变量的 extend 方法，不会修改变量的引用 def demo(num, num_list): print("函数内部代码") # num = num + num num += num # num_list.extend(num_lis...
python中+=表示什么意思
03-24
然后，引用[1]提到Python没有++操作符，这里可能需要澄清用户是否混淆了+=和++，但用户的问题明确是关于+=的，所以暂时不用深入。不过可以提到+=用于自增操作，比如n +=1代替n++。 引用[3]中的例子涉及复合赋值和...
shell中+=的陷阱
weixin_43726471的博客
10-14 1670
这两天因为工作比较忙，没有更新Python相关的学习，但是工作中因为装环境开发给了一个安装依赖包的文档，里面都是重复的后台安装命令，而且环境一来就是三台虚机，1条命令就要重复执行3次，所以想着趁此机会练练shell脚本（之前有写过，有点基础但是这个东西不用就会忘记） 今天写脚本遇到的问题： 在实现我的需求时，需要用到数据类型字典，我是这样定义的： declare -A dic dic=() dic=dic+([name]=jack) echo ${!dic[@]} echo ${dic[@]} 返回结果是
++，+=这两个符号什么意思怎么用
最新发布
09-10
- 引用[3]则讨论了Python中的+和+=运算符，特别指出它们在可变与不可变类型上的不同行为。 考虑到用户上次的问题是关于快速排序的代码实现，这次转向运算符使用，我需要确保回答适用于通用编程场景，同时突出不同...
+=怎么理解
04-03
+= 是一个复合赋值运算符，常见于很多编程语言，比如Python、Java、C++等。我需要先解释它的基本作用：将左边的变量与右边的值相加，然后把结果重新赋给左边的变量。例如，x += 5 就相当于 x = x + 5。 接下来，...
Python小记——一个关于+=的谜题
Jia ming 的日常学习笔记
10-24 363
In [11]: t = (1, 2, [30, 40]) In [12]: t[2] += [50, 60] ------------------------------------------------------------ TypeError Traceback (most recent call last) <ipython-input-12-...
python语言入门t_python之入门篇
weixin_30316287的博客
02-04 1232
1.， 连接符，返回的是多个值，返回逗号两边的值+ 连接符，返回一个值2.print 后面的值必须先定义再调用3.‘‘‘....‘‘‘ 代表多行表示字符串，省略\n4.r 表示后面的内容是字符串，省去\的转义5.u(u必须紧靠语句) 对字符串进行Unicode编码# -*- coding: utf-8...
Python中tuple+=赋值的四个问题
一苇以航
09-04 691
转自：http://shomy.top/2017/08/17/python-tuple-assign/ 最近偶尔翻看Fluent Python，遇到有意思的东西就记下来. 下面的是在PyCon2013上提出的一个关于tuple的Augmented Assignment也就是增量赋值的一个问题。 并且基于此问题, 又引申出3个变种问题. 问题 首先看第一个问题, 如下面的代码段: 1 2 >>> t = (1...
Python中+=运算踩坑小记
weixin_46606785的博客
03-15 1090
+=是原地修改
关于 Python 元组的不可变属性特例
藕丝空间
06-15 1493
元组可以被看做为不可变列表，也就是说元组的里的元素是不能随意改变的。但是，元组是可以接受一个可变对象——列表作为元素的。这会产生一些意想不到的边界效果。摘自《流畅的 Python》第 2.6 章节。 1 一个谜题 定义一个接受可变对象——列表作为元素的元组，然后利用切片操作列表对象。 &gt;&gt;&gt; t = (1, 2 ,[ 30, 40]) &gt;&gt;&gt...
python 一个关于+=的 谜题
qq_15407209的博客
10-14 310
Leonardo Rochael 在 2013 年的 Python 巴西会议上提到这个谜题。 t 变成 (1, 2, [30, 40, 50, 60])。 同时因为 tuple 不支持对它的元素赋值，所以会抛出 TypeError 异常。 t[2] 被改动了，但是也有异常抛出。 如果写成 t[2].extend([50, 60]) 就能避免这个异常 可视化分析 查看其字节码 从中我们能学习到 ...
python中+=是什么意思_python中+=连用是什么意思
weixin_39801714的博客
11-21 4802
对可变类型来说，我们可以在原地对变量进行修改，也就是说它的存储空间是可读可写的，例如 list；而对于不可变类型来说，它的存储空间则是只读的，无法对其进行修改，如果需要对不可变类型进行某些操作来得到新的结果，则需要重新开辟一份存储空间来存放这个新产生的结果。对于可变类型：+=代表追加操作，即 in-place 操作，在原地把另一个对象的内容追加到对象中。对于不可变类型：+=代表连接或求和操作，其操...
【Python学习日记】20220401
weixin_43579997的博客
04-01 1618
1. python中+=的意思： ①两个值相加，返回值给符号左侧的变量，比如 意思就是 c = c + 1；输出的c就是3； 2.Python的运算符 ①算术运算符 Python算数运算符包括：+、-、*、**、/、//、% +：　　加法运算 -：　　减法运算 *：　　乘法运算 **： 幂运算 /: 　　除法运算（如果有小数则返回结果为小数，如果都为整数则返回结果为整数） //： 整除，取整数部分 %：　 取余 ②关系运算符 Python关系运算符包括...
Python手记：+ 和 += 的区别
垃圾管理员的垃圾站
01-24 2354
内容目录序一、“+”的执行过程二、“+=”的执行过程1.引入库2.读入数据总结 序 在学习过程中，我们被告知以下两种书写方式的效果是一样的： a = a + b a += b 然而，此处的效果相同仅是运算结果的相同，并不代表两句代码的执行过程相同。 一、“+”的执行过程 我们知道，Python中一切皆为对象（不是“找”的那个，是new的那个）。 “+”运算符怎样执行，取决于“+”之前数据的类型。如果是“1+2”，则会执行整数对象的__add__方法。 如果是“ ‘abc’ + ‘def’ ”，则会调用
python的+=
07-24
<think>我们被要求解释Python中`+=`运算符的工作原理及使用示例。根据引用[1]和引用[3]，我们知道`+=`是加法赋值运算符，它等价于`c = c + a`，但有一些细节需要注意。 ### 一、基本工作原理 `+=`运算符是Python中的一种**复合赋值运算符**，它将右侧操作数的值加到左侧操作数上，并将结果重新赋值给左侧操作数。其基本形式为： ```python a += b ``` 这等价于： ```python a = a + b ``` ### 二、关键特性 1. **对不可变对象**：当操作不可变对象（如整数、字符串、元组）时，`a += b`会创建一个新对象，并将变量`a`重新绑定到这个新对象上[^4]。 2. **对可变对象**：当操作可变对象（如列表）时，`a += b`会就地修改对象，而不会创建新对象。这意味着原始对象的内容会被改变，且变量`a`仍然绑定到同一个对象[^4]。 ### 三、使用示例 #### 示例1：整数（不可变对象） ```python a = 5 print(id(a)) # 输出a的初始内存地址 a += 3 print(a) # 输出: 8 print(id(a)) # 内存地址改变，说明创建了新对象 ``` #### 示例2：列表（可变对象） ```python lst = [1, 2, 3] print(id(lst)) # 输出列表的初始内存地址 lst += [4, 5] # 等价于lst.extend([4,5]) print(lst) # 输出: [1, 2, 3, 4, 5] print(id(lst)) # 内存地址不变，说明是原地修改 ``` #### 示例3：字符串（不可变对象） ```python s = "Hello" print(id(s)) s += " World" # 创建新字符串 print(s) # 输出: "Hello World" print(id(s)) # 内存地址改变 ``` ### 四、与`+`运算符的区别 - 对于可变对象（如列表），`a = a + b`会创建一个新列表，而`a += b`会就地修改原列表[^4]。 - 示例对比： ```python # 使用 + 运算符 lst1 = [1, 2] lst2 = lst1 lst1 = lst1 + [3] # 创建新列表 print(lst1) # [1, 2, 3] print(lst2) # [1, 2] (lst2未改变) # 使用 += 运算符 lst1 = [1, 2] lst2 = lst1 lst1 += [3] # 就地修改 print(lst1) # [1, 2, 3] print(lst2) # [1, 2, 3] (lst2也随之改变) ``` ### 五、注意事项 1. **不可变对象的重新绑定**：由于不可变对象在修改时会创建新对象，因此使用`+=`可能会导致性能问题（如大量字符串拼接时）。推荐使用`str.join()`方法替代多次`+=`操作字符串[^5]。 2. **可变对象的副作用**：由于`+=`会就地修改可变对象，可能会意外影响其他引用该对象的变量（如上例中的`lst2`）。 3. **运算符重载**：自定义类可以通过实现`__iadd__`方法来自定义`+=`的行为。如果未实现`__iadd__`，则回退到`__add__`方法。 ### 六、性能优化建议 - 字符串拼接：使用`str.join()`代替循环中的`+=` ```python # 不推荐 s = "" for i in range(10000): s += str(i) # 推荐 s = ''.join(str(i) for i in range(10000)) ``` - 列表扩展：使用`list.extend()`或`+=`（两者等效）代替`+`运算符，避免不必要的复制。 ### 总结 | 特性 | 不可变对象 (int, str, tuple等) | 可变对象 (list, dict等) | |-------------------|---------------------------------------|----------------------------------| | `a += b` 的效果 | 创建新对象，变量重新绑定 | 就地修改对象 | | 内存地址变化 | 改变 | 不变 | | 对其他引用的影响 | 无影响（新对象） | 有影响（原对象被修改） | 通过理解这些特性，可以避免在Python编程中因误用`+=`而导致的常见错误。 §§相关问题§§ 1. Python中其他复合赋值运算符（如`-=`、`*=`）的行为是否与`+=`一致？ 2. 如何为自定义类实现`+=`运算符？ 3. 为什么在循环中使用`+=`拼接字符串会导致性能问题？ 4. Python中`is`运算符和`==`运算符在比较`+=`操作结果时有何不同？</think>在 Python 中，`+=` 运算符是**复合赋值运算符**（也称为增强赋值运算符），它结合了加法运算和赋值操作。理解它的工作原理对于编写高效、正确的 Python 代码至关重要。 ### 一、基本工作原理 `a += b` 等价于 `a = a + b`，但执行过程有重要区别： 1. **对不可变对象**（如整数、字符串、元组）： - 创建新对象 - 将新对象赋值给左侧变量 - 原始对象不变 ```python a = 5 print(id(a)) # 输出内存地址1 a += 3 # 等价于 a = a + 3 print(a) # 输出: 8 print(id(a)) # 输出新内存地址（与之前不同）[^4] ``` 2. **对可变对象**（如列表、字典）： - 直接修改原对象（就地操作） - 不创建新对象 ```python lst = [1, 2] print(id(lst)) # 输出内存地址1 lst += [3, 4] # 等价于 lst.extend([3,4]) print(lst) # 输出: [1, 2, 3, 4] print(id(lst)) # 内存地址不变（与之前相同）[^4] ``` ### 二、与普通加法`+`的关键区别 | 特性 | `a = a + b` | `a += b` | |------------------|------------------------|------------------------| | 对象创建 | 总是创建新对象 | 可变对象不创建新对象 | | 内存地址 | 总是改变 | 可变对象地址不变 | | 执行效率 | 较低（需复制对象） | 较高（就地修改） | | 副作用 | 无 | 影响其他引用该对象的变量 | **示例对比**： ```python # 使用 + 运算符 lst1 = [1, 2] lst2 = lst1 lst1 = lst1 + [3] # 创建新列表 print(lst1) # [1, 2, 3] print(lst2) # [1, 2]（未改变） # 使用 += 运算符 lst1 = [1, 2] lst2 = lst1 lst1 += [3] # 就地修改 print(lst1) # [1, 2, 3] print(lst2) # [1, 2, 3]（随之改变！） ``` ### 三、不同类型的使用示例 1. **数值类型**： ```python count = 10 count += 5 # 等价于 count = count + 5 print(count) # 输出: 15 ``` 2. **字符串拼接**： ```python s = "Hello" s += " World!" # 创建新字符串对象 print(s) # 输出: "Hello World!" [^5] ``` 3. **列表扩展**（高效方式）： ```python items = [1, 2] items += [3, 4] # 比 items = items + [3,4] 高效 print(items) # 输出: [1, 2, 3, 4] ``` 4. **自定义类**（需实现`__iadd__`方法）： ```python class Counter: def __init__(self, value): self.value = value def __iadd__(self, other): self.value += other return self # 必须返回自身 c = Counter(10) c += 5 print(c.value) # 输出: 15 ``` ### 四、注意事项 1. **不可变对象的陷阱**： ```python t = (1, 2) t += (3,) # 实际创建新元组 (1, 2, 3) ``` 2. **与`is`运算符的关系**： ```python a = [1, 2] b = a a += [3] # 就地修改 print(a is b) # 输出: True（仍是同一对象）[^2] ``` 3. **性能优化**： - 对于列表操作：`list += iterable` 比 `list = list + iterable` 快约30% - 对于字符串：避免在循环中使用 `+=`（会创建多个临时对象），改用 `str.join()` ### 五、与其他运算符的对比 | 运算符 | 等价形式 | 示例 | 结果 | |--------|--------------|---------------|-------| | `+=` | `a = a + b` | `a=5; a+=3` | 8 | | `-=` | `a = a - b` | `a=5; a-=2` | 3 | | `*=` | `a = a * b` | `a=3; a*=4` | 12 | | `/=` | `a = a / b` | `a=10; a/=2` | 5.0 | | `%=` | `a = a % b` | `a=10; a%=3` | 1 | | `**=` | `a = a ** b` | `a=2; a**=3` | 8 | | `//=` | `a = a // b` | `a=10; a//=3` | 3 [^3] 理解 `+=` 运算符的行为差异（特别是对可变/不可变对象的处理）可以帮助避免常见的编程错误，如意外修改共享对象或产生性能瓶颈。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值