07.py

07. 万恶之源-set集合,深浅拷⻉以及部分知识点补充 本节主要内容:

1. 基础数据类型补充

2. set集合

3. 深浅拷⻉ 主要内容

: ⼀. 基础数据类型补充 ⾸先关于int和str在之前的学习中已经讲了80%以上了. 所以剩下的⾃⼰看⼀看就可以了. 我们补充给⼀个字符串基本操作 li = ["李嘉诚", "麻花藤", "⻩海峰", "刘嘉玲"] s = "_".join(li) print(s) li = "⻩花⼤闺⼥" s = "_".join(li) print(s) 列表: 循环删除列表中的每⼀个元素 li = [11, 22, 33, 44] for e in li: li.remove(e) print(li)

结果: [22, 44] 分析原因: for的运⾏过程. 会有⼀个指针来记录当前循环的元素是哪⼀个, ⼀开始这个指针指向第0 个. 然后获取到第0个元素. 紧接着删除第0个. 这个时候. 原来是第⼀个的元素会⾃动的变成 第0个. 然后指针向后移动⼀次, 指向1元素. 这时原来的1已经变成了0, 也就不会被删除了. ⽤pop删除试试看: li = [11, 22, 33, 44] for i in range(0, len(li)): del li[i] print(li) 结果: 报错 # i= 0, 1, 2 删除的时候li[0] 被删除之后. 后⾯⼀个就变成了第0个. # 以此类推. 当i = 2的时候. list中只有⼀个元素. 但是这个时候删除的是第2个 肯定报错啊 经过分析发现. 循环删除都不⾏. 不论是⽤del还是⽤remove. 都不能实现. 那么pop呢? for el in li: li.pop() # pop也不⾏ print(li) 结果: [11, 22] 只有这样才是可以的: for i in range(0, len(li)): # 循环len(li)次, 然后从后往前删除 li.pop() print(li) 或者. ⽤另⼀个列表来记录你要删除的内容. 然后循环删除 li = [11, 22, 33, 44] del_li = [] for e in li: del_li.append(e) for e in del_li: li.remove(e) print(li) 注意: 由于删除元素会导致元素的索引改变, 所以容易出现问题. 尽量不要再循环中直接去删 除元素. 可以把要删除的元素添加到另⼀个集合中然后再批量删除. dict中的fromkey(),可以帮我们通过list来创建⼀个dict dic = dict.fromkeys(["jay", "JJ"], ["周杰伦", "麻花藤"]) print(dic) 结果: {'jay': ['周杰伦', '麻花藤'], 'JJ': ['周杰伦', '麻花藤']} 前⾯列表中的每⼀项都会作为key, 后⾯列表中的内容作为value. ⽣成dict 好了. 注意: dic = dict.fromkeys(["jay", "JJ"], ["周杰伦", "麻花藤"]) print(dic) dic.get("jay").append("胡⼤") print(dic) 结果: {'jay': ['周杰伦', '麻花藤', '胡⼤'], 'JJ': ['周杰伦', '麻花藤', '胡⼤']} 代码中只是更改了jay那个列表. 但是由于jay和JJ⽤的是同⼀个列表. 所以. 前⾯那个改了. 后 ⾯那个也会跟着改 dict中的元素在迭代过程中是不允许进⾏删除的 dic = {'k1': 'alex', 'k2': 'wusir', 's1': '⾦⽼板'} # 删除key中带有'k'的元素 for k in dic: if 'k' in k: del dic[k] # dictionary changed size during iteration, 在循环迭 代的时候不允许进⾏删除操作 print(dic) 那怎么办呢? 把要删除的元素暂时先保存在⼀个list中, 然后循环list, 再删除 dic = {'k1': 'alex', 'k2': 'wusir', 's1': '⾦⽼板'} dic_del_list = [] # 删除key中带有'k'的元素 for k in dic: if 'k' in k: dic_del_list.append(k) for el in dic_del_list: del dic[el] print(dic) 类型转换: 元组 => 列表 list(tuple) 列表 => 元组 tuple(list) list=>str str.join(list) str=>list str.split() 转换成False的数据: 0,'',None,[],(),{},set() ==> False ⼆. set集合 set集合是python的⼀个基本数据类型. ⼀般不是很常⽤. set中的元素是不重复的.⽆序的.⾥ ⾯的元素必须是可hash的(int, str, tuple,bool), 我们可以这样来记. set就是dict类型的数据但 是不保存value, 只保存key. set也⽤{}表⽰ 注意: set集合中的元素必须是可hash的, 但是set本⾝是不可hash得. set是可变的. 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])} # 报错 set中的元素是不重复的, 且⽆序的. s = {"周杰伦", "周杰伦", "周星星"} print(s) 结果: {'周星星', '周杰伦'} 使⽤这个特性.我们可以使⽤set来去掉重复 # 给list去重复 lst = [45, 5, "哈哈", 45, '哈哈', 50] lst = list(set(lst)) # 把list转换成set, 然后再转换回list print(lst) set集合增删改查 1. 增加 s = {"刘嘉玲", '关之琳', "王祖贤"} s.add("郑裕玲") print(s) s.add("郑裕玲") # 重复的内容不会被添加到set集合中 print(s) s = {"刘嘉玲", '关之琳', "王祖贤"} s.update("麻花藤") # 迭代更新 print(s) s.update(["张曼⽟", "李若彤","李若彤"]) print(s) 2. 删除 s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"} item = s.pop() # 随机弹出⼀个. print(s) print(item) s.remove("关之琳") # 直接删除元素 # s.remove("⻢⻁疼") # 不存在这个元素. 删除会报错 print(s) s.clear() # 清空set集合.需要注意的是set集合如果是空的. 打印出来是set() 因为要和 dict区分的. print(s) # set() 3. 修改 # set集合中的数据没有索引. 也没有办法去定位⼀个元素. 所以没有办法进⾏直接修改. # 我们可以采⽤先删除后添加的⽅式来完成修改操作 s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"} # 把刘嘉玲改成赵本⼭ s.remove("刘嘉玲") s.add("赵本⼭") print(s) 4. 查询 # set是⼀个可迭代对象. 所以可以进⾏for循环 for el in s: print(el) 5. 常⽤操作 s1 = {"刘能", "赵四", "⽪⻓⼭"} s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"} # 交集 # 两个集合中的共有元素 print(s1 & s2) # {'⽪⻓⼭'} print(s1.intersection(s2)) # {'⽪⻓⼭'} # 并集 print(s1 | s2) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'} print(s1.union(s2)) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'} # 差集 print(s1 - s2) # {'赵四', '刘能'} 得到第⼀个中单独存在的 print(s1.difference(s2)) # {'赵四', '刘能'} # 反交集 print(s1 ^ s2) # 两个集合中单独存在的数据 {'冯乡⻓', '刘能', '刘科⻓', '赵四'} print(s1.symmetric_difference(s2)) # {'冯乡⻓', '刘能', '刘科⻓', '赵四'} s1 = {"刘能", "赵四"} s2 = {"刘能", "赵四", "⽪⻓⼭"} # ⼦集 print(s1 < s2) # set1是set2的⼦集吗? True print(s1.issubset(s2)) # 超集 print(s1 > s2) # set1是set2的超集吗? False print(s1.issuperset(s2)) set集合本⾝是可以发⽣改变的. 是不可hash的. 我们可以使⽤frozenset来保存数据. frozenset是不可变的. 也就是⼀个可哈希的数据类型 s = frozenset(["赵本⼭", "刘能", "⽪⻓⼭", "⻓跪"]) dic = {s:'123'} # 可以正常使⽤了 print(dic) 这个不是很常⽤. 了解⼀下就可以了 三. 深浅拷⻉ lst1 = ["⾦⽑狮王", "紫衫⻰王", "⽩眉鹰王", "⻘翼蝠王"] lst2 = lst1 print(lst1) print(lst2) lst1.append("杨逍") print(lst1) print(lst2) 结果: ['⾦⽑狮王', '紫衫⻰王', '⽩眉鹰王', '⻘翼蝠王', '杨逍'] ['⾦⽑狮王', '紫衫⻰王', '⽩眉鹰王', '⻘翼蝠王', '杨逍'] 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': '范瑶'} 对于list, set, dict来说, 直接赋值. 其实是把内存地址交给变量. 并不是复制⼀份内容. 所以. lst1的内存指向和lst2是⼀样的. lst1改变了, lst2也发⽣了改变 浅拷⻉ lst1 = ["何炅", "杜海涛","周渝⺠"] lst2 = lst1.copy() lst1.append("李嘉诚") print(lst1) print(lst2) print(id(lst1), id(lst2)) 结果: 两个lst完全不⼀样. 内存地址和内容也不⼀样. 发现实现了内存的拷⻉ lst1 = ["何炅", "杜海涛","周渝⺠", ["麻花藤", "⻢芸", "周笔畅"]] lst2 = lst1.copy() lst1[3].append("⽆敌是多磨寂寞") print(lst1) print(lst2) print(id(lst1[3]), id(lst2[3])) 结果: ['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅', '⽆敌是多磨寂寞']] ['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅', '⽆敌是多磨寂寞']] 4417248328 4417248328 浅拷⻉. 只会拷⻉第⼀层. 第⼆层的内容不会拷⻉. 所以被称为浅拷⻉ 深拷⻉ import copy lst1 = ["何炅", "杜海涛","周渝⺠", ["麻花藤", "⻢芸", "周笔畅"]] lst2 = copy.deepcopy(lst1) lst1[3].append("⽆敌是多磨寂寞") print(lst1) print(lst2) print(id(lst1[3]), id(lst2[3])) 结果: ['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅', '⽆敌是多磨寂寞']] ['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅']] 4447221448 4447233800 都不⼀样了. 深度拷⻉. 把元素内部的元素完全进⾏拷⻉复制. 不会产⽣⼀个改变另⼀个跟着 改变的问题 补充⼀个知识点

 

一. 昨日内容回顾
    1. id() 内置函数. 查看变量的内存地址
    2. == 和 is的区别
        == 两端的内容是否一致
        is 两端的内存地址是否一致
    3. 编码
        encode(编码格式) 编码之后的结果是 bytes  b''
        decode(编码格式) 解码, 把bytes变回字符串
        用什么编码就用什么解码

二. 作业讲解

三. 今日主要内容
    1. 补充基础数据类型的相关知识点
        1. str. join() 把列表变成字符串
        2. 列表不能再循环的时候删除. 因为索引会跟着改变
        3. 字典也不能直接循环删除.
            把要删除的内容记录在列表中. 循环列表. 删除原列表, 字典中的数据
        4. fromkeys() 不会对原来的字典产生影响. 产生新字典(神坑, 考试)
        5. set集合. 不重复, 无序.
        6. 想转换成什么.就用什么括起来
        7. 深浅拷贝
            1. 直接赋值. 两个变量指向同一个对象.
            2. 浅拷贝:只拷贝第一层内容. copy()
            3. 深度拷贝: 对象中的所有内容都会被拷贝一份
                import copy
                copy.deepcopy()

 s = "abc"
# s1 = s.join("非常可乐") # 把字符串s插入到"非常可乐"中
# print(s1)

# s = "tx".join("sb")
# print(s)

# s = "_".join(["alex", "wuse", "taibai", "ritian"])  # join可以把列表变成字符串, 把字符串变成列表.split()
# print(s)

s = "sb".join(["王者荣耀", "LOL", "跑跑卡丁车"])
print(s)

# lst = ["我不是药神", "西游记", "西红柿首富", "天龙八部"]
#
# # lst.clear()
# # list在循环的时候不能删. 因为会改变索引
# del_lst = []
# for el in lst:
#     del_lst.append(el)  # 记录下来要删除的内容
#
# for el in del_lst:  # 循环记录的内容
#     lst.remove(el)  # 删除原来的内容
# print(lst)

# lst = ["周杰伦", "周润发", "周星星", "马化腾", "周树人"]
# 删除掉姓周的人的信息
# del_lst = []
# for el in lst:
#     if el.startswith("周"):
#         del_lst.append(el)
#
# for el in del_lst:
#     lst.remove(el)
# print(lst)

# 字典也不能在循环的时候更改大小
# dic = {"a":"123", "b":"456"}
# for k in dic:
#     dic.setdefault("c", "123")

# a = dict.fromkeys(["jj", 'jay', 'taibai'], "sb")  # 静态方法


# dic = {"a":"123"}
# s = dic.fromkeys("王健林", "思聪" ) # 返回给你一个新字典
# print(s)

# s = set() # 空集合
# dic = dict()
# s = str()
# i = int()
# lst = list()
# print(i)

# s = {"王者荣耀", "英雄联盟", "王者荣耀", 123, True, True}
# print(s)
# s = {123, {1,2,3}}    # 不合法
# print(s)

# lst = ["张强", "李强", "王磊", "刘伟", "张伟", "张伟", "刘洋", "刘洋"]
# s = set(lst)    # 去重复
# print(s)
#
# # 变回来
# lst = list(s)
# print(lst)


# 冻结了的set集合. 可哈希的. 不可变
# s = frozenset([1, 3, 6, 6, 9, 8])   # 可以去重复. 也是set集合
# print(s)
#
# ss = {"a", s}
# print(ss)

# lst1 = ["金毛狮王", "紫衫龙王", "白眉鹰王", "青衣服往"]
# lst2 = lst1 # 列表, 进行赋值操作. 实际上是引用内存地址的赋值. 内存中此时只有一个列表. 两个变量指向一个列表
#
# lst2.append("杨做事")  # 对期中的一个进行操作. 两个都跟着变
# print(lst2)
# print(lst1)


# 浅拷贝 copy 创建新对象
# lst1 = ["赵本山", "刘能", "赵四"]
# # lst2 = lst1.copy()  # lst2 和lst1 不是一个对象了
# lst2 = lst1[:]  # 切片会产生新的对象
# lst1.append("谢大脚")
# print(lst1, lst2)
# # print(id(lst1), id(lst2))


# lst1 = ["超人", "七龙珠", "葫芦娃", "山中小猎人", ["金城武", "王力宏", "渣渣辉"]]
# lst2 = lst1.copy()  # 拷贝. 浅拷贝 拷贝第一层
#
# lst1[4].append("大阳哥")
#
# print(lst1, lst2)
# 深拷贝

import copy
lst1 = ["超人", "七龙珠", "葫芦娃", "山中小猎人", ["金城武", "王力宏", "渣渣辉"]]
lst2 = copy.deepcopy(lst1)  # 把lst1扔进去进行深度拷贝 , 包括内部的所有内容进行拷贝
lst1[4].append("大阳哥")
print(lst1, lst2)

# 为什么要有深浅拷贝
# 拷贝比创建对象的过程要快