本文详细介绍了Python中的set和dict。set是一种可变、无序、不重复的元素集合，支持add、remove、update等操作；而dict是键值对的集合，支持通过key访问value，提供了defaultdict和OrderedDict等扩展。文章涵盖了它们的定义、初始化、操作及集合运算。
集set
-
约定
- set翻译为集合
- collection翻译为集合类型或容器，是一个大概念
-
set
- 可变的，无序的，不重复，不可索引，可迭代的元素集合
set定义，初始化
s1 = set() # 空集合
s1 = set(iterable)
s1 = set( “可hash对象” )
s2 = {} #空字典dict
hash
| 可hash(不可变类型) | 不可hash（可变类型） |
|---|---|
| 数值型：int，float，complex | 列表List |
| 布尔型：True,Flash | bytearray |
| 字符串：string，bytes | 字典dict |
| 元组tuple | 集合set |
| None |
set 操作
增
-
add( X )
-
增加元素X到set中，X必须是可hash
-
如果X存在，则什么也不做
s1 = {'A','B','C'} s1.add('D') s1 {'A', 'B', 'C', 'D'}
-
-
update（*other）
-
合并其他元素到set集合中来
-
参数other必须是可迭代对象
-
就地修改
s1 = {'A','B','C'} s1.update(range(5)) s1 {0, 1, 2, 3, 4, 'A', 'B', 'C'}
-
-
不可用“+”，不可用“*“
删
-
remove(X)
-
从set中移除一个元素X
-
元素不存在，抛出异常KeyError异常
s1 = {0, 1, 2, 3, 4, 'A', 'B', 'C'} s1.remove('A') s1 {0, 1, 2, 3, 4, 'B', 'C'} ("===========================================") s1 = {0, 1, 2, 3, 4, 'A', 'B', 'C'} s1.remove('d') s1 KeyError: 'd'
-
-
discard(X)
-
从set中移除一个元素X
-
元素不存在，什么也不做
s1 = {0, 1, 2, 3, 4, 'A', 'B', 'C'} s1.remove('d') s1 {0, 1, 2, 3, 4, 'B', 'C'} ("===========================================") s1 = {0, 1, 2, 3, 4, 'A', 'B', 'C'} s1.discard('D') 不报错，无返回值
-
-
pop() --> item
- 移除并返回任意的元素
- 空集返回KeyError异常
-
clear()
- 移除所有元素
修改
无修改操作，可以删除，再增添
查询
-
非线性结构，无法索引
-
可以迭代所有元素，
-
遍历的时间复杂度O(n)，查找元素的时间复杂度是O(1)
-
成员运算符
-
in和not in 判断元素是否在set中
-
返回bool值
s1 = {0, 1, 2, 3, 4, 'A', 'B', 'C'} -1 in s1 False
-
集合
集合概念
-
全集
- 所有元素的集合
-
子集subset 和 超集superset
- 一个集合A所有元素都在另一个集合B内，A是B的子集，B是A的超集
-
真子集和真超集
- A是B的子集，且A不等于B，A就是B的真子集，B就是A的真超集
-
并集： 多个集合合并的结果
-
交集： 多个集合的公共部分
-
差集： 集合中出去和其他集合公共部分
集合运算
-
并集
-
union(*other)
-
| 运算符重载
- 等同于union
-
update(*other)
- 和多个集合合并，就地修改
-
|=
- 等同于update
-
-
交集
-
intersection(*other)
- 返回和多个集合的交集
-
&
- 等同于intersection
-
intersection_update(*other)
- 获取和多个集合的交集，就地修改
-
&=
- 等同于intersection_update
-
-
差集
-
集合A和B，由所有属于A且不属于B的元素组成的集合
-
difference(*other)
- 返回和多个集合的差集
-
difference_update(*other)
- 获取和多个集合的差集并就地修改
-
-=
- 等同difference_update
-
-
对称差集
-
集合A和B，由所有不属于A和B的交集元素组成的集合，记作(A-B)U(B-A)
-
symmetric_difference(other)
- 返回和另一个集合的对称集合
-
^
- 等同symmetric_difference
-
symmetric_difference_update(other)
- 获取和另一个集合对称差集并就地修改
-
^=
- 等同symmetric_difference_update
-
-
判断
-
issubset(other) <=
- 判断当前集合是否是另一个集合的子集
-
set1 < set2
- 判断set1是否是set2 的真子集
-
issuperset (other) >=
- 判断当前集合是否是other的超集
-
set 1 > set 2
- 判断set1 是否是set2 的真超集
-
isdisjoint(other)
- 当前集合和另一个集合没有交集
- 没有交集，返回True
-
字典dict
- key-value 键值对的数据的集合
- 可变的，无序的，key不重复
字典dict定义，初始化
-
d = dict() 或者 d = {}
-
dict(**kwargs) 使用 name = value对 初始化一个字典
d1 = dict(a= 1, b= 10, c= 100, d= '1000') d1 {'a': 1, 'b': 10, 'c': 100, 'd': '1000'} -
dict(iterable ,**kwarg) 使用可迭代对象和name=value对 构造字典，不过可迭代对象的元素必须是一个二元结构
-
d = dict(((1,‘a’),(2,‘b’))) 或者 d = dict(([1,‘a’],[2,‘b’]),c = 300)
d = dict(((1,'a'),(2,'b'))) d {1: 'a', 2: 'b'}d = dict(([1,'a'],[2,'b']),c = 300) d {1: 'a', 2: 'b', 'c': 300}
-
dict (mapping,**kwarg)使用一个字典构建另一个字典
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': '1000'} d2 = dict(d1) d2 'a': 1, 'b': 10, 'c': 100, 'd': '1000'}d1 = {'a': 1, 'b': 10, 'c': 100, 'd': '1000'} d2 = dict(d1,a=111) d2 {'a': 111, 'b': 10, 'c': 100, 'd': '1000'}d1 = {'a': 1, 'b': 10, 'c': 100, 'd': '1000'} d2 = dict(d1,f=111) d2 {'a': 1, 'b': 10, 'c': 100, 'd': '1000', 'f': 111} -
d = {‘a’:10,‘b’:20,‘c’:None,‘d’:[1,2,3]}
-
类方法dict.fromkeys(iterable,value)
d1 = dict.fromkeys(('abcdefghijk'),100) d1 {'a': 100, 'b': 100, 'c': 100, 'd': 100, 'e': 100, 'f': 100, 'g': 100, 'h': 100, 'i': 100, 'j': 100, 'k': 100}
字典元素的访问
-
d[key]
- 返回key对应的值value
- key不存在 抛出异常KeyError
- 返回key对应的值value
-
get(key [, default])
-
返回key对应的值value
-
key不存在时返回缺省值default，如果没有设置缺省值，就返回None
-
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
d1.get('b')
10
("===========================================")
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
d1.get('e',111)
111
("===========================================")
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
d1.get('e')
返回None，无输出
```
3. setdefault(key [,default])
- 返回key对应的值value
- key不存在，添加KV对，value设置为default，并返回default，如果没有设置default，缺省为None
```py
```
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
d1.setdefault('a')
1
("===========================================")
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
d1.setdefault('e',1234)
1234
d1
{'a': 1, 'b': 10, 'c': 100, 'd': 1000, 'e': 1234}
("===========================================")
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
d1.setdefault('f')
返回None，无输出
```
## 字典添加和修改
1. d[key] = value
- 将key对应的值修改为value
- key不存在添加新的KV对
2. update([other]) - -> None
- 使用另一个字典的KV对更新本字典
- key不存在，就添加
- key存在，覆盖已经存在的key对应的值
- 就地修改
## 字典删除
1. pop(key [,default])
- key存在，移除它，并返回它的value
- key不存在，返回给定的default
- default未设置，key不存在则抛出KeyError异常
2. popitem()
- 移除并返回一个任意的键值对
- 字典为empty，抛出KeyError异常
3. clear()
- 请空字典
4. del语句
- del d['c'] 看着像删除了一个对象，本质上减少了一个对象的引用，del实际上删除的是名称，而不是对象
## 字典遍历
1. for··· in dict
- 遍历key
```py
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
for k in d1:
print(k,end=" ")
a b c d
("===========================================")
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
for k in d1.keys():
print(k,end=" ")
a b c d
```
- 遍历value
```py
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
for k in d1:
print(d1[k],end=" ")
1 10 100 1000
("===========================================")
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
for k in d1.keys():
print(d1.get(k),end=" ")
1 10 100 1000
("===========================================")
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
for v in d1.values():
print(v,end=" ")
1 10 100 1000
```
- 遍历item，即KV对
```python
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
for item in d1.items():
print(item,end=" ")
('a', 1) ('b', 10) ('c', 100) ('d', 1000)
("===========================================")
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
for item in d1.items():
print(item[0],item[1],end=" ")
a 1 b 10 c 100 d 1000
("===========================================")
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
for k,v in d1.items():
print(k,v,end=" ")
a 1 b 10 c 100 d 1000
("===========================================")
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
for k,_ in d1.items():
print(k,end=" ")
a b c d
("===========================================")
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': 1000}
for _,v in d1.items():
print(v,end=" ")
1 10 100 1000
```
## 字典遍历和移除
```python
d1 = {'a': 1, 'b': 10, 'c': 100, 'd': '1000'}
keys = []
for k,v in d1.items():
if isinstance(v,str): #判断value的类型
keys.append(k)
for k in keys:
d1.pop(k)
print(d1)
{'a': 1, 'b': 10, 'c': 100}
字典的key
- key的要求和set的元素要求一致
- set的元素可以看作就是key，set可以看作是dict的简化版
- hashable 可哈希才可以作为key，可以使用hash()测试
defaultdict
-
collections.defaultdict([default_factory [,……]])
-
第一个参数是default_factory，缺省是None，它提供一个初始化函数，当key不存在时，会调用这个工厂函数来生成对应的value
import random d1 = {} for k in 'abcdef': for i in range(random.randint(1,5)): if k not in d1.keys(): d1[k] = [] d1[k].append(i) print(d1) {'a': [0, 1, 2, 3], 'b': [0, 1], 'c': [0, 1, 2, 3], 'd': [0], 'e': [0, 1, 2, 3, 4], 'f': [0, 1, 2]}from collections import defaultdict d1 = defaultdict(list) for k in 'abcdef': for i in range(random.randint(1,5)): d1[k].append(i) print(d1) defaultdict(<class 'list'>, {'a': [0, 1], 'b': [0], 'c': [0, 1, 2, 3], 'd': [0], 'e': [0, 1], 'f': [0, 1, 2, 3, 4]})
-
OrderedDict
- collections.OrderedDict([items])
- key 并不是按照加入的顺序排列，可以使用OrderedDict记录顺序
扫一扫
603
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
