left/right 赋值运算符手边的不同切片行为

Question

作为C++出身的Python新手，Python(3.4.x)中的切片操作符让我觉得很可笑。我只是不明白 "special rule" 背后的设计理念。让我解释一下为什么我说它是 "special".

一方面，根据 Stack Overflow 的回答 here，切片运算符创建列表或部分列表的（深）副本，即一个新列表。 link 可能较旧（早于 python 3.4.x），但我只是通过以下使用 python 3.4.2 的简单实验确认了该行为：

words = ['cat', 'window', 'defenestrate']
newList = words[:] # new objects are created; a.k.a. deep copy
newList[0] = 'dog'

print(words) # ['cat' ...
print(newList) # ['dog' ...

另一方面，根据官方文档here：

Assignment to slices is also possible, and this can even change the size of the list or clear it entirely:
>>>

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters 
[]

很明显，切片运算符[:]这里并没有做深拷贝

根据观察，似乎表明切片运算符在 left/right 侧相对于赋值运算符产生不同的行为。我不知道操作员可以产生类似行为的任何语言。毕竟，运算符是一个函数，只是一个语法上特殊的函数，函数的行为应该是独立的，完全由它的所有输入决定。

那么 Python 设计理念中的 "special rule" 是什么？

P.S。如果我的结论不正确，那真的只有两种可能：

1、Python的切片'operator'其实不是运算符，所以我的假设不成立---那又是什么呢（'slicing operator'[:])?

2，行为的差异是由一些未观察到的潜在因素引起的。切片运算符的位置（left/right 手边）相对于赋值运算符意外地与不同行为的观察共存。他们没有因果关系---那么导致行为差异的潜在因素是什么？

Answer 1

Python 运算符最好被视为 "magic" 方法的语法糖；例如，x + y 被评估为 x.__add__(y)。以同样的方式：

foo = bar.baz 变为 foo = bar.__getattr__(baz)；而
bar.baz = foo 变为 bar.__setattr__(baz, foo)；

Python "slicing operator" * a[b] 被评估为：

a.__getitem__(b)；或
a.__setitem__(b, ...)；

取决于作业的哪一侧；这两个 并不完全 相同（另请参阅 How assignment works with python list slice）。写成"longhand"，因此：

>>> x = [1, 2, 3]
>>> x.__getitem__(slice(None))  # ... = x[:]
[1, 2, 3]
>>> x.__setitem__(slice(None), (4, 5, 6))  # x[:] = ...
>>> x
[4, 5, 6]

data model documentation explains these methods in more detail (e.g. __getitem__), and you can read the docs on slice也是。

注意切片是浅拷贝，不是深拷贝，如下所示：

>>> foo = [[], []]
>>> bar = foo[:]
>>> bar is foo
False  # outer list is new object
>>> bar[0] is foo[0]
True  # inner lists are same objects
>>> bar[0].append(1)
>>> foo
[[1], []]

* 好吧，不是 严格来说 而是 operator.

left/right 赋值运算符手边的不同切片行为

Different slicing behaviors on left/right hand side of assignment operator

python

python-3.x

operators

slice

deep-copy