【Python学习】——语言风格（变量赋值、深浅拷贝、for循环陷阱）

目录

1、赋值

 2、赋值的分类——引用赋值、值赋值

1) 不可变对象引用赋值——字符串、数值、元组等

2）可变对象引用赋值——列表、集合、字典

3）可变与不可变对象的引用赋值内部分析

4）在py文件中，和作用域有关，如在同一个函数中的相同值的变量是相等的，即值相等，地址也相等

3、深拷贝与浅拷贝

4、循环——序列和非序列的循环中进行元素的修改

---

 

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或任意个元素到列表。

不管如何，收集的结果总是列表，只不过可能是空列表或者只有一个元素的列表。

 

两个注意事项：

1. 因为序列解包是根据元素位置来进行赋值的，所以不能出现多个解包变量
2. 如果将序列直接赋值给单个解包变量时(即没有普通变量)，这个解包变量必须放在列表或元组中

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)

 注意：在进行可变对象数据对象的迭代与修改时，我们只需要将迭代对象和修改对象分开就不会出现上述的错误。