• 列表是数值索引，不支持其它索引，而且列表相对较慢，字典是一种无序可变容器，且可存储任意类型对象。字典的每个键(key=>value)对用冒号(:)分割，每个对之间用逗号分割，整个字典包括在花括号{}中。字典键必须唯一且不可变，值可以是任意类型，也可以重复。
• 字典格式：d = {key1 : value1, key2 : value2 }

1 . 初始化

In [146]: d={}                                                                                        

In [147]: d={‘name‘:‘zhangsan‘}                                                           

In [148]: d                                                                                             

Out[148]: {‘name‘: ‘zhangsan‘}

In [150]: d=dict.fromkeys(‘abc‘,‘test‘) 

In [152]: d                                                                                             

Out[152]: {‘a‘: ‘test‘, ‘b‘: ‘test‘, ‘c‘: ‘test‘}

2.增加,修改元素

• d[‘key1‘] = ‘value1‘
• d.update({‘key‘:‘value‘})
• d.setdefault(‘key‘,‘test‘)

列如：

In [153]: d.update({‘age‘:20})                                                                              

In [154]: d                                                                                                 
Out[154]: {‘a‘: ‘test‘, ‘b‘: ‘test‘, ‘c‘: ‘test‘, ‘age‘: 20}

In [155]: d.setdefault(‘age‘,‘100‘)        
如果键‘key‘，存在不对字典操作，如果‘key‘不存在，则添加 ‘key‘:‘test‘

Out[155]: 20

In [156]: d                                                                                                 
Out[156]: {‘a‘: ‘test‘, ‘b‘: ‘test‘, ‘c‘: ‘test‘, ‘age‘: 20}

3.查看键值

• d.keys()
• d.values()
• d.items()

列如：

In [157]: d.keys()                               \\查看键                                                           
Out[157]: dict_keys([‘a‘, ‘b‘, ‘c‘, ‘age‘])

In [158]: d.values()                              \\查看值                                                
Out[158]: dict_values([‘test‘, ‘test‘, ‘test‘, 20])

In [159]: d.items()                                \\查看全部                                                         
Out[159]: dict_items([(‘a‘, ‘test‘), (‘b‘, ‘test‘), (‘c‘, ‘test‘), (‘age‘, 20)])

4.获取单个键值

• d.get(key[,d])
• d.pop(key[,d])
• a.popitem()

列如：

In [165]: d                                                                                                 

Out[165]: {‘a‘: ‘test‘, ‘b‘: ‘test‘, ‘c‘: ‘test‘, ‘age‘: 20}

In [166]: d.get(‘a‘)                                                                                        
Out[166]: ‘test‘

In [166]: d.get(‘a‘)                                                                                        
Out[166]: ‘test‘

In [173]: d.popitem()                    \\随机删除                                                                   
Out[173]: (‘c‘, ‘test‘)

5.其他方法

• d1.clear()
• key in d
• key not in d
• del(D[‘tom‘]) \将字典D中的 键为 ‘tom‘的元素删除掉

列如：

In [187]: d1                                                                                                
Out[187]: {‘name‘: ‘lisi‘, ‘age‘: ‘20‘}

In [188]: d1.clear()                           \\清除所有                                                            

In [189]: d1                                                                                                
Out[189]: {}

In [198]: d={"name":"zhangsan","dizhi":"beijin"}    

In [201]: "name" in d                                                                                       
Out[201]: True

In [202]: "name" not in d                                                                                   
Out[202]: False

In [206]: del(d[‘name‘])

标准数据类型--集合

set和dict类似，是一组key的集合没有value 而且keys不可以重复并且必须为不可变对象。相当于一个只有key没有value的字典。

1. 创建集合

In [209]: t1=set([1,2,3,4,5,6])                                                                             

In [210]: type(t1)                                                                                          
Out[210]: set

2.增

• add(添加元素)
• update（将两个集合合并到一块）

例如:

In [211]: t1.add(‘abc‘) 

In [215]: t1.update(a)  

3.删

• clear （清空）
• discard（删除一个元素，如果元素不存在什么也不做）
• pop （随机弹出一个元素）
• remove （删除指定元素，若不存在则异常）

列如：

In [217]: t1                                                                                                
Out[217]: {1, 2, 3, 4, 5, 6, ‘a‘, ‘abc‘, ‘d‘, ‘f‘, ‘g‘, ‘h‘, ‘j‘, ‘s‘, ‘test‘}

In [218]: t1.discard(‘abc‘)                                                                                 

In [219]: t1.pop()                                                                                          
Out[219]: 1

In [220]: t1.pop()                                                                                          
Out[220]: 2

In [221]: t1.remove(‘test‘)                                                                                 

In [222]: t1.clear()                                                                                        

In [223]: t1                                                                                                
Out[223]: set()

4.判断

• isdisjoint (没有交集返回True)
• issubset (A.issubset(B),判断集合A是不是集合B的子集)
• issuperset (A.issuperset(B),判断集合A是不是集合B的父集合)

列如：

In [234]: a=set([1,2,3,4,5,6])                                                                              

In [235]: b=set([2,3,4,5,6,7])                                                                   
In [237]: c=set([2,3,4])

In [236]: a.isdisjoint(b)                                                                                   
Out[236]: False

In [238]: c.issubset(a)                                                                                     
Out[238]: True

In [239]: a.issuperset(c)                                                                                   
Out[239]: True

5.求差集

• difference A.difference(B),在集合A中但不再集合B中
• difference_update A.difference_update(B)，类似difference，区别是将结果复制给A.
• symmetric_difference 返回两个集合中不同的元素
• symmetric_difference_update A.symmetric_difference_update(B),返回两个集合中的不同元
  素，并将结果赋值给A

例如：

In [240]: a                                                                                                 
Out[240]: {1, 2, 3, 4, 5, 6}

In [241]: b                                                                                                 
Out[241]: {2, 3, 4, 5, 6, 7}

In [242]: c                                                                                                 
Out[242]: {2, 3, 4}

In [243]: a.difference(b)                                                                                   
Out[243]: {1}

In [246]: a.difference_update(c)                                                                            

In [247]: a                                                                                                 
Out[247]: {1}

In [248]: b.symmetric_difference(c)                                                                         
Out[248]: {5, 6, 7}

In [249]: b.symmetric_difference_update(c)                                                                  

In [250]: b                                                                                                 
Out[250]: {5, 6, 7}

6.求交集

• intersection A.intersection(B),返回两个集合的交集
• intersection_update A.intersection_update(B),返回集合A和集合B的交集，并将结果赋值给A
• 也可以直接使用 & 符号
  列如：

In [254]: a=set([1,2,3,4,5,6])                                                                              

In [255]: b=set([2,3,4,5])                                                                                  

In [256]: a.intersection(b)                                                                                 
Out[256]: {2, 3, 4, 5}

In [257]: a.intersection_update(b)                                                                          

In [258]: a                                                                                                 
Out[258]: {2, 3, 4, 5}

7.求并集

• union 返回两个集合的并集

列如：

In [262]: a=set([1,2,3,4,5])                                                                                

In [263]: b=set([5,6,7,8,9])                                                                                

In [264]: a.union(b)                                                                                        
Out[264]: {1, 2, 3, 4, 5, 6, 7, 8, 9}

7.深拷贝

• copy （深拷贝）
  列如：

In [270]: a=b.copy()                                                                                        

In [271]: b                                                                                                 
Out[271]: {5, 6, 7, 8, 9}

In [272]: a                                                                                                 
Out[272]: {5, 6, 7, 8, 9}

In [273]: b.add("test")                                                                                     

In [274]: b                                                                                                 
Out[274]: {5, 6, 7, 8, 9, ‘test‘}

In [275]: a                                                                                                 
Out[275]: {5, 6, 7, 8, 9}

标准数据类型--字典 集合

原文：https://blog.51cto.com/14400213/2537753