集合和基础类型的填坑以及深浅拷贝

s2_day1

一、集合

关键字 : set 是不可哈希的(可变的),也是无序的(没有索引)，集合内的元素​必须是可哈希的(不可变得)。

定义是 s = {}    #当里面没有元素的时候​​表现为字典数据类型         

方法:

增:

.add(元素)​​​       #随记添加在集合的某个位置

.update()         #迭代添加

删:

.pop() #随机删除 ,有返回值,删除什么返回什么元素

.clear() #清空集合

del set #删除整个集合​​

.​​remove(元素)​ #删除指定的元素

改:​

只能先用remove()把要改的元素删了,在把需要的元素添加进去​​

集合的特性:

集合是可以天然去重​​​​! 

#面试题:1,lis = [1,2,1,2,1,25,1,5,6,9,8,115,226,11,22,11,22]​用一行代码去重？

    print(list(set(lis)))​       

#将列表转换为集合去重,然后在换回列表即可

集合的其他操作:

& 和 intersectiion   #取两个集合的交集 没有交集就返回空集合

|​                             #取两个集合的并集,合并两个集合

s - s1                     #取后面相对于前面的补集​​ 

s ^ s1                     #反交集,取两个集合不重合的元素​​

s < s1                    #判断s是不是s1的子集

s1 > s                    #判断s1是不是s的父集

.frozenset():           #将集合冻住，即变成不可变得数据（可哈希）

a = frozenset({1,2,3,4})​​​​​​​ #将集合冻住,变成不可变得数据,即可以当字典的键​

dic[a :1]

print(dicup)

 

二、二次编码

 ascii码不支持中文

 unicode 万国码 中文四个字节 英文两个字节​

 utf-8 最少使用一个字节,欧洲两个字节,亚洲三个字节

 gbk 中文两个字节,英文一个字节​

a = '你好黑'

a . encode('gbk')   #编码​​​ 括号里放编码方式,将其变为什么编码

a.decode(''gbk')    #解码 ,必须用同一种编码方式

注意：用什么编码就用什么解码

#在国内windows系统默认使用gbk编码方式

#bytes 字节 是一个数据类型 是用来存储和传输

三、基础补充

#1.用for循环将列表清空 (错误方式)

lst = [1,2,3,4,5]

for i in lst:   #这种问题是for循环的循环机制导致的,这个是当for要循环的数据为空时,他就停止循环

lst.remove(i)    #这样子删除不行,循环删除是位置上的值,当这个位置删除过

print(lst)       #了,下次再循环就不会再删除这个位置了

#2.正确方式

lst = [1,2,3,4,5]

for i in range(len(lst)):   #通过for实现循环次数，但是并不参与删除操作

lst.pop(0)     #默认删除最后一个，可以规避掉for的循环机制

print(lst)

 

lst = [1,2,3,4,5]           

lst1 = []                          #通过另建一个新表

for i in lst: 

　　lst1.append(i)                #使用另一个列表来规避掉for的循环机制

for k in lst1:

　　lst.remove(k)

　　print(lst)

 

#字典在for循环中是不能进行删除的，但是可以用方法规避在原字典使用for循环

dic = {'a':1,'b':2}

dic1 = {}                       #通过建立一个新的字典

for i in dic:

　　dic1[i] = dic[i]             #规避for的循环机制

for i in dic1:

　　dic.pop(i)

　　print(dic)



dic = dict.fromkeys(['alex','wusir'],[]'太白','姗姗')    # 第一个是键,第二是

dic['alex'].append('老村长')                             # 值,这个方法快速大量的建立很多值是一样的键值
                                                        对,他们用的值是一样的,所有的内存地址是一样的

print(dic)

 

四、深浅拷贝

注意只有使用了  .deepcopy方法才能进行深度拷贝!　　

import copy

lst = copy.deepcopy(lst1)

 

 

浅拷贝: 拷贝的是第一层,将第一层的内容复制,第二级元素却公用一个内存地址，既将第一层没有第二层元素的元素复制到新的地址，有第二层元素的第一层元素还是共用的。

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]))
结果:
['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅', '⽆敌是多磨寂寞']]
['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅', '⽆敌是多磨寂寞']

 

深拷贝: 彻底拷贝,拷贝完之后两个内容完全不一样,内存地址也不一样​，就是说拷贝完之后的数据与原数据没有一点关系。

 

import copy
lst1 = ["何炅", "杜海涛","周渝⺠", ["麻花藤", "⻢芸", "周笔畅"]]
lst2 = copy.deepcopy(lst1)
lst1[3].append("⽆敌是多磨寂寞")
print(lst1)
print(lst2)
print(id(lst1[3]), id(lst2[3]))
结果:
['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅', '⽆敌是多磨寂寞']]
['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅']]
4447221448 4447233800
都不⼀样了.

 

 

 

#面试题: ​​写出下面的结果

a = [1,2]

a[1] = a

print(a[1])​​ 输出是: [1, [...]]

四,课堂随笔

#集合
'''
s = {}                                  #空的{}代表空的字典,而不是集合
print(type(s))
'''
s = {1,2,3,4,5,6,7,8,9}
#添加
s.add('a')                                    #添加指定元素
s.update('alex')                            #添加可迭代元素
#删除
s.remove(1)                                  #删除指定元素
s.pop()                                      #随机删除 删除什么返回什么
s.clear()                                     #清空集合
print(s)                                      #字典自动去重

#基础补充
#1.用for循环将列表清空 (错误方式)
'''
lst = [1,2,3,4,5]
for i in lst:                 #问题是for循环的循环机制导致的,这个是当for要循环的数据为空时,他就停止循环
    lst.remove(i)              #这样子删除不行,循环删除是位置上的值,当这个位置删除过
print(lst)                     # 了,下次再循环就不会再删除这个位置了
'''
#2.正确方式
'''
lst = [1,2,3,4,5]
for i in range(len(lst)):
    lst.pop(0)
print(lst)
'''
'''
lst = [1,2,3,4,5]
lst1 = []
for i in lst:
    lst1.append(i)
for k in lst1:
    lst.remove(k)
print(lst)
'''
#字典在for循环中是不能进行删除的
#但是可以用方法规避在原字典使用for循环
'''
dic = {'a':1,'b':2}
dic1 = {}
for i in dic:
    dic1[i] = dic[i]
for i in dic1:
    dic.pop(i)
print(dic)
'''
'''
dic = dict.fromkeys(['alex','wusir'],[]'太白','姗姗') # 第一个是键,第二是
dic['alex'].append('老村长')   # 值,这个方法快速大量的建立很多值是一样的键值对,他们用的值是一样的,所有的内存地址是一样的
print(dic)
'''
#深浅拷贝
#1.浅拷贝
a = [1,2]
a[1] = a
print(a[1])

 

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]))

结果:

['何炅', '杜海涛'