python基础之数据类型操作补充,集合及其操作,深浅拷贝

内容概要： 数据类型操作补充 集合及其操作 深浅拷贝
1.基础数据类型补充
   1.1字符串的操作补充
li = ["李嘉诚", "麻花藤", "黄海峰", "刘嘉玲"]
s = "_".join(li)   # 添加后列表变成字符串
print(type(s),s)

li = "黄花大闺女"
s = "_".join(li) # 仍然是字符串
print(type(s),s)

    1.2列表的循环删除（for循环） 不能用for循环要删除的列表（tips：字典在循环过程中不允许增加和删除，可以对内容修改），因为删除元素会引起索引号位置发生变化，导致报错或者删除不完全
常用删除的方法有 1.创建另外一个新列表，并将要删除的值赋予新列表，循环新列表来删除对应旧列表的信息
new_lis = []
lis = ["李嘉诚", "麻花藤", "黄海峰", "刘嘉玲"]
for i in lis:
    if i.startswith("刘"):
        new_lis.append(i)
for el in new_lis:
    lis.remove(el)
print(lis)

2.也可用.pop来删除，但较麻烦不推荐
lis = ["李嘉诚", "麻花藤", "黄海峰", "刘嘉玲"]
for i in lis:   # 这样不行
    lis.pop()
print(lis)

for i in range (0,len(lis)):  #这样才可以，计算lis长度，利用计数弹出
    lis.pop()
print(lis)

3.fromkeys  主要形式：dict.fromkeys(iter， value)，把可迭代对象进行迭代。和后面的value组合成键值对，返回新字典
实例
dic = dict.fromkeys(["李嘉诚", "麻花藤"],["黄海峰"])
print(dic)

3.1 几个大坑
坑一
dic = {}
dic1 = dic.fromkeys(["李嘉诚", "麻花藤"],["黄海峰"])
print(dic)  #输出是个空字符{}，因为 fromkeys 是创建一个新列表，如果dic原本就存在，则此过程会忽略

坑二
dic1 = dict.fromkeys(["李嘉诚", "麻花藤"],["黄海峰"])
dic1["李嘉诚"].append("黄花菜")
print(dic1)   # 输出 {'李嘉诚': ['黄海峰', '黄花菜'], '麻花藤': ['黄海峰', '黄花菜']} 因为指向同一个列表

set 集合 特点：1.set内的元素是不可以改变，可HASH的 2.不可重复,无序

1.1 set内的元素是不可以改变，可HASH的
set1 = {'1','alex',2,True,[1,2,3]} # 报错
set2 = {'1','alex',2,True,{1:2}} # 报错
set3 = {'1','alex',2,True,(1,2,[2,3,4])} # 报错

1.2 不可重复,无序(很重要，可以用来去除重复项)
s = {"周杰伦", "周杰伦", "周星星"}
print(list(set(s)))  # 结果:{'周星星', '周杰伦'}

2.集合的操作
2.1增
s = {"周杰伦", "彭于晏", "周星星"}
s.add("尼古拉斯赵四")
print(s)

s = {"刘嘉玲", '关之琳', "王祖贤"}
s.update("麻花藤") # 迭代更更新
print(s)
s.update(["张曼玉", "李若彤","李若彤"])
print(s)

2.2 删
s = {"周杰伦", "彭于晏", "周星星"}
s.clear()
s.remove("彭于晏")
item = s.pop()   #随机弹出一个,每次运行结果都不一样。
print(item)
print(s)

2.3.改
# 集合因为没有索引，是无序的，不能直接修改，可采用先删除后添加的方式
s = {"周杰伦", "彭于晏", "周星星"}
s.remove("彭于晏")
s.add("尼古拉斯赵四")
print(s)

2.4 查 set是可迭代对象，可用For循环便利查询
for el in set:
print(set)

2.5 其他操作
s1 = {"刘能", "赵四", "皮长山"}
s2 = {"刘科长", "冯乡长", "皮长山"}

print(s1 & s2) # 交集
print(s1 | s2) # 并集
print(s1 - s2)  # 差集，得到第一个中单独存在的
print(s2 - s1)  # 差集，得到第二个中单独存在的
print(s1 ^ s2)   # 反并集，并集减去交集

s1 = {"刘能", "赵四"}
s2 = {"刘能", "赵四", "⽪皮⻓长⼭山"}
print(s1 > s2) # 超集，判断s1是否为s2的超集
print(s1 < s2) # 子集，判断s1是否为s2的子集

3.深浅拷贝

3.1 赋值
dic1 = {"id": 123, "name": "谢逊"}
dic2 = dic1
print(dic1)
print(dic2)

dic1['name'] = "范瑶"
print(dic1)
print(dic2)

结果:
{'id': 123, 'name': '谢逊'}
{'id': 123, 'name': '谢逊'}
{'id': 123, 'name': '范瑶'}
{'id': 123, 'name': '范瑶'}
总结：直接赋值. 其实是把内存地址交给变量量. 并不是复制⼀份内容. 所以.lst1的内存指向和lst2是⼀一样的. lst1改变了了, lst2也发⽣生了了改变

3.2 浅拷贝 只会拷贝第一层. 第⼆层的内容不会拷贝. 所以被称为浅拷⻉
lst1 = ["何炅", "杜海涛","周渝民", ["麻花藤", "马芸", "周笔畅"]]
lst2 = lst1.copy()
lst1.append("刘德华")
print(lst1)
print(lst2)
print(id(lst1), id(lst2))   # 改变lst第一层的元素，发现拷贝的列表不会改变，并且第一层的内存id也完全不一样
lst1[3].append("无敌是多么寂寞")
print(lst1)
print(lst2)
print(id(lst1[3]), id(lst2[3])) # 改变lst第2层的元素，发现拷贝的列表第二层一起改变，并且第2层的内存id也完全一样

3.3 深度拷贝. 把元素内部的元素完全进行拷贝复制. 不会产生一个改变另一个跟着改变的问题
import copy  # 引进拷贝
lst1 = ["何炅", "杜海涛","周渝民", ["麻花藤", "马芸", "周笔畅"]]
lst2 = copy.deepcopy(lst1)  # copy.deepcopy()  深度拷贝的表达形式
lst1.append("刘德华")
print(lst1)
print(lst2)
print(id(lst1), id(lst2))   # 改变lst第一层的元素，发现拷贝的列表不会改变，并且第一层的内存id也完全不一样
lst1[3].append("无敌是多么寂寞")
print(lst1)
print(lst2)
print(id(lst1[3]), id(lst2[3])) # 改变lst第2层的元素，发现拷贝的列表第二层也不会一起改变，并且第2层的内存id也完全不一样