【31天蓝桥杯冲刺！】蓝桥杯相关的 Python 知识点总结（1）输入输出数据的相关操作（详细）_蓝桥杯python速成

码字不易，希望大家点赞支持一下

使用方法：磨刀不误砍柴工，建议大家花上两个小时把这些例子跟着敲一遍，熟悉一下python的基本操作，这里出现的都是我之前刷蓝桥杯题目的时候常出现的能用到的python语法

1.输入方式（每道题目都要用到）

涉及到的函数：

input（）函数
map（）函数
split（）函数

1.1 接受单个输入数据

如果直接用input（）输入数据，可以看到数据的类型是字符串类型，

所以这里需要注意的是某些题目需要整数类型的数据时，要将其转化成为整数类型。

a = input()   #输入整数 520
print(type(a))
a = int(a)
print(type(a))

a=input("input:") #输人字符串 Hello
print(type(a))

1
2
3
4
5
6
7
8

输出结果：

·
·
比如说题目要求整数的类型，就可以这样写（用print看一下是什么类型）：

n = int(input())   #输入整数520

print(type(n))

1
2
3
4

.
.

1.2 同一行输入多个数据（以空格隔开）

比如说这道题目的要求：

用这种写法：

n = int(input()) # 输入一个整数n
a, b, c = map(int, input().split()) # 输入三个整数，用空格分隔
1
2

·
·

1.3 接下来n行每行输入一个数据

• 像这种需要 n 行的输入，可以使用 for 循环用上述的方法读入：

• 建立一个列表，然后用 append( ) 函数存入这个列表即可。

n = int(input())
score = []
for i in range(n):
  score.append(int(input()))
1
2
3
4

1.4 接下来n行每行输入多个数据

• 以此类推，接下来n行每行输入多个数据就可以这么写：
  

for _ in range(m):
   l, r, k = map(int, input().split())
1
2

• 上面这个是根据题意建立了一个列表来存放，这道题是在 for 循环里直接就把输入进来的参数进行运算了，所以没有进行处理。其他题目可能会需要向上面一样利用列表来存放数据，如果我遇到类似的题目再更新进来。

1.5 小结

# 1、接受单个输入数据
a = input()         #字符串
a = int(input())    #整数

# 2、同一行输入多个数据（以空格隔开）
a, b, c = map(int, input().split()) # 输入三个整数，用空格分隔

# 3、接下来n行每行输入一个数据
score = []
for i in range(n):
  score.append(int(input()))

# 4、接下来m行每行输入多个数据
for _ in range(m):
   l, r, k = map(int, input().split())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2. 字符串相关操作

2.1 字符串简介

• 访问字符串中的元素：使用 方括号 + 下标
• 切片： s [ start : end : step]，字符串s下标为 [start , end] 中， 步长为 step
• len（s）：求字符串的长度
• 连接字符串： a + b
• 存在，不存在： in 、 not in
• str(x): 把x强制转换成字符串

a = "Hello World!"
b = "WORLD!!"
# 1、访问下标
print("下标0= ",a[0])
print("下标3= ",a[3])

# 2、切片
print("a[4:8]= ",a[4:8])

# 3、len（a）
print("len(a) = ", len(a))

# 4、连接字符串
print("a + b = ", a + b)

# 5、存在/不存在
if 'Hello' in a:
    print("Yes")

# 6、强制转换字符串
c = 5
print(str(c))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

• 输出结果：

下标0=  H
下标3=  l
a[4:8]=  o Wo
len(a) =  12
a + b =  Hello World!WORLD!!
Yes
5
1
2
3
4
5
6
7

2.2 字符串常用方法

判断篇：

• s.isalnum() 检查字符串中的字符是否都是字母或数
• s.isalpha() 检查字符串中的所有字符是否都是字母
• s.isdigit() 检查字符串是否只包含数字
• s.isupper() 判断字符串是否全为大写
• s.islower() 判断字符串是否全为小写
• s.isspace() 检查字符串中是否只包含空白
• s.isnumeric() 检查字符串中的所有字符是否都是数字字符

# 标题化判断
print("Hello World".istitle())
print("Hello world".istitle())
print('-'*10)

# 大小写判断
print("HELLO".isupper())
print("HELLO".islower())
print('-'*10)

# 数字字母判断
print("Hello5201314".isalpha())
print("Hello5201314".isalnum())
print("Hello".isalpha())
print('-'*10)

# 空白判断
print("    ".isspace())
print("\t\n\t".isspace())
print("".isspace())


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

输出结果：

True
False
----------
True
False
----------
False
True
True
----------
True
True
False

进程已结束，退出代码 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

转换篇（加粗的为重点掌握）：

• title() : “标题化”字符串
• lower(): 转换成小写
• upper(): 转换成大写
• swapcase():字符串中大写转换为小写，小写转换为大写
• strip([chars]):截掉字符串左边的空格或指定字符chars
• rstrip([chars]):截掉字符串右边的空格或指定字符chars
• strip([chars]):调用lstrip([chars])和 rstrip([chars])
• replace(old, new[,max]):将字符串中的 old 替换成 new ,如果 max 指定，则替换不超过 max 次

# 标题化
s = "hello world"
t = s.title()
print("s =  ", s)
print("t = ", t)
print("-"*10)

# 转换成小写
s = "HELLO WORLD!"
t = s.upper()
print("s =  ", s)
print("t = ", t)
print("-"*10)

# 转换成大写
s = "hello world!"
t = s.lower()
print("s =  ", s)
print("t = ", t)
print("-"*10)

# 大小写互换
s = "hello world!"
t = s.title().swapcase()
print("s =  ", s)
print("t = ", t)
print("-"*10)

# 删除字符串左边的空格
s = "      hello world!"
t = s.lstrip()
print("s =  ", s)
print("t = ", t)
print("-"*10)

# 删除字符串左边的多个字符：e,h,空格
s = "      hello world!"
t = s.lstrip("eh ")
print("s =  ", s)
print("t = ", t)
print("-"*10)

# 替换字符
s = "abcd abcd abcd abcd"
t = s.replace("a", "A")
z = s.replace('a', 'A', 2)
print("s =  ", s)
print("t = ", t)
print("z = ", z)
print("-"*10) 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

• 输出结果：

s =   hello world
t =  Hello World
----------
s =   HELLO WORLD!
t =  HELLO WORLD!
----------
s =   hello world!
t =  hello world!
----------
s =   hello world!
t =  hELLO wORLD!
----------
s =         hello world!
t =  hello world!
----------
s =         hello world!
t =  llo world!
----------
s =   abcd abcd abcd abcd
t =  Abcd Abcd Abcd Abcd
z =  Abcd Abcd abcd abcd
----------

进程已结束，退出代码 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

查找篇（加粗的为常用）：

• count(str, beg = 0, end = len(string)) :求 str 在字符串中出现次数，如果指定查找范围，则在[beg,end]中查找
• find(str, beg = 0, end = len(string)) :判断 str 是否在字符串中，如果指定查找范围则在[beg,end]中查找，如果找到的起始下标，不存在返回-1
• rfind(str, beg = 0, end = len(string)):从右往左查找
• index(str, beg = 0, end = len(string)):与 find 相同，只是如果 str 不存在，则抛出异常
• rindex(str,beg = 0, end = len(string)):从右往左查找
• startswith(substr, beg = 0, end = len(string)):判断是否以 substr 开头
• endswith(suffix, beg = 0, end = len(string)):判断是否以 suffix 结尾

2.3 修改字符串的方法：

• 字符串转换成list（由于 python中 字符串本身是不可修改的，转换成list可以进行修改）：

# 直接转换成list：列表的每个元素都是长度为 1 的字符串
s = "Hello World!"
t = list(s)
print(s)
print(t)

# 利用split()方法对字符串进行分割
# str.split(str = "", num = string.count(str))
# str 表示分隔符，默认为空字符，包括空格、换行、指标符等
# num -- 分割次数，如果设置了这个参数，则最多分割成 num + 1 个字符串。默认为 -1，即分隔所有
s = "My name is Wang Shi      Er. "
t = s.split()
print(t)
t = s.split(' ', 4)
print(t)
t = s.split('Wang')
print(t)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• 输出结果：

Hello World!
['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!']
['My', 'name', 'is', 'Wang', 'Shi', 'Er.']
['My', 'name', 'is', 'Wang', 'Shi      Er. ']
['My name is ', ' Shi      Er. ']

进程已结束，退出代码 0
1
2
3
4
5
6
7

2.3.1如何修改字符串？

python中不可以直接在字符串上修改，因为字符串不可修改

可以通过以下方式对字符串进行修改：

• 1、转换成 list 列表、修改后再转换成字符串
• 2、利用切片
• 3、重新赋值
• 4、利用 replace()函数

2.4 format 格式化

python中指出格式化字符串的输出，利用 format 函数来调整字符串的格式

• 其中 { } 表示占位符，format 里面的参数将逐个放入字符串中的占位符（由于 format 的参数要逐个放入占位符中，此时参数的数量必须大于等于占位符的数量）。

name = "王十二"
s = "大家好，我是{}".format(name)
print(s)
1
2
3

• 输出结果：

大家好，我是王十二

进程已结束，退出代码 0
1
2
3

• python 字符串中{0}、{1} 表示占位符，其中非负整数表示这个位置为 format 中的第几个参数，从0开始计数， {x} 中的 x 不可以大于 format 中的参数数量

name = "王十二"
age = 24
s = "大家好，我是{0},今年{1}岁".format(name, age)
print(s)
1
2
3
4

• 输出结果：

大家好，我是王十二,今年24岁

进程已结束，退出代码 0
1
2
3

• { }中可以加入冒号 ： ，冒号后面可以控制数字的输出格式，包括宽度，小数点等
• p.s : 下表摘自菜鸟教程

^ , < , > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制 。

3.列表相关操作

列表的定义在这里就不过多阐述，举例说明：

a = ['apple', 'banana', 'pen']
# a 的类型
print(type(a))
print(a)
1
2
3
4

输出：

<class 'list'>
['apple', 'banana', 'pen']

进程已结束，退出代码 0
1
2
3
4

3.1 如何访问列表

• 通过下标访问
• 下标只能为 [-n, -1] , 分为 [0, n - 1]（顺数第几个）, 和 [-n, -1] 倒数第几个
• p.s : 列表中的每一个元素都可以重新赋值，可以正常参与运算

a = ['apple', 'banana', 'pen']
print(a[0])
print(a[1])
print(a[-1])
1
2
3
4

输出：

apple
banana
pen
进程已结束，退出代码 0
1
2
3
4

3.2 如何给列表添加元素

1、在末尾添加单个元素（重要）：

a.append(x) 为列表a末尾添加x元素

a = ['apple', 'banana', 'pen']
a.append('Hello')
print("a = ",a)
1
2
3

输出：

a =  ['apple', 'banana', 'pen', 'Hello']
进程已结束，退出代码 0
1
2

2、在末尾添加多个元素：

a.extend(x) : 列表a末尾添加x，x为可迭代对象，包括列表、元组、字符串等，不能是单个数字

a = ['apple', 'banana', 'pen']
a.extend([1,2,3,'a'])
print("a = ",a)
1
2
3

输出：

a =  ['apple', 'banana', 'pen', 1, 2, 3, 'a']

进程已结束，退出代码 0
1
2
3

3、在中间插入元素：

a.insert(idx, x) : 列表a在下标 idx 位置插入元素x，原来下标大于等于 idx 的元素往右移动一个位置。

a = ['apple', 'banana', 'pen']
a.insert(0, '0')
a.insert(2, "2")
print("a = ",a)
1
2
3
4

输出：

a =  ['0', 'apple', '2', 'banana', 'pen']
进程已结束，退出代码 0
1
2

4、删除元素：

• 利用 del 删除列表中的元素： del a[idx] : 删除列表a中下标为 idx 的元素
• 利用 pop 删除列表中的元素：（1）a.pop(idx) :删除列表a下标为idx的元素 (2) a.pop() 删除列表a中的最后一个元素
• 区别： del 删除没有返回值， pop 删除返回的是删除的那个元素

# 利用del删除元素
a = ['apple', 'banana', 'pen']
del a[0]
print("a = ",a)

# 利用pop删除元素
a = ['apple', 'banana', 'pen']
del_a = a.pop(1)
print("a = ",a)
print("删除的元素为：", del_a)

# pop 不加参数，默认删除末尾元素
a = ['apple', 'banana', 'pen']
del_a = a.pop()
print("a = ",a)
print("删除的元素为：", del_a)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出：

a =  ['banana', 'pen']
a =  ['apple', 'pen']
删除的元素为： banana
a =  ['apple', 'banana']
删除的元素为： pen

进程已结束，退出代码 0
1
2
3
4
5
6
7

5、查找元素

• a.count(x): 计算 x 在 a 中出现的次数，如果未出现则为0，否则为出现次数
• a.index(x, start, stop): 计算元素 x 在列表下标 [start, stop) 中第一次出现的位置；（1）要保证 x 必须在区间 [start, stop) 中存在，否则报错；（2）start， end 不赋值，默认为在整个列表中查找；（3）只赋值 start ， stop 默认为列表长度

a = ['apple', 'banana', 'cat', 'pen', 'cat']
print(a.count('apple'))
# 在整个列表中查找第一个 'cat'
print(a.index('cat'))
# 从下标3开始查找第一个 'cat'
print(a.index('cat', 3))
1
2
3
4
5
6

输出：

1
2
4

进程已结束，退出代码 0
1
2
3
4
5

6、翻转列表

• a.reverse() : 列表 a 进行翻转 ， 调用两次变回原列表

a = [1, 2, 3, 4, 5]
a.reverse()
print('a = ', a)
a.reverse()
print('a = ', a)

1
2
3
4
5
6

输出：

a =  [5, 4, 3, 2, 1]
a =  [1, 2, 3, 4, 5]
进程已结束，退出代码 0
1
2
3

7、求出列表长度

• len(a):求出列表a的长度

a = [1, 2, 3, 4, 5]
# 输出a的长度
print(len(a))
1
2
3

输出：

5

进程已结束，退出代码 0
1
2
3

3.3 遍历整个列表

• 利用for循环遍历列表

a = ['apple', 'pen', 'hello']
for i in a:
    print(i)
1
2
3

输出：

apple
pen
hello
进程已结束，退出代码 0
1
2
3
4

• 利用for循环遍历列表，同时获取下标
• 相关函数： enumerate(a, start = 0) : 将列表a每个元素和对应的下标组合为一个带索引的序列，下标默认从0开始，遍历的时候同步遍历下标和值

a = ['apple', 'pen', 'hello']
for idx, i in enumerate(a):
    print(idx, i)
1
2
3

0 apple
1 pen
2 hello
进程已结束，退出代码 0
1
2
3
4

3.4 列表操作符

• ‘+’ ： 连接两个列表
• ‘a*x’ : a 是list， x 是int， 构成一个新列表，其内容为a复制x次

a = [0, 1, 2, 3, 4, 5]
print("a = ", a)
b = ['a', 'b', 'c']
print("b = ", b)
print(a + b)
print(a * 3)
1
2
3
4
5
6

输出：

a =  [0, 1, 2, 3, 4, 5]
b =  ['a', 'b', 'c']
[0, 1, 2, 3, 4, 5, 'a', 'b', 'c']
[0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5]
进程已结束，退出代码 0
1
2
3
4
5

3.5 内置函数(常用的)

• sum(a):求和
• max(a):求列表a中的最大值
• min(a):求列表a中的最小值

a = [0, 1, 2, 3, 4, 5]
print("max = ", max(a))
print("min = ", min(a))
print("sum = ", sum(a))
1
2
3
4

输出：

max =  5
min =  0
sum =  15
进程已结束，退出代码 0
1
2
3
4

3.6 列表解析式（重点操作）

• 列表解析式： [expression for member in iterable]
• 对于可迭代对象 iterable 的 每个元素 member， 都执行 expression 表达式构成的新的列表
• 下面代码对 列表 [0，1，2] 中的每个对象都执行了 x 二次方的运算，构成了一个新的列表

a = [x**2 for x in range(3)]
print(a)
1
2

输出：

[0, 1, 4]
进程已结束，退出代码 0
1
2

p.s: range（）函数的细节会放在for循环部分进行说明

• 列表解析式：可以基于已有的列表筛选并生成相关的新的列表
• [expression for member in iterable if conditional ]
• 对于可迭代对象 iterable 的每个元素 member ，如果满足条件 conditional 才执行 expression 构成新的列表
• 下面代码表示 对于列表[0,1,2,3,4,5,6,7,8,9,10]，需要满足x为偶数，才能加入新列表，新列表元素为x的平方

a = [x**2 for x in range(11) if x % 2 == 0]
print(a)
1
2

输出：

[0, 4, 16, 36, 64, 100]
进程已结束，退出代码 0
1
2

3.7 列表切片

a = [1,'apple','banana', 2, 3, 4, 5]

# 切片[2:4], 步长为1
b = a[2:4]
print(b)
# 切片[0,n], 步长为2
c = a[::2]
print(c)
# 前3个元素
d = a[:3]
print(d)
# 后3个元素
e = a[-3:]
print(e)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出：

['banana', 2]
[1, 'banana', 3, 5]
[1, 'apple', 'banana']
[3, 4, 5]
进程已结束，退出代码 0
1
2
3
4
5

3.8 复制列表

• 先明确一个概念，列表的赋值不等同于复制，列表的赋值只是引用，相当于两个变量名代表同一个列表

a = [1,'apple','banana', 2, 3, 4, 5]
b = a
b[0] = "hello"
print("b = ", b)
print("a = ", a)
1
2
3
4
5

输出：

b =  ['hello', 'apple', 'banana', 2, 3, 4, 5]
a =  ['hello', 'apple', 'banana', 2, 3, 4, 5]
进程已结束，退出代码 0
1
2
3

• 正确的复制方法：
• （1）利用切片： b = a[:]
• （2）利用 copy函数： b = a.copy()

a = [1,'apple','banana', 2, 3, 4, 5]
b = a.copy()
c = a[:]
print("a = ", a)
print("b = ", b)
print("c = ", c)
1
2
3
4
5
6

输出：

a =  [1, 'apple', 'banana', 2, 3, 4, 5]
b =  [1, 'apple', 'banana', 2, 3, 4, 5]
c =  [1, 'apple', 'banana', 2, 3, 4, 5]
进程已结束，退出代码 0
1
2
3
4

4.字典的相关操作

4.1 创建字典

• python 中用 { } 表示字典，可以使用 { } 创建一个字典
• 字典中的 key 和 value 之间用冒号 ： 分隔，元素之间用 逗号， 分隔
• 字典的 key 只能为数字、字符串、元组，大多数情况使用字符串作为key
• value的类型没有限制

# 创建了一个空字典
a = {}
print("type(a) = ", type(a))
print("a = ", a)

# 创建字典
a = {'a':123, 'b':456, 0:789}
print("type(a) = ", type(a))
print("a = ", a)

1
2
3
4
5
6
7
8
9
10

输出：

type(a) =  <class 'dict'>
a =  {}
type(a) =  <class 'dict'>
a =  {'a': 123, 'b': 456, 0: 789}

进程已结束，退出代码 0
1
2
3
4
5
6

• 使用 dict 创建字典
• 此时 key 只能是字符串

# 创建了一个空字典
a = dict()
print("type(a) = ", type(a))
print("a = ", a)

# 创建字典
a = dict(a=123, b=456, c=789)
print("type(a) = ", type(a))
print("a = ", a)
1
2
3
4
5
6
7
8
9

输出：

type(a) =  <class 'dict'>
a =  {}
type(a) =  <class 'dict'>
a =  {'a': 123, 'b': 456, 'c': 789}
进程已结束，退出代码 0
1
2
3
4
5

• 也可以传入一个列表或者元组，每个元素也是一个包含两个元素的列表或者元组
• 则此时可以按照第一个元素作为 key，第二个元素作为 value

# 传入列表
a = dict([['a',123],['b',456],['c',789]])
print("type(a) = ", type(a))
print("a = ", a)

# 传入元组
a = dict([('a',123), ('b',456), ('c',789)])
print("type(a) = ", type(a))
print("a = ", a)

1
2
3
4
5
6
7
8
9
10

输出：

type(a) =  <class 'dict'>
a =  {'a': 123, 'b': 456, 'c': 789}
type(a) =  <class 'dict'>
a =  {'a': 123, 'b': 456, 'c': 789}
进程已结束，退出代码 0
1
2
3
4
5

• zip（）函数：把多个序列相同下标的元素组装成元组，结果是一个可迭代对象
• 结果可以转换成list，但是首次转换后迭代器就为空

keys = ['a', 'b', 'c']
value = [123, 456, 789]
zipped = zip(keys, value)
print(zipped)
print(list(zipped))
# 首次转换后迭代器为空
print(list(zipped))
1
2
3
4
5
6
7

输出：

<zip object at 0x0000014E3F16C0C0>
[('a', 123), ('b', 456), ('c', 789)]
[]

进程已结束，退出代码 0
1
2
3
4
5

• **具体应用：**假设有一个 key 列表和 value 列表，可以利用 **list（zip（key，value））**将二者组装好，作为 dict 的初始化

keys = ['a', 'b', 'c']
value = [123, 456, 789]
a = dict(list(zip(keys, value)))
print("a = ", a)
1
2
3
4

输出：

a =  {'a': 123, 'b': 456, 'c': 789}
进程已结束，退出代码 0
1
2

• 先前所有的创建字典的策略，都要满足：
• 1.Key不能重复、Value无限制
• 2.Key必须是字符串、数字、元组不可变的类型

4.2 访问字典

• python的字典通过 key 来访问 value，把 key 看作下标即可
• a[x]: a 为 dict、x 为 a 中的一个 key，必须存在否则会报错

keys = ['a', 'b', 'c']
value = [123, 456, 789]
a = dict(list(zip(keys, value)))
print("a = ", a)

print(a['a'], a['b'])
# 若是不存在则会报错
print(a['d'])
1
2
3
4
5
6
7
8

输出：

Traceback (most recent call last):
  File "E:\Master\SKILL\python_ 蓝桥杯\test.py", line 8, in <module>
    print(a['d'])
KeyError: 'd'

a =  {'a': 123, 'b': 456, 'c': 789}
123 456
1
2
3
4
5
6
7

• 如果并不知道 x 是否在字典的 key 中，需要查询字典中 x 对应的 value，可以使用 get 的方法
• a.get(x, value = None): a 表示字典， x 表示查询的 key， value 表示默认值
• 如果 x 在字典的 key 中，则上述的结果为 a[x]， 如果不存在，上述的结果为 value

keys = ['a', 'b', 'c']
value = [123, 456, 789]
a = dict(list(zip(keys, value)))
print("a = ", a)

# 'a'是key，则输出a['a']
print(a.get('a','XXX'))
# 'd'不是key，则输出给定默认值XXX
print(a.get('d','XXX'))
# 'e' 不是key，没有设定默认值，则此时为None
print(a.get('e'))
1
2
3
4
5
6
7
8
9
10
11

输出：

a =  {'a': 123, 'b': 456, 'c': 789}
123
XXX
None
进程已结束，退出代码 0
1
2
3
4
5

• 字典通过直接利用 key 可以访问对应的 value ，类似添加元素、修改元素也是直接利用 key 和 value 就能进行添加或者更新

a = {}
print("a = ", a)
# 添加元素
a['分数'] = 80
print("a = ", a)

# 修改元素
a['分数'] = 85
print("a = ", a)
1
2
3
4
5
6
7
8
9

输出：

a =  {}
a =  {'分数': 80}
a =  {'分数': 85}
进程已结束，退出代码 0
1
2
3
4

4.3 添加、修改和删除元素

• 字典通过直接利用 key 可以访问对应的 value，类似的，添加元素、修改元素也是直接利用 key 和 value 就能进行添加或者更新
• 删除字典中的键值对，可以用python本身的删除语法 del
• 也可用 pop 删除

a = {}
# 添加元素
a['小蓝'] = 15
print("a = ", a)
# 添加元素
a['小红'] = 16
print("a = ", a)
# 修改元素
a['小蓝'] = 16
print("a = ", a)
# 删除元素
del a['小蓝']
print("a = ", a)
# pop
a.pop('小红')
print("a = ", a)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出：

a =  {'小蓝': 15}
a =  {'小蓝': 15, '小红': 16}
a =  {'小蓝': 16, '小红': 16}
a =  {'小红': 16}
a =  {}
进程已结束，退出代码 0
1
2
3
4
5
6

4.4 遍历字典

• 与 list 一样，直接利用 for 语句就可以遍历字典

# x 是循环变量，a 是字典，此时遍历的是 a 的 key 列表
s = {'a':123, 'b':456, 'c':789}
for x in s:
    print(x)

# 利用 a.keys(), a.values(), a.items, 可以分别循环遍历 key，value、二元组（key,value）
s = {'a':123, 'b':456, 'c':789}
for x in s.keys():
    print(x)

for y in s.values():
    print(y)
    
for x, y in s.items():
    print(x, y)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出：

a
b
c
a
b
c
123
456
789
a 123
b 456
c 789
进程已结束，退出代码 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.4 判断是否存在元素

• 字典中可以使用 in、 not in 判断某元素是否在字典中
• x in a、x in a.keys（）:判断 x 是否在 a 的 key 中
• x in a.values(): 判断 x 是否在 a 的 value中
• (x, y) in a.items(): 判断 x 是否在 a 的 key 中，并且对应的 value 为 y

s = {'a':123, 'b':456, 'c':789}
print('a' in s)
print('d' in s.keys())

print(123 in s.values())
print(135 in s.values())

print(('a', 123) in s.items())
print(('b', 123) in s.items())
1
2
3
4
5
6
7
8
9

输出：

True
False
True
False
True
False

进程已结束，退出代码 0
1
2
3
4
5
6
7
8

4.4 合并两个字典

• 字典利用 update 方法可以将另一个字典的 key，value 更新到已有的字典中
• a.update(b):把字典b中的每一个元素放入到a中更新
• 如果b中的key在a中没有，则直接在a中添加一组新的 key-value对
• 如果b中的key在a中有，则直接更新对应的value

s = {'a':123, 'b':456, 'c':789}
t = {'a':321, 'd':1000}
s.update(t)
print("s = ", s)
print("t = ", t)
1
2
3
4
5

输出：

s =  {'a': 321, 'b': 456, 'c': 789, 'd': 1000}
t =  {'a': 321, 'd': 1000}

进程已结束，退出代码 0
1
2
3
4

继续更新中，敬请关注…