Python之哈希表-字典

Python之哈希表-字典

字典Dict

• Dict即Dictionary，也称为mapping。
• Python中，字典由任意个元素构成的集合，每一个元素称为Item，也称为Entry。这个Item是由(key, value)组成的二元组。
• 字典是可变的、无序的、key不重复的key-value pairs键值对集合。

初始化

• dict(**kwargs) 使用name=value对初始化一个字典
• dict(iterable, **kwarg) 使用可迭代对象和name=value对构造字典，不过可迭代对象的元素必须是一个二元结构
• dict(mapping, **kwarg) 使用一个字典构建另一个字典

元素访问

• d[key]
  • 返回key对应的值value
  • key不存在抛出KeyError异常
• get(key[, default])
  • 返回key对应的值value
  • key不存在返回缺省值，如果没有设置缺省值就返回None
• setdefault(key[, default])
  • 返回key对应的值value
  • key不存在，添加kv对，value设置为default，并返回default，如果default没有设置，缺省为None

新增和修改

• d[key] = value
  • 将key对应的值修改为value
  • key不存在添加新的kv对
• update([other]) -> None
  • 使用另一个字典的kv对更新本字典
  • key不存在，就添加
  • key存在，覆盖已经存在的key对应的值
  • 就地修改

删除

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

遍历

• 遍历Key
• 遍历Value
• 遍历Item

Python3中，keys、values、items方法返回一个类似一个生成器的可迭代对象

• Dictionary view对象，可以使用len()、iter()、in操作
• 字典的entry的动态的视图，字典变化，视图将反映出这些变化
• keys()返回一个类set对象，也就是可以看做一个set集合。如果values()都可以hash，那么items()也可以看做是类set对象

Python2中，上面的方法会返回一个新的列表，立即占据新的内存空间。所以Python2建议使用iterkeys、itervalues、iteritems版本，返回一个迭代器，而不是返回一个copy

---

dict(), {}, dict({})
# 空字典的表达形式
# 返回结果：({}, {}, {})
1
2
3

dict? # 查看字典的帮助信息
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
    (key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
    d = {}
    for k, v in iterable:
        d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
    in the keyword argument list.  For example:  dict(one=1, two=2)
1
2
3
4
5
6
7
8
9
10

dict({'a':100})
# 返回结果：{'a': 100}
1
2

dict([]), dict({}), dict(())
# 返回结果：({}, {}, {})
1
2

dict([('a', 1), [1, 100]])
# 返回结果：{'a': 1, 1: 100}
1
2

dict(a=1, b='abc')
# 返回结果：{'a': 1, 'b': 'abc'}
1
2

dict({'a':1, 'b':100, 1:'abc'})
# 返回结果：{'a': 1, 'b': 100, 1: 'abc'}
1
2

dict({'a':1, 'b':100, 1:'abc'}, a=2, c=300)
# 相同的会发生覆盖
# 返回结果：{'a': 2, 'b': 100, 1: 'abc', 'c': 300}
1
2
3

dict.fromkeys('abcde')
# 没有指定value，默认None
# 返回结果：{'a': None, 'b': None, 'c': None, 'd': None, 'e': None}
1
2
3

dict.fromkeys('abcde', 100)
# 指定value值为100，默认都是100
# 返回结果：{'a': 100, 'b': 100, 'c': 100, 'd': 100, 'e': 100}
1
2
3

d1 = dict.fromkeys('abcde', [1])
d1
# 返回结果：{'a': [1], 'b': [1], 'c': [1], 'd': [1], 'e': [1]}
1
2
3

d1['d']
# key 是 hash 的
# 先对d求哈希值，有了hash值就知道对应的内存地址了
# 返回结果：[1]
1
2
3
4

d1['d'] = 5
d1
# 修改key的值
# 返回结果：{'a': [1], 'b': [1], 'c': [1], 'd': 5, 'e': [1]}
1
2
3
4

d1['b'][0] = 2
d1
# 把b中列表的0改成2，其他的值也变了，是因为他们引用的都是同一个内存地址
# 返回结果：{'a': [2], 'b': [2], 'c': [2], 'd': 5, 'e': [2]}
1
2
3
4

d1 = {'a':1, 'b':'abc', 'c':False}
d1
# 返回结果：{'a': 1, 'b': 'abc', 'c': False}
1
2
3

d1['c']
# 返回结果False是c的值hash定位原理
# 返回结果：False
1
2
3

'd' in d1, 'c' in d1
# 字典只有使用了key来做判断，才是最优秀的，时间复杂的是O(1)
# 返回结果：(False, True)
1
2
3

d1
# d1的现有值
# 返回结果：{'a': 1, 'b': 'abc', 'c': False}
1
2
3

d1.get('b')
# 使用get查询
# 返回结果：'abc'
1
2
3

d1.get('d')
# get不抛异常，返回了None
1
2

d1 = {'a': 1, 'b': 'abc', 'c': False, 'd':None}
d1
# 重新定义d1的值
# 返回结果：{'a': 1, 'b': 'abc', 'c': False, 'd': None}
1
2
3
4

d1.setdefault('f', 234)
# 返回结果：234
# 字典中添加值
d1
# 返回结果：{'a': 1, 'b': 'abc', 'c': False, 'd': None, 'f': 234}
1
2
3
4
5

d1.setdefault('e')
# 字典中添加值
# 默认value值是None
d1
# 返回结果：{'a': 1, 'b': 'abc', 'c': False, 'd': None, 'f': 234, 'e': None}
1
2
3
4
5

del d1 
# 代表删除整个字典
1
2

del d1['e'] 
# 删除字典中的e
1
2

---

报错

dist(range(5))
# 字典必须是key/value的结构 也就是键值对
# 返回结果：NameError: name 'dist' is not defined
1
2
3

d1['d']
# 因为没有d这个key
# 返回结果：KeyError: 'd'
1
2
3