字典 dict 和集合 set 基本用法

字典

  • key-value
  • {}
  • 可变，无序，key 不重复, key 可哈希 (可用 hash() 方法验证)

字典是一系列由键（key）和值（value）配对组成的元素的集合，在 Python3.7+，字典被确定为有序（注意：在 3.6 中，字典有序是一个 implementation detail，在 3.7 才正式成为语言特性，因此 3.6 中无法 100% 确保其有序性）

定义及初始化

  • d = dict() 或 d = {}
  • d = {'a':1,'b':2,'c':[1,2],'d':None,1:'a'}
  • d = dict(a=1,b=2,c=[1,2])
  • d = dict(iterable)，可迭代对象的元素必须是二元结构
    • dict([('a',1),['b',2],['c',[1,2]],{1,2}])
  • d = dict(mapping), 使用一个字典构造另外一个字典
    • d1 = {'a':1,'b':2}
    • d2 = dict(d1, a=100, d=200)
  • 类方法 dict.fromkeys(iterable,value)
    • d = dict.fromkeys(range(5))
    • d = dict.fromkeys(range(5),1)
# 列表去重，利用字典键的唯一性来去重
l = [2, 1, 2, 3, 4, 5, 6, 6, 5, 4, 3, 2, 1]
print(dict.fromkeys(l).keys())

字典元素的访问

  • d[key]
  • get(key[,default])
    • key 不存在时返回缺省值，未设置缺省值时为 None
    • key 存在返回对应的 value 值
  • setdefault(key[,default])
    • key 不存在时，添加 kv 对且 value 设置为 default，返回缺省值，未设置缺省值时为 None
    • key 存在时，返回对应的 value 值

字典的增加和修改

  • d[key] = value
    • key 存在时修改对应的值为 value
    • key 不存在时，添加新的 kv 对
  • update(other)
    • 返回值为 None
    • key 不存在就添加
    • key 存在则覆盖
    • d.update(a=1),d.update({'a':1}),d.update((('a',1),))

字典的删除

  • pop(key[,default])
    • key 存在则移除并返回对应 value
    • key 不存在返回给定的 default，default 未设置则抛出 KeyError 异常
  • popitem()
    • 移除并返回一个任意的键值对
    • 字典为空时抛出 KeyError 异常
  • clear()
    • 清空字典
  • del
    • del d['a']

字典的遍历

  • for k in d.keys(),for k in d,for k,_ in d.items()
  • for v in d.values(),for _,v in d.items()
  • for k in d:print(d[k])
  • for k in d:print(d.get(k))
  • for k,v in d.items()
  • for item in d.items():print(item[0],item[1])

字典的遍历移除

  • 错误的做法dictionary changed size during iteration
d = {'a':1,'b':2}
for k,v in d.items():
    d.pop(k)
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-70-952e6df2df38> in <module>()
----> 1 for k,v in d.items():
      2     d.pop(k)
RuntimeError: dictionary changed size during iteration
  • 正确的做法
# 例：移除value值为字符串的kv
d = {'a':1,'b':2,'c':'abc'}
keys = []
for k,v in d.items():
    if isinstance(v,str):
        keys.append(k)
for k in keys:
    d.pop(k)
print(d)

defaultdict

  • collections.defaultdict([default_factory[, ...]])
    • 第一个参数 default_factory，缺省是 None，它提供一个初始化函数。当 key 不存在的时候，会调用这个工厂函数来生成 key 对应的 value
  • 例子
# 未采用defaultdict
import random
d1 = {}
for k in 'abcdef':
    for v in range(random.randint(1, 5)):
        if k not in d1.keys():
            d1[k] = [] # 避免异常
        d1[k].append(v)
        # d1.setdaultdict(k,[]).append(v)
print(d1)

# 采用defaultdict
from collections import defaultdict
import random
d1 = defaultdict(list)
for k in 'abcdef':
    for v in range(random.randint(1, 5)):
        d1[k].append(v)
print(d1)

OrderedDict

  • py3.6 版本字典就是有序的
  • 兼容老版本，可使用 OrderedDict
from collections import OrderedDict
od = OrderedDict()
for i in range(10):
    od[i] = random.randint(1,5)
print(od)
for k,v in od.items():
    print(k,v)

集合

  • 可变的，无序的，不重复元素的集合
  • set 的元素必须可以 hash，如 list，set 不可 hash
  • 不可索引，因为无序，非线性结构
  • set 可迭代

set 的定义和初始化

  • s = set()
  • s = {} #错误type(s)
  • s = set(iterable) 如 set(list(range(10)))
  • s = {1,(2,3),'a'}

set 的增加

  • add(element)
  • update(other)
    • 合并其他元素到 set 集合中来
    • 返回 None

set 的删除

  • remove(element)
    • 元素不存在，抛 KeyError 异常
  • discard(element)
    • 元素不存在，不抛异常
  • pop()
    • 移除并返回任意元素
    • set 为空时返回 KeyError 异常
  • clear()
    • 清空，移除所有元素

set 的 in 和 not in

  • 和 list 等线性结构查询比较，线性结构查询时间复杂度为 O(n)
  • set 和 dict 等结构，时间复杂度为 O(1), 内部使用 hash 值作为 key

可 hash

集合运算

  • 略

参考

  • magedu