1.小数据池和代码块

# 小数据池 -- 缓存机制(驻留机制)

# == 判断两边内容是否相等

# a = 10
# b = 10
# print(a == b)

# is 是

# a = 10
# b = 10
# print(a is b)  is判断基于内存地址进行判断

# print(id(a))
# print(id(b))

# 小数据池的数字范围: -5 ~ 256

# a = -2.5 * 2
# b = -2.5 * 2
# print(id(a))
# print(id(b))  #float不行

# a = "alex你好" *2
# b = "alex你好" *2
# print(id(a))
# print(id(b))

# 代码块:一个文件,一个函数,一个类,一个模块,终端中每一个行是一个代码块
# 支持:

# 数字:
#   在同一代码块下 只要内容相同就采用相同的内存地址(-5以后就不是)
#   数字在做乘法的时候范围 -5 ~ 256  ****
#   数字在做乘法的时候不能使用浮点数
# 字符串:
#   在同一代码块下 只要内容相同就采用相同的内存地址
#   乘法的时候总长度不能超过20   ****
#   乘法的时候中文,特殊符号乘以1或0
# 布尔值:
#   在同一代码块下 只要内容相同就采用相同的内存地址

# 小数据池:
# 数字:  -5 ~ 256   ****
# 字符串:
#       在同一代码块下 只要内容相同就采用相同的内存地址
#       乘法的时候总长度不能超过20   ****
#       乘法的时候中文,特殊符号乘以0
# 布尔值:
#       在同一代码块下 只要内容相同就采用相同的内存地址
# 小数据池的验证方法,必须脱离代码块才能进行验证
# 先执行代码块的规则,在执行小数据的规则 --(驻留机制)

# 必会:
# ==  判断等号两边的值是否相等   ****
# is  判断两边的内存地址是否相等  ****

2.深浅拷贝

建议参考:http://39.97.99.7/python/13%20深浅拷贝.html

对于list, set, dict来说, 直接赋值. 其实是把内存地址交给变量. 并不是复制⼀份内容.

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也发⽣了改变

浅拷贝:只会拷贝第一层. 第二层的内容不会拷贝. 所以被称为浅拷贝

1.浅拷贝在修改新拷贝的列表中(不可变和可变)的元素的时候,原列表不进行改变

2.浅拷贝在新拷贝的列表中的可变数据类型中进行增删改的时候,源列表进行改变

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]))
结果:
["章超印", "周道镕","朱凡宇", ["章超印", "周道镕","朱凡宇", '他们是多么的帅']]
["章超印", "周道镕","朱凡宇", ["章超印", "周道镕","朱凡宇", '他们是多么的帅']]
2385045841544   2385045841544

深拷贝:本质是不可变数据类型共用一个,可变数据类型另开辟一块空间(复制一份) 不会产生一个改变另一个跟着改变的问题

import copy
lst1 = ["章超印", "周道镕","朱凡宇", ["章超印", "周道镕","朱凡宇"]]
lst2 = copy.deepcopy(lst1)
lst1[3].append("他们是多么的帅")
print(lst1)
print(lst2)
print(id(lst1[3]), id(lst2[3]))

结果:
['章超印', '周道镕', '朱凡宇', ['章超印', '周道镕', '朱凡宇', '他们是多么的帅']]
['章超印', '周道镕', '朱凡宇', ['章超印', '周道镕', '朱凡宇']]
1724477331208    1724477331272

面试题:

a = [1, 2]
a[1] = a
print(a[1])　

结果:
[1, [...]]

3.集合 (set) -- 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 增删改查

增加

方法:

add()

s = {"zcy","zdr",123}
s.add(Ture)
print(s)
s.add("zdr")    # 重复的东西不添加到set
print(s)

update()

s = {"zcy","zdr",123,Ture,(123,456)}
s.update("123") #迭代添加,进入集合后每一个字符都成为集合的成员
print(s)
s.update(["123"])   #"123"这个字符串成为了集合的成员
print(s)

删除

方法:

​ pop()

s = {"zcy","zdr",123,Ture,(123,456)}
item = s.pop() # 随机弹出⼀个.有返回值
print(s)
print(item)

​ remove()

s.remove("zdr") # 指定元素删除
# s.remove("周道镕") # 不存在这个元素. 删除会报错
print(s)

​ clear()

s = {" "}
s.clear() # 清空set集合.需要注意的是set集合如果是空的. 打印出来是set() 因为要和dict区分的.
print(s) 

结果:
# set()

s = {}
s.clear()
print()

结果:
{}

修改

set集合中的数据没有索引. 也没有办法去定位⼀个元素. 所以没有办法进⾏直接修改.

我们可以采⽤先删除后添加的⽅式来完成修改操作

s = {"zcy","zdr",123,Ture,(123,456)}
s.remove("zdr") # 直接删除元素
s.add("周道镕")
print(s)

查询

# set是⼀个可迭代对象. 所以可以进⾏for循环
s = {"zcy","zdr",123,Ture,(123,456)}
for e in s:
 print(e)

常用操作

交集:两个集合中的共有元素

&

intersection()

s1 = {"周道镕", "章超印", "朱凡宇"}
s2 = {"戴军", "章超印", "杨红兴"}
# 交集
# 两个集合中的共有元素
print(s1 & s2) # {'章超印'}
print(s1.intersection(s2)) # {'章超印'}

并集

|

union()

s1 = {"周道镕", "章超印", "朱凡宇"}
s2 = {"戴军", "章超印", "杨红兴"}
# 并集
print(s1 | s2) # {"周道镕", "章超印", "朱凡宇","戴军", "杨红兴"}
print(s1.union(s2)) # {"周道镕", "章超印", "朱凡宇","戴军", "杨红兴"}

差集

difference()

s1 = {"周道镕", "章超印", "朱凡宇"}
s2 = {"戴军", "章超印", "杨红兴"}
# 差集
print(s1 - s2) # {"周道镕", "朱凡宇"}得到第⼀个中单独存在的
print(s1.difference(s2)) # {"周道镕", "朱凡宇"}

反交集

^

symmetric_difference()

s1 = {"周道镕", "章超印", "朱凡宇"}
s2 = {"戴军", "章超印", "杨红兴"}
# 反差集
print(s1 ^ s2) # {"周道镕", "朱凡宇","戴军", "章超印", "杨红兴"} 两个集合中单独存在的数据
print(s1.symmetric_difference(s2))# {"周道镕", "朱凡宇","戴军", "章超印", "杨红兴"}

子集

<

issubset()

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

超集

​ >

issuperset()

# 超集
print(s1 > s2) # set1是set2的超集吗? False
print(s1.issuperset(s2))

set集合本⾝是可以发⽣改变的. 是不可hash的. 我们可以使⽤frozenset来保存数据. frozenset是不可变的. 也就是⼀个可哈希的数据类型

frozenset() 冻结集合 可以作字典的键

s = frozenset(["周道镕", "章超印", "朱凡宇","杨红兴"])
dic = {s:'123'} # 可以正常使⽤了
print(dic)

结果:
{frozenset({'杨红兴', '朱凡宇', '章超印', '周道镕'}): '123'}