当前位置：首页 > news >正文

电子学会的二级考试复习资料

news 来源：原创 2025/5/26 5:47:21

电子学会的二级考试复习过程中根据电子学会考纲及相关复习资料整理出来的笔记，感觉二级考试的重难点就是在基本数据类型的理解与应用，整理笔记也是方便自己随时查询。

一. 总述
Python 3 中有常见的 6 个标准的数据类型：数字（Number）、字符串（String）、列表（List）、元组（Tuple）、集合（Set）、字典（Dictionary）。其中集合不在二级考纲內。

数字、字符串、列表、元组属于序列。集合、字典属于非序列。

可变数据类型包括列表、集合、字典，不可变数据类型包括数字、字符串、元组。

二. 列表
1. 列表的二级访问
a = ["a","b",[1,2,3],"c"]
Print( a[2][1] )
# 运行结果：2
# 运行结果获取的是a列表下标为2的列表的下标为 1 的值
2. 序列的（切片）截取
序列的截取（切片）格式为：变量 [ 头下标 : 尾下标 : 步长 ] ，返回值为截取后的结果，注意以下几种形式：

a =(1,2,3,4,5,6,8)
b = a[1:3:1]
print(b)
'''运行结果：(2, 3) ---含头不含尾，且步长为1，如步长参数省略，则步长默认为：1'''
a =(1,2,3,4,5,6,8)
b = a[3:1:1]
print(b)
'''运行结果：（） ----如果从右开始到左结束，如果步长为正数，那么结果是空值。'''
a =(1,2,3,4,5,6,8)
b = a[3:1:-1]
print(b)
'''运行结果：(4,3) ----如果从右开始到左结束，如果步长为负数，也是从左到右，含头不含尾。'''
a =(1,2,3,4,5,6,8)
b = a[1::1]
print(b)
'''运行结果：(2, 3, 4, 5, 6, 8) -----如果尾下标省略，
则从头下标（含头又含尾）一直截取到最后'''
a =(1,2,3,4,5,6,8)
b = a[:6:1]
print(b)
'''运行结果：(1, 2, 3, 4, 5, 6) ------如果头下标省略，
则从头下标一直取到尾下标（含头不含尾）'''
a =(1,2,3,4,5,6,8)
b = a[-6:-1:-1]
print(b)
'''运行结果：() -------如果是从左开始到右结束，但是下标为负数，
那么步长是负数的话则是取到空值。'''
a =(1,2,3,4,5,6,8)
b = a[-6:-1:1]
print(b)
'''运行结果：(2, 3, 4, 5, 6) --------如果是从左开始到右结束，但是下标为正数，
那么步长是正数的情况下，则是从左边开始的下标一直取到右边结束的下标（注意含头不含尾）'''
a =(1,2,3,4,5,6,8)
b = a[-1:-6:1]
print(b)
'''运行结果：（） ---------如果是从右开始到左结束，下标为负数，步长为正数，则只能取到空值'''
a =(1,2,3,4,5,6,8)
b = a[-1:-6:-1]
print(b)
'''运行结果：(8, 6, 5, 4, 3) ---------如果是从右开始到左结束，下标为负数，
步长为负数，则从右边开始下标取到左边开始下标（含头不含尾）'''
有关序列的截取，主要注意几点（开始做笔记了^-^）:

1）开始位置--如果指定了开始下标，就从开始下标开始截取（是含开始小标的哦），如果没有指定开始下标，就是从0下标开始截取（是含0下标的哦）。

2）结束位置---如果指定了结束下标，那么截取就截止到结束下标的前一个下标（截取的时候是不包含结束下标哦）。如果没有指定结束下标，就一直截取到序列的最后一个元素（是包含序列的最后一个元素的哦）。

3）步长的正负数表示，实际是从截取开始的下标到结束的下标加步长还是减步长的问题，比如开始的下标是1，结束的下标是3，那肯定要用正的步长。如果开始的下标是3，结束的下标是1，那肯定要用负的步长。下标是负数的时候也是一样的。

4）最后一点就是要注意 a[1:-1] 步长默认为1，这样也是可以截取到值的（其实这里-1不就是最后一个元素么^_^）

3. 获取序列长度
T = [1,2,3,4,5] # 取序列长度
len(T)
# 运行结果：5
4. 检查某一个元素是否在该序列中
T = [1,2,3,["a","b","c"],4,5,(10,9,8)] # 检查某一个元素是否在该序列中。
print(8 in T)
'''运行结果：False （注意：只能查找序列的某一项元素匹配查找，无法匹配查找到元素里面的内容）'''
5. 取序列里的最大值
''' 取序列里的最大值（序列里面必须都是数字，或者都是字符串）'''
T = [21,2,3,4,5,8,0]
print(max(T))
'''运行结果：21 '''
6. 取序列里的最小值
'''取序列里的最小值（序列里面必须都是数字，或者都是字符串）'''
T = [21,2,3,4,5,8,0]
print(min(T))
''' 运行结果：0 '''
7. 序列求和运算
''' 序列求和运算（序列里必须全部是数字类型的） '''
T = [21,2,3,4,5,8,0]
print(sum(T))
''' 运行结果：43 '''
8.序列加法运算
''' 序列加法运算（两个相加的序列必须是同种类型的序列，比如列表与列表相加，
元组与元组相加，字符串与字符串相加等）'''
T = [21,2,3,4,5,8,0]
t = ['a','b','c']
print(T+t)
''' 运行结果：[21,2,3,4,5,8,0,'a','b','c'] '''
9. 修改列表的某个下标对应的值
''' 修改序列的某个下标对应的值 '''
a = ['a','b','c','d','e']
a[2] = 'aa'
print(a)
''' 运行结果：['a','b','aa','d','e'] '''
10. 同时修改列表中连续的元素
''' 利用切片技术同时修改列表中连续的多个元素。'''
a = ['a','b','c','d','e']
a[1:4] = [1,2,3]
print(a)
''' 运行结果：['a',1,2,3,'e'] '''
11. 删除列表中下标对应的元素
''' 有下标则删除列表中下标对应的元素，下标省略(包括中括号也要省略)
则是删除整个列表变量.
格式：del list_name[index] # index代表下标 '''
a = ['a','b','c','d','e']
del a[1]
print（a）
''' 运行结果：['a','c','d','e'] '''
b = ['a','b','c','d','e']
del b
Print(b)
''' 运行结果：NameError: name 'b' is not deﬁned # 报错，没有找到 'b' '''
12. 删除指定下标的元素
''' 删除指定下标的元素，如果没有指定下标，则默认删除最后一个元素
# 格式：list_name.pop(index) index代表下标 '''
a = ['a','b','c','d','e']
a.pop(1)
print(a)
''' 运行结果：['a','c','d','e'] '''
b = ['a','b','c','d','e']
b.pop()
print(b)
''' 运行结果：['a','b','c','d'] '''
13. 移除列表里面第1次出现的指定值的元素
''' 移除列表里面第1次出现的指定值的元素。我们有时候需要删除某一个元素，
但是不知道它在列表的什么位置，这时候使用 remove() 最合适。
# 格式：list_name.remove(obj) # obj 代表元素值 '''
a = ['a','b','c','d','e']
a.remove('c')
print(a)
''' 运行结果：['a','b','d','e'] '''
b = ['a','b','c','d','e']
b.remove('f')
''' 运行结果：ValueError: list.remove(x): x not in list #报错 '''
14. 清除列表所有的元素
''' 清除列表所有的元素，但是不删除列表，只是列表为空
# 格式：list_name.clear() '''
a = ['a','b','c','d','e']
a.clear()
print(a)
''' 运行结果：[] # 列表 List依然存在，但是为空列表 '''
15. 将元素添加到列表的末尾
''' 将元素添加到列表的末尾
# 格式：list_name.append(obj) # obj 代表元素值 '''
a = ['a','b','c','d','e']
a.append(1)
print(a)
''' 运行结果：['a','b','c','d','e',1] '''
16. 将元素插入列表指定的位置
''' 将元素插入指定的位置
# 格式：list_name.insert(index,obj) # obj 代表元素值，index代表下标 '''
a = ['a','b','c','d','e']
a.insert(2,"Python")
ptint(a)
''' 运行结果：['a','b','Python','c','d','e'] '''
17. 查找元素在列表中的位置
''' 查找元素在列表中的位置，返回值为该元素在列表中的下标，list_name 代表列表名称，
obj 代表要查找的元# 素的值，start 代表开始查找的位置，end 代表结束查找的位置。start、end
为非必要选项，如果没有，
# 则代表在整个列表里进行查找
# 格式：list_name.index(obj,start, end) '''
a = ['a','b','c','d','e']
print(a.index("c"))
''' 运行结果： 2 # a.index("c")返回的值是“c”在列表里所对应的下标 '''
18. 统计某个元素在列表中出现的次数
'''统计某个元素在列表中出现的次数，返回值为该元素的个数
格式：list_name.count(obj) # obj 代表需要统计的元素'''
a = ['a','b','c','a','d','e']
print(a.count("a"))
# 运行结果：2
19. 对原列表进行排序，不返回新列表
'''对原列表进行排序，不返回新列表。要求待排列元素必须为同一类型，
常见的为数字类型和字符串类型。默认按照从小到大进行排序，。
格式：list_name.sort(cmp=None, key=None, reverse=False)
# reverse 代表否翻转，默认为False不翻转,reverse=1或者reverse=True，
则按照从小到大排序后再进行翻转，三个参数都可以省略。'''
a = ['e','b','a','d','c','f']
a.sort()
print(a)
''' 运行结果：['a','b','c','d','e','f'] '''
20. 对可迭代的对象进行排序操作，会生成新的列表
'''对可迭代的对象进行排序操作，会生成新的列表。这里可迭代的对象可以是列表、元组等。
格式：sorted(iterable, cmp=None, key=None, reverse=False)
# reverse 代表否翻转，默认为False不翻转,reverse=1或者reverse=True，
则按照从大到小的顺序排序，三个参数都可以省略。'''
a = [122,23,1,9,-34,546,12.3]
b = sorted(a,reverse=True)
print(a)
''' 运行结果：[122,23,1,9,-34,546,12.3] '''
print(b)
''' 运行结果：[546, 122, 23, 12.3, 9, 1, -34] '''
21. 反向排列列表中的元素
''' reverse() 函数也是列表中的内置函数，用于反向排列列表中的元素。
reverse() 并不进行排序，而是将列表里的元素进行顺序上的前后颠倒；
另外，reverse() 和 sort() 一样：都是在原列表中进行操作，所以没有返回值，
但是会改变原列表的值。'''
a = [122,23,1,9,-34,546,12.3]
a.reverse()
print(a)
''' 运行结果：[12.3, 546, -34, 9, 1, 23, 122] '''
三. 元组
1. 创建元组的方法
''' 方法 1：在括号中添加元素，并使用逗号隔开即可 '''
a = (1,2,3,4,5)
''' 方法 2：使用 tuple() 函数将其他数据类型（必须为可迭代对象）转换为元组 '''
a = [1,2,3]
print(tuple(a))
''' 运行结果：(1,2,3) '''
2. 元组的访问
''' 元组的访问也是借助于索引，其索引的表示方法和列表相同，
分为正方向索引和反方向索引。 '''
a = (1,2,3,4,5,6)
print(a[2])
''' 运行结果：3 '''
3. 元组的嵌套
''' 元组也是可以嵌套的，并且嵌套的数据类型也不仅仅局限于元组，
列表等可变序列以及字典等其他数据也可以嵌套到元组中，
元组中嵌套的元素是被当作一个整体看待的，
访问被嵌套的元素中的某一个值需要通过逐级索引访问。 '''
a = (1,2,3,4,[10,11,12],6)
print(a[4][1])
''' 运行结果： 11 '''
4. 元组的截取和列表的截取相同
5. 元组的以下运算和列表的运算相同
（1）len()：获取元组的长度。

（2）in：检查元素是否包含在元组中。

（3）max()：求最大元素。

（4）min()：求最小元素。

（5）sum()：求和运算。

（6） +：元组的加法运算。元组虽然是不可变序列，但是依然可以进行加法运算。元组的加法是将两个元组结合在一起，形成一个新的元组，并不改变原元组的值

a = (21,2,3,4,5,8,0)
b = ('a','b','c')
print(a+b)
''' 运算结果： (21,2,3,4,5,8,0,'a','b','c') '''
（7）*：元组的乘法运算。元组也可以进行乘法运算，和列表的乘法运算一样，也是将元组的元素重复相应的次数，如下例所示

T = ('a','b','c','d')
print(T*2)
''' 运算结果：('a','b','c','d','a','b','c','d') '''
6. 查找元素在元组中的位置
''' 在元组中，index() 和在列表中一样，查找元素在元组中的位置，
返回值是该元素第一次出现的下标。语法格式也和在列表中一样：
元组名 .index( 需要查找的元素值 ) '''
a = ('a','b','c','d','b','e','b')
print(a.index('b'))
''' 运算结果： 1 # 返回的是要查询的值所对应的下标 '''
7.查找元素在元组中的个数
''' 在元组中，count() 该函数的作用是查找元素在元组中的个数，返回值为整数 '''
a = ('a','b','c','d','b','e','b')
print(a.count('b'))
''' 运行结果：3 '''
8. 使用 sorted() 进行排序
''' sorted() 由于元组是不可变序列，所以无法使用 sort() 进行排序，
但是可以使用 sorted() 进行排序。前面我们已经介绍过，
sorted() 是 Python 的内置函数，可用于所有可迭代对象，
返回的是一个新的列表，所以 sorted() 可以用于元组排序，
其使用方法和要求同列表中的 sorted() '''
a = ('a','b','c','d','b','e','b')
print(sorted(a))
''' 运行结果：['a', 'b', 'b', 'b', 'c', 'd', 'e'] # 这里特别注意，返回的是列表 '''
9. 元组其它注意事项
如果元组中只有一个元素，仍然需要加逗号，否则该对象并非元组

a = (1)
b = (1,)
print(type(a))
''' 运行结果：<class 'int'> '''
print(type(b))
''' 运行结果：<class 'tuple'> '''
元组为不可变序列，所以列表的很多操作是无法在元组中使用的，比如更新元素、删除元素、添加元素、反向排序等。

四. 字符串
1. 字符串的创建
（1）直接赋值，如 var = "Python"。

（2）使用 str() 从其他类型转换，如 str(1234)。

2. 字符串的访问
''' 字符串的访问 '''
a = "Python"
print(a[0])
''' 结果：P '''
3. 字符串的截取
与列表截取规则是一样的,且字符串也有负下标，规则跟列表一样

4. 字符串的其它操作
1. len()

获取字符串的长度。

2. in

检查某一个字符或者字符串是否包含在字符串中。

3. max()

求字符串中 Unicode 编码值最大的元素。Python 3 是按照 Unicode 编码进行排序的，其基本规律如下：数字在最前面，接下来是大写字母，然后是小写字母，最后是中文等其他文字。

4. min()

求字符串中 Unicode 编码值最小的元素。

5. +

字符串的加法运算，将两个字符串连接在一起。

6. sorted()

字符串排序。由于字符串也是不可变序列，所以不可以使用 sort 命令进行排序，sorted() 依然按照 Unicode 编码顺序排序。

7. index()

查找某个元素的位置，使用方法同其他数据类型中的 index()，返回值为该元素的下标。

8. count()

查找某个字符或者字符串在整个字符串中的个数，使用方法同元组中的 count()。

5. Python中的重要转义字符
转义符

描述

案例

反斜杠

>>>print('\\') \

单引号

>>>print('\'')

双引号

>>>print('\"')

退格键

>>> print("Hello\bWorld!") Hello World!

换行

>>> print("Hello\nWorld!")

Hello

World!

6. % 的格式化输出
在 Python 中，% 格式化输出要求比较严格，要求元素的数量和数据类型必须一一对应

符号

描述

案例

格式化整数，如果 s 前面有数字，则代表该整数所要占的位置

>>>print(" 这是第 %s 行。"%3) 这是第 3 行。

>>>print(" 这是第 %4s 行。"%3)

这是第 3 行。（3 的前面有 3 个空格）

格式化浮点数，如果 f 前面有数字，则代表保留的小数精度，具体请参考易错点介绍

>>>print(' 圆周率的近似值是：%f。'%3.1415926535 8979323846)

圆周率是：3.141593。

>>>print(' 圆周率的近似值是：%.2f。 '%3.1415926535 8979323846)

圆周率的近似值是：3.14。

格式化字符串，如果前面有数字，则代表字符串的长度，具体请参考易错点介绍

>>>print(" 我的名字叫 %s，我是 %s 的学生。 "%(' 小明 ',' 四年级 3 班 '))

我的名字叫小明，我是四年级 3 班的学生。

7. format 格式化输出
相对于 % 格式化输出，format 格式化输出的要求就没那么严格了。

第一种：使用 format 后面的元组索引位置格式，如下例所示

print('1乘以 {0} 等于 {0}，2乘以 {1} 等于 {2}。'.format(3,4,8))

''' 结果：1乘以 3 等于 3，2乘以 4 等于 8。 '''
第二种：使用命名方式，给每个需要格式化的位置命名，然后在 format 中进行变量赋值，如下例所示

print(' 我叫 {name}，我会的编程语言有 {program1}和 {program2}，我学习编程已经{age}年了，用得最多的编程语言是{program2}。'.format(name='张三 ',program1= 'Scratch',program2='Python',age=4))

''' 结果：我叫张三，我会的编程语言有 Scratch和 Python，我学习编程已经 4年了，用得最多的编程语言是 Python。'''
8. split() 字符串分割
''' 将一个完整的字符串使用分割符分割成字符串列表
格式：字符串名字 .split(" 分隔符 ") '''

a="苹果 ,香蕉 ,橘子 , 葡萄 "
b=a.split(",")
print(b)

''' 结果：['苹果 ', '香蕉 ', '橘子 ', ' 葡萄 ']
# 注意对字符串使用split()函数，不会改变字符串本身，而是生成一个新的列表 '''
9. join() 函数的用法
''' join() 函数和 split() 的功能刚好相反，将列表结合为字符串。
格式：" 连接符 ".join( 字符串名 ) '''

a=['苹果 ', '香蕉 ', '橘子 ', ' 葡萄 ']
b = ",".join(a)
print(b)

''' 结果：苹果 ,香蕉 ,橘子 ,葡萄 '''
10. 字符串其它重点
（1）字符串中的很多操作，比如检查是否在字符串中、字符串中某一个字符出现的次数等都要注意字符串要加引号，否则 Python 会认为是变量而不是字符串.

（2）%f 可以有两个参数，由小数点隔开，比如 %3.2f；小数点前面的数字代表整个小数的占位数量，如果数位不够，则用空格在前面补齐；小数点后面的数字代表小数位数，如果小数位数不够则用 0 补齐，如下例所示。小数位数的保留采用四舍五入的进位法保留

print('这个数是：%10.5f'%1.2)

''' 结果：这个数是： 1.20000
# 个位的前面有3个空格整个小数一共 10 个字符 '''
（3）%s 的 s 前面可以加整数，代表字符串的长度。如果字符串长度超出了该数字，则显示全部字符串；如果没有超出，则在字符串的前面用空格补齐

print(' 我的名字叫：%s。'%'Python')

''' 结果：我的名字叫：Python。'''

print(' 我的名字叫：%2s。'%'Python')

''' 结果：我的名字叫：Python。'''

print(' 我的名字叫：%10s。'%'Python')

''' 结果：我的名字叫： Python '''
（4）% 格式化输出可以混合使用，但是每个 % 对应一个内容，必须用元组一一对应注明出来

print(' 我的名字叫：%s，今年 %d 岁了，我是 %.1f班的学生。'%(' 张三 ',10,4.3))

''' 结果：我的名字叫：张三，今年 10 岁了，我是 4.3班的学生 '''
五. 字典
1. 访问字典里的值
第一种：使用字典名加键进行访问，这种方法有点像是把键当作字典的“索引”来访问，格式为“字典名 [ 键名 ]”

a = {"西瓜 ":9.6,"桃子 ":2,"苹果 ":4,"樱桃 ":12}
print(a['樱桃 '])

''' 结果： 12 '''
第二种：使用字典中的 get() 函数进行访问，格式为“字典名 .get( 键名 )”，如下例所示

a = {"西瓜 ":9.6,"桃子 ":2,"苹果 ":4,"樱桃 ":12}
print(a.get("苹果 "))

''' 结果：4 '''
2. 修改已有的键的值
''' 直接使用字典名加键的方式进行赋值即可 '''

a = {"西瓜 ":9.6,"桃子 ":2,"苹果 ":4,"樱桃 ":12}
a['樱桃 '] = 20
print(a)

''' 结果：{"西瓜 ":9.6,"桃子 ":2,"苹果 ":4,"樱桃 ":20} '''
3. 给字典增添新的键值对
''' 同样也采用字典加键的方式直接赋值即可，也就是说：采用该方法赋值，
如果字典中已有键，则将该键的值修改为最新的值；如果字典中没有该键，
则新增该键值对到字典中 '''

a = {"西瓜 ":9.6,"桃子 ":2,"苹果 ":4,"樱桃 ":12}
a['梨 '] = 8
print(a)

''' 结果：{"西瓜 ":9.6,"桃子 ":2,"苹果 ":4,"樱桃 ":12,'梨 ':8} '''
4. 删除字典里面已有的值
''' 使用 del 可以删除一个键值对 '''

a= {' 牛奶 ': '18元 ', '鸡蛋 ': '30元 ', '薯条 ': '23元 '}
del a[' 牛奶 ']
print(a)

''' 结果：{'鸡蛋 ': '30元 ', '薯条 ': '23元 '} '''
5. 清空字典里的值
''' clear() 可以清空字典里的所有值，使字典成为一个空字典。
格式：字典名 .clear() '''

a= {' 牛奶 ': '18元 ', '鸡蛋 ': '30元 ', '薯条 ': '23元 '}
a.clear
print(a)

''' 结果： {} '''
6. 求字典的长度
a = {' 牛奶 ': '18元 ', '鸡蛋 ': '30元 ', '薯条 ': '23元 '}
print(len(a))

''' 结果：3 '''
7. 检查键是否在字典中
''' 使用 in 可以检测键是否在字典中，如果在则返回 True，否则返回 False；
但是这里要注意：in 只检查键，并不检查值。如下例中的”Python”是值，
并不是键，所以返回值依然是 False '''

a = {'name': 'Python', 'age': '21', 'edi': 3.7}
print('Python' in a)

''' 结果：False '''
8. 字典其它重要知识点
（1）字典的键具有唯一性，如果创建时同一键被赋值两次，则后一个值会取代前一个值成为键的值，如下例所示

a = {' 牛奶 ': '18元 ', '鸡蛋 ': '30元 ', ' 牛奶 ': '23元 '}
print ("a[' 牛奶 ']: ", a[' 牛奶 '])

''' 结果：a[' 牛奶 ']: 23元 '''
（2）键必须不可变，所以可以用数字、字符串或元组充当，而用列表就不行，会报 TypeError 错误，如下例所示

a = {['name']: 'Python', 'age': '18 岁 '}
print (a[['name']])

''' 结果：TypeError: unhashable type: 'list' '''
（3）字典的值必须使用字典里已有的键来访问，如果用字典里没有的键访问，会报 KeyError 错误

（4）把键当作“索引”访问字典和使用 get() 函数访问字典的区别：最大的区别是 get() 函数可以自定义没有该键时的返回值，如果没有自定义，则返回 None；而把键当作“索引”来访问字典时，如果没有该键，则会报错。

以上就是电子学会python二级考试重点知识点整理，希望能帮到你。