尝试解决以下问题, 然后检查以下答案.
提示: 所有问题都有共同点, 因此在解决其余问题之前检查第一个问题的解决方案可以减轻挑战.
问题 1
假设我们有几个变量:
- x = 1
- y = 2
- l = [x, y]
- x += 5
- a = [1]
- b = [2]
- s = [a, b]
- a.append(5)
l 和 s 的打印结果是什么?
跳到解决方案
问题 2
让我们定义一个简单的函数:
- def f(x, s=set()):
- s.add(x) print(s)
如果您决定, 将会发生什么:
- >>f(7)
- >>f(6, {
- 4, 5
- })
- >>f(2)
- ?
跳到解决方案
问题 3
让我们定义两个简单的函数:
- def f():
- l = [1]
- def inner(x):
- l.append(x)
- return l
- return inner
- def g():
- y = 1
- def inner(x):
- y += x
- return y
- return inner
以下命令将产生什么结果?
- >>ff_inner = f()
- >>print(f_inner(2))
- >>gg_inner = g()
- >>print(g_inner(2))
跳到解决方案
您对自己的回答有多自信? 让我们看看您是否正确.
解决问题 1
- >>print(l)
- [1, 2]
- >>print(s)
- [[1, 5], [2]]
为什么第二个列表对第一个元素 a.append(5)的更改有反应, 但是第一个列表完全忽略 x + = 5 的类似变化?
解决问题 2
让我们看看发生了什么:
- >>f(7){
- 7
- }
- >>f(6, {
- 4, 5
- }){
- 4, 5, 6
- }
- >>f(2){
- 2, 7
- }
等待, 最后输出不是 {2} 吗?
解决问题 3
输出将是以下内容:
- >>ff_inner = f()
- >>print(f_inner(2))[1, 2]
- >>gg_inner = g()
- >>print(g_inner(2))
- UnboundLocalError: local variable 'y' referenced before assignment
为什么 g_inner(2)不输出 3? f()的内部函数如何记住其外部范围, 而 g()的内部函数却不记得呢? 它们实际上是相同的!
说明
如果我告诉您这些怪异的行为与 Python 中可变对象和不可变对象之间的区别有关怎么办?
诸如列表, 集合或字典之类的可变对象可以在适当位置进行更改 (变异). 不变的对象(如整数, 字符串和元组) 不能 - 此类对象的 "更改" 会导致创建新对象.
问题 1 的说明
- x = 1
- y = 2
- l = [x, y]
- x += 5
- a = [1]
- b = [2]
- s = [a, b]
- a.append(5)
- >>print(l)
- [1, 2]
- >>print(s)
- [[1, 5], [2]]
由于 x 是不可变的, 因此操作 x + = 5 不会更改原始对象, 而是创建一个新对象. 列表的第一个元素仍指向原始对象, 因此其值保持不变.
对于可变对象 a,a.append(5)更改原始对象, 因此 list s"看到" 更改.
问题 2 的解释
- def f(x, s=set()):
- s.add(x)
- print(s)
- >>f(7)
- {7}
- >>f(6, {4, 5})
- {4, 5, 6}
- >>f(2)
- {2, 7}
前两个输出完全有意义: 首先将值 7 添加到默认空集中, 得到 {7}, 然后将值 6 添加到一组{4,5} 中, 得到{4,5,6 }.
但是随后发生了一件奇怪的事情: 将值 2 添加到默认的空集而不是添加到 {7} 的集. 为什么? 可选参数 s 的默认值仅被评估一次 - 仅在第一次调用 s 期间将被初始化为空集. 由于 s 在调用 f(7)之后是可变的, 因此就地进行了修改. 第二个调用 f(6,{4,5})不会影响默认参数 - 提供的集合 {4,5} 将其遮蔽, 换句话说,{4,5}是一个不同的变量. 第三次调用 f(2)使用的是与第一次调用相同的 s 变量, 但是 s 未作为空集重新初始化 - 使用了其先前的值{7}.
这就是为什么您不应该使用可变的默认参数的原因. 在这种情况下, 应按以下方式修改功能:
- def f(x, s=None):
- if s is None:
- s = set()
- s.add(x)
- print(s)
问题 3 的解释
- def f():
- l = [1]
- def inner(x):
- l.append(x)
- return l
- return inner
- def g():
- y = 1
- def inner(x):
- y += x
- return y
- return inner
- >>ff_inner = f()
- >>print(f_inner(2))
- [1, 2]
- >>gg_inner = g()
- >>print(g_inner(2))
- UnboundLocalError: local variable 'y' referenced before assignment
在这个问题中, 我们处理闭包 - 内部函数记住定义时它们的封闭名称空间的外观. 或至少应该如此 - 第二个功能保持扑克面孔, 就像从未听说过其外部作用域一样.
这是为什么? 当我们执行 l.append(x)时, 在定义时创建的可变对象被修改, 但是变量 l 仍然指向内存中的相同地址. 但是, 尝试更改第二个函数 y + = x 中的不可变变量会导致 y 指向内存中与以前不同的地址 - 原始 y 将不再被记住, 因此导致 UnboundLocalError.
结论
Python 中可变对象与不可变对象之间的区别非常重要. 请注意这一点, 以避免出现本文所述的奇怪行为. 特别是:
不要使用可变的默认参数.
不要尝试在内部函数中更改不可变的闭包变量.
请随意分享其他示例, 这些示例可能是由于您在响应中误用了可变的和不变的对象而导致的潜在问题.
来源: http://developer.51cto.com/art/202006/618434.htm