15.1-創建字典：
第一種方式：
說明：字典的鍵不僅僅可以是字符串，也可以是數字。
>>> dic = {
... "k1" : 11,
... "k2" : 22,
... 3 : 33
... }
>>> type(dic)
<type 'dict'>
第二種方式：
>>> dic = dict({
... "k1" : 11,
... "k2" : 22,
... 3 : 33
... })
>>> type(dic)
<type 'dict'>
def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
"""
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)
# (copied from class doc)
"""
pass
通過源碼可以看出 dict 可以初始化一個映射對象的 (鍵,值)對，即創建一個與該映射對象具有相同鍵-值對的字典。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = dict(k1 = 11,k2 = 22)
print(dic)
運行結果：
還可以接收一個可迭代對象，會將可迭代對象里的元素通過for循環一遍，將其元素當做字典的值，而鍵是默認沒有的，所以可以通過 enumerate() 函數給它加一個序號，當做字典的鍵。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
li = [11,22,33,44]
dic = dict(enumerate(li))
print(dic)
運行結果：
15.2-索引
說明：由于字典是無序的，所以字典是通過鍵來進行索引的，索引取值時，若是鍵不存在就會報錯。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
# 索引
print(dic["k2"])
運行結果：
注：字典是不能夠進行切片的。
15.3-for循環：
默認循環：
循環時默認循環的是 key。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
# 默認循環是 key
for i in dic:
print(i)
運行結果：
循環key：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
# 循環key，和默認循環相同
for i in dic.keys():
print(i)
運行結果：
注：和默認循環相同。
循環value：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
# 循環 value
for i in dic.values():
print(i)
運行結果：
循環key-value：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
# 循環 鍵值對
for k,v in dic.items():
print(k,v)
運行結果：
15.4-字典（dict）內部方法介紹：
clear(self)：
說明：刪除字典中所有的元素。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
print(dic)
# 清空字典
dic.clear()
print(dic)
運行結果：
copy(self)：
說明：淺拷貝。
fromkeys(*args, **kwargs)：
說明：創建一個新的字典，第一個元素為可迭代的對象，將其中的元素作為字典的鍵，第二個元素為字典所有鍵對應的值。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = dict.fromkeys(["k1","k2","k3"],123456)
print(dic)
運行結果：
簡單深入的例子：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic1 = dict.fromkeys(["k1","k2","k3"],11)
print(dic1)
dic2 = {"k1":11,"k2":11,"k3":11}
print(dic2)
運行結果：
注：默認生成一個字符串或者一個數字時，以上兩個之間是沒有區別的，但是如果生成的是一個列表或其它類型就有區別了。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic1 = dict.fromkeys(["k1","k2","k3"],[])
print("dic1:",dic1)
dic2 = {"k1":[],"k2":[],"k3":[]}
print("dic2:",dic2)
print("-----" * 8)
# 在 空列表 里追加內容，通過 fromkeys 創建時，所有的鍵 共同對應著 同一個列表
dic1["k1"].append("11")
print("dic1",dic1)
# 每一個列表各自占一個內存
dic2["k1"].append("11")
print("dic2",dic2)
運行結果：
get(self, k, d=None)：
說明：返回指定鍵的值， k 表示要指定的鍵， d 表示指定鍵不存在時返回的值，默認返回None。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
# 返回 "k2" 的值
ret = dic.get("k2")
print(ret)
# 指定鍵不存在時，默認返回 None
ret2 = dic.get("k4")
print(ret2)
# 指定鍵不存在時，設置返回值
ret3 = dic.get("k4",0)
print(ret3)
運行結果：
items(self)：
說明：將字典中的鍵值對組成元組，并放到列表中返回。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
ret = dic.items()
print(ret)
運行結果：
keys(self)：
說明：返回一個包含字典中鍵的列表。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
ret = dic.keys()
print(ret)
運行結果：
pop(self, k, d=None)：
說明：移除字典中指定鍵對應的值，并返回該鍵對應的值， k 表示指定的鍵， d 表示當鍵不存在又不想處理異常時填寫即可。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
# 刪除 "k2" 并返回 "k2" 對應的值
ret = dic.pop("k2")
print(ret)
print(dic)
# 當 "k4" 不存在時，輸出 "0"
ret2 = dic.pop("k4",0)
print(ret2)
運行結果：
popitem(self)：
說明：隨機刪除字典中一對鍵和值，并返回該鍵值對。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
# 隨即刪除并返回
print(dic.popitem())
print(dic)
運行結果：
setdefault(self, k, d=None)：
說明：如果指定鍵不存在，則創建鍵，如果存在則返回該鍵對應的值， k 表示指定的鍵， d 表示指定鍵不存在時，設置的默認值，默認為None。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
# 指定鍵存在時，返回該鍵對應的值
ret1 = dic.setdefault("k2")
print(ret1)
# 指定鍵不存在時，則創建該鍵，該鍵默認值為 None
ret2 = dic.setdefault("k4")
print(ret2)
# 設置默認值
ret3 = dic.setdefault("k5",55)
print(ret3)
print(dic)
運行結果：
update(self, E=None, **F)：
說明：更新，將一個字典中的鍵值對更新到另一個字典中，如果字典原有的鍵與新添加的鍵重復，則新添加的覆蓋原有的， E 表示添加到指定字典中的字典。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic1 = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
dic2 = {
"k3" : "v3v3",
"k4" : 44,
"k5" : 55
}
dic1.update(dic2)
print(dic1)
運行結果：
values(self)：
說明：返回一個包含字典中值的列表。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
ret = dic.values()
print(ret)
運行結果：
15.5-檢查字典中指定key是否存在：
可以通過 in 來查看指定 key 是否存在字典中，如果存在字典中返回 True ，否則返回 False。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
# 指定 鍵 存在字典中
ret1 = "k2" in dic.keys()
print(ret1)
# 指定 鍵 不存在字典中
ret2 = "k4" in dic.keys()
print(ret2)
運行結果：
既然可以通過 in 來查看指定 key 是否存在字典中，那么也是可以通過 in 來查看指定 value 是否存在字典中的。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
# 指定 值 存在字典中
ret1 = 33 in dic.values()
print(ret1)
# 指定 值 不存在字典中
ret2 = 44 in dic.values()
print(ret2)
運行結果：
15.6-刪除字典指定鍵值對：
通過 del 關鍵字刪除字典中指定的鍵值對。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"k1" : 11,
"k2" : 22,
"k3" : 33
}
print(dic)
# 刪除 "k1" 這個鍵值對
del dic["k1"]
print(dic)
運行結果：
15.7-enumerate()函數：
說明： enumerate(iterable, start=0) 根據可迭代對象創建枚舉對象，即同時返回索引和值， iterable 表示接受一個可迭代對象， start 表示指定索引的起始值，默認為0。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
li = ["手機","電腦","汽車用品","圖書"]
# 起始值從 1 開始，默認為 0
for key,item in enumerate(li,1):
print(key,item)
choice = int(input("請選取商品:"))
# 索引是從 0 開始的，只不過打印是從 1 開始的
# 所以選 1 的時候打印的還是電腦，所以可以讓輸入的值 -1
buy = li[choice-1]
print(buy)
運行結果：
15.8-練習題：
元素分類：
要求：有如下值集合[11,22,33,44,55,66,77,88,99,90]將所有大于 66 的值保存至字典的第一個key中，將小于 66 的值保存至第二個key的值中。即： {'k1': 大于66的所有值, 'k2': 小于等于66的所有值}。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
l1 = [11,22,33,44,55,66,77,88,99,90]
dic = {
"k1" : [],
"k2" : []
}
# 循環 l1 并對里面每一個元素進行判斷
for i in l1:
if i > 66:
dic["k1"].append(i)
else:
dic["k2"].append(i)
print(dic)
運行結果：
通過for循環將列表轉換成字典：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
li = [11,22,33,44]
dic = {}
# key 是從 10 開始遞增的
for k,v in enumerate(li,10):
dic[k] = v
print(dic)
# dic = dict(enumerate(li,10)) # 上面的循環就是字典內部的本質，就是說這一句的本質就是上面的循環
# print(dic)
運行結果：
查找列表中符合條件元素：
要求：查找列表中元素，移除每個元素的空格，并查找以 a或A開頭 并且以 c 結尾的所有元素。
li = ["alec", " aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}
注：以上三個任選其一即可。
列表：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
li = ["alec", " aric", "Alex", "Tony", "rain","abcd"]
for i in li:
i = i.strip()
#if 判斷的順序是從前到后的，如果第一個條件為 True 后面跟著 or 就表示自己成功就行了，就不會去判斷后面的了
# 前面加一個括號，將這個括號當成了一個整體
if (i.startswith("a") or i.startswith("A")) and i.endswith("c"):
print(i)
運行結果：
元組：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
li = ("alec", " aric", "Alex", "Tony", "rain","abcd")
for i in li:
i = i.strip()
if (i.startswith("a") or i.startswith("A")) and i.endswith("c"):
print(i)
運行結果：
字典：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}
for i in dic.values():
i = i.strip()
if (i.startswith("a") or i.startswith("A")) and i.endswith("c"):
print(i)
運行結果：
