基础补充

对于元组，最少要两个元素，当括号内只有一个元素时，该元素为什么数据类型元组就为什么数据类型

a=('a')
b=('b',)
print(a,type(a))
print(b,type(b))
#输出：a <class 'str'>
           ('b',) <class 'tuple'>

对于list：按照索引去循环删除列表的时候，容易出错，因为每次循环删除后列表的元素索引会发生变化。为了避免这种情况，可以用以下方式来进行删除操作

#删除列表中的所有索引为奇数的元素，第一种用del切片删除
l1=[1,'a',2,'b',3,'c']
del l1[1::2]
print(l1)
#输出：[1, 2, 3]

#第二种方法倒序删除，因为倒序删除时不会影响前面还未操作的元素的索引，只会影响我们已经进行过删除操作的元素的索引。
l1 = [1, 'a', 2, 'b', 3, 'c']
for i in range( len(l1)-1, -1, -1):
    if i % 2 == 1:
        del l1[i]
print(l1)
#输出：[1, 2, 3]

list删除操作

对于字典，和list类似，再循环删除某些键值对时容易出错。

#fromkeys(可迭代对象，值)，把可迭代对象的每个元素作为键，对应听养的值
dic = dict.fromkeys('abc', 'sb')
print(dic)
dic1 = dict.fromkeys([1, 2, 3], [])
print(dic1)
dic1[1].append('abcd')       #这里所有的键对应的相同值是用统一内存地址的一个值，一变全变
print(dic1)
#输出：{'a': 'sb', 'b': 'sb', 'c': 'sb'}
           {1: [], 2: [], 3: []}
           {1: ['abcd'], 2: ['abcd'], 3: ['abcd']}     

#循环删除字典里含‘k’的键对应的键值对
dic={'k1':111,'k2':222,'k3':333,'k4':444,'aq':'ywaq'}
for i in dic:
    if 'k' in i:
        del dic[i]
print(dic)
#会报错，RuntimeError: dictionary changed size during iteration
dic={'k1':111,'k2':222,'k3':333,'k4':444,'aq':'ywaq'}
key=list(dic.keys())      #把键都放到key这个列表中
for i in key:
    if 'k' in i:
        del dic[i]              
print(dic)
#输出：{'aq': 'ywaq'}

字典补充

深浅copy

对于列表字典等可变数据类型来说，赋值操作就是把几个变量同时指向同一个内存地址的数据，如果在这个内存地址下的数据改变了，则这些变量的值会同时改变。以下以列表为例说明深浅copy的不同之处

#对列表和字典的赋值操作
#列表
l1 = [1, 2, 3, 4]
l2 = l1
print(l1, l2)
l1.append(555)
print(l1, l2)
#输出：[1, 2, 3, 4] [1, 2, 3, 4]
           [1, 2, 3, 4, 555] [1, 2, 3, 4, 555]

#字典
dic1={'k1':111,'k2':222}
dic2= dic1
print(dic1, dic2)
dic1['k5']=555
print(dic1, dic2)
#输出：{'k1': 111, 'k2': 222} {'k1': 111, 'k2': 222}
           {'k1': 111, 'k2': 222, 'k5': 555} {'k1': 111, 'k2': 222, 'k5': 555}

列表字典的赋值操作

浅copy不需要调用python的copy模块，深copy则需要

#列表浅copy是重新建了一个列表，这样和赋值不同，因为两个列表的内存地址不一样，互相独立
l1 = [1, 2, 3]
l2 = l1.copy()
print(l1, id(l1))
print(l2, id(l2))
#输出：[1, 2, 3] 1945901737160
           [1, 2, 3] 1945901737416

#改变其中一个列表，另外一个不变，可见他们是相互独立的
l1 = [1, 2, 3]
l2 = l1.copy()
l1.append(666)
print(l1, id(l1))
print(l2, id(l2))
#输出：[1, 2, 3, 666] 2542130177224
           [1, 2, 3] 2542130177480

#当列表嵌套时，以上规则只对列表第一层有用，而在列表的第二层同样和赋值一样，属于同一个内存地址的数据
l1 = [1,[22,33],2,3]
l2 = l1.copy()
print(l1[1],id(l1[1]))
print(l2[1],id(l2[1]))
#输出：[22, 33] 3064328627400
           [22, 33] 3064328627400

#当改变第二层的数据时，两个列表的第二层都改变
l1 = [1,[22,33],2,3]
l2 = l1.copy()
l1[1].append(666)
print(l1[1],id(l1[1]))
print(l2[1],id(l2[1]))
#输出：[22, 33, 666] 2331350803784
           [22, 33, 666] 2331350803784

浅copy

对于深copy来说，不管嵌套多少层，原列表和copy得到的列表之间都是互相独立的

#对于深copy来说，嵌套的第任意层也是相互独立的
import copy
l1 = [1,[22,33],2,3]
l2 = copy.deepcopy(l1)
# l1[1].append(666)
print(l1[1],id(l1[1]))
print(l2[1],id(l2[1]))
#输出：[22, 33] 1520409323208
           [22, 33] 1520409324616

#同时改变第一二层
import copy
l1 = [1,[22,33],2,3]
l2 = copy.deepcopy(l1)
l1.append(777)
l1[1].append(666)
print(l1)
print(l2)
#输出：[1, [22, 33, 666], 2, 3, 777]
           [1, [22, 33], 2, 3]

深copy

 

转载于:https://www.cnblogs.com/banjiang/p/8377944.html