python学习-赋值语句

出自：https://blog.csdn.net/gavin_john/article/details/49906095

在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）

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

序列赋值

[python]  view plain  copy

1. >>> nudge = 1  
2. >>> wink =2  
3. >>> A,B = nudge,wink  
4. >>> A,B  
5. (1, 2)  
6. >>> [C,D] = [nudge,wink]  
7. >>> C,D  
8. (1, 2)  

[python]  view plain  copy

1. >>> nudge = 1  
2. >>> wink =2  
3. >>> nudge,wink = wink,nudge  
4. >>> nudge,wink  
5. (2, 1)  

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

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

[python]  view plain  copy

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

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

高级序列赋值语句模式

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

[python]  view plain  copy

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

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

[python]  view plain  copy

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

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

[python]  view plain  copy

1. >>> L=[1,2,3,4]  
2. >>> while L:  
3.     front,L = L[0],L[1:]  
4.     print(front,L)  
5.   
6.       
7. 1 [2, 3, 4]  
8. 2 [3, 4]  
9. 3 [4]  
10. 4 []  

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

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

扩展解包的实际应用：

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

[python]  view plain  copy

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

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

[python]  view plain  copy

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

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

[python]  view plain  copy

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

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

[python]  view plain  copy

1. >>> a,b,*c = seq  
2. >>> a  
3. 1  
4. >>> b  
5. 2  
6. >>> c  
7. [3, 4]  

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

[python]  view plain  copy

1. >>> a,*b = 'spam'  
2. >>> a,b  
3. ('s', ['p', 'a', 'm'])  

[python]  view plain  copy

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

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

[python]  view plain  copy

1. >>> L=[1,2,3,4]  
2. >>> while L:  
3.     front,*L = L  
4.     print(front,L)  
5.   
6.       
7. 1 [2, 3, 4]  
8. 2 [3, 4]  
9. 3 [4]  
10. 4 []  

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

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

[python]  view plain  copy

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

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

[python]  view plain  copy

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

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

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

应用于for循环：

[python]  view plain  copy

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

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

[python]  view plain  copy

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

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

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

[python]  view plain  copy

1. >>> a = b = c = 'spam'  
2. >>> a,b,c  
3. ('spam', 'spam', 'spam')  
4. >>> a is b is c  
5. True  

其相当于三个赋值语句：

[python]  view plain  copy

1. >>> a = 'spam'  
2. >>> b =a  
3. >>> c = a  

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

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

[python]  view plain  copy

1. >>> a = b = 0  
2. >>> a += 1  
3. >>> a,b  
4. (1, 0)  

[python]  view plain  copy

1. >>> a = b = []  
2. >>> a.append('test')  
3. >>> a,b  
4. (['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.优化技术会自动选择。对于支持在原处修改的对象而言，增强形式会自动执行原处的修改运算，而不是相比来说速度更慢的复制。