python基础知识4——字典和集合

zhang-ge

已于 2024-04-02 15:04:08 修改

阅读量328

点赞数 7

分类专栏： python 文章标签： python

于 2024-03-29 18:43:05 首次发布

本文链接：https://blog.csdn.net/weixin_40837318/article/details/137153379

版权

python 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

python基础知识学习笔记之常用数据类型操作

1、字典

1.1、字典的概念
字典是无序的可变的键值对集合。

1.2、字典的定义

# 定义1：{key1:value1, key2:value2...}
person = {"name":"zhangsan", "age":18}
print(person, type(person))
print(person["name"])
print(person["age"])

# 定义2：类调用：dict.fromkeys([key, ...], value)
d = dict.fromkeys("abc", 666)
print(d, type(d))

d = dict.fromkeys(["name", "age"], 666)
print(d, type(d))

注意：

key不能出现重复。如果重复，后值会把前值覆盖掉。
key必须是任意不可变类型（值改变后，id不变）。
以上两点主要原因是字典是hash存储的方式。

1.3、字典的增加

# dic[key] = value, 当key在字典中不存在时，即为新增操作
d = {"name" : "zhangsan", "age" : "18"}
d["height"] = 170
print(d, type(d))

1.4、字典的删除

# del语法: del dic[key]
d = {"name" : "zhangsan", "age" : "18"}
del d["name"]
print(d, type(d))

# dic.pop(ker[, default]), 删除指定的键值对，并返回对应的值
# 如果key不存在，则返回给定的default值，不做删除动作
d = {"name" : "zhangsan", "age" : "18"}
v = d.pop("age")
print(v, d)

# dic.popitem(), 删除按升序排序后的第一个键值对，并以元组的形式返回该键值对
d = {"name" : "zhangsan", "age" : "18"}
t = d.popitem()
print(t, d)

# dic.clear(), 删除字典内说有的键值对
d = {"name" : "zhangsan", "age" : "18"}
d.clear()
print(d)

1.5、字典的修改

# 修改单个键值对: dic[key] = value
d = {"name" : "zhangsan", "age" : "18"}
d["age"] = 20
print(d)

# 批量修改键值对
# olddic.update(newdic), 根据新的字典，批量更新旧字典中的键值对，如果旧字典没有对应的key则新增键值对
d = {"name" : "zhangsan", "age" : "18"}
d.update({"age": 20, "addr":"bj"})
print(d)

1.6、字典的查找

1.6.1、获取单个值

# 方式1: dic[key]
d = {"name" : "zhangsan", "age" : "18"}
print(d["name"])

# 方式2: dic.get(key[, default]), 如果不存在对应的key,则返回默认值
d = {"name" : "zhangsan", "age" : "18"}
print(d.get("name"))

# 方式3: dic.setdefault(key[, default]), 如果不存在对应的key,则设置给定默认值
d = {"name" : "zhangsan", "age" : "18"}
print(d.setdefault("addr", "bj"))
print(d)

1.6.2、获取所有

# dic.values(), 获取所有值
d = {"name" : "zhangsan", "age" : "18"}
print(d.values())

# dic.keys(), 获取所有的键
d = {"name" : "zhangsan", "age" : "18"}
print(d.keys())

# dic.items(), 获取键值对
d = {"name" : "zhangsan", "age" : "18"}
print(d.items())

1.6.3、遍历

# 方式1: 先遍历所有的key，然后根据key获取对应的值
d = {"name" : "zhangsan", "age" : "18"}
keys = d.keys()
for key in keys:
    print(d[key])

# 方式2: 直接遍历所有的键值对
kvs = d.items()
print(kvs)
for k,v in kvs:
    print(k, v)

1.7、字典的计算和判定

# len(d): 计算键值对的个数
d = {"name" : "zhangsan", "age" : "18"}
print(len(d))

# x in dic: 判定dic中的key是否存在x
# x not in dic: 判定dic中的key是否不存在x
d = {"name" : "zhangsan", "age" : "18"}
print("name" in d)

2、集合

2.1、集合的概念
集合是无序的不可随机访问的，不可重复的元素集合。与数学中的集合概念类似，可进行交、并、差、补运算。
集合可分为可变集合和非可变集合。

2.2、集合的定义

2.2.1、可变集合

# 定义1:
s = {1, 2, 3}
print(s, type(s))

# 定义2: s = set(iterable), iterable可以是字符串、列表、元组、字典等
s = set([1, 2, 3, 4, 5])
print(s, type(s))
s = set((1, 2, 3, 5))
print(s, type(s))
s = set({"name": "zhangsan", "age": 20})
print(s, type(s))

# 定义3: 集合推导式
s = set(x * 2 for x in range(0, 10, 1))
print(s, type(s))

s = {x * 1 for x in range(0, 10, 1)}
print(s, type(s))

2.2.2、不可变集合

# 定义1: fs = frozenset(iterable)
fs = frozenset("abc")
print(fs, type(fs))

fs = frozenset([1, 2, 3])
print(fs, type(fs))

fs = frozenset({"name": "zhangsan", "age": 20})
print(fs, type(fs))

# 定义2: 集合推导式
fs = frozenset(x * 2 for x in range(0, 10, 1))
print(fs, type(fs))

2.3、集合的注意事项

# 1、定义一个空集合时，需要使用set()或frozenset(), 不能使用s = {}, 因为这样会被定义成字典；
s = {}
print(s, type(s))

# 2、集合中的元素必须时可哈希的(在自己的生命周期中有唯一的哈希值，那么它就是可哈希的)；
s = {1, 2, [3, 4]} 
print(s, type(s))

# 3、如果集合中的元素出现重复，则会被合并为1个
s = {1, 2, 3, 3} 
print(s, type(s))

2.4、单一集合的操作

2.4.1、可变集合的增加

s = {1, 2, 3}
s.add(5)
print(s, type(s))

2.4.2、可变集合的删除

# s.remove(element), 删除指定的元素，没有则报错
s = {1, 2, 3, 4}
s.remove(3)
print(s, type(s))

# s.discard(), 删除指定的元素，没有则什么也不做
s = {1, 2, 3, 4}
s.remove(3)
print(s, type(s))

# s.pop(element), 随机删除并返回集合中的一个元素
s = {1, 2, 3, 4}
print(s.pop(), s)

# s.clear(), 清空集合中的所有元素
s = {1, 2, 3, 4}
s.clear()
print(s)

2.4.3、集合的遍历

# 通过for in遍历
s = {1, 2, 3, 4}
for v in s:
    print(v)

# 通过迭代器遍历
s = {1, 2, 3, 4}
it = iter(s)
for v in it:
    print(v)

2.5、集合之间的操作

2.5.1、集合的交集

# 方式1: s.intersection(Iterable)
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5}
print(s1.intersection(s2))

# 方式2：逻辑与 &
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5}
print(s1 & s2)

# 方式3: s.intersection_update(...), 交集计算完后会赋值给原对象，只适用于可变集合
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5}
s1.intersection_update(s2)
print(s1)

2.5.2、集合的并集

#方式1: s.union(): 返回并集
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5}
print(s1.union(s2))

# 方式2: 逻辑或 | 
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5}
print(s1 | s2)

# 方式3: s.union(): 更新并集到当前集合，只适用于可变集合
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5}
s1.update(s2)
print(s1)

2.5.3、集合的差集

# 方式1: s.difference(): 返回差集
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5}
print(s1.difference(s2))

# 方式2: 算术运算符 -
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5}
print(s1 - s2)

# 方式3: s.difference_update(): 返回差集到当前集合，只适用于可变集合
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5}
s1.difference_update(s2)
print(s1)

2.5.4、集合的判定

# isdisjoint(): 判断两个集合不相交
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5}
s3 = {6, 7, 8}
print(s1.isdisjoint(s2))
print(s1.isdisjoint(s3))

# issuperset(): 判断一个集合包含另一个集合
s1 = {1, 2, 3, 4}
s2 = {3, 4}
s3 = {6, 7, 8}
print(s1.issuperset(s2))
print(s1.issuperset(s3))

# issubset(): 判断一个集合包含于另一个集合
s1 = {1, 2, 3, 4}
s2 = {3, 4}
s3 = {6, 7, 8}
print(s2.issubset(s1))
print(s1.issubset(s3))