python----字典_将下列字典实例化。 d={‘b’:1,’a’:0,’c’:2}

python----字典

---

创建字典

# 创建空字典
dit1 = {}
dit2 = dict()
print(type(dit1),type(dit2))    # <class 'dict'> <class 'dict'>

# 创建字典并初始化值
d1 = {"a":1,"b":2,"c":3}
print(d1)           # {'a': 1, 'b': 2, 'c': 3}
d2 = dict(a=1,b=2,c=3)
print(d2)           # {'a': 1, 'b': 2, 'c': 3}
ls1 = ["a","b","c"]
ls2 = [1,2,3]
d3 = dict(zip(ls1,ls2))
print(d3)           # {'a': 1, 'b': 2, 'c': 3}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意：{键1：值1，键2：值2}，字典的元素是由键值对组成

获取键-值对的数量

字典的键不可重复

函数：len()
作用：返回字典键-值对的数量，也就是字典元素个数。

dit = {'a': 1, 'b': 2, 'c': 3}
le = len(dit)
print(le)       # 3
1
2
3

用键查找字典的值

dit = {'键1':'值1','键2':'值2','键3':'值3'}
print(dit['键1'])    # 值1
print(dit['键2'])    # 值2
print(dit['键3'])    # 值3
1
2
3
4

修改字典元素

dit = {'键1':'值1','键2':'值2','键3':'值3'}
dit['键1'] = 666
dit['键2'] = 888
dit['键3'] = 999
# 若字典中没有这个键，则添加一个键值dui
dit['键4'] = "haha"
print(dit)      # {'键1': 666, '键2': 888, '键3': 999, '键4': 'haha'}
1
2
3
4
5
6
7

注意：建议使用 dit[‘键4’] = "haha"添加键值对，不建议用fromkeys() 添加键值对。

del删除字典元素

dit = {'键1': 666, '键2': 888, '键3': 999, '键4': 'haha'}
del dit['键1'],dit['键2']
print(dit)      # {'键3': 999, '键4': 'haha'}
# 删除整个字典
del dit
print(dit)  # 报错：NameError: name 'dit' is not defined. Did you mean: 'dir'?
1
2
3
4
5
6

查看字典中是否存在某个键

dit = {'键1': 666, '键2': 888, '键3': 999, '键4': 'haha'}
a = '键1' in dit
print(a)        # True
b = 'aa' in dit
print(b)        # False
1
2
3
4
5

字典方法

（1）、fromkeys()

功能：使用一组键和默认值创建字典
格式：字典.fromkeys(键，值)
返回值：创建的新字典
注意：若键是一个序列，则序列不同元素为键指向同一个空间的地址值（值相同）

dic = {}.fromkeys("a","haha")
print(dic)      # {'a': 'haha'}

lst = ["键1","键2","键3"]
dic1 = {}.fromkeys(lst,"666")
print(dic1)     # {'键1': '666', '键2': '666', '键3': '666'}
# "键1","键2","键3",对应的值都都同时指向同一个内存地址
print(id(dic1['键1']))   # 1881642265200
print(id(dic1['键2']))   # 1881642265200
print(id(dic1['键3']))   # 1881642265200
print(dic1['键1'] is dic1['键2'])     # True
1
2
3
4
5
6
7
8
9
10
11

（2）、update()

功能：批量更新(有该键就更新,没该键就添加)
格式：字典.update(字典) 、字典.update(键1=值1，键2=值2)
返回值：None
注意：新添加的键值对在字典的末尾，该方法直接操作原有字典

dit = {'键1':'值1','键2':'值2','键3':'值3'}
# 有该键就更新
d = dit.update({'键1': 666, '键2': 888, '键3': 999})
print(d)        # None
print(dit)      # {'键1': 666, '键2': 888, '键3': 999}

# 没该键就添加
dit.update({"键4":"值4"})
dit.update(键5="值5")
print(dit)      # {'键1': 666, '键2': 888, '键3': 999, '键4': '值4', '键5': '值5'}
1
2
3
4
5
6
7
8
9
10

（3）、pop()

功能： 通过键去删除键值对 (若没有该键可设置默认值,预防报错)
格式：字典.pop(键，[预设值])
返回值：有键则返回键对应的值、没有键则返回预设值
注意：该方法直接操作原有字典

# 有键则返回键对应的值
dit = {'键1':'值1','键2':'值2','键3':'值3'}
d = dit.pop('键1',"字典中没有该键值对")
print(d)        # 值1
print(dit)      # {'键2': '值2', '键3': '值3'}

# 没有键则返回预设值
d1 = dit.pop('键5',"字典中没有该键值对")
print(d1)       # 字典中没有该键值对
1
2
3
4
5
6
7
8
9

（4）、popitem()

功能：删除最后一个键值对
格式：字典.popitem()
返回值：以元组的形式返回字典最后一个元素
注意：该方法直接操作原有字典，字典没有元素则报错：KeyError: ‘popitem(): dictionary is empty’

dit = {'键1':'值1','键2':'值2','键3':'值3'}
d = dit.popitem()
print(d)        # ('键3', '值3')
print(dit)      # {'键1': '值1', '键2': '值2'}
1
2
3
4

（5）、clear()

功能：清空字典
格式：字典.clear()
返回值：None
注意：该方法直接操作原有字典，原字典结果为空字典

dit = {"top1":"钟无艳","top2":"貂蝉","top3":"后羿"}
d = dit.clear()
print(d)        # None
print(dit)      # {}
1
2
3
4

（6）、get()

功能：通过键获取值(若没有该键可设置默认值,预防报错)
格式：字典.get(键，[预设值])
返回值：当键存在时则返回键对应的值、当键不存在时且没有预设值时返回None、当键不存在时且有预设值时返回预设值

dit = {"top1":"钟无艳","top2":"貂蝉","top3":"后羿"}
# 当键存在时
d = dit.get("top1")
print(d)    # 钟无艳

# 当键不存在时且没有预设值时
d1 = dit.get("top5")
print(d1)    # None

# 当键不存在时且有预设值时
d2 = dit.get("top5",1)
print(d2)    # 1
1
2
3
4
5
6
7
8
9
10
11
12

（7）、setdefault()

功能：通过键获取值（若有键则返回对应的值，若没有则用预设值与键组成新的键值对插入字典）
格式：字典.setdefault(键，[预设值])
返回值：当键存在时则返回键对应的值、当键不存在时返回None
注意：若有键则返回对应的值，若没有则用预设值与键组成新的键值对插入字典的末尾

dit = {"top1":"钟无艳","top2":"貂蝉","top3":"后羿"}

# 当键存在时
d = dit.setdefault("top1")
print(d)    # 钟无艳

# 当键不存在时且没有预设值时
d1 = dit.setdefault("top5")
print(d1)       # None
print(dit)      # {'top1': '钟无艳', 'top2': '貂蝉', 'top3': '后羿', 'top5': None}

# 当键不存在时且有预设值时
d2 = dit.setdefault("top6","没有该键值对")
print(d2)       # None
print(dit)      # {'top1': '钟无艳', 'top2': '貂蝉', 'top3': '后羿', 'top5': None, 'top6': '没有该键值对'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

（8）、keys()

功能：将字典的键组成新的可迭代对象
格式：字典.keys()
返回值：返回一个dict_keys序列

dit = {"top1":"钟无艳","top2":"貂蝉","top3":"后羿"}
d = dit.keys()
print(d)          # dict_keys(['top1', 'top2', 'top3'])
print(type(d))    # <class 'dict_keys'>
1
2
3
4

（9）、values()

功能：将字典中的值组成新的可迭代对象
格式：字典.values()
返回值：返回一个dict_values序列

dit = {"top1":"钟无艳","top2":"貂蝉","top3":"后羿"}
d = dit.values()
print(d)          # dict_values(['钟无艳', '貂蝉', '后羿'])
print(type(d))    # <class 'dict_values'>
1
2
3
4

（10）、items()

功能：将字典的键值对凑成一个个元组,组成新的可迭代对象
格式：字典.items()
返回值：返回一个dict_items序列

dit = {"top1":"钟无艳","top2":"貂蝉","top3":"后羿"}
d = dit.items()
print(d)          # dict_items([('top1', '钟无艳'), ('top2', '貂蝉'), ('top3', '后羿')])
print(type(d))    # <class 'dict_items'>
1
2
3
4

列表、元组与字典之间的转换

dit = {"top1":"钟无艳","top2":"貂蝉","top3":"后羿"}

# 字典转列表
ls = list(dit)
# 默认将键转换为列表
print(ls)       # ['top1', 'top2', 'top3']

# 字典转元组
tp = tuple(dit)
# 默认将键转换为元组
print(tp)       # ('top1', 'top2', 'top3')
1
2
3
4
5
6
7
8
9
10
11