day11-元組與字典

1、元組Tuple與列表類似，不同之處在于元組的元素不能修改。

元組使用小括號，列表使用中括號。
元組可以查詢，可以使用內置函數count、index。但是不能修改、增加、刪除（兒子不能，孫子有可能）。
name = ('a','a','b')
print(name.count('a'))
2
可以索引，可以切片（步長）。
name = ('a','a','b')
print(name[2])
b

2、字典：
使用大括號來表示字典，前面是元素的名字，后面是元素的值（可以是字符，也可以是數字或其他任意類型），中間用冒號隔開。

info = {'name':'xiaowang','sex':'f','address':'中國北京'}
print(info)
{'name': 'xiaowang', 'sex': 'f', 'address': '中國北京'}

字典的查詢效率比列表快，因為字典首先將key值進行hash并進行排序，當查詢字典時只需查詢key的hash值，而不需要從頭進行循環，由于hash值進行了有序排序所以查詢快
而列表不能對元素建立一個索引，所以只能從頭循環查找

字典常見操作一：
2.1 按key值查詢元素的值
>>> info['name']
'xiaowang'

2.2、get()查詢
查詢時，如果查詢一個字典中不存在的元素，則程序會報錯。為了不報錯，可以使用get方法來查詢字典
a.get('age') //不會返回任何值
a.get('age',0) //會將age的默認值設置為0，但是不會將默認值添加到字典中。
a.get('name','ddd') //會返回name的值abc，如果查詢到了元素的值，則不會修改元素的值。

2.3、修改元素的值
>>> info['name'] = 'xiaozhang'
>>> info
{'name': 'xiaozhang', 'sex': 'f', 'address': '中國北京'}

2.4、添加元素的值
>>> info['high']= '170cm'

2.5、dict.setdefault(key, default)
許多時候我們需要往字典中的元素添加數據，我們首先要判斷這個元素是否存在，不存在則創建一個默認值，存在則不變動。我們可以使用 dict.setdefault(key, default) 。
info.setdefault('sex','m')
print(info)
{'name': 'xiaowang', 'sex': 'f', 'address': '中國北京'}

2.6、刪除元素的值,有del和clear、pop三種方法
>>> del info['high'] 刪除high元素的值
>>> del info 刪除整個info字典，如果del了整個字典后，再想在info中添加元素，則需要重新定義info字典。
>>> info.clear() 清空字典中所有元素的值，但是字典本身還在，只是成為了一個空字典
>>> info
>>> {}

pop(key) 函數，可以返回 key 對應的 value，并將該 key:value 鍵值對刪除：

?

用pop()刪除時可以指定字符串，如果要刪除的key不存在時，則返回指定字符串，而不會報錯
print(user.pop('tel','111'))
111
{'name': 'xiaozhang', 'sex': 'f', 'address': '中國北京'}

#popitem()會隨機刪除字典中的鍵值對
user.popitem()

2.7、創建字典
同 set 一樣，字典也可以使用 dict 函數進行創建，參數是一個包含若干個二元組的元組（注意括號的數量）：
dic = dict(((1,'Linux'), (2,'Vim')))
print(dic)
{1: 'Linux', 2: 'Vim'}

2.8、len()
測量字典中鍵值的個數
>>>dict = {'name':'zhangsan','sex':'m'}
>>>len(dict)
2

2.9、keys
返回一個包含字典所有key的列表
>>>dict = {'name':'zhangsan','sex':'m'}
>>>dict.keys()
dict_keys(['name','sex'])

>>>for i in dict.keys():
print(i)

2.10、values
返回一個包含字典中所有值的列表
>>>dict = {'name':'zhangsan','sex':'m'}
>>>dict.values()
dict_values(['zhangsan','m'])

>>>for i in dict.values():
print(i)

2.11、items
返回一個包含所有（鍵、值）元組的列表
>>> info.items()
dict_items([('name', 'xiaowang'), ('sex', 'f'), ('address', '中國北京')])

for i,j in temp:
? ? print('key:%s,value:%s'%(i,j))

key:name,value:xiaowang
key:sex,value:f
key:address,value:中國北京

user = {'name': 'xiaozhang', 'sex': 'f', 'address': '中國北京'}
print(list(user.keys()))
print(list(user.values()))
print(list(user.items()))

['name', 'sex', 'address']
['xiaozhang', 'f', '中國北京']
[('name', 'xiaozhang'), ('sex', 'f'), ('address', '中國北京')]

#獲取字典的key和value有以下兩種方法，建議用第一種方法效率高，因為第二種方法是先將字典轉換成一個列表，再輸出
user = {'name': 'xiaozhang', 'sex': 'f', 'address': '中國北京'}
for key in user:
print(key,user[key])

for k,v in user.items():
print(k,v)

2.12、has_key(在python2中有，3中沒有這個方法，3中使用get()方法）
如果key在字典中，返回True，否則返回False
>>>dict = {'name':'zhangsan','sex':'m'}
>>>dict.has_key('name')
True
>>>dict.has_key('phone')
False

2.13、type(info)
可以查看info的類型是字典
<class 'dict'>

2.14、help(info)
可以查看info字典可以用的方法，info是字典的名字。

2.15、dict.fromkeys() 生成一個字典，用列表中的每一個元素作為一個key，可以指定value的默認值，如果不指定則value為None
user = ['tom','Jack','mike']
dict_user1 = dict.fromkeys(user,1)
print(dict_user1)
{'tom': 1, 'Jack': 1, 'mike': 1}

也可以將value指定成一個列表
user = ['tom','Jack','mike']
dict_user1 = dict.fromkeys(user,[1,2,3])
print(dict_user1)
{'tom': [1, 2, 3], 'Jack': [1, 2, 3], 'mike': [1, 2, 3]}

但是如果更改了任意一個value列表中的某個值，則所有value的值都會跟著更改

dict_user1['mike'][0]=0
print(dict_user1)
#{'tom': [0, 2, 3], 'Jack': [0, 2, 3], 'mike': [0, 2, 3]}

2.16、update()將兩個字典進行合并
dict_1 = {'a':1,'b':2}
dict_2 = {'c':3,'d':4}
dict_1.update(dict_2)
print(dict_1)

#{'a': 1, 'b': 2, 'c': 3, 'd': 4}

2.17、copy()? 淺copy
第2個字典copy第1個字典，修改字典中的值時，如果元素是不可變數據類型，則另一個字典不會隨著改，如果元素是可變數據類型（列表、字典），則另一個字典也會隨著改變。2個字典的id是不一樣的，但是字典內元素的id是一樣的，所以如果元素是列表或字典，當更改列表或字典內的值時，2個變量都是改變。

card_1 = {'name':'tom','acc':{'id':111,'balance':1000}}
card_2 = card_1.copy()
card_2['name'] = "tom's wife"
print(card_1)
print(card_2)
card_1['acc']['balance']-=100
print(card_1)
print(card_2)

{'name': 'tom', 'acc': {'id': 111, 'balance': 1000}}
{'name': "tom's wife", 'acc': {'id': 111, 'balance': 1000}}
{'name': 'tom', 'acc': {'id': 111, 'balance': 900}}
{'name': "tom's wife", 'acc': {'id': 111, 'balance': 900}}

2.18、copy.deepcopy(x)? 深copy
#修改字典中的值時，其他字典不會隨著改變，深copy是形成了兩個完全獨立的變量，變量id和變量內元素的id，以及可變元素內層的元素id都是不一樣的
card_1 = {'name':'tom','acc':{'id':111,'balance':1000}}
card_2 = card_1.copy()
card_2['name'] = "tom's wife"
import copy
card_3 = copy.deepcopy(card_1)
card_3['name'] = 'mike'
print(card_1)
print(card_2)
print(card_3)
card_1['acc']['balance']-=100
print(card_1)
print(card_2)
print(card_3)

{'name': 'tom', 'acc': {'id': 111, 'balance': 1000}}
{'name': "tom's wife", 'acc': {'id': 111, 'balance': 1000}}
{'name': 'mike', 'acc': {'id': 111, 'balance': 1000}}
{'name': 'tom', 'acc': {'id': 111, 'balance': 900}}
{'name': "tom's wife", 'acc': {'id': 111, 'balance': 900}}
{'name': 'mike', 'acc': {'id': 111, 'balance': 1000}}

2.19、排序

d = {'Tom':20, 'Jack':22, 'Mike':28, 'Rose':30}
print(sorted(d.keys())) #將key值進行排序
['Jack', 'Mike', 'Rose', 'Tom']

print(sorted(d.values()))#將value值進行排序
[20, 22, 28, 30]

print(sorted(d.items()))#按key值對鍵值對進行排序
[('Jack', 22), ('Mike', 28), ('Rose', 30), ('Tom', 20)]

print(sorted(d.items(),key=lambda i:i[1])) #按value值對鍵值對進行排序
[('Tom', 20), ('Jack', 22), ('Mike', 28), ('Rose', 30)]

-----------------------------------------------------
例子：
將字典中的key鍵含有'k'元素的所有鍵值對刪除。
由于在循環一個字典時，不能改變該字典的大小，所以不能直接在for循環的時候直接刪除字典中的鍵值對，只能將需要刪除的key先保存在一個列表中，再循環這個列表去刪除字典中的鍵值對。

dic = {'k1':'v1','k2':'v2','k3':'v3','name': 'alex'}
L1 = []
for key in dic:if 'k' in key:L1.append(key)
for key in L1:del dic[key]
print(dic)

結果：{'name': 'alex'}

?