Python——赋值语句

在Python的语法模型中：
【1】.一行的结束就是终止该行语句（没有分号）。

【2】.嵌套语句是代码块并且与实际的缩进相关（没有大括号）

注意：不应该在同一段Python代码中混合使用制表符和空格！！

=======================================================================================

赋值语句

运算	解释
spam='Spam'	基本形式
spam,ham = 'yum','YUM'	元组赋值运算（位置性）
[spam,ham]=['yum','YUM']	列表赋值运算（位置性）
a,b,c,d='spam'	序列赋值运算，通用性
a,b,c = [1,2,3]
a,*b = 'spam'	扩展的序列解包（Python3.0）
spam = ham = 'lunch'	多目标赋值运算
spams += 42	增强赋值运算（相当于spams = spams + 42）

-------------------------------------------------------------------------------------------------------------------------------------------------------

序列赋值

>>> nudge = 1
>>> wink =2
>>> A,B = nudge,wink
>>> A,B
(1, 2)
>>> [C,D] = [nudge,wink]
>>> C,D
(1, 2)

>>> nudge = 1
>>> wink =2
>>> nudge,wink = wink,nudge
>>> nudge,wink
(2, 1)

元组赋值语句可以得到Python中一个常用的编写代码的技巧。
因为语句执行时，Python会建立临时的元组，来存储右侧变量原始的值，分解赋值语句也是一种交换两变量的值，却不需要自行创建临时变量的方式：右侧的元组会自动记住先前的变量的值。

事实上，Python中原始的元组和列表赋值语句形式，最后已经被通用化，以接受右侧可以是任何类型的序列，只要长度相等即可。
你可以将含有一些值的元组赋值给含有一些变量的列表，字符串中的字符赋值给含有一些变量的元组。

>>> [a,b,c]=(1,2,3)
>>> a,c
(1, 3)
>>> (a,b,c)='ABC'
>>> a,c
('A', 'C')

-------------------------------------------------------------------------------------------------------------------------------------------------------

高级序列赋值语句模式

可以赋值嵌套序列，而Python会根据其情况分解其组成部分，就像预期的一样：

>>> string = 'SPAM'
>>> (a,b),c=string[:2],string[2:]
>>> a,b,c
('S', 'P', 'AM')

序列解包赋值语句也会产生另一种Python常见用法，也就是赋值一系列整数给一组变量。

>>> red,green,blue = range(3)
>>> red,blue
(0, 2)

另一个会看见元组赋值语句的地方就是，在循环中把序列分割为开头和剩余的两部分，如下：

>>> L=[1,2,3,4]
>>> while L:
	front,L = L[0],L[1:]
	print(front,L)

	
1 [2, 3, 4]
2 [3, 4]
3 [4]
4 []

-------------------------------------------------------------------------------------------------------------------------------------------------------
Python3.0中的扩展序列解包

一个带有单个星号的名称，可以在赋值目标中使用，以指定对于序列的一个更为通用的匹配——一个列表赋给了带星号的名称，该列表收集了序列中没有赋值给其他名称的所有项。对于前面示例中把序列划分为其“前面”和“剩余”部分的常用编码模式，这种方法特别方便。

扩展解包的实际应用：

a匹配序列中的第一项，b匹配剩下的内容：

>>> seq = [1,2,3,4]
>>> a,*b = seq
>>> a
1
>>> b
[2, 3, 4]

b匹配序列的最后一项，a匹配最后一项之前的所有内容：

>>> *a,b=seq
>>> a
[1, 2, 3]
>>> b
4

第一项和最后一项分别赋给了a和c，而b获取了二者之间的所有内容：

>>> a,*b,c = seq
>>> a,
(1,)
>>> b
[2, 3]
>>> c
4

更一般的，不管带星号的名称出现在哪里，包含该位置的每个未赋值名称的一个列表都将赋给它：

>>> a,b,*c = seq
>>> a
1
>>> b
2
>>> c
[3, 4]

和常规的序列赋值一样，扩展的序列解包语法对于任何序列类型都有效，而不只是对列表有效：

>>> a,*b = 'spam'
>>> a,b
('s', ['p', 'a', 'm'])

>>> a,*b,c = 'spam'
>>> a,b,c
('s', ['p', 'a'], 'm')

Python3.0有了这一扩展，我们处理前面一个小节最后一个例子的列表变得容易得多了：

>>> L=[1,2,3,4]
>>> while L:
	front,*L = L
	print(front,L)

	
1 [2, 3, 4]
2 [3, 4]
3 [4]
4 []

-------------------------------------------------------------------------------------------------------------------------------------------------------
边界情况

首先，带星号的名称可能只匹配单个的项，但是，总是会向其赋值一个列表：

>>> seq
[1, 2, 3, 4]
>>> a,b,c,*d = seq
>>> print(a,b,c,d)
1 2 3 [4]

其次，如果没有剩下的内容可以匹配带星号的名称，它会赋值一个空的列表，不顾该名称出现在哪里。

>>> a,b,c,d,*e = seq
>>> print(a,b,c,d,e)
1 2 3 4 []

最后，如果有多个带星号的名称，或者如果值少了而没有带星号的名称，以及如果带星号的名称自身没有编写到一个列表中，都会引起错误
-------------------------------------------------------------------------------------------------------------------------------------------------------

一个有用的便利形式：常用的“第一个，其余的”分片编码模式可以用扩展的解包来编写

应用于for循环：

for(a,*b,c) in [(1,2,3,4),(5,6,7,8)]:
...

当在这种环境中使用的时候，在每次迭代中，Python直接把下一个值得元组分配给名称的元组，例如，在第一次循环中，就好像我们运行如下的赋值语句：

a,*b,c = (1,2,3,4)  # b gets [2,3]

=======================================================================================
多目标赋值语句

多目标赋值语句就是直接把所有提供的变量名都赋值给右侧的对象：

>>> a = b = c = 'spam'
>>> a,b,c
('spam', 'spam', 'spam')
>>> a is b is c
True

其相当于三个赋值语句：

>>> a = 'spam'
>>> b =a
>>> c = a

-------------------------------------------------------------------------------------------------------------------------------------------------------
多目标赋值以及共享引用

记住，这里只有一个对象，由三个变量共享（全都指向内存内同一对象）。
这种行为对于不可变类型而言并没有问题，但对于可变对象，我们就要小心一点：

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

>>> a = b = []
>>> a.append('test')
>>> a,b
(['test'], ['test'])

上例中，因为a和b引用相同的对象，通过b在原处附加值上去，而我们通过a也会看见所有的效果。

=======================================================================================
增强赋值

x+=y
x*=y
x%=y
x&=y
x^=y
x<<=y
x-=y
x/=y
x**=y
x|=y
x>>=y
x//=y

优点：
1.程序员输入减少
2.左侧只需计算一次。在完整形式x = x+y中，x出现两次，必须执行两次。因此，增强赋值语句通常执行得更快。
3.优化技术会自动选择。对于支持在原处修改的对象而言，增强形式会自动执行原处的修改运算，而不是相比来说速度更慢的复制。