python基础——数据结构之字典

dict的使用：

dict是python中非常重要的数据类型，就像它的字面意思一样，就是个字典

其实就是key-value键值对

字典类型是python中唯一的映射类型

”映射“是数学中的术语，简单理解，它指的是元素之间相互对应的关系，即通过一个元素可以唯一找到另一个元素

创建

1.使用{}创建字典

dictname={‘key1’:‘value1’,‘key2’:‘value2’,…,‘keyn’:‘valuen’,}

其中dictname表示的是字典变量名，key:value表示各个元素的键值对，中间用逗号隔开

注意：同一字典中的各个键必须唯一，不能重复，若有重复保留最后一个

#使用字符串作为key
scores={'数学':90,'英语':95}
print(scores)
>>>
{'数学': 90, '英语': 95}

#使用元组和数字作为key
dict1={(20,30):'great',30:[1,2,3]}
print(dict1)
>>>
{(20, 30): 'great', 30: [1, 2, 3]}

#创建空字典
dict1={}
print(dict1)
>>>
{}

2.通过fromkeys()方法创建字典

dictname=dict.fromkeys(list,value=none)

其中list参数表示字典中所有键的列表，value参数表示默认值（如果不写则表示空值none）

subject=['语文','数学','英语']
scores=dict.fromkeys(subject,70)
print(scores)
>>>
{'语文': 70, '数学': 70, '英语': 70}

3.通过dict()映射函数创建字典

#创建空的字典
d=dict()
print(d)
>>>
{}

#将元组构成的列表转换为字典                       严格按照键值对形式才能执行
demo=[("a",1),("b",2),("c",3)]
d=dict(demo)
print(d)
>>>
{'a': 1, 'b': 2, 'c': 3}

#使用zip函数
keys=["a","b","c","d"]
vals=[1,2,"abc","djks"]
dt1=dict(zip(keys,vals))
print(dt1)
>>>
{'a': 1, 'b': 2, 'c': 'abc', 'd': 'djks'}

增加

直接通过键值对方式添加dict中的元素

d={'xiaoming':80,'xiaohong':70,'xiaobai':82}
print(d)
d['xiaohei']=99
print(d)
>>>
{'xiaoming': 80, 'xiaohong': 70, 'xiaobai': 82}
{'xiaoming': 80, 'xiaohong': 70, 'xiaobai': 82, 'xiaohei': 99}

删除

能删单一的元素也能清空字典，清空只需要一项操作

#删除键,只需要删除键就可以
d={'xiaoming':80,'xiaohong':70,'xiaobai':82}
print(d)
del d['xiaohong']
print(d)
>>>
{'xiaoming': 80, 'xiaohong': 70, 'xiaobai': 82}
{'xiaoming': 80, 'xiaobai': 82}

#清空字典
d={'xiaoming':80,'xiaohong':70,'xiaobai':82}
print(d)
d.clear()
print(d)
>>>
{'xiaoming': 80, 'xiaohong': 70, 'xiaobai': 82}
{}

#删除字典
d={'xiaoming':80,'xiaohong':70,'xiaobai':82}
print(d)
del d
print(d)
>>>
{'xiaoming': 80, 'xiaohong': 70, 'xiaobai': 82}
Traceback (most recent call last):
  File "D:\pythonProject\demo3.py", line 127, in <module>
    print(d)
NameError: name 'd' is not defined. Did you mean: 'id'?

修改

若对象存在，会直接覆盖原始值；若对象不存在，则会增加一项

d={'xiaoming':80,'xiaohong':70,'xiaobai':82}
print(d)
d['xiaohong']=100
print(d)
>>>
{'xiaoming': 80, 'xiaohong': 70, 'xiaobai': 82}
{'xiaoming': 80, 'xiaohong': 100, 'xiaobai': 82}

查找

#使用键值进行查找，若键不存在则会报错
d={'xiaoming':80,'xiaohong':70,'xiaobai':82}
print(d['xiaoming'])
>>>
80

#所以我们可以增加一个判定方法，if in
d={'xiaoming':80,'xiaohong':70,'xiaobai':82}
key='xiaoming'
if key in d:
    print(d[key])
else:
    print("key不存在")
>>>
82
    
d={'xiaoming':80,'xiaohong':70,'xiaobai':82}
key='xiaohei'
if key in d:
    print(d[key])
else:
    print("key不存在")
>>>
key不存在

#直接使用get的保险操作方法
d={'xiaoming':80,'xiaohong':70,'xiaobai':82}
key='xiaobai'
if d.get(key):
    print(d[key])
else:
    print("key不存在")
>>>
82

遍历字典

#遍历输出所有的key
d={'xiaoming':80,'xiaohong':70,'xiaobai':82}
for k in d:
    print(k)
>>>
xiaoming
xiaohong
xiaobai

#使用keys()遍历输出所有的key
d={'xiaoming':80,'xiaohong':70,'xiaobai':82}
for k in d.keys():
    print(k)
>>>
xiaoming
xiaohong
xiaobai

#遍历输出所有的值value
d={'xiaoming':80,'xiaohong':70,'xiaobai':82}
for k in d:
    print(d[k])
>>>
80
70
82

#使用values()遍历输出所有的value
d={'xiaoming':80,'xiaohong':70,'xiaobai':82}
for k in d.values():
    print(k)
>>>
80
70
82

#遍历输出所有的键值对
d={'xiaoming':80,'xiaohong':70,'xiaobai':82}
for k in d:
    print(k,d[k])
>>>
xiaoming 80
xiaohong 70
xiaobai 82

#使用items()遍历输出所有的键值对
d={'xiaoming':80,'xiaohong':70,'xiaobai':82}
for k,v in d.items():
    print(k,v)
>>>
xiaoming 80
xiaohong 70
xiaobai 82

合并字典

#更新d2，将d1的内容增添到d2
d1={"a":1,"b":2}
d2={"c":3}
d2.update(d1)
print(d2)
>>>
{'c': 3, 'a': 1, 'b': 2}

#括号内的内容为增添部分
d1={"a":1,"b":2}
d2={"c":3}
d2.update(d1)
print(d2)
d1.update(d2)
print(d1)
>>>
{'c': 3, 'a': 1, 'b': 2}
{'a': 1, 'b': 2, 'c': 3}

#或者如下这样
d1={"a":1,"b":2}
d2={"c":3}
d3={}
for k,v in d1.items():
    d3[k]=v
for k,v in d2.items():
    d3[k]=v
print(d3)
>>>
{'a': 1, 'b': 2, 'c': 3}

字典的特性：

1.不允许同一个键出现两次。创建时如果出现同一个键被赋值两次，只会记住最后面的赋值

2.键必须不可变，可以用数字、字符串、元组充当，列表不可以

3.通过键而不是通过索引来读取元素：字典类型有时也称为关联数组或者散列表，它是通过键将一系列的值联系起来的，这样就可以通过键从字典中获取指定项，但不能通过索引来获取

4.字典是任意数据类型的无序集合：和列表、元组不同，通常会将索引值0对应的元素称为第一个元素，而字典中的元素是无序的

5.字典是可变的，并且可以任意嵌套：字典可以在原处增长或者缩短（无需）生成一个副本，并且它支持任意深度的嵌套，即字典存储的值也可以是列表或者其他的字典

字典的内置方法

1.len(dict) 计算字典中键值对的个数（元素个数、键的总数）

d1={"a":1,"b":2}
d2={"c":3}
d3={}
print(len(d1),len(d2),len(d3))
>>>
2 1 0

2.str(dict) 输出字典，以可打印的字符串表示

d1={"a":1,"b":2}
d2={"c":3}
d3={}
print(str(d1),str(d2),str(d3))
>>>
{'a': 1, 'b': 2} {'c': 3} {}

3.type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型

d1={"a":1,"b":2}
d2={"c":3}
d3={}
print(type(d1))
print(type(str(d1)))
>>>
<class 'dict'>
<class 'str'>

练习题

dict={“k1”:“v1”,“k2”:“v2”,“k3”:“v3”}

1.请循环遍历出所有的key

dict={"k1":"v1","k2":"v2","k3":"v3"}
for k in dict.keys():
    print(k)
>>>
k1
k2
k3



dict={"k1":"v1","k2":"v2","k3":"v3"}
for k in dict:
    print(k)
>>>
k1
k2
k3

2.请循环遍历出所有的value

dict={"k1":"v1","k2":"v2","k3":"v3"}
for k in dict.values():
    print(k)
>>>
v1
v2
v3

dict={"k1":"v1","k2":"v2","k3":"v3"}
for k in dict:
    print(dict[k])
>>>
v1
v2
v3

3.请循环遍历出所有的key和value

dict={"k1":"v1","k2":"v2","k3":"v3"}
for k in dict:
    print(k,dict[k])
>>>
k1 v1
k2 v2
k3 v3


dict={"k1":"v1","k2":"v2","k3":"v3"}
for k,v in dict.items():
    print(k,v)
>>>
k1 v1
k2 v2
k3 v3

4.请在字典中增加一个键值对 “k4”:“v4” ，输出添加后的字典

dict={"k1":"v1","k2":"v2","k3":"v3"}
dict["k4"]="v4"
print(dict)
>>>
{'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': 'v4'}

5.请删除字典中键值对"k1":“v1”，并输出删除后的结果

dict={"k1":"v1","k2":"v2","k3":"v3"}
print(dict)
del dict["k1"]
print(dict)
>>>
{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
{'k2': 'v2', 'k3': 'v3'}

6.请获取字典中"k2"对应的值

dict={"k1":"v1","k2":"v2","k3":"v3"}
print(dict["k2"])
>>>
v2


dict={"k1":"v1","k2":"v2","k3":"v3"}
key="k2"
if key in dict:
    print(dict[key])
else:
    print("键值不存在")
>>>
v2


dict={"k1":"v1","k2":"v2","k3":"v3"}
key="k2"
if dict.get(key):
    print(dict[key])
else:
    print("键值不存在")
>>>
v2