目录
4）在py文件中，和作用域有关，如在同一个函数中的相同值的变量是相等的，即值相等，地址也相等
?
1、赋值
# 赋值包含多种赋值方式，一般赋值、元组赋值、序列赋值、解包赋值
a = "long"
b,c = "1",2
d,e,f,g = "long"
h,*i = "long"
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
print(g)
print(h)
print(i)long
1
2
l
o
n
g
l
['o', 'n', 'g']
当使用一个
*前缀变量的时候，表示将序列中对应的元素全部收集到一个列表中(注意，总是一个列表)，这个列表名为*开头的那个变量名。*号可以出现在任意位置处，只要赋值的时候能前后对应位置关系即可。注意其中的几个关键字：序列、对应的元素、列表
- 序列意味着可以是列表、元组、字符串等等
- 列表意味着只要收集不报错，赋值给解包变量的一定是一个列表
- 对应的元素意味着可能收集到0或任意个元素到列表。
不管如何，收集的结果总是列表，只不过可能是空列表或者只有一个元素的列表。
?
两个注意事项：
- 因为序列解包是根据元素位置来进行赋值的，所以不能出现多个解包变量
- 如果将序列直接赋值给单个解包变量时(即没有普通变量)，这个解包变量必须放在列表或元组中
a,*b,c,*d = L # 错误 *a = L # 错误 [*a] = L # 正确 (*a) = L # 正确
?2、赋值的分类——引用赋值、值赋值
引用赋值——指的是将内存地址赋值给变量来实现赋值
1) 不可变对象引用赋值——字符串、数值、元组等
a = 1000
b = a
a = 2000
前两行b=a是将1000的地址赋值给b，即a和b都是指向值1000的内存地址。第三行a=2000是对a重新进行赋值，因为数值是不可改变的对象，因此会先开辟一个内存地址用于存储2000，然后将a指向2000
不可变对象变量之间不会互相影响，即如果一开始两个变量指向同一个内存地址，当其中一个变量的值发生了改变的时候，另一个变量不会受到影响
对于不可变对象，修改变量的值意味着在内存中要新创建一个数据对象
a = 10000
b = a
a = 20000
>>> a,b
(20000, 10000)2）可变对象引用赋值——列表、集合、字典
对于可变对象，比如列表，它是在"原处修改"数据对象的(注意加了双引号)。比如修改列表中的某个元素，列表的地址不会变，还是原来的那个内存对象，所以称之为"原处修改"。例如：
L1 = [111,222,333]
L2 = L1
L1[1] = 2222
>>> L1,L2
([111, 2222, 333], [111, 2222, 333])L2是通过引用赋值得到的值，值为可变对象列表，当对L1改变一个列表元素时，其列表的地址不会发生改变，因此其L2的值也会发生相应的改变
在L1[1]赋值的前后，数据对象[111,222,333]的地址一直都没有改变，但是这个列表的第二个元素的值已经改变了。因为L1和L2都指向这个列表，所以L1修改第二个元素后，L2的值也相应地到影响。也就是说，L1和L2仍然是同一个列表对象[111,2222,333]。
结论是：对于可变对象，变量之间是相互影响的。
3）可变与不可变对象的引用赋值内部分析
可变对象和不可变对象的赋值形式虽然一样，但是修改数据时的过程不一样。
对于不可变对象，修改数据是直接在堆内存中新创建一个数据对象。如图：
对于可变对象，修改这个可变对象中的元素时，这个可变对象的地址不会改变，所以是"原处修改"的。但需要注意的是，这个被修改的元素可能是不可变对象，可能是可变对象，如果被修改的元素是不可变对象，就会创建一个新数据对象，并引用这个新数据对象，而原始的那个元素将等待垃圾回收器回收。
>>> L=[333,444,555]
>>> id(L),id(L[1])
(56583832, 55771984)
>>> L[1]=4444
>>> id(L),id(L[1])
(56583832, 55771952)
如图所示：
4）在py文件中，和作用域有关，如在同一个函数中的相同值的变量是相等的，即值相等，地址也相等
3、深拷贝与浅拷贝
1）深拷贝
完全创建一个新的数据对象，不会受到其他变量的元素值变化的影响
2)浅拷贝，只是拷贝了第一层的元素，若第一层的元素是可变对象，则引用的是可变对象的地址，因此还是会受到其他变量的影响
# 引用赋值——只是得到了地址
print("赋值----------------------")
L = [1,2,[3,4,5]]
L2 = L
print("修改元素前-----------")
print(L)
print(L2)
print("修改元素后-----------")
L[0] = 0
print(L)
print(L2)赋值----------------------
修改元素前-----------
[1, 2, [3, 4, 5]]
[1, 2, [3, 4, 5]]
修改元素后-----------
[0, 2, [3, 4, 5]]
[0, 2, [3, 4, 5]]?
print("浅拷贝------------------------")
print("浅拷贝1------------------------")
# 浅拷贝——只是拷贝了第一层的元素，若为不可变元素，则会重新为元素创建一个新的数据对象，若为可变数据对象，则只是拷贝了地址
L = [1,2,[3,4,5],6]
L1 = L.copy()
print("修改不可变对象的元素前-----------")
print(L)
print(L1)
print("修改不可变对象的元素后-----------")
L[0] = 0
print(L)
print(L1)
print("浅拷贝1------------------------")
L = [1,2,[3,4,5],6]
L1 = L.copy()
print("修改可变对象的元素前-----------")
print(L)
print(L1)
print("修改可变对象的元素后-----------")
L[2][0] = 0
print(L)
print(L1)
print("浅拷贝2------------------------")
L = [1,2,[3,4,5]]
L3 = L[:]
print("修改元素前-----------")
print(L)
print(L3)
print("修改元素后-----------")
L[0] = 0
L[2][0] = 0
print(L)
print(L3)?
浅拷贝------------------------
浅拷贝1------------------------
修改不可变对象的元素前-----------
[1, 2, [3, 4, 5], 6]
[1, 2, [3, 4, 5], 6]
修改不可变对象的元素后-----------
[0, 2, [3, 4, 5], 6]
[1, 2, [3, 4, 5], 6]
浅拷贝1------------------------
修改可变对象的元素前-----------
[1, 2, [3, 4, 5], 6]
[1, 2, [3, 4, 5], 6]
修改可变对象的元素后-----------
[1, 2, [0, 4, 5], 6]
[1, 2, [0, 4, 5], 6]
浅拷贝2------------------------
修改元素前-----------
[1, 2, [3, 4, 5]]
[1, 2, [3, 4, 5]]
修改元素后-----------
[0, 2, [0, 4, 5]]
[1, 2, [0, 4, 5]]
from copy import deepcopy
print("深拷贝------------------------")
L = [1,2,[3,4,5]]
L1 = deepcopy(L)
L[0] = 0
L[2][0] = 0
print(L)
print(L1)深拷贝------------------------
[0, 2, [0, 4, 5]]
[1, 2, [3, 4, 5]]
一般我们使用到的都是浅拷贝
4、循环——序列和非序列的循环中进行元素的修改
https://www.cnblogs.com/f-ck-need-u/p/10129317.html
1）列表进行原地修改时（L+=[val1,val2]）,进行后面的迭代时，进行迭代的是修改后的列表，因为for是一个迭代器，使用的是next，即通过索引进行的，因此列表原地修改会导致元素出现奇怪的现象
为了避免这种情况，我们对列表进行修改时，建议生成一个新的列表对象来进行存放
L = ['a','b','c','d','e']
## 原处修改列表，新元素f、g也会被迭代
for i in L:
if i in "de":
L += ["f", "g"]
print(i)
## 创建新列表，新元素f、g不会被迭代
for i in L:
if i in "de":
L = L + ["f", "g"]
print(i)这个for迭代器在迭代刚开始的时候，先找到L所指向的迭代对象，即内存中的[1,2,3,4]。如果迭代过程中如果L变成了一个集合，或另一个列表对象，for的迭代并不会收到影响。但如果是在原处修改这个列表，那么迭代将会收到影响，例如新增元素也会被迭代到。
这里通过列表索引来进行元素的遍历和修改即可避免上面的情况
2）迭代一个列表，迭代过程中删除一个列表元素。
L = ['a','b','c','d','e']
for i in L:
if i in "bc":
L.remove(i)
print(i)
print(L)
输出的结果将是：
b
['a', 'c', 'd', 'e']
这个for循环的本意是想删除b、c元素，但结果却只删除了b。通过结果可以发现，c根本就没有被for迭代。之所以会这样，是因为迭代到b的时候，满足if条件，然后删除了列表中的b元素。正因为删除操作，使得列表中b后面的元素整体前移一个位置，也就是c元素的索引位置变成了index=1，而index=1的元素已经被for迭代过(即元素b)，使得c幸运地逃过了for的迭代。
3）迭代的是字典或者集合时，虽然两者都是可变序列，但是时无序的，因此在迭代的过程中，是不允许字典或者集合发生改变的，否则会报错
D = {'a':1,
'b':2,
'c':3,
'd':4,
'e':5}
for i in D:
if i in "bc":
del D[i]
print(i)
print(D)
报错：
b
Traceback (most recent call last):
File "g:/pycode/lists.py", line 12, in <module>
for i in D:
RuntimeError: dictionary changed size during iteration
S = {'a','b','c','d','e'}
for i in S:
if i in "bc":
S.remove(i)
print(i)
print(S)
报错：
b
Traceback (most recent call last):
File "g:/pycode/lists.py", line 4, in <module>
for i in L:
RuntimeError: Set changed size during iteration
若想修改字典的话，我们可以复制一份数据对象作为副本，然后将副本进行迭代，将原来的字典或集合作为修改对象?
D = {'a':1,'b':2,'c':3,'d':4,'e':5}
for i in D.copy():
if i in "bc":
D.pop(i)
print(i)
print(D)
S = {'a','b','c','d','e'}
for i in S.copy():
if i in "bc":
S.remove(i)
print(i)
print(S)?注意：在进行可变对象数据对象的迭代与修改时，我们只需要将迭代对象和修改对象分开就不会出现上述的错误。