基础数据类型补充 set集合 深浅拷贝

一.基础数据类型补充

　　1. "拼接字符串".join(可迭代对象)

　　可迭代对象为列表时,输出列表元素与拼接字符串的拼接

li = ['张三', '李四', '王五', '赵四']
s = '_'.join(li)
print(s)
输出:张三_李四_王五_赵四

　　可迭代对象为字符串时,输出单个字符与拼接字符串的拼接

li = 'asdfgh'
s = '_'.join(li)
print(s)
输出:a_s_d_f_g_h

　　2.列表与字典的删除补充

　　列表和字典在迭代过程中无法进行删除操作,需要把删除的内容记录在新列表中,然后循环新列表,删除字典或列表

li = [11, 22, 33, 44]
for e in li:
    li.remove(e)
print(li)
输出:[22, 44]   #列表语法删除彻底

　　可以循环生成一个新列表,通过循环新列表找到旧列表对应的元素,进行一一删除.

li = [11, 22, 33, 44]
new_li = []
for e in li:
    new_li.append(e)
for i in new_li:
    li.remove(i)
print(li)
输出:[]

　　通过循环索引从后向前删除

li = [11, 22, 33, 44]
for i in range(len(li)):
    li.pop()
print(li)
输出:[]

　　注意: 由于删除元素会导致元素的索引改变, 所以容易出现问题. 尽量不要在循环中直接去删除元素. 可以把要删除的元素添加到另⼀个集合中然后再批量删除

　　字典的删除

dic = {'k1': 'v1', 'k2': 'v2', 's1': 's1'}
del_dic = []
for i in dic:
    if 'k' in i:
        del_dic.append(i)
for n in del_dic:
    dic.pop(n)
print(dic)
输出:{'s1': 's1'}

　　字典的fromkey()   生成一个新字典

dic = dict.fromkeys(['jay', 'jj'], ['周杰伦', '林俊杰'])
print(dic)
输出:{'jay': ['周杰伦', '林俊杰'], 'jj': ['周杰伦', '林俊杰']}

　　前面的列表中的每一个元素作为新字典的key,后面列表整体作为新字典的value

dic = dict.fromkeys(['jay', 'jj'], ['周杰伦', '林俊杰'])
print(dic)
dic.get('jay').append('小马')
print(dic)
输出:
{'jay': ['周杰伦', '林俊杰'], 'jj': ['周杰伦', '林俊杰']}
{'jay': ['周杰伦', '林俊杰', '小马'], 'jj': ['周杰伦', '林俊杰', '小马']}

　　注意:代码中只是更改了jay那个列表.由于jay和jj用的是同一个value列表.所以,前面的改变后面的也会跟着改变

　　类型转换

　　元组 => 列表　　list(tuple)

　　列表 => 元组　　tuple(list)

　　list => str　　str.join(list)

　　str => list　　str.split()

　　转换成False

　　0,'',None,[],(),{},se() ==> False

二.set集合

　　1.特点:

　　　　　　无序,不重复,元素必须是可哈希的(不可变的)   (不可变的可哈希.    可变的不可哈希)

集合本身是可变的数据类型,不可哈希,有增删查改操作

　　2.作用:

　　　　　　去重复

li = [123, 321, 345, 564, 465, 345]
s = set(li)
print(s)
n = list(s)
print(n)
输出:

{321, 465, 564, 345, 123}
[321, 465, 564, 345, 123]

　　增加:

　　　　add()    update()

s = {123, 432, 'sdf'}　　
s.add('jffj')　　　　　　　#添加,不能添加重复的内容
print(s)
s.update('周杰伦')　　　　　#迭代更新
print(s)
输出:

{432, 'jffj', 123, 'sdf'}
{'jffj', 'sdf', '伦', '周', 432, '杰', 123}

　　删除:

　　　　pop()       remove()      clear()

s = {'jffj', 'sdf', '伦', '周', 432, '杰', 123}
s.pop()　　　　　　　　　　#随机删除一个
print(s)
s.remove('周')　　　　　　#直接删除元素
print(s)
s.clear()　　　　　　　　　#清空set集合　
print(s)
输出:

{'杰', 'jffj', 'sdf', 432, '周', 123}
{'杰', 'jffj', 'sdf', 432, 123}
set()

　　修改:

　　　　set集合是无序的,没有索引,不能直接修改,只能通过先删除后添加的方式完成修改操作.

s = {'jffj', 'sdf', '伦', '周', 432, '杰', 123}
s.remove('周')　　　　　　#移除'周'
s.add('马')　　　　　　　　#添加'马'
print(s)
输出:{'马', 123, '杰', 432, 'sdf', '伦', 'jffj'}

　　查询:

　　　　set集合是一个可迭代的对象,可以进行for循环查询

s = {'jffj', 'sdf', '伦', '周', 432, '杰', 123}
for i in s:
    print(i)
输出:

杰
123
432
jffj
伦
周
sdf

三. 深浅拷贝

　　1. 直接赋值    没有创建新对象,共用同一个对象

lst1 = ["⾦金金⽑毛狮王", "紫衫⻰龙王", "⽩白眉鹰王", "⻘青翼蝠王"]
lst2 = lst1
print(lst1)
print(lst2)
lst1.append("杨逍")
print(lst1)
print(lst2)
输出:

['⾦金金⽑毛狮王', '紫衫⻰龙王', '⽩白眉鹰王', '⻘青翼蝠王']
['⾦金金⽑毛狮王', '紫衫⻰龙王', '⽩白眉鹰王', '⻘青翼蝠王']
['⾦金金⽑毛狮王', '紫衫⻰龙王', '⽩白眉鹰王', '⻘青翼蝠王', '杨逍']
['⾦金金⽑毛狮王', '紫衫⻰龙王', '⽩白眉鹰王', '⻘青翼蝠王', '杨逍']

　　对于list,dict,set来说,直接赋值,就是把内存地址交给变量,并不是复制一份.所以lst1和lst2的内存指向是一样的,lst1改变了,lst2也会跟着改变.

浅拷贝:    拷贝第一层列表内容,共用内层列表内容. 切片[:]或copy()

　　　　　例:lst1 = ['金毛狮王', '紫衫龙王', '青翼蝠王', '白眉鹰王', ['张无忌', '赵敏', '周芷若']]

　　　　　　　　lst2 = lst1[:]

　　　　　　　　

#第一层添加元素
lst1 = ["金毛狮王", "紫衫龙王", "青翼蝠王", "白眉鹰王",["张无忌","赵敏","周芷若"]]
lst2 = lst1[:]　　　　　　　　　#拷贝第一层内容,列表lst2与lst1的列表['张无忌', '赵敏', '周芷若']的内存地址是同一个
lst1.append('小昭')　　　　　　#在lst1中添加元素
print(lst1)
print(lst2)
print(id(lst1))
print(id(lst2))
输出:　　　　　　　　　　　　　　#只拷贝第一层内容,lst1添加元素lst2不会发生改变

['金毛狮王', '紫衫龙王', '青翼蝠王', '白眉鹰王', ['张无忌', '赵敏', '周芷若'], '小昭']
['金毛狮王', '紫衫龙王', '青翼蝠王', '白眉鹰王', ['张无忌', '赵敏', '周芷若']]
82725424
83085232

　　

#在内层添加元素
lst1 = ["金毛狮王", "紫衫龙王", "青翼蝠王", "白眉鹰王",["张无忌","赵敏","周芷若"]]
lst2 = lst1[:]　　　　　　　　　　#列表lst2与lst1的列表['张无忌', '赵敏', '周芷若']的内存地址是同一个

lst1[4].append('小昭')　　　　　#在内层列表中添加元素 print(lst1) print(lst2) print(id(lst1)) print(id(lst2))
输出:　    #只拷贝第一层,共用第二层列表内容内存地址,lst1第二层列表元素改变,lst2跟着改变.

['金毛狮王', '紫衫龙王', '青翼蝠王', '白眉鹰王', ['张无忌', '赵敏', '周芷若', '小昭']]
['金毛狮王', '紫衫龙王', '青翼蝠王', '白眉鹰王', ['张无忌', '赵敏', '周芷若', '小昭']]
52513328
52873176

　　

深拷贝:把元素内部的元素也拷贝,改变原列表,(字典,集合)新列表(字典,集合)数据不会跟着改变

import copy　　　　　　　　　　　　　　　#深度拷贝,需要导入copy模块
lst1 = ["金毛狮王", "紫衫龙王", "青翼蝠王", "白眉鹰王",["张无忌","赵敏","周芷若"]]
lst2 = copy.deepcopy(lst1)　　　　　　#深度拷贝lst1,列表lst2与lst1的列表['张无忌', '赵敏', '周芷若']的内存地址不同

lst1[4].append('小昭')　　　　　　　　　#对lst1中的第二层列表添加元素 print(lst1) print(lst2) print(id(lst1)) print(id(lst2))
输出:　　　　　　　　　　　　　　#深度拷贝,改变lst1内第二层列表元素,lst2不会发生改变

['金毛狮王', '紫衫龙王', '青翼蝠王', '白眉鹰王', ['张无忌', '赵敏', '周芷若', '小昭']]
['金毛狮王', '紫衫龙王', '青翼蝠王', '白眉鹰王', ['张无忌', '赵敏', '周芷若']]
88552112
88554232