字典与集合

python的第五节课笔记（基础入门）

散列类型：

在Python中，散列类型（Hashable Type）指的是一种可以作为字典（Dictionary）键值的数据类型。散列类型的特点是不可变（Immutable），即创建后不能被修改。散列类型在Python中用于支持字典的快速查找和唯一性的要求。

以下是Python中常见的散列类型：

不可变的原始数据类型（Immutable Primitive Types）：包括整数（int）、浮点数（float）、布尔值（bool）和元组（tuple）等。
字符串（str）：字符串是不可变的，因此可以用作字典的键。
冻结集合（frozenset）：冻结集合是不可变的，因此可以作为字典的键。与可变集合（set）不同，冻结集合的元素不能被修改。

请注意，可变的数据类型（如列表、集合和字典等）不能作为散列类型，因为它们可以在创建后进行修改，从而导致散列值发生变化，无法保证字典的一致性和查找的准确性。

当你尝试将一个不可散列的对象用作字典的键时，Python会引发TypeError异常。因此，在选择字典的键时，确保选择散列类型以保证字典的正常使用。

字典：

语法结构：

变量名 = {key0:value0 , key1:value1, key2:value2}

di_cg = {“name”: “春光”, “age”: 28, “id”: 2}

定义方式一	{key1:value1, key2:value2}
定义方式二	dict(变量名=值, 变量名1=值2)
空字典	{}

1
2
3

#定义方式一
di_cg = {"name": "春光", "age": 28, "id": 2}
print(type(di_cg))    #<class 'dict'>

1
2
3

li = ["name", "age", "id"]
print(dict(li))  
#报错，li是一个列表，它只包含字符串元素，而没有键值对的结构

#定义方式二
di_cg2 = dict(name="春光", age=28, id=2)
print(di_cg2)  
#{'name': '春光', 'age': 28, 'id': 2}

#键必须是不可变的数据类型(int、float、str、tuple)
di_cg1 = {1: '春光', 'age': 28, 'id': 2}
di_cg2 = {(1,): '春光', 'age': 28, 'id': 2}
#di_cg2 = {[1]: '春光', 'age': 28, 'id': 2}  # 报错--->列表可变，不可以做键（key）
print(type(di_cg1))   #<class 'dict'>
print(type(di_cg2))    #<class 'dict'>

注意：

字典里面的元素，以键值对的形式存在
key:value 键值对（将键和值使用冒号链接就叫做键值对）
key 键，冒号前面的
value 值，冒号后面的
键必须是不可变的数据类型(int、float、str、tuple)
值key是任意的数据类型
字典也叫dict

字典的查询：

字典的键必须是唯一的，如果键名重复，后面的值会覆盖掉原来的值

语法	解释
dict[key]	存在则返回键对应的值不存在则报错
dict.get(key)	存在则返回键对应的值不存在则返回None(空值)

1
2
3

di_96 = {"name": "96", "age": 27, "id": 6}
print(di_96["age"])   #27
# print(di_96["sex"])  # 没有则报错

1
2
3

di_96 = {"name": "96", "age": 27, "id": 6}
print(di_96.get("name"))    #96
print(di_96.get("sex"))  # 返回None，表示没有这个值

字典的修改：

思路：先找到，再赋予新的值覆盖掉旧值

语法	解释
dict[key]	key存在，新值覆盖旧值 key不存在，新建键值对
dict.setdefault(key, 值)	key 存在，返回所对应的value key 不存在新建键值对（键值对的值为指定在括号里面的第二个参数）
dict.update({k1:v1,k2:v2})	当键名重复的时候，可以进行一个批量替换

1 2	di_96 = {"name": "96", "age": 27, "id": 6, "name": "1996"} print(di_96) #{'name': '1996', 'age': 27, 'id': 6}

di_dl = {"name": "达龙", "age": 28, "id": 4}
di_dl["age"] = 26
di_dl["sex"] = "男"
print(di_dl)     #{'name': '达龙', 'age': 26, 'id': 4, 'sex': '男'}

di_dl = {"name": "达龙", "age": 28, "id": 4}
print(di_dl.setdefault("id", 14))  # 4, 原因,id存在，所以返回id对应的值-->4
print(di_dl.setdefault("num", 14))  # 14 原因,num不存在，所以返回我们自己设定的14
print(di_dl)     #{'name': '达龙', 'age': 28, 'id': 4, 'num': 14}

di_dl = {"name": "达龙", "age": 28, "id": 4,'num': 14}
di_hn = {"name": "昊楠", "age": 32}
di_dl.update(di_hn)
print(di_dl)    #{'name': '昊楠', 'age': 32, 'id': 4, 'num': 14}

字典的视图方法：

di_hn = {"name": "昊楠", "age": 32, "id":1, "num":13}
print(di_hn.keys())
print(di_hn.values())
print(di_hn.items())

运行结果为：

#遍历出所有的键
di_hn = {"name": "昊楠", "age": 32, "id":1, "num":13}
for i in di_hn:
    print(i)

#遍历出所有的值
di_hn = {"name": "昊楠", "age": 32, "id":1, "num":13}
for v in di_hn.values():
    print(v)

di_hn = {"name": "昊楠", "age": 32, "id":1, "num":13}
#遍历出所有的键和值，items()将字典变成元组，元组可以拆包，俩个变量接收俩个元素就可以了
for k, v in di_hn.items():
    print(k, v)

字典的删除：

语法	解释
dict.pop(key)	通过key删除键值，对 key不存在将报错
dict.popitem()	随机删除,本质是随机删除，<br/但是python3.6版本之后，就自动做了一个排序，表现为删除最后一个
del dict[key]	指定删除，对 key不存在将报错
del dict	删除整个字典

di_hn = {"name": "昊楠", "age": 32, "id":1, "num":13}
di_hn.pop("num")
# di_hn.popitem()
print(di_hn)    #{'name': '昊楠', 'age': 32, 'id': 1}

1
2
3

di_hn = {"name": "昊楠", "age": 32, "id":1, "num":13}
di_hn.popitem()
print(di_hn)    #{'name': '昊楠', 'age': 32, 'id': 1}

di_hn = {"name": "昊楠", "age": 32, "id":1, "num":13}
del di_hn["id"]
# del di_hn["sex"]    #报错
print(di_hn)   #{'name': '昊楠', 'age': 32, 'num': 13}

1
2
3

di_hn = {"name": "昊楠", "age": 32, "id":1, "num":13}
del di_hn
print(di_hn)   #删除整个字典，没有了，所以报错

集合:

语法结构：

变量名 = {值1 , 值2, 值3}

s1 = {1, 2, 3, 4}

注意：

set也叫集合
集合里面的元素是唯一的，并且也是无序的

集合的运算:

交集 &	两个集合相同的元素
并集 \|	两个集合全部加在一起
差集 -	我有你没有

s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
print(s1 & s2)    #{3, 4}
print(s1 | s2)     #{1, 2, 3, 4, 5, 6}
print(s1 - s2)  # s1 有的 s2 没有的，{1, 2}
print(s2 - s1)  # s2 有的 s1 没有的，{5, 6}

集合的增删改查:

语法	解释
set.add(元素)	添加单个
set.update(可迭代对象)	添加多个
set.pop()	随机删除
set.remove()	指定删除

1
2
3

s1 = {1, 2, 3, 4}
s1.add("韩同学")   
print(s1)   ##{1, 2, 3, 4, '韩同学'}

1
2
3

s1 = {1, 2, 3, 4}
s1.add(1)  # 集合里面已经有1，去重，只能有一个
print(s1)   #{1, 2, 3, 4}

s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s1.update(s2)
print(s1)    #{1, 2, 3, 4, 5, 6}

1
2
3

s2 = {3, 4, 5, 6}
s2.pop()  # 底层无序，但是对于较小的数值，会自动排序，随机一直删除的都是1
print(s2)    #{4, 5, 6}

set1 = {"简诚", "子良", "锋", "圣文"}
#set1.pop()   #{'圣文', '子良', '锋'}，随机删除
set1.remove("圣文")   #{'简诚', '子良', '锋'}，指定删除
print(set1)

阶段总结:

判断:

判断的时候,判断的都是布尔值(True False),判断某一个数据的布尔值

if True:
    print("条件成立执行")
else:
    print("条件不成立执行")

数值:	0 为 False 其他为 True
其他数据类型:	空 False 但凡里面有值都是 True

print(bool(1))   #True
print(bool(-1))  # True
print(bool(-1.1))   #True
print(bool(0))   #False
print(bool("0"))  # T 字符串里面有一个字符0，True
print(bool(" "))  # T 字符串里面有一个字符空格，True
print(bool(""))  # F 字符串里面没有字符，False

print(bool([]))    #False
print(bool([1]))  #True

#抱歉,无可查询对象，返回的是空
li = []
if li:
    print("开始群发消息")
else:
    print("抱歉,无可查询对象")

六大基础数据类型总结:

类型	符号	特点
数值	int float bool	不可变的非序列可以进行数学运算
字符串	str	不可变的序列可以更具索引(下标)查找值可以增删改查,但是要使用新的变量接受
元组	tuple	不可变的序列没有增删改查可以进行拆包
列表	list	可变序列增删改查
字典	dict	可变的键值对映射结构—可以快速查找增删改查
集合	set	可变的,无序求去重增删改查集合运算

进一步总结：