標準數據類型--字典 集合

標準數據類型--字典簡介

• 列表是數值索引，不支持其它索引，並且列表相對較慢，字典是一種無序可變容器，且可存儲任意類型對象。字典的每一個鍵(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}