这两天放在 一起没什么特别的，就是之前懒了，也不算是懒吧，这编程学习的难度比我想的大多了

 一 基础数据类型补充

li=【‘元素1’，‘元素2’，’元素3‘】

s=‘_’。join（li）

print（s）              一个字节等于8位 byte    一个字符看情况等于几个字节 字符是人能看懂的

在每一个元素中间加下划线      就一个元素的话就在每个字符下面加下划线        

2 列表循环删除每一个元素

li=【‘元素1’，‘元素2’，‘元素3’】

for i in li：

    li。remove（i）

for 在运行的时候，一直是往后一个数的，删除一个 后面的跟上，就插进来了，删除不掉，也可以看是隔一个删一个

把想删除的打印到一个列表里 再删除列表

活着循环range，0，len（变量） 然后pop（）默认删除最后一个 这样从最后一个开始删除一点一点删除  尽量不要按索引删除 可以吧要删除的元素集中在一个新的列表中，否则删除影响原列表的位置


dic = dict.fromkeys(["jay", "JJ"], ["周杰伦", "麻花藤"])

print(dic)                                       这里面第一个列表每一项都会作为key，后面的列表，两个一起做值，


dic = dict.fromkeys(["jay", "JJ"], ["周杰伦", "麻花藤"])          print(dic)

dic.get("jay").append("胡⼤大")            print(dic)                                因为他俩共享一个值  所以前面的变后面的也变

结果:
{'jay': ['周杰伦', '麻花藤', '胡⼤大'], 'JJ': ['周杰伦', '麻花藤', '胡⼤大']}

dic在循环的时候不允许删除也不允许增加，改变size就不可以        只能创建一个新的列表，再循环列表删除

 

类型转换:
元组 => 列列表 list(tuple)列列表 => 元组 tuple(list)

list=>str str.join(list) str=>list str.split()    

list 变str list里不能是纯数字，要是好几个字符串，加入东西的话必须是2个以上元素才能加， 而字符串中间加东西 是把每一个字符拆开

转换成False的数据: 0,'',None,[],(),{},set() ==> False

 

set集合

set 简单理解为dic类型，但不保存值     只保存key set元素必须是可哈希的 但set本身不可哈希   set 是可变的        不可变的现在有字符串，数字int，元组

set集合是不重复，无序的，如果列表里有重复的 打印出来的默认去重   根据内存地址  ID

变量=原变量类型（set（变量））   去重

添加也是   变量。app（）

               变量。update（）    迭代添加 把里面 的每个元素都分字符拆开，然后在里面 这个是随机添加，分开的每个字符都是字符串

这个 update 和之前的dic一样也可以s  和s1 那个 s.undate（s2）
打印 s就改变了 s1不变

s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟玉", "李李若彤"} item = s.pop() # 随机弹出⼀一个.
print(s)                   pop都有一个返回值， 这个的话item相当于一个变量吧，pop会把他删除的值返回到item里
print(item)                           可能是因为随机排序，所以也是随机删除吧  正常是删除最后一个

s.remove("关之琳") # 直接删除元素
# s.remove("⻢马⻁虎疼") # 不不存在这个元素. 删除会报错print(s)  

s.clear() # 清空set集合.需要注意的是set集合如果是空的. 打印出来是set() 因为要和dict区分的.
print(s) # set()         这个打印出的是（）区分一下字典


# set集合中的数据没有索引. 也没有办法去定位⼀一个元素. 所以没有办法进⾏行行直接修改. # 我们可以采⽤用先删除后添加的⽅方式来完成修改操作
s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟玉", "李李若彤"}
# 把刘嘉玲改成赵本⼭山

s.remove("刘嘉玲") s.add("赵本⼭山")print(s)                          这个还是因为是无序的事，   基本操作都差不多，就是考虑一下随机的事

不能用pop pop后面加的是索引，这个无序没索引

del s【】 这样报错 不知道为什么 也没什么方法 替换了

 

查询的话也就只能for循环了

for el in s:

print(el)           无序的不然怎么循环   循环出来的也是无序的


s1 = {"刘能", "赵四", "⽪皮⻓长⼭山"}
s2 = {"刘科⻓长", "冯乡⻓长", "⽪皮⻓长⼭山"}

# 交集
# 两个集合中的共有元素
print(s1 & s2) # {'⽪皮⻓长⼭山'}print(s1.intersection(s2)) # {'⽪皮⻓长⼭山'}        

    一些其他常规操作，交集啊  并集，差集，反交集


print(s1 | s2) # {'刘科⻓长', '冯乡⻓长', '赵四', '⽪皮⻓长⼭山', '刘能'}print(s1.union(s2)) # {'刘科⻓长', '冯乡⻓长', '赵四', '⽪皮⻓长⼭山', '刘能'}

这个并集感觉和前文的 update 列表 差不多，up是迭代添加 如果只是字符串就会变成，每个字符一个字符串加进去

并集也去重

# 差集
print(s1 - s2) # {'赵四', '刘能'} 得到第⼀一个中单独存在的print(s1.difference(s2)) # {'赵四', '刘能'} 第一个减去和第二个相同的地方打印出第一个

# 反交集
print(s1 ^ s2) # 两个集合中单独存在的数据 {'冯乡⻓长', '刘能', '刘科⻓长', '赵四'}print(s1.symmetric_difference(s2)) # {'冯乡⻓长', '刘能', '刘科⻓长', '赵四'}

子集和超集

s1 = {"刘能", "赵四"}
s2 = {"刘能", "赵四", "⽪皮⻓长⼭山"}

# ⼦子集
print(s1 < s2) # set1是set2的⼦子集吗? Trueprint(s1.issubset(s2))

# 超集
print(s1 > s2) # set1是set2的超集吗? Falseprint(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, {'id': 123, {'id': 123, {'id': 123,

'name': '谢逊'} 'name': '谢逊'} 'name': '范瑶'} 'name': '范瑶'}

对于list, set, dict来说, 直接赋值. 其实是把内存地址交给变量量. 并不是复制⼀一份内容. 所以. lst1的内存指向和lst2是⼀一样的. lst1改变了了, lst2也发⽣生了了改变

浅拷⻉贝

lst1 = ["何炅", "杜海海涛","周渝⺠民"] lst2 = lst1.copy() lst1.append("李李嘉诚")print(lst1)

print(lst2)
print(id(lst1), id(lst2))

lst2 = lst1[:] # 浅拷贝                浅拷贝分两种， 一种是写copy的lst2=lst1s.copy()

结果:
两个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

都不⼀一样了了. 深度拷⻉贝. 把元素内部的元素完全进⾏行行拷⻉贝复制. 不会产⽣生⼀一个改变另⼀一个跟着 改变的问题

其实说了这么多 就是觉得浅拷贝就是随前面的变，深拷贝就是自己是自己了，不管他怎么变了。

本来想弄一下7 8 两天的，考试太多了，也好 ，今天知道确实是之前自己没努力学，瞎看    而且后来还是复制的，没办法 我今天一定要把作业写出来。