Python 数据类型 之 字典集合

字典 dict

字典是键:值对（key:value）的无序集合，具有极快的查找速度(相当于加了索引)。序列类似数组，字典类似关联数组.  

创建字典：

dc={'k1':'v1','k2':'v2'} 或 dc=dict({'k1':'v1','k2':'v2'})

注意：key必须是不可变对象，因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。要保证hash的正确性，作为key的对象就不能变。

常用操作方法：

• 新增  obj['key']=value ，obj.update()
• 删除  obj.pop()
• 键、值、键值对  obj.keys(), obj.values(), obj.items()
• 迭代 for/while，对字典的循环默认返回keys
• 长度 len()  

| clear(...)　　''' 清空所有元素 '''
| D.clear() -> None. Remove all items from D.

| copy(...)　　''' 浅拷贝 '''
| D.copy() -> a shallow copy of D

| fromkeys(iterable, value=None, /) from builtins.type  ''' 以序列seq中元素做字典的键，value为字典所有键对应的初始值创建一个新字典'''
| Returns a new dict with keys from iterable and values equal to value.

>>> dc.fromkeys(['k1','k2','k3'],10)  
{'k1': 10, 'k2': 10, 'k3': 10}

| get(...)   ''' 根据key获取值，不存在则返回d, d默认为None(命令行看不到结果，可以赋值)'''

| D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.

>>> dc={'k1':'v1','k2':'v2'}

>>> dc.get('k3','v3')

'v3'

>>> print(dc)

{'k1': 'v1', 'k2': 'v2'}


| setdefault(...)　　
| D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D

>>> dc.setdefault('k3','v3')

'v3'

>>> print(dc)
{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}


| keys(...)　　''' 返回所有的key 存为列表 '''
| D.keys() -> a set-like object providing a view on D's keys

| values(...)　　''' 返回所有的 值 存为列表 '''
| D.values() -> an object providing a view on D's values

| items(...)　　''' 返回所有的key:value 存为列表 '''
| D.items() -> a set-like object providing a view on D's items

>>> dc.keys()
dict_keys(['k1', 'k2'])
>>> dc.values()
dict_values(['v1', 'v2'])

>>> dc.items()
dict_items([('k1', 'v1'), ('k2', 'v2')])

| pop(...)  ''' 移除指定key的值，并获取到这个值, 若key不存在则异常 '''
| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
| If key is not found, d is returned if given, otherwise KeyError is raised

>>> dc={'k1': 'v1', 'k2': 'v2'}

>>> dc.pop('k2')
'v2'

| popitem(...)　　''' 随机移除一个键值对，并获取到这个键值对（字典是无序的，没有所谓的最后一项或是其它顺序）'''
| D.popitem() -> (k, v), remove and return some (key, value) pair as a
| 2-tuple; but raise KeyError if D is empty.

>>>  dc={'k1': 'v1', 'k2': 'v2','k3':'v3'}

>>> dc.popitem()
('k3', 'v3')


| update(...)  ''' key存在则更新值，不存在则新加键值对 '''
| D.update([E, ]**F) -> None. Update D from dict/iterable E and F.

>>> dc={'k1': 'v1', 'k2': 'v2'}

>>> dc.update({'k2': 'v4'})

>>> dc.update({'k3': 'v3'})

>>> print(dc)
{'k1': 'v1', 'k2': 'v4', 'k3': 'v3'}

 

集合 set

集合是一个无序且不重复的元素集合

内部是key:value, 只是不需要关注里面的key ,内存自己维护，访问速度快，原生解决了重复问题。

创建集合:　

st={'a','b','c'}  或 st=set({'a','b','c'})

>>> st1=set(['b','o','o','k'])　　''' 自动去重 ，且无序'''

>>> print(st1)

{'b', 'k', 'o'}

注意：集合是一组无序排列的可哈希的值，它本身是可变对象。但不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证集合内部“不会有重复元素”。

>>> st={'a',[1,2],'b'}

TypeError: unhashable type: 'list'

集合常用操作方法：

• 包含 in/not in
• 迭代 for/while
• 添加 add()
• 删除 pop() , remove()
• 拷贝 copy()
• 交集 st1 & st2    st1.intersection(st2)  
• 并集 st1 | st2st1.union(st2)  
• 差集 st1 - st2     st1.difference(st2)    
• 对称差集   st1 ^ st2    st1.symmetric_difference(st2)

不支持 索引 、切片

| add(...)　　''' 添加元素 '''
| Add an element to a set.
| 
| This has no effect if the element is already present. 

| clear(...)　　''' 清空元素 '''
| Remove all elements from this set.

| copy(...)  ''' 浅拷贝 '''
| Return a shallow copy of a set. 



| discard(...)　　''' 移除集合中的某个元素， 若元素不在集合中则不做任何操作'''
| Remove an element from a set if it is a member.
| If the element is not a member, do nothing.

| pop(...)　　''' 随机移除移除集合中的元素（没有参数），并返回该元素 '''
| Remove and return an arbitrary set element.
| Raises KeyError if the set is empty.

| remove(...)　　''' 移除移除集合中的某个元素，若元素不在集合中则异常 '''
| Remove an element from a set; it must be a member.
| If the element is not a member, raise a KeyError.

 

| isdisjoint(...)　　''' 如果两个集合没有交集则返回True '''
| Return True if two sets have a null intersection.

| issubset(...)　　''' 是否是另外一个集合的子集 '''
| Report whether another set contains this set.

| issuperset(...)　　''' 是否是另外一个集合的父集 '''
| Report whether this set contains another set.



| difference(...)　　''' 取新集合关于原集合的相对补集才即差集，返回一个新的集合对象 '''
| Return the difference of two or more sets as a new set.

| difference_update(...)   '''  取新集合关于原集合的相对补集才即差集，更新原集合 '''
| Remove all elements of another set from this set.

| symmetric_difference(...)　　''' 取除去两个集合并集的所有元素，即去重，返回一个新的集合对象 '''
| Return the symmetric difference of two sets as a new set.

| symmetric_difference_update(...)　　''' 取除去两个集合并集的所有元素，即去重。更新原集合 '''
| Update a set with the symmetric difference of itself and another.

>>> st1={'b','e','d'}

>>> st2={'b','a','d'}

>>> st3=st1.difference(st2)

>>> print(st1,st2,st3)
{'e', 'd', 'b'} {'a', 'd', 'b'} {'e'}

>>> st3=st1.symmetric_difference(st2)

>>> print(st1,st2,st3)
{'e', 'd', 'b'} {'a', 'd', 'b'} {'e', 'a'}

| intersection(...)　　''' 取两个集合的交集，返回一个新的集合 '''
| Return the intersection of two sets as a new set.

| intersection_update(...)   ''' 取两个集合的交集，并更新原集合 '''
| Update a set with the intersection of itself and another.

>>> st1={'b','e','d'}

>>> st2={'b','a','d'}

>>> st3=st1.intersection(st2)

>>> print(st1,st2,st3)

{'e', 'd', 'b'} {'a', 'd', 'b'} {'b', 'd'}

| union(...)　　''' 取两个集合的并集， 返回一个新的集合 '''
| Return the union of sets as a new set.

| update(...)　　''' 取两个集合的并集，更新原集合  '''
| Update a set with the union of itself and others.

>>> st1={'b','e','d'}

>>> st2={'b','a','d'}

>>> st3=st1.union(st2)

>>> print(st1,st2,st3)
{'e', 'd', 'b'} {'a', 'd', 'b'} {'a', 'b', 'e', 'd'}