Python 语言程序设计期末复习整理(下)
- 2026-02-06 06:05:51
第 4 章 面向对象
1. 类和对象的关系即数据类型与变量的关系， 类规定了可以用于存储什么数据， 而 对象 用于实际存储数据，每个对象可存储不同的数据。
2. 类中包含属性和方法。 属性对应一个类可以用来保存哪些数据，而方法 对应 一个类可以支持哪些操作（即数据处理）。
3. 私有属性 ，是指在类内可以直接访问、而在类外无法直接访问的属性。
4. 构造方法是 Python 类中的内置方法之一，它的方法名为__init__，在创建一个类 对象时会自动执行，负责完成新创建对象的初始化工作。
5. 析构方法是类的另一个内置方法，它的方法名为__del__，在销毁一个类对象时会 自动执行，负责完成待销毁对象的资源清理工作，如关闭文件等。
6. __str__方法的返回值必须是 字符串。
7. 通过继承，可以基于已有类创建新的类，新类除了继承已有类的所有属性和方法， 还可以根据需要增加新的属性和方法。
8. 通过多态 ，可以使得在执行同一条语句时，能够根据实际使用的对象类型决定调 用哪个方法。
9. 如果一个类 C1 通过继承已有类 C 而创建，则将 C1 称作 子类 ，将 C 称做基类、 父类或超类。
10. 如果一个子类只有一个父类，则将这种继承关系称为 单继承；如果一个子类有两 个或更多父类，则将这种继承关系称为多重继承。
11. 方法重写是指子类可以对从父类中继承过来的方法进行重新定义，从而使得子类 对象可以表现出与父类对象不同的行为。
12. 内置函数 isinstance 用于判断一个对象所属的类是否是指定类或指定类的子类。
13. 内置函数 issubclass 用于判断一个类是否是另一个类的子类。
14. 内置函数 type 用于获取一个对象所属的类。
15. Python 提供了__slots__变量以限制可动态扩展的属性。
16. Python 提供了@property 装饰器，可以将类中属性的访问和赋值操作自动转为 方法调用，这样可以在方法中对属性值的取值范围做一些条件限定。
17. 直接使用@property 可以定义一个用于获取属性值的方法（即 getter）。如果需 要对属性 score 定义一个设置属性值的方法（setter），需要用到的装饰器为 @score.setter。
18. 元类 可以看成是创建类时所使用的模板，也可以理解为是用于创建类的类。
19. 单例模式 是指在程序运行时确保某个类最多只有一个实例对象。
20. 在执行__init__前，还会执行类的一个内置的类方法__new__，其作用是创建对象 并返回。
21. 关于类和对象说法正确的是（A）
A. 根据一个类可以创建多个对象，而每个对象只能是某一个类的对象
B. 根据一个类只能创建一个对象，而每个对象只能是某一个类的对象
C. 根据一个类可以创建多个对象，而每个对象可以属于多个类
D. 根据一个类只能创建一个对象，而每个对象可以属于多个类
22. 下列关于构造方法的说法错误的是（C）
A. 构造方法是 Python 类中的普通方法之一，在创建一个类对象时会自动执行， 负责完成新创建对象的初始化工作
B. 构造方法中，除了 self，也可以设置其他参数
C. 构造方法的参数只能是 self
D. 构造方法也可以设置默认参数
23. 进行 self>=other 运算时自动执行哪个内置方法（C）
A. __gt__(self,other)
B. __lt__(self,other)
C. __ge__(self,other)
D. __le__(self,other)
24. 关于 super 方法的说法错误的是（D）
A. super 方法用于获取父类的代理对象，以执行已在子类中被重写的父类方法
B. super 方法有两个参数：第一个参数是要获取父类代理对象的类名。
C. 在一个类A的定义中调用super方法时，可以将两个参数都省略，此时，super() 等价于 super(A, self)
D. 第二个参数必须传入对象名，该对象所属的类必须是第一个参数指定的类或该 类的子类，找到的父类对象的 self 会绑定到这个对象上
25. 关于类方法的说法错误的是（D）
A. 类方法是指使用@classmethod 修饰的方法
B. 类方法的第一个参数是类本身（而不是类的实例对象）
C. 类方法既可以通过类名直接调用，也可以通过类的实例对象调用。
D. 类方法只能通过类名直接调用
26. 关于静态方法的说法错误的是（B）
A. 静态方法是指使用@staticmethod 修饰的方法
B. 静态方法的第一个参数是类本身（而不是类的实例对象）
C. 静态方法既可以通过类名直接调用，也可以通过类的实例对象调用。
D. 静态方法中没有类方法中的第一个类参数
27. 已知 Complex 类的类方法 add(cls,c1,c2)实现两个复数的相加运算，程序可以使 用不同的方式调用该方法，下面错误的调用方式是（C）
A. c3=Complex.add(c1,c2)
B. c3=c1.add(c1,c2)
C. c3.add(Complex,c1,c2)
D. c3=Complex().add(c1,c2)
28. 关于动态扩展类的说法正确的是（A）
A. Python 除了可以在定义类时定义属性和方法外，还可以动态地为已经创建的 对象绑定新的属性和方法
B. Python 只能在定义类时定义属性和方法，不能动态扩展
C. Python 只能动态扩展属性，不能动态扩展方法
D. Python 只能动态扩展方法，不能动态扩展属性
29. 写出下面程序的输出结果。
class Student:
name='Unknown'
age=0
if __name__=='__main__':
print('姓名：',Student.name)
print('年龄：',Student.age)
stu=Student()
print('stu 姓名：%s,年龄： %d'%(stu.name,stu.age))
Student.name='张三'
Student.age=18
print('stu 姓名：%s,年龄： %d'%(stu.name,stu.age))
stu.name='李四'
stu.age=19
print('stu 姓名：%s,年龄： %d'%(stu.name,stu.age))
Student.name='张三'
Student.age=18
print('stu 姓名：%s,年龄： %d'%(stu.name,stu.age))
答：输出结果为：
姓名： Unknown
年龄： 0
stu 姓名：Unknown,年龄： 0
stu 姓名：张三,年龄： 18
stu 姓名：李四,年龄： 19
stu 姓名：李四,年龄： 19
30. 写出下面程序的输出结果。
class Person:
def __init__(self,name):
self.name=name
def Display(self):
print(self.name)
class Student(Person):
def __init__(self,sno,name):
super().__init__(name)
self.sno=sno
def Display(self):
super(Student,self).Display()
print(self.sno)
if __name__=='__main__':
per=Person("张三")
per.Display()
stu=Student(78,"李四")
stu.Display()
答：输出结果为：
张三
李四
78
31. 写出下面程序的输出结果。
class Person:
pass
class Student(Person):
pass
if __name__=='__main__':
per=Person()
stu=Student()
print("stu 所属类是 Person 类的子类",isinstance(stu,Person))
print("Student 类是 Person 类的子类",issubclass(Student,Person))
print("per 所属类是 Studnet 类的子类",isinstance(per,Student))
print("Person 类是 Student 类的子类",issubclass(Person,Student))
print('stu 对象所属的类：', type(stu)) print('per 对象所属的类：', type(per))
答：输出结果为：
stu 所属类是 Person 类的子类 True
Student 类是 Person 类的子类 True
per 所属类是 Studnet 类的子类 False
Person 类是 Student 类的子类 False
stu 对象所属的类： <class '__main__.Student'>
per 对象所属的类： <class '__main__.Person'>
32. 写出下面程序的运行结果。
class Cylinder:
Radius=5
Height=10
def Display(self):
print("圆柱体半径为",self.Radius)
class Circle:
Radius=50
def Display(self):
print("圆半径为",self.Radius)
if __name__=='__main__':
c1=Cylinder()
c2=Circle()
c1.Display()
c2.Display()
答：运行结果为：
圆柱体半径为 5
圆半径为 50
33. 下面程序对圆柱体类 Cylinder 实现动态绑定方法，请将程序填写完整。
from types import MethodType #从 types 模块导入 MethodType 方法
class Cylinder:
pass
def SetRadius(self,r):
self.Radius=r
def SetHeight(self,h):
self.Height=h
if __name__=='__main__':
c1=Cylinder()
c2=Cylinder()
#为 c1 对象绑定 SetRadius 方法
c1.SetRadius=MethodType(SetRadius,c1)
#为 Cylinder 类绑定 SetHeight 方法
Cylinder.SetHeight=SetHeight
c1.SetRadius(10)
c2.SetRadius(20) #c2 对象未绑定 SetRadius 方法，此语句有误
c1.SetHeight(30)
c2.SetHeight(40)
第 5 章 序列、集合和字典
1. Python 中，通过列表中的 index 方法可以根据指定值查找第一个匹配的列表元素 的位置。
2. Python 中，通过列表中的 insert 方法可以将一个元素插入到列表的指定位置。
3. 若在列表的最后添加新元素，则可以直接使用列表的 append 方法。
4. 使用 del 语句可以删除某个变量或列表中的某个元素。
5. 使用 max 方法可以获取一个列表中最大元素的值。
6. 使用 min 方法可以获取一个列表中最小元素的值。
7. 使用列表中的 count 方法可以统计某个值在列表中出现的次数。
8. Python 中集合有两种插入元素的方法，分别是 add 和 update。
9. 集合中的 issubset 方法可以用于判断一个集合是否是另一个集合的子集。
10. 集合中的 issuperset 方法可以用于判断一个集合是否是另一个集合的父集。
11. 使用 del 可以删除某个元素，也可以使用字典中的 pop 方法删除指定键的元素。
12. 使用字典中的 clear 方法可以一次将一个字典中的所有元素都清除。
13. 判断字典中是否存在某个键可以使用字典中的 get 方法，也可以使用成员运算符 in。
14. 已知 ls=[x*2 for x in range(5)]，则 print(ls)的输出结果为[0,2,4,6,8]。
15. 迭代器是指可以通过 next 函数不断获取下一个值的对象。
16. 下列属于可变类型的是（A）
A. 列表
B. 元组
C. 字符串
D. 数字
17. 下列叙述正确的是（B）
A. 列表和元组都是用一对中括号括起来的多个元素的有序集合，各元素之间用逗 号分隔
B. 列表是用一对中括号括起来的多个元素的有序集合，各元素之间用逗号分隔， 元组是用一对小括号括起来的多个元素的有序集合，各元素之间用逗号分隔
C. 列表是用一对小括号括起来的多个元素的有序集合，各元素之间用逗号分隔， 元组是用一对中括号括起来的多个元素的有序集合，各元素之间用逗号分隔
D. 列表和元组都是用一对小括号括起来的多个元素的有序集合，各元素之间用逗号分隔
18. 关于复制列表元素说法错误的是（C）
A. Python 中，通过赋值运算实际上是将两个变量指向同一个对象，而不是将一 个变量的值赋给另一个变量。
B. 采用元素截取的方法，可以根据一个已有列表对象复制出另一个新的列表对 象，后面对两个对象的操作完全独立
C. 如果一个列表中包含列表类型的元素，元素截取的方法完全可行，两个列表中 的相同列表类型的元素完全独立
D. 为了真正实现列表的复制操作，可以使用 Python 在 copy 模块中提供的 deepcopy 函数
19. 已知学生类中有属性 name 和 sno，列表 ls 中含有若干学生对象，若要求列表 ls 按照学生的姓名的降序排序，相应的语句是（A）
A. ls.sort(key=lambda stu:stu.name,reverse=True)
B. ls.sort(key=lambda stu:stu.name)
C. ls.sort(key=name,reverse=True)
D. ls.sort(name)
20. 下列叙述错误的是（C）
A. 可以使用一对大括号{}或 set 函数创建集合
B. 可以使用一对大括号{}或 dict 函数创建字典
C. 可以使用{}或 set()创建空集合
D. 可以使用{}或 dict()创建空字典
21. 已知定义： d=dict(sno='1810100', name='李晓明', age=19,t=(3,4),s=[3,4,5]) 则 len(d)的值为（A）
A. 5
B. 6
C. 7
D. 8
22. 已知字典 d，获取字典中键值集合的语句是（C）
A. d.items()
B. d.values()
C. d.keys()
D. d.get()
23. 下列有关生成器叙述错误的是（D）
A. 将列表生成表达式中的一对中括号改为一对小括号即可得到生成器
B. 对于生成器对象，也可以像其他可迭代对象一样使用 for 循环遍历对象中的每 一个元素
C. 如果生成元素的方法比较复杂，不适合用 for 循环方式实现，我们还可以借助 yield 关键字利用函数实现生成器的功能
D. 生成器就是一次性在内存中产生大量列表元素，占用大量的内存空间
24. 关于说法正确的是（B）
A. 列表是可迭代对象、但不是迭代器；同样，生成器是可迭代对象、但不是迭代 器
B. 列表是可迭代对象、但不是迭代器；而生成器既是可迭代对象、又是迭代器
C. 列表既是可迭代对象、又是迭代器；而生成器是可迭代对象、但不是迭代器
D. 列表既是可迭代对象、又是迭代器；而生成器是迭代器、但不是迭代对象
25. 写出下面程序的运行结果。
t1=("zhangsan",18,95.5)
t2=()
t3=(33,)
t4=([44,55,66])
t5=t1+t3
print(t1,t2,t3,t4,t5)
print(t5)
print(max(t4))
print(min(t4))
答：运行结果为：
('zhangsan', 18, 95.5) () (33,) [44, 55, 66] ('zhangsan', 18, 95.5, 33)
('zhangsan', 18, 95.5, 33) 66 44
26. 写出下面程序的运行结果。
ls=[1,2,3,2,3,4]
print(ls.index(4))
print(ls.count(3))
print(max(ls))
print(min(ls))
print(len(ls))
del ls[3]
print(ls)
ls.sort(reverse=True)
print(ls)
答：运行结果为：
5
2
4
1
6
[1, 2, 3, 3, 4]
[4, 3, 3, 2, 1]
27. 写出下面程序的运行结果。
import copy
s1=[4,5,6]
s2=s1 s2[1]="nk"
print(s1,s2)
s3=s1[1:3]
s3[1]="cn" print(s1,s3)
s4=copy.deepcopy(s1)
s4[1]=333
print(s1,s4)
s5=[4,[5,6]]
s6=s5[1:3]
s5[1][0]="cn"
print(s5,s6)
s7=copy.deepcopy(s5)
s7[1]="nk" print(s5,s7)
答：运行结果为：
[4, 'nk', 6] [4, 'nk', 6]
[4, 'nk', 6] ['nk', 'cn']
[4, 'nk', 6] [4, 333, 6]
[4, ['cn', 6]] [['cn', 6]]
[4, ['cn', 6]] [4, 'nk']
28. 写出下面程序的运行结果。
s1={1,2,3}
s2=set([2,3,3,4])
s1.add(3)
s2.update('ab')
s3=s1.intersection(s2)
s4=s1.union(s2)
s5=s1.difference(s2)
s6=s1.symmetric_difference(s2)
print(s1)
print(s2)
print(s3)
print(s4)
print(s5)
print(s6)
答：运行结果为：
{1, 2, 3}
{2, 3, 4, 'b', 'a'}
{2, 3}
{1, 2, 3, 4, 'a', 'b'}
{1}
{1, 4, 'b', 'a'}
29. 写出下面程序的运行结果。
d1={'name':"zhangsan",'sno':"001",'score':99}
d2=dict().fromkeys(['radius','height'],0)
print(d1)
print(d2)
d1.update({'age':19})
d2.update(radius=10)
print(d1)
print(d2)
del d1['age']
height=d2.pop('height','not found')
print(d1)
print(d2)
print(height)
print(len(d1))
print(len(d2))
答：运行结果为：
{'name': 'zhangsan', 'sno': '001', 'score': 99}
{'radius': 0, 'height': 0}
{'name': 'zhangsan', 'sno': '001', 'score': 99, 'age': 19}
{'radius': 10, 'height': 0}
{'name': 'zhangsan', 'sno': '001', 'score': 99}
{'radius': 10} 0 3 1
30. 写出下面程序的运行结果。
s1=[1,2,3,4,5,6,7,8,9,10]
s2=list(range(10,20))
s3=s1[2:8:2]
s4=s2[-8::-2]
print(s1)
print(s2)
print(s3)
print(s4)
答：运行结果为：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
[3, 5, 7]
[12, 10]
31. 该程序用到字典的浅拷贝和深拷贝，已知程序运行结果，请将程序填写完整。
import copy
d1={'name':"zhangsan",'sno':"001",'score':{'math':99,'C++':88}}
d2=d1.copy()
d3=copy.deepcopy(d1)
d1['name']="li"
d1['score']['C++']=90
print(d1)
print(d2)
print(d3)
已知程序运行结果为：
{'name': 'li', 'sno': '001', 'score': {'math': 99, 'C++': 90}}
{'name': 'zhangsan', 'sno': '001', 'score': {'math': 99, 'C++': 90}}
{'name': 'zhangsan', 'sno': '001', 'score': {'math': 99, 'C++': 88}}
第 6 章 字符串
1. Python 中，创建字符串时，可以使用单引号、双引号和三引号。
2. Python 中，使用字符串的 split 方法可以按照指定的分隔符对字符串进行切割， 返回由切割结果组成的列表。
3. 可以利用运算符+连接两个字符串，也可以使用 join 方法将序列中的元素以指定 的字符连接成一个新的字符串。
4. Python 中正则表达式中的普通字符需要做精确匹配，而特殊字符指定的匹配模式 则对应了用于模糊 匹配的规则。
5. Python 中正则表达式的特殊序列是由 \ 和一个字符构成。
6. 使用 Python 提供的 re 模块，可以实现基于正则表达式的模糊匹配。
7. compile 函数用于将一个字符串形式的正则表达式编译成一个正则表达式对象， 供 match、search 以及其他一些函数使用。
8. re 模块中的 match 函数用于对字符串开头的若干字符进行正则表达式的匹配。匹 配成功，返回一个 Match 对象；匹配失败，返回 None 。
9. re 模块中的 finditer 函数与 re.findall 函数功能都是用于在字符串中找到所有与正 则表达式匹配的子串，区别在于 re.findall 函数返回 列表形式的结果，而 re.finditer 返回 迭代器形式的结果。
10. re 模块中的 split 函数用于将字符串按与正则表达式匹配的子串分割。
11. 已知 s1="I "am a student.",s2='I \'am a student'，则 print(s1,s2)的输出结果 为（D）
A. I 'am a student. I 'am a student
B. I "am a student. I 'am a student
C. I "am a student. I \'am a student
D. 程序报错
12. 下列说法错误的是（D）
A. find 方法是在指定检索范围中按照从左至右的顺序检索，找到子串第一次出现 的位置
B. rfind 方法在指定检索范围中按照从右至左的顺序检索，找到子串第一次出现 的位置
C. index 与 find 作用相同，rindex 与 rfind 作用相同，只是 find 和 rfind 在检 索不到字符串时返回-1，而 index 和 rindex 会引发 ValueError 异常
D. index 与 find 作用相同，rindex 与 rfind 作用相同，只是 find 和 rfind 找到 一个就返回，而 index 和 rindex 会检索到所有的子串
13. 下列关于 replace 方法 str.replace(old, new[, max])的说法错误的是（C）
A. 使用字符串中的 replace 方法可以将字符串中的指定子串替换成其他内容
B. str 是要做替换操作的字符串，old 和 new 分别是要替换的子串和替换成的字 符串
C. max 是最多替换的子串数量，如果不指定 max 参数则只替换第一个满足条件 的子串
D. replace 方法返回替换后的字符串
14. print(len("中国\"china"))的输出结果是（B）
A. 7
B. 8
C. 9
D. 10
15. 下列匹配模式叙述错误的是（D）
A. ^用于匹配字符串开头的若干字符
B. *用于匹配前一个模式 0 次或多次
C. ?用于匹配前一个模式 0 次或 1 次
D. A|B 表示同时匹配模式 A 和模式 B
16. 关于正则表达式特殊序列叙述错误的是（C）
A. \A 匹配字符串开头的若干字符，功能同^
B. \d 匹配任一数字字符，等价于[0-9]
C. \S 匹配任一空白字符
D. \D 与\d 作用相反，匹配任一非数字字符，等价于[^0-9]
第 7 章 I/O 编程与异常
1. 利用 os 模块查看当前系统的名字，应当使用 os.name 。
2. 利用 os 模块获取当前系统平台路径的分隔符，应当使用 os.sep 。
3. 利用 os 模块获取当前工作目录，应当使用 os.getcwd 方法。
4. 利用 os 模块创建目录，可以使用 os.mkdir 方法或 os.makedirs 方法。
5. 判断指定路径目标是否是文件的方法是 os.path.isfile 。
6. os 模块中判断指定路径是否存在的方法是 os.path.exists 。
7. 根据文件对象的 closed 属性可以判断文件是否已关闭。
8. 使用文件对象的 seek 方法可以移动文件指针，从而实现文件的随机读写。
9. 使用 writer 对象的 writerow 方法或 writerows 方法可以向 CSV 文件中写入数据。
10. os 模块中用于依次创建路径中所有不存在的目录的方法是（ A ）。
A. makedirs
B. makedir
C. mkdirs
D. mkdir
11. 下面说法中，错误的是（ B ）。
A. 如果要创建的目录已经存在，则 os.mkdir 函数会报错
B. 如果要创建的目录已经存在，则 os.makedirs 函数不会报错
C. 如果要删除的目录不存在，则 os.rmdir 函数会报错
D. 如果要删除的目录已存在但目录不为空，则 os.rmdir 函数会报错
12. os 模块中用于删除指定路径的最后多层目录的方法是（ A ）。
A. removedirs
B. removedir
C. rmdirs
D. rmdir
13. open 函数的默认打开方式是（ C ）。
A. w
B. w+
C. r
D. r+
14. 下面文件文件打开方式中，不能对打开的文件进行写操作的是（ C ）。
A. w
B. wt
C. r
D. a
15. 要从文件中按行读取所有数据，则应使用（ D ）方法。
A. read
B. readall
C. readline
D. readlines
16. 无论 try 子句执行时是否发生异常，都会执行的子句是（ B ）。
A. else
B. finally
C. except
D. 不存在
17. 写出下面程序的运行结果。
for i in range(3): #循环 3 次
try:
num=(i+1)*5
assert num%2!=0
print(num)
except AssertionError:
print('断言失败！num=%d'%num)
运行结果：
5
断言失败！num=10
15
18. 写出下面程序的运行结果。
import os
for n in os.path.split('D:\\mydir\\subdir1\\test.txt'):
print(n)
运行结果：
D:\mydir\subdir1
test.txt
