博客

一、字典的应用场景及定义

1、什么时候用字典，当下标不好用的时候

例如：

序列名 = [‘华为’,520,‘小米’,520,‘苹果’,14,‘三星’,24]

当顺序变化后，数据就乱了，而且下标也不管用了。

这个时候，就要用到字典了，字典和数据顺序无关，所以字典不支持下标，字典是按key（键）和value（值）的方式成对出现，俗称键值对。

2、字典的定义：

字典序列名 = {‘华为’:520,‘小米’:520,‘苹果’:14,‘三星’:24}

字典用大括号包裹，数据是键:值成对出现。

空字典的创建

名字 = { }

名字 = dict( )

二、字典的增删改查（可变型）

1、增加和修改数据

增加和修改数据：

语法： 字典序列名[键] = 值

如果键存在则修改对应的值，如果键不存在新增这个键和值。

a={'华为':520,'小米':520,'苹果':14,'三星':24}
a['华为']=521 #存在华为：520 改变华为的值
print(a)
a['一加']=321 #字典a中不存在一加，添加一加：321这个数据
print(a)

{‘华为’: 521, ‘小米’: 520, ‘苹果’: 14, ‘三星’: 24}

{‘华为’: 521, ‘小米’: 520, ‘苹果’: 14, ‘三星’: 24, ‘一加’: 321}

2、删数据：

删除字典内数据语法：del字典序列名[键] # 只需要写键，它会把键和值一起删除

删除整个字典的语法：del 字典序列名

清空字典：clear( ) 字典序列名.clear( )



代码：

del a['华为']#删除华为：521这个键值对
print(a)
a.clear()# 清空字典
print(a)

{‘小米’: 520, ‘苹果’: 14, ‘三星’: 24, ‘一加’: 321}

{}

3、查

**3.1查数据： **注意只能用键查值，不能用值查键，因为键是唯一的，值可能是重复的。

字典序列名 = {‘华为’:520,‘小米’:520,‘苹果’:14,‘三星’:24}

print(字典序列名[‘小米’]) 返回：520

print(字典序列名[‘诺基亚’]) 返回：报错

总结：如果键存在，我们返回值，否则报错。

3.2 字典的查询方法：


（1）get( ) 语法： 字典序列名.get(键，随便写)

如果键存在，返回值。如果键不存在，返回默认值，默认值是你随便写的内容，如果省略了这个参数，返回None。

（2）values( ) 语法： 字典序列名.values( ) # 返回字典中所有的值

（3）items( ) 语法：字典序列名.items( ) #可迭代对象（里面的数据是元组）,迭代就是重复反馈过程

a={'华为':520,'小米':520,'苹果':14,'三星':24}
print(a['小米'])#查小米的值

print(a.get('小米'))#使用get方法#变量名.方法

print(a.get('一加','不存在'))#一加不存在返回默认值不存在
print(a.get('一加'))#省略了返回的参数，返回None

print(a.values())#返回字典中所有的值
print(a.items())#返回以元组形式出现的键值对

结果：



520

520

不存在

None

dict_values([520, 520, 14, 24])

dict_items([(‘华为’, 520), (‘小米’, 520), (‘苹果’, 14), (‘三星’, 24)])

三、字典的循环遍历

1、遍历字典的键

字典序列名 = {‘华为’:520,‘小米’:520,‘苹果’:14,‘三星’:24}

for 键 in 字典序列名.keys( ):

print(键)

2、遍历字典的value

字典序列名 = {‘华为’:520,‘小米’:520,‘苹果’:14,‘三星’:24}

for 值 in 字典序列名.values( ):

print(值)

3、遍历字典的元素 （返回：每行是一个元组）

字典序列名 = {‘华为’:520,‘小米’:520,‘苹果’:14,‘三星’:24}

for 元素 in 字典序列名.items( ):

print(元素)

4、遍历字典的键和值

字典序列名 = {‘华为’:520,‘小米’:520,‘苹果’:14,‘三星’:24}

for 键 , 值 in 字典序列名.items( ):

print( f’ {键} = {值} ‘)

a = {'华为':520,'小米':520,'苹果':14,'三星':24}

for i in a.keys():#遍历字典的键
    print(i)

for i in a.values():#遍历字典的值
    print(i)

for i in a.items():#以元素的形式遍历
    print(i)

for i,j in a.items():
    print(f'{i}={j}')

结果：



华为

小米

苹果

三星

520

520

14

24

(‘华为’, 520)

(‘小米’, 520)

(‘苹果’, 14)

(‘三星’, 24)

华为=520

小米=520

苹果=14

三星=24

四、集合

1、集合的创建

创建集合：可以用{ } 或 set( )创建集合，但是创建空集合必需用set( )，因为{ }创建的是空字典

集合的特点： (1)自动去除重复数据 (2)顺序是随机的，所以不支持下标

集合名 = {1,2,3,4,5,6,7}

集合名 = {1,2,3,4,4,5,5,6,7} # {1, 2, 3, 4, 5, 6, 7} 自动去重复

空集合 = set( )

a={}
print(type(a))
a={1,2,3}
print(type(a))
a=set()
print(type(a))

结果：


<class ‘dict’>

<class ‘set’>

<class ‘set’>

2、集合的常见操作

2.1增加数据：


集合名.add(数据) # 因为集合自动去重复，所以增加重复内容时不进行任何操作


2.2 追加数据序列：


集合名.update(数据序列) # 数据序列：列表，字符串，元组


2.3删除数据：


集合名.remove(数据) # 如果数据不存在，报错

集合名.discard(数据) # 如果数据不存在，不报错

集合名.pop( ) # 随机删除集合中某个数据，并返回这个数据

查看返回数据 变量名 =集合名.pop( )

查看被删除的数据 print(变量名)

查看集合还剩下什么 print(集合名)


2.4查找数据：


in: 判断数据是否在集合序列中

not in: 判断数据不在集合序列中

print( 数据 in 集合名 ) # 返回 True 或 False

print( 数据 not in 集合名 ) # 返回 True 或 False

#增加数据
a={1,2,3,4,5,6,3,4}
print(a)
a.add(9)
print(a)

#增加序列
a.update([7,8,9])#添加列表
print(a)

a.update((11,12))#添加元组
print(a)

a.update("abc")#添加字符串
print(a)


#删除数据
a.remove(1)
print(a)

a.discard(9)
print(a)

#a.remove(77)#删除不存在的数据报错
#print(a)

a.discard(34)#删除不存在的数据不报错
print(a)

print(a.pop())#随机删除某个数据
print(a)

#查找数据
print(1in a)
print(1not in a)

#类型转换
a=[1,2,3]
b=(4,5,6)
print(set(a))#序列转换为集合
print(set(b))#元组转换为集合

结果



{1, 2, 3, 4, 5, 6}

{1, 2, 3, 4, 5, 6, 9}##增加数据

{1, 2, 3, 4, 5, 6, 7, 8, 9}#增加列表

{1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12}

{1, 2, 3, 4, 5, 6, 7, 8, 9, ‘c’, 11, 12, ‘b’, ‘a’}

{2, 3, 4, 5, 6, 7, 8, 9, ‘c’, 11, 12, ‘b’, ‘a’}

{2, 3, 4, 5, 6, 7, 8, ‘c’, 11, 12, ‘b’, ‘a’}

{2, 3, 4, 5, 6, 7, 8, ‘c’, 11, 12, ‘b’, ‘a’}

2

{3, 4, 5, 6, 7, 8, ‘c’, 11, 12, ‘b’, ‘a’}

False#查找数据

True

{1, 2, 3}#数据转换

{4, 5, 6}

五、牛客网练习题

1、创建一个字典列表，并遍历字典中的值

my_dict_1={'name': 'Niuniu','Student ID': 1}
my_dict_2={'name': 'Niumei','Student ID': 2}
my_dict_3={'name': 'Niu Ke Le','Student ID': 3}
dict_list=[]
dict_list.append(my_dict_1)#字典1追加到列表中
dict_list.append(my_dict_2)
dict_list.append(my_dict_3)
for i in dict_list:#此时的i是列表中的元素，也就是一个字典，是my_dict_1/my_dict_2/my_dict_3
    print(f"{i['name']}'s student id is {i['Student ID']}.")

结果：



Niuniu’s student id is 1.

Niumei’s student id is 2.

Niu Ke Le’s student id is 3.

2、创建一个字典，其值以键值对的形式存在，遍历输出其键和值

描述

创建一个依次包含键-值对’Beijing’: {Capital: ‘China’}、‘Moscow’: {Capital: ‘Russia’}和’Paris’: {Capital: ‘France’}的字典cities_dict，

请使用for循环遍历”已使用sorted()函数按升序进行临时排序的包含字典cities_dict的所有键的列表”，

对于每一个遍历到的城市名，使用print()语句一行输出类似字符串’Beijing is the capital of China!’的语句。



代码：

cities_dict={'Beijing': {"Capital": 'China'},
            'Moscow': {"Capital": 'Russia'},
            'Paris': {"Capital": 'France'}
            }
for i in sorted(cities_dict.keys()):
    print(f"{i} is the capital of {cities_dict[i]['Capital']}!")

结果：



Beijing is the capital of China!

Moscow is the capital of Russia!

Paris is the capital of France!

3、创建一个字典，其值以列表的形式存在，遍历输出其键和值

描述：

使用for循环遍历”使用sorted()函数按升序进行临时排序的包含字典result_dict的所有键的列表”，对于每一个遍历到的名字，先使用print()语句一行输出类似字符串”Allen’s favorite colors are:”的语句，然后再使用for循环遍历该名字在字典result_dict中对应的列表，依次输出该列表中的颜色。

代码：

result_dict={'Allen': ['red', 'blue', 'yellow'],'Tom': ['green', 'white', 'blue'],'Andy': ['black', 'pink']}
for i in sorted(result_dict.keys()):#i是字典的键
    print(f"{i}'s favorite colors are:")
    for j in range(len(result_dict[i])):#j是列的下标
        print(result_dict[i][j])

结果：



Allen’s favorite colors are:

red

blue

yellow

Andy’s favorite colors are:

black

pink

Tom’s favorite colors are:

green

white

blue

解题思路：


先找到字典的值，在找到值（列表）的每一个数据

4、讲两份列表封装成字典

name=input().split()#创建列表
language=input().split()
print(dict(zip(name,language)))

知识点：

zip函数



打包：

zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

示例：

list1 = [1,2,3,4,5]
list2 = ["hello","good","nice","haha"]
set3 = {True,False,None,0}
zipobj = zip(list1,list2,set3)  # 打包

print(zipobj) # 这是一个包,显示的是包所在的地址 <zip object at 0x00000149CFFFAB48>

print(list(zipobj)) #可以将包转化为列表,查看包中的内容 

# 打印结果为 [(1, 'hello', False), (2, 'good', True), (3, 'nice', None)]

解释：



1、列表中的元素只有3个，是因为set3()是集合，集合的特点：无序、去重

2、打包的具体过程

首先在list1中取出元素1，在list2中取出元素hello，在set3中取出元素False,组成了第一个元组(1, ‘hello’, False)；

然后在list1中取出元素2，在list2中取出元素good，在set3中取出元素True,组成了第二个元组(2, ‘good’, True)；

在list1中取出元素3，在list2中取出元素nice，在set3中取出元素None,组成了第三个元组(3, ‘nice’, None)；

set3里只有三个元素，所以，list1和list2中剩余的元素就被舍弃，最后，将三个元组放入列表中，[(1, ‘hello’, False), (2, ‘good’, True), (3, ‘nice’, None)]，最终打包完成。

解包：

zip()函数可以对 zip对象进行解包处理

语法：zip(*zipobj)

5、查找一个键是否在字典中，字典的值为列表形式

输入描述：

输入一个字母，必定在上述字典中。

输出描述：

同一行中依次输出每个单词，单词之间以空格间隔。

dict1={'a': ['apple', 'abandon', 'ant'], 'b': ['banana', 'bee', 'become'], 'c': ['cat', 'come'], 'd': 'down'}
zimu=input()
for j in range(len(dict1[zimu])):
    print(dict1[zimu][j],end=' ')

输入：

a

输出：

apple abandon ant

思路：


先找到值，求这个值（列表）的长度，用range 、for遍历输出 这个键的值

6、使用字典计数

letter=input()
dict1={}
for i in letter:
    dict1[i]=letter.count(i)#对letter字符串使用计数的方法
print(dict1)

声明：

1、此博客仅供交流学习

2、主要参考孙兴华老师的课程：孙兴华老师的python基础课程

3、部分知识点来源于本站其他博主总结，详见链接