电子学会python二级知识笔记

python二级复习文档

二级考试标准

中国电子学会考评中心网站

考试标准：

1、了解与掌握如下的python编程的进阶知识，并会使用： 1)知道如下几种数据类型：列表、元组、字典、字符串、range、集合六大 内置核心数据类型； 2)理解列表类型的概念，掌握它的基础用法及操作：访问/更新、获取元素 个数、遍历、转换为列表型数据、添加和删除、连接、排序等等； 3)理解元组类型的概念，理解元组和列表的不同，掌握它的基础用法及操 作：元组的声明与赋值、元组的访问与更新、元组的遍历、添加、删除、排序 等等； 4)理解字符串类型的概念，掌握它的基础用法及操作：字符串的分割、结 合、替换、检索、长度获取。

2、会编写较为复杂的Python程序，掌握Python编程的控制语句： 1)理解选择结构语句的功能和写法，能够完成简单选择结构的程序； 2)掌握程序的单分支结构，理解二分支、多分支结构语句； 3)理解循环结构语句的功能和写法，能够完成简单循环结构的程序；理解 for循环、while循环、break和continue循环控制结构语句； 4)理解range类型的概念，掌握它的基础用法及操作。

数据类型

字符串、列表、元组、集合、字典、range

字符串

📜 字符串定义与创建

字符串是字符序列，用单引号' '、双引号" "或三引号''' '''/""" """定义

s1 = ‘单引号字符串’  
 s2 = “双引号字符串”  
 s3 = ‘’‘多行字符串
 支持换行
 支持换行
 ‘’’
 s4 = “”"
 多行字符串
 支持换行
 “”"

特点：

• 有序序列：支持索引（从0开始）和切片操作

操作类型	语法/方法	示例	说明
拼接	+	"Hi" + "!" → "Hi!"	连接字符串
重复	*	"A" * 3 → "AAA"	重复字符串多次
长度	len()	len("abc") → 3	获取字符数量
索引	[index]	"Python"[1] → 'y'	获取单个字符（支持负索引）
切片	[start:stop:step]	"Python"[1:4] → 'yth'	获取子串（左闭右开）
存在检查	in / not in	"th" in "Python" → True	判断子串是否存在

实用方法

1. 大小写转换

• upper()：全转大写 → "hello".upper() → "HELLO"

• lower()：全转小写 → "HELLO".lower() → "hello"

• title()：单词首字母大写 → "hello world".title() → "Hello World"

2. 空白处理

• strip()：移除首尾空白 → " text ".strip() → "text"

• lstrip()/rstrip()：仅移除左/右侧空白

3. 搜索与替换

• find(sub)：返回子串首次位置（无则-1）→ "apple".find('p') → 1

• index(sub)：类似find()，但无子串时报错 → "apple".index('z') ❌ ValueError

• replace(old, new)：替换子串 → "cat".replace('c', 'b') → "bat"

• count(sub)：统计子串出现次数 → "apple".count('p') → 2

4. 分割与连接

• split(sep)：按分隔符拆分 → "a,b,c".split(',') → ['a','b','c']

• join(iterable)：连接可迭代对象 → ",".join(['a','b']) → "a,b"

字符串连接、重复

print(“A” + “B” )    #“AB”
 print(“A” * 3 )    #“AAA”

占位符% （格式化输出)

result = “格式化字符串 % 值1”             # 单个值
 result = “格式化字符串 % (值1, 值2)”      # 多个值
 ​
 name = “Alice”
 print(“Hello, %s!” % name)  # 输出：Hello, Alice!

常用占位符：

%s	字符串	"%s" % "abc"	"abc"
%d	整数	"%d" % 42	"42"
%f	浮点数	"%f" % 3.14159	"3.141590"（默认6位小数）
%e/%E	科学计数法	"%e" % 1000	"1.000000e+03"
%o	八进制整数	"%o" % 10	"12"（即八进制的12）
%x/%X	十六进制整数	"%x" % 255	"ff"
%%	输出百分号%	"50%%"	"50%"

浮点数指定小数位数

print(“%.3f” % 3.14159)  # 保留3位小数 → "3.142"

字符串截取字符数

print(“%.3s” % “Python”)  # 截取前3字符 → "Pyt"

format()函数 （格式化输出）

1. 位置参数与索引

# 按顺序替换
 s1 = “{} {}”.format(“Hello”, “Python”)  # 输出: “Hello Python”
 # 指定索引顺序
 s2 = “{1} {0}”.format(“Hello”, “Python”)  # 输出: “Python Hello”(@ref)
 # 重复使用索引
 s3 = “{0} is powerful, {0} is easy”.format(“Python”)  # 输出: “Python is powerful, Python is easy”

2. 关键字参数

s4 = “Name: {name}, Age: {age}”.format(name=“Alice”, age=25)  # 输出: “Name: Alice, Age: 25”

数字格式化

精度控制

# 保留2位小数
 num = 3.14159
 s5 = “Pi ≈ {:.2f}”.format(num)  # 输出: “Pi ≈ 3.14”
 # 百分比显示
 s6 = “Ratio: {:.0%}”.format(0.25)  # 输出: “Ratio: 25%”

千位分隔符

s7 = “{:,}”.format(1000000) # 输出: “1,000,000”

组合使用：千位分隔+保留小数

s8 = “Value: {:,.2f}”.format(12345.6789) # 输出: “Value: 12,345.68”

进制转换

s9 = “Hex: 0x{:X}”.format(255) # 输出: “Hex: 0xFF”（十六进制）
s10 = “Bin: {:b}”.format(10) # 输出: “Bin: 1010”（二进制）

文本对齐与填充

对齐方式

左对齐（宽度10）

s11 = “{:<10}”.format(“Left”) # 输出: "Left "

右对齐（宽度10）

s12 = “{:>10}”.format(“Right”) # 输出: " Right"

居中对齐（宽度10，用*填充）

s13 = “{:*^10}”.format(“Center”) # 输出: “Center”

符号控制

强制显示正负号

s14 = “{:+d}”.format(10) # 输出: “+10” 1
s15 = “{:+d}”.format(-10) # 输出: “-10” 1

---

列表

📚 Python列表的概念

Python列表（List）是一种有序、可变的数据结构，用于存储一组元素（可包含不同类型），通过方括号 [] 定义

特点：

• 有序性：元素按插入顺序存储，支持索引访问（正索引从0开始，负索引从-1开始）

• 可变性：支持动态增删改元素

• 支持嵌套：可包含子列表（多维列表）

操作类型	方法	示例	适用场景
增加	append()/extend()	lst.append(4)	末尾添加单个或多个元素
	insert()	lst.insert(1, 0)	指定位置插入元素
删除	remove()/pop()	lst.remove(2)	按值删除或按索引删除并返回
	del	del lst[0]	按索引或切片删除
查找	in/index()	if 3 in lst	判断存在或获取位置
	切片	lst[1:3]	获取子列表
修改	索引赋值	lst[0] = 10	修改单个元素
	循环遍历	for i in range(len(lst)): ...	条件性批量修改

增加操作

1. append()：在末尾添加单个元素

nums = [1, 2]
nums.append(3) # [1, 2, 3]

2. extend()：将可迭代对象（如列表）的所有元素追加到末尾

nums = [1, 2]
nums.extend([4, 5]) # [1, 2, 3, 4, 5]

3. insert()：在指定索引位置插入元素

nums = [1, 2]
nums.insert(1, 1.5) # [1, 1.5, 2, 3, 4, 5]

4. 切片赋值：通过切片替换或插入多个元素

nums = [1, 2]
nums[1:1] = [0, 0] # 在索引1处插入[0, 0]

删除操作

1. remove()：删除第一个匹配的元素值，不存在则报错

lst = [1, 2, 2, 3]
lst.remove(2) # [1, 2, 3]

2. pop()：删除指定索引的元素并返回该元素（默认删除末尾）

lst = [1, 2, 2, 3]
popped = lst.pop(0) # 删除索引0的元素

3. del语句：按索引或切片删除元素

lst = [1, 2, 2, 3]
del lst[1] # 删除索引1
del lst[0:2] # 删除前两个元素

4. clear()：清空整个列表

lst = [1, 2, 2, 3]
lst.clear() # []

查找操作

1. 索引访问：通过索引获取元素（支持正负索引）

lst = [1, 2, 3, 4]
print(lst[0]) # 第一个元素
print(lst[-1]) # 最后一个元素

2. 切片操作：获取子列表

lst = [1, 2, 3, 4]
sub = lst[1:3] # 索引1到2的子列表

3. in运算符：判断元素是否存在

lst = [1, 2, 3, 4]
if 3 in lst: print(“存在”)

4. index()：返回元素首次出现的索引号（编号），不存在则报错

lst = [1, 2, 3, 4]
idx = lst.index(3) # 返回3的索引

5. count()：统计元素出现次数

lst = [1, 2, 3, 4]
count = lst.count(2) # 2出现的次数

修改操作

1. 直接索引赋值：修改单个元素

lst = [1, 2, 3, 4]
lst[0] = “new” # 修改索引0的元素

2. 切片赋值：替换多个元素

lst = [1, 2, 3, 4]
lst[1:3] = [“a”, “b”] # 替换索引1-2的元素

3. 循环遍历修改：根据条件批量修改

lst = [1, 2, 3, 4]
for i in range(len(lst)):
if lst[i] % 2 == 0:
lst[i] *= 2 # 偶数元素加倍

---

元组

元组与列表的异同

共同点：

• 有序结构：均按插入顺序存储元素，支持索引（正/负）和切片操作

• 异构性：可混合存储不同类型的数据（如数字、字符串、其他容器）

• 操作符支持：均支持 +（拼接）、*（重复）、in（成员检查）、len()（长度）等操作

区别点：

• 列表可变，元组不可变

• 列表定义用方括号 []，元组定义用圆括号 ()，而且单元素需加逗号 (x,)

访问元组

1. 索引访问

t = (10, 20, 30)
print(t[0]) # 10（正索引）
print(t[-1]) # 30（负索引）

2. 切片操作

t = (‘a’, ‘b’, ‘c’, ‘d’)
print(t[1:3]) # (‘b’, ‘c’) # 左闭右开
print(t[::2]) # (‘a’, ‘c’) # 步长为2

3. 循环遍历

for item in t: # 同时获取值
print(item)

for idx, item in enumerate(t): # 同时获取索引和值
print(f"Index {idx}: {item}")

修改元组元素

！！！元组不可直接修改，但可通过间接方法生成新元组

1. 创建新元组替换元素

t = (1, 2, 3)
new_t = (10,) + t[1:] # 替换首元素 → (10, 2, 3)

2. 借助列表转换修改

t = (1, 2, 3)
temp_list = list(t)
temp_list[1] = 20 # 修改元素
new_t = tuple(temp_list) # (1, 20, 3)

删除元组元素

！！！元组不支持直接删除元素，但可通过以下方式间接实现：

1. 创建新元组跳过元素

t = (1, 2, 3, 4)
new_t = t[:2] + t[3:] # 删除索引2的元素 → (1, 2, 4) 8,10

2. 转换为列表删除后转回

t = (1, 2, 3, 4)
temp_list = list(t)
temp_list.remove(3) # 删除值为3的元素
new_t = tuple(temp_list) # (1, 2, 4)

3. 删除整个元组

t = (1, 2, 3)
del t # 删除元组对象
print(t) # ❌ NameError: name ‘t’ is not defined

---

集合（set）

定义：通过{}创建或set()

非空集合

s1 = {1, 2, 3} # 花括号直接创建
s2 = set([4, 5, 6]) # 从列表转换（自动去重）
s3 = set(“hello”) # 从字符串创建 → {‘h’, ‘e’, ‘l’, ‘o’}

空集合（必须用 set()）

empty_set = set() # ✅ 正确
not_set = {} # ❌ 这是空字典

特点：

• 集合（Set）是一种无序、可变、元素唯一的数据结构，用于存储不重复的数据项

• 元素无固定顺序，不支持索引访问（如 s[0] 会报错）

• 元素唯一

添加元素

1. add()：添加单个元素

s = {1, 2}
s.add(3) # {1, 2, 3}

2. update()：添加多个元素（支持列表、元组等可迭代对象）

s.update([3, 4], (5,)) # {1, 2, 3, 4, 5}

删除元素

1. remove()：删除指定元素（元素不存在时报 KeyError）

s = {1,2,3,4,5}
s.remove(2) # {1, 3, 4, 5}

2. discard()：删除指定元素（元素不存在时不报错）

s.discard(10) # 无副作用

3. pop()：随机删除并返回一个元素

s = {1,2,3,4,5}
item = s.pop() # 随机删除一个元素

4. clear()：清空集合

s.clear() # set()

查询元素

1. 成员检查：in 操作符

s = {1,2,3,4,5}
print(3 in s) # True

2. 遍历元素：（无序）

for item in s:
print(item) # 无序输出所有元素

集合运算（数学操作）

1. **并集（Union）**返回两集合所有唯一元素。

A = {1, 2}; B = {2, 3}
A | B # {1, 2, 3}
A.union(B) # 同上

2. **交集（Intersection）**返回两集合共有元素。

A & B # {2}
A.intersection(B) # 同上

3. 子集/超集判断：

C = {1, 2}
C <= A # True（子集）
A >= C # True（超集）

应用场景

快速去除列表中的重复项：

lst = [1, 2, 2, 3]
unique_lst = list(set(lst)) # [1, 2, 3]

字典

核心概念：

• 字典（Dictionary）是键值对（key-value）的无序集合（Python 3.7+ 保留插入顺序）

• 键（Key）：必须唯一且不可变（字符串、数字、元组等）

• 值（Value）：可为任意数据类型（包括嵌套字典）

创建字典

方法	示例	适用场景
花括号 {}	d1 = {"name": "Alice", "age": 25}	直接定义键值对
dict() 构造函数	d2 = dict(name="Bob", age=30) 或 d3 = dict([("name", "Charlie")])	动态生成或转换其他数据结构

⚠️注意：空字典需用 {} 或 dict()，不可用 { } 表示空集合

访问字典

1. 直接访问

• 通过键获取值：d["name"]

• ❌ 键不存在时报 KeyError

2. 安全访问

• get(key, default=None)：键不存在时返回默认值

age = d.get(“age”, 0) # 若"age"不存在，返回0

• in关键字检查键是否存在：if “name” in d:

3. 获取键值的方法

• keys()：返回所有键（dict_keys 类型）

• values()：返回所有值（dict_values 类型）

• items()：返回键值对元组（dict_items 类型）

4. 遍历字典

for key in d: … # 遍历键
for value in d.values(): … # 遍历值
for key, value in d.items(): … # 遍历键值对

字典修改

1. 直接修改值

d[“age”] = 31 # 键存在：修改值；键不存在：添加新键值对

2. 批量更新

• update()：合并其他字典或可迭代对象

d.update({“age”: 32, “city”: “Paris”}) # 更新多个键值对

3. 遍历修改

for key in d:
if key == “age”:
d[key] *= 2 # 将"age"值翻倍

字典删除

方法	示例	特点
del 语句	del d["name"]	直接删除键值对，键不存在时报 KeyError
pop(key)	value = d.pop("age")	删除并返回值，可设默认值避免报错
popitem()	k, v = d.popitem()	删除并返回最后插入的键值对（Python 3.7+）
clear()	d.clear()	清空字典 → {}

range

在Python中，range是一种不可变的序列类型，专门用于生成整数序列。它通过range()函数创建

特点：

• range是Python内置的不可变序列类型（类似元组），用于生成整数序列

• 返回range对象（如range(0, 5)），而非实际列表，需用list()或tuple()转换后才能查看具体元素

• 不可变性：创建后无法修改元素（如range(5)[0] = 10会报错）

range的定义方法

通过range()函数定义，支持三种参数组合：

参数形式	语法	示例	生成序列	适用场景
单参数	range(stop)	range(5)	[0, 1, 2, 3, 4]	从0开始到stop-1的循环
双参数	range(start, stop)	range(2, 6)	[2, 3, 4, 5]	指定起始和结束范围
三参数（含步长）	range(start, stop, step)	range(1, 10, 2)	[1, 3, 5, 7, 9]	自定义步长或倒序（负步长）

参数说明：

• start**：起始值（包含），默认

• stop：结束值（不包含），必填

• step：步长（默认1），若为负则递减（如range(10, 0, -1)生成[10,9,...,1]）

应用场景

1. 控制循环次数

for i in range(3): # 循环3次
print(“Hello”) # 输出：Hello（重复3次）

2. 遍历序列索引

fruits = [“apple”, “banana”, “cherry”]
for i in range(len(fruits)): # 遍历索引
print(f"Index {i}: {fruits[i]}")

3. 生成数值序列

even_numbers = list(range(0, 10, 2)) # [0, 2, 4, 6, 8]

类型转换

隐式转换（自动）

1. 数字类型提升 :整数（int）与浮点数（float）运算 → 自动转为 float

result = 5 + 3.14 # 8.14（float）

2. 布尔值参与运算:True转为1，False转为0

result = True + 2.5 # 3.5（float）

局限：不支持字符串与数字的隐式转换（如 "10" + 5 报错 TypeError）

显示转换（手动）

通过内置函数强制转换数据类型：

1. 基础类型转换函数

函数	作用	示例	注意事项
int(x)	转整数	int("42") → 42	字符串需为数字格式
float(x)	转浮点数	float("3.14") → 3.14	支持科学计数法字符串
str(x)	转字符串	str(100) → "100"	任意类型均可转换
bool(x)	转布尔值	bool(0) → False	空容器/0/None 为 False
complex(real, imag)	创建复数	complex(3, 4) → (3+4j)	imag 默认为 0

2. 容器类型转换函数

函数	作用	示例
list(seq)	转列表	list((1, 2)) → [1, 2]
tuple(seq)	转元组	tuple([1, 2]) → (1, 2)
set(seq)	转集合（自动去重）	set([1, 1, 2]) → {1, 2}
dict(seq)	转字典	dict([('a', 1), ('b', 2)]) → {'a':1}

3. 特殊转换函数

chr(x)	ASCII 码 → 字符	chr(65) → 'A'
ord(x)	字符 → ASCII 码	ord('A') → 65
hex(x)	整数 → 十六进制字符串	hex(255) → '0xff'
oct(x)	整数 → 八进制字符串	oct(64) → '0o100'
eval(s)	字符串 → Python 表达式结果	eval("2 * 3") → 6

流程控制

三大结构：

• 顺序结构

• 分支结构

• 循环结构

顺序结构

分支结构（条件判断语句）

关键字： if、elif、else

关键特性：

• 缩进敏感：代码块通过缩进（通常4空格）定义

if x > 0:
print(“正数”) # 正确缩进
print(“此处无论条件如何都会执行”) # 无缩进，不属于 if 代码块

• 条件表达式：支持比较运算符（==, >, <= 等）和逻辑运算符（and, or, not）

if age >= 18 and (has_license or is_exempt):
print(“允许驾驶”)

• 三元表达式：简化单行条件赋值

result = “通过” if score >= 60 else “未通过”

语法：

单分支

if condition:
# 条件为 True 时执行

双分支

if condition:
# True 时执行
else:
# False 时执行

多分支

if condition1:
# 条件1为 True
elif condition2:
# 条件1为 False 且条件2为 True
else:
# 所有条件为 False

循环结构（循环语句）

用于重复执行代码块，分为 for 循环和 while 循环。

for 循环

遍历序列（列表、字符串等）或可迭代对象。

遍历列表

fruits = [“apple”, “banana”]
for fruit in fruits:
print(fruit) # 依次输出 apple, banana

遍历字典

user = {“name”: “Alice”, “age”: 25}
for key, value in user.items():
print(key, value) # 输出 name Alice, age 25

range() 函数：生成整数序列，控制循环次数。

for i in range(3): # 0,1,2
for i in range(1, 10, 2): # 1,3,5,7,9（步长2）

while 循环

条件为 True 时重复执行，适用于循环次数未知的场景。

count = 0
while count < 3:
print(count) # 输出 0,1,2
count += 1

避免无限循环：需确保条件最终变为 False

while True:
user_input = input(“输入 ‘exit’ 退出：”)
if user_input == “exit”:
break # 强制退出

循环控制语句

break：立即终止整个循环

for i in range(10):
if i == 5:
break # 终止于 i=5

continue：跳过当前迭代，进入下一次循环

for i in range(5):
if i == 2:
continue # 跳过 i=2
print(i) # 输出 0,1,3,4

else：循环正常结束（非 break 退出）时执行

for i in range(3):
print(i)
else:
print(“循环完成”) # 输出 0,1,2,循环完成

嵌套结构

条件与循环可多层嵌套，但需控制复杂度（建议不超过3层）

嵌套循环（打印九九乘法表）

for i in range(1, 10):
for j in range(1, i+1):
print(f"{i}{j}={ij}“, end=”\t")
print() # 换行11

条件嵌套

if temp > 30:
if humidity > 70:
print(“高温高湿警报！”)
else:
print(“高温干燥”)

关键注意事项

• 缩进一致：缩进错误引发 IndentationError

• 避免无限循环：确保 while 循环条件可变为 False

• 运算符误用：=（赋值）与 ==（相等比较）区分

• 类型错误：避免不同类型比较（如 "5" > 3）