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

 一 基础数据类型补充

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 两天的,考试太多了,也好 ,今天知道确实是之前自己没努力学,瞎看    而且后来还是复制的,没办法 我今天一定要把作业写出来。