欢迎访问奥鹏在离线作业答案网!

奥鹏在离线作业答案网

当前位置: 网站首页 > 免费作业答案 >

南开《Python编程基础》复习资料-王恺

时间:2019-09-15 09:33来源:未知 作者:admin 点击:
《Python编程基
《Python编程基础》课程期末复习资料

《Python编程基础》课程讲稿章节目录:
第1章、简介及示例(4个知识点)
01 Python简介
02 程序基础和Python编程环境
03 HelloWorld程序
04 输入、输出及IDLE环境介绍
第2章、基础语法(17个知识点)
01变量的定义
02 Number数据类型
03 String数据类型
04 List数据类型
05 Tuple数据类型
06 Set数据类型
07 Dictionary数据类型
08占位运算符和算术运算符
09赋值运算符、比较运算符和逻辑运算符
10位运算符
11身份运算符和成员运算符
12序列运算符和运算符优先级
13条件语句概述
14条件语句实现和pass
15循环语句概述和for循环
16 while循环和索引
17 break、continue和else
第3章、函数(18个知识点)
01函数的定义与调用
02形参和实参
03默认参数和关键字参数
04不定长参数
05拆分参数列表
06返回值
07模块概述和import语句
08全局变量__name__和系统模块
09 from...import
10包
11猴子补丁和第三方模块获取安装
12变量的作用域和局部变量
13全局变量和global关键字
14 nonlocal关键字
15递归函数
16高阶函数和lambda函数
17闭包
18装饰器
第4章、面向对象(16个知识点)
01面向对象概述
02类的定义和创建实例
03类属性定义及其访问
04类中普通方法定义及调用
05私有属性
06构造方法
07析构方法
08常用内置方法
09继承的概念
10子类的定义
11方法重写和鸭子类型
12 super方法
13内置函数isinstance、issubclass和type
14类方法和静态方法
15动态扩展类与实例和__slots__变量
16 @property装饰器
第5章、序列、集合和字典(17个知识点)
01可变类型与不可变类型
02创建列表和拼接列表
03复制列表元素
04列表元素的查找、插入和删除
05列表元素的最大值、最小值、出现次数和列表长度
06列表元素排序
07元组的操作
08集合的创建和插入元素
09集合的运算
10字典的创建和初始化
11字典元素的修改、插入和删除
12字典的浅拷贝和深拷贝
13判断字典中是否存在键及拼接两个字典
14字典的其他常用操作
15切片和列表生成表达式
16生成器
17迭代器
第6章、字符串(14个知识点)
01创建字符串和不同引号的区别
02字符串比较
03字符串切割
04字符串检索和替换
05去除字符串空格和大小写转换
06字符串的其他常用操作
07占位符和format方法
08正则表达式的基础语法
09 re模块使用-compile和match
10 re模块使用-search
11 re模块使用-匹配对象
12 re模块使用-findall和finditer
13 re模块使用-split、sub和subn
14爬虫程序示例
第7章、IO编程与异常(13个知识点)
01 os模块的使用-基础操作
02 os模块的使用-目录创建和删除
03 os模块的使用-获取绝对路径、路径分离和连接
04 os模块的使用-条件判断
05文件打开和关闭
06文件对象方法-write和read
07文件对象方法-readline、readlines和seek
08一维数据和二维数据
09 CSV操作一维、二维数据
10异常的定义和分类
11异常处理-try except
12异常处理-else、finally和raise
13异常处理-断言和自定义异常

一、客观部分:(单项选择、多项选择、不定项选择、判断)
(一)、单项选择
1、Python程序在执行一次之后会自动生成扩展名为(  B  )的字节码文件,以提高运行效率。
A、.py    B、.pyc    C、.pyb    D、.pyf
★考核知识点: 程序基础和Python编程环境
参见讲稿章节:1-02
附1.1.1(考核知识点解释):
Python是一种解释型语言,但为了提高运行效率,Python程序在执行一次之后会自动生成扩展名为.pyc的字节码文件;字节码不同于机器语言,但很容易转换为机器语言。
2、Python3.x环境创建Python脚本文件时,需要将文件编码格式设置为(  C  )。
A、ANSI   B、GBK    C、UTF-8   D、UNICODE
★考核知识点: HelloWorld程序
参见讲稿章节:1-03
附1.1.2(考核知识点解释)
使用Python 3.x环境创建Python脚本文件时,需要将文件编码格式设置为UTF-8,否则运行脚本时可能会报错。
3、下列选项中,用于接收标准输入数据(即从键盘输入)、返回为string类型(字符串)的函数是(  B  )。
A、eval   B、input   C、print   D、get
★考核知识点: 输入、输出及IDLE环境介绍
参见讲稿章节:1-04
附1.1.3(考核知识点解释)
input函数接收标准输入数据(即从键盘输入),返回为string类型(字符串)。
示例:
name=input("请输入你的姓名:") #输入“张三”
print(name) #输出“张三”
4、执行“print(0x20)”,则在屏幕上会输出(  D  )。
A、20    B、0x20   C、16    D、32
★考核知识点: Number数据类型
参见讲稿章节:2-02
附1.1.4(考核知识点解释)
整型数字包括正整数、0和负整数,不带小数点,无大小限制。整数可以使用不同的进制来表示:不加任何前缀为十进制整数;加前缀0o为八进制整数;加前缀0x则为十六进制整数。
例:
a,b,c=10,0o10,0x10 #a、b、c的值分别为10、8、16
5、下列选项中,执行时不会报错的语句是(  C  )。
A、int('23.5') B、float('23.5+1') C、float('23.5') D、int('2a',8)
★考核知识点: String数据类型
参见讲稿章节:2-03
附1.1.5(考核知识点解释)
int函数:第一个参数是要转换为整数的字符串(要求必须是一个整数字符串,否则会报错);第二个参数是字符串中整数的数制(不指定则默认为10)。例如:int('35')返回整数35,int('35',8)返回整数29,int('35+1')则会因无法转换而报错。提示:int函数仅是将字符串中的数字直接转为整数,不会做任何运算。当要转换的字符串是一个包含运算的表达式时,int函数会报错。
float函数:只有一个参数,即要转换为浮点数的字符串(要求必须是一个整数或浮点数字符串)。例如:float('35')返回浮点数35.0,float('35.5')返回浮点数35.5,float('35.5+3')则会因无法转换而报错。提示:与int函数类似,float函数仅是将字符串中的数字直接转为浮点数,不会做任何运算。当要转换的字符串是一个包含运算的表达式时,float函数会报错。
6、下列选项中,描述错误的选项是(  A  )。
A、列表中的元素类型必须相同
B、列表中的元素之间用逗号分隔
C、列表中的元素可以是列表类型
D、列表中可以包含数字类型的元素
★考核知识点: List数据类型
参见讲稿章节:2-04
附1.1.6(考核知识点解释)
List(列表)是Python中一种非常重要的数据类型。列表中可以包含多个元素,且元素类型可以不相同。每一元素可以是任一数据类型,包括列表(即列表嵌套)及后面要介绍的元组、集合、字典。所有元素都写在一对方括号“[]”中,每两个元素之间用逗号分隔。对于不包含任何元素的列表,即[],称为空列表。
7、已知t=(12,34.5,True,'test',3+5j),则下列选项中,输出结果为“('test',)”的选项是(  C  )。
A、t[3]   B、t[4]   C、t[3:4]   D、t[4:5]
★考核知识点: Tuple数据类型
参见讲稿章节:2-05
附1.1.7(考核知识点解释)
元组中元素的索引方式与列表中元素的索引方式完全相同。与列表相同,利用下标“[]”可以从已有元组中取出其中部分元素形成一个新元组,其语法格式为:t[beg:end]。其中,t为元组,beg是要取出的部分元素在t中的起始下标,end是要取出的部分元素在t中的结束下标。例如:
t=(1, 2.5, 'test', 3+4j, True, [3,1.63], 5.3)
print(t[1:4]) #输出“(2.5, 'test', (3+4j))”
print(t[-3:-1]) #输出“(True, [3, 1.63])”
如果只访问元组t中的某一个元素,则可以使用下面的写法:t[idx]。其中,idx是要访问的元素的下标。例如:
t=(1, 2.5, 'test', 3+4j, True, [3,1.63], 5.3)
print(t[2]) #输出“test”
print(t[-3]) #输出“True”
8、下列选项中,执行时不会报错的语句是(  D  )。
A、{['Python',True]}    B、{3.5,[1.2,True]}
C、{3.5,{1.2,True}}    D、{3.5,1.2,True}
★考核知识点: Set数据类型
参见讲稿章节:2-06
附1.1.8(考核知识点解释)
与元组和列表类似,Set(集合)中同样可以包含多个不同类型的元素,但集合中的各元素无序、不允许有相同元素且元素必须是可哈希(hashable)的对象。可哈希对象是指拥有__hash__(self)内置函数的对象。列表、集合和字典类型的数据不是可哈希对象,所以它们不能作为集合中的元素。
9、下列选项中,错误的描述是(  C  )。
A、字典中的每一个元素是一个键:值对
B、字典中不同元素的键不能相同
C、字典中不同元素的值不能相同
D、通过“{}”可以创建一个空字典
★考核知识点: Dictionary数据类型
参见讲稿章节:2-07
附1.1.9(考核知识点解释)
Dictionary(字典)是另一种无序的对象集合。但与集合不同,字典是一种映射类型,每一个元素是一个键(key):值(value)对。
在一个字典对象中,键必须是唯一的,即不同元素的键不能相同;另外,键必须是可哈希数据,即键不能是列表、集合、字典等类型;值可以是任意类型。
对于不包含任何元素的字典,即{},称为空字典。
10、3*5**2的运算结果为(  C  )。
A、30   B、225   C、75   D、报错
★考核知识点: 序列运算符和运算符优先级
参见讲稿章节:2-12
附1.1.10(考核知识点解释)
对于具有不同优先级的运算符,会先完成高优先级的运算,再完成低优先级的运算。例如,表达式3+5*6中,“*”优先级高于“+”,因此会先计算5*6,再计算3+30。运算符优先级如下表所示。

11、调用函数时函数名后面的一对小括号中给出的参数称为(  A  )。
A、实参   B、形参   C、类型参数  D、名字参数
★考核知识点: 形参和实参
参见讲稿章节:3-02
附1.1.11(考核知识点解释)
实参的全称是实际参数,即在调用函数时函数名后面的一对小括号中给出的参数列表。当调用函数时,会将实参的值传递给对应的形参,函数中再利用形参做运算、得到结果。
12、不定长的位置参数在传递给函数时会被封装成(  A  )。
A、元组   B、列表   C、集合   D、字典
★考核知识点: 不定长参数
参见讲稿章节:3-04
附1.1.12(考核知识点解释)
不定长参数,即在调用函数时可以接收任意数量的实参,这些实参在传递给函数时会被封装成元组(位置参数)或字典(关键字参数)形式。
一般情况下,不定长参数是放在形参列表的最后,前面传入的实参与普通形参一一对应,而后面剩余的实参会被封装成元组或字典后传给不定长参数。
对于使用位置参数形式的不定长参数,Python也允许普通形参放在不定长参数后面,但此时要求在调用函数时必须使用关键字参数方式给不定长参数后面的形参传递实参。对于有默认参数的形参,在调用函数时也可以不传入相应实参。
13、一个脚本文件M.py单独执行时,其__name__变量的值为(  B  )。
A、M   B、__main__   C、M.py   D、不存在
★考核知识点: 全局变量__name__和系统模块
参见讲稿章节:3-08
附1.1.13(考核知识点解释)
每个模块中都有的一个全部变量__name__。
__name__的作用是获取当前模块的名称,如果当前模块是单独执行的,则其__name__的值就是__main__;否则,如果是作为模块导入,则其__name__的值就是模块的名字。
例如:
module.py脚本文件中的代码:
print(__name__) #输出全局变量__name__的值
testmodule.py脚本文件中的代码:
import module #导入module模块
提示:当我们执行module.py时,会在屏幕上输出:__main__;而当我们执行testmodule.py时,则会在屏幕上输出:module。即module.py单独运行和作为模块导入时其__name__的值是不同的。
14、局部变量的作用域是(  B  )。
A、从定义变量的位置到文件结束位置
B、从定义变量的位置到函数结束位置
C、所有函数
D、所有文件
★考核知识点: 变量的作用域和局部变量
参见讲稿章节:3-12
附1.1.14(考核知识点解释)
在一个函数中定义的变量就是局部变量(包括形参),其作用域是从定义局部变量的位置至函数结束位置。
15、内层函数使用外层函数中定义的变量,应使用(  B  )关键字。
A、local   B、nonlocal   C、global   D、nonglobal
★考核知识点: nonlocal关键字
参见讲稿章节:3-14
附1.1.15(考核知识点解释)
在Python中,函数的定义可以嵌套,即在一个函数的函数体中可以包含另一个函数的定义。通过nonlocal关键字,可以使内层的函数直接使用外层函数中定义的变量。
例:使用nonlocal关键字示例。
def outer(): #定义函数outer
    x=10 #定义局部变量x并赋为10
    def inner(): #在outer函数中定义嵌套函数inner
        nonlocal x #nonlocal声明
        x=20 #将x赋为20
        print('inner函数中的x值为:',x)
    inner() #在outer函数中调用inner函数
    print('outer函数中的x值为:',x)
outer() #调用outer函数
运行结果为:
inner函数中的x值为: 20
outer函数中的x值为: 20
提示:通过“nonlocal x”声明在inner函数中使用outer函数中定义的变量x、而不是重新定义一个局部变量x。
16、lambda函数是指(  B  )。
A、在一个函数内部通过调用自己完成问题的求解
B、不使用def定义函数的形式
C、一个函数不断被其他函数调用完成问题的求解
D、把函数作为参数的一种函数
★考核知识点: 高阶函数和lambda函数
参见讲稿章节:3-16
附1.1.16(考核知识点解释)
lambda函数也称为匿名函数,是一种不使用def定义函数的形式,其作用是能快速定义一个简短的函数。lambda函数的函数体只是一个表达式,所以lambda函数通常只能实现比较简单的功能。
语法格式为:
lambda [参数1[, 参数2, ..., 参数n]]: 表达式
其中,冒号后面的表达式的计算结果即为该lambda函数的返回值。
17、在闭包中,外层函数的返回值是(  B  )。
A、内层函数的调用     B、内层函数的引用
C、任意值       D、无返回值
★考核知识点: 闭包
参见讲稿章节:3-17
附1.1.17(考核知识点解释)
如果内层函数使用了外层函数中定义的局部变量,并且外层函数的返回值是内层函数的引用,就构成了闭包。定义在外层函数中但由内层函数使用的变量被称为自由变量。
18、类中的(  A  )对应一个类可以用来保存哪些数据。
A、属性  B、方法   C、数据   D、对象
★考核知识点: 类的定义和创建实例
参见讲稿章节:4-02
附1.1.18(考核知识点解释)
在一个类中,除了可以包含前面所说的属性,还可以包含各种方法。属性对应一个类可以用来保存哪些数据,而方法对应一个类可以支持哪些操作(即数据处理)。
19、类中在特定情况下由系统自动执行的方法是(  C  )。
A、类方法  B、静态方法  C、内置方法  D、普通方法
★考核知识点: 类中普通方法定义及调用
参见讲稿章节:4-04
附1.1.19(考核知识点解释)
类中的方法分为两类:普通方法和内置方法。
(1)普通方法需要通过类的实例对象根据方法名调用;
(2)内置方法是在特定情况下由系统自动执行。
20、析构方法的形参个数为(  B  )。
A、0   B、1   C、至少1个   D、不限
★考核知识点: 析构方法
参见讲稿章节:4-07
附1.1.20(考核知识点解释)
析构方法是类的另一个内置方法,它的方法名为__del__,在销毁一个类对象时会自动执行,负责完成待销毁对象的资源清理工作,如关闭文件等。
例:析构方法示例。
class Student: #定义Student类
    def __init__(self,name): #定义构造方法
        self.name=name
        print('姓名为%s的对象被创建!'%self.name)
    def __del__(self): #定义析构方法
        print('姓名为%s的对象被销毁!'%self.name)
21、用于获取父类代理对象的方法是(  D  )。
A、parent   B、proxy   C、delegate   D、super
★考核知识点: super方法
参见讲稿章节:4-12
附1.1.21(考核知识点解释)
super方法用于获取父类的代理对象,以执行已在子类中被重写的父类方法,其语法格式为:
              super([类名[, 对象名或类名]])
22、类方法的第一个形参对应(  A  )。
A、类    B、对象   C、第一个实参   D、第二个实参
★考核知识点: 类方法和静态方法
参见讲稿章节:4-14
附1.1.22(考核知识点解释)
类方法是指使用@classmethod修饰的方法,其第一个参数是类本身(而不是类的实例对象)。类方法的特点是既可以通过类名直接调用,也可以通过类的实例对象调用。
23、为A类中的t属性定义一个获取属性值的方法(即getter),则应使用(  A  )装饰器。
A、@property       B、@t.getter
C、@property.getter     D、t.property.getter
★考核知识点: @property装饰器
参见讲稿章节:4-16
附1.1.23(考核知识点解释)
Python提供了@property装饰器,可以将类中属性的访问和赋值操作自动转为方法调用,这样可以在方法中对属性值的取值范围做一些条件限定。
直接使用@property就可以定义一个用于获取属性值的方法(即getter)。如果要定义一个设置属性值的方法(setter),则需要使用名字“@属性名.setter”的装饰器。
如果一个属性只有用于获取属性值的getter方法,而没有用于设置属性值的setter方法,则该属性是一个只读属性,只允许读取该属性的值、而不能设置该属性的值。
24、已知“a=[1,[2,3]]”且“b=a[:]”,则执行“a[1]=10”后,b的值为(  B  )。
A、[1,10]   B、[1,[2,3]]   C、[1,[10,3]]   D、报错
★考核知识点: 复制列表元素
参见讲稿章节:5-03
附1.1.24(考核知识点解释)
例:利用元素截取方法,实现修改一个对象中的元素值不会影响另一个对象。
ls1=[1,2,3] #创建列表对象并赋给变量ls1
ls2=ls1[:] #通过ls1[:]将ls1的所有元素截取生成新对象并赋给ls2
print('ls1和ls2的值分别为:',ls1,ls2)
print('ls1和ls2的内存地址分别为:',id(ls1),id(ls2))
ls1[1]=5 #将ls1中下标为1的元素值修改为5
print('ls1和ls2的值分别为:',ls1,ls2)
ls1=[1,[2,3]] #创建列表对象并赋给变量ls1
ls2=ls1[:] #通过ls1[:]将ls1的所有元素截取生成新对象并赋给ls2
print('ls1和ls2的值分别为:',ls1,ls2)
print('ls1和ls2的内存地址分别为:',id(ls1),id(ls2))
print('ls1[1]和ls2[1]的内存地址分别为:',id(ls1[1]),id(ls2[1]))
ls1[1][0]=5 #将ls1下标为1的列表元素(即ls[1])中下标为0的元素值修改为5
print('ls1和ls2的值分别为:',ls1,ls2)
程序运行结果为:
ls1和ls2的值分别为: [1, 2, 3] [1, 2, 3]
ls1和ls2的内存地址分别为: 2021463056968 2021463057032
ls1和ls2的值分别为: [1, 5, 3] [1, 2, 3]
ls1和ls2的值分别为: [1, [2, 3]] [1, [2, 3]]
ls1和ls2的内存地址分别为: 1416753996424 1416754486344
ls1[1]和ls2[1]的内存地址分别为: 1416753996360 1416753996360
ls1和ls2的值分别为: [1, [5, 3]] [1, [5, 3]]
25、统计列表ls中的值为3的元素个数应使用(  A  )。
A、ls.count(3)   B、count(ls,3)
C、ls.len(3)    D、len(ls,3)
★考核知识点: 列表元素的最大值、最小值、出现次数和列表长度
参见讲稿章节:5-05
附1.1.25(考核知识点解释)
使用列表中的count方法可以统计某个值在列表中出现的次数,count方法的语法格式如下:
ls.count(x)
其作用是统计值x在列表ls中出现的次数。
26、已知“a=dict(x=1,y=dict(y1=2,y2=3))”且“b=a.copy()”,则执行“a['y']['y1']=10”后,则print(b)的输出结果为(  C  )。
A、{x=1,y={y1=10,y2=3}}
B、{x=1,y={y1=2,y2=3}}
C、{'x':1,'y':{'y1':10,'y2':3}}
D、{'x':1,'y':{'y1':2,'y2':3}}
★考核知识点: 字典的浅拷贝和深拷贝
参见讲稿章节:5-12
附1.1.26(考核知识点解释)
使用字典中的copy方法可以实现一个字典的浅拷贝。copy方法的语法格式为:
d.copy()
其作用是返回一个对字典d进行浅拷贝而得到的新字典。
27、生成器解决了使用列表存储数据可能存在的(  A  )问题。
A、内存不足     B、访问速度慢
C、元素值不能重复    D、元素可修改
★考核知识点: 生成器
参见讲稿章节:5-16
附1.1.27(考核知识点解释)
当一个列表中包含大量元素时,如果一次性生成这些元素并保存在列表中,将占用大量的内存空间(有的情况下可用内存甚至无法满足存储需求)。
对于这个问题,我们可以通过生成器(generator)来解决,即根据需要进行计算并获取列表中某个元素的值。
28、与正则表达式“^ab[a-z]*c”匹配的字符串是(  A  )。
A、abdec   B、abc    C、ab0c   D、cabc
★考核知识点: 正则表达式的基础语法
参见讲稿章节:6-08
附1.1.28(考核知识点解释)
Python中提供的部分匹配模式如下表所示。
匹配模式 描述
^(插入符) 匹配字符串开头的若干字符。例如,对于正则表达式“^py”,其与“python”匹配,但与“puppy”不匹配。
[] 字符集合,对应位置可以是该集合中的任一字符。既可以依次指定每一个字符,如[0123456789];也可以通过短横线“-”指定一个范围,如[0-9]。在字符序列前加^表示取反,如[^0-9]表示匹配不在0至9之间的字符。
* 匹配前一个模式0次或多次。例如,对于正则表达式“a[0-9]*c”,其与“ac”、“a0c”和“a01c”匹配,但与“abc”不匹配。

29、已知m是一个Match对象,则m.groups()返回的结果必然是一个(  B  )。
A、字符串   B、元组   C、列表    D、不确定
★考核知识点: re模块使用-匹配对象
参见讲稿章节:6-11
附1.1.29(考核知识点解释)
Match对象中的groups()方法返回一个由所有分组的匹配结果字符串组成的元组。
30、要从文件中按行读取所有数据,则应使用文件对象的(  D  )方法。
A、read   B、readall   C、readline   D、readlines
★考核知识点: 文件对象方法-readline、readlines和seek
参见讲稿章节:7-07
附1.1.30(考核知识点解释)
使用文件对象的readlines方法可以从文件中按行读取所有数据,其语法格式为:
f.readlines()
其中,f是open函数返回的文件对象。readlines方法将从文件中按行读取的所有数据以列表形式返回。
(二)、多项选择
1、下列占位运算符中,表示有符号浮点型十进制数的占位符是(  AC  )。
A、%f    B、%d    C、%F    D、%s
★考核知识点: 占位运算符和算术运算符
参见讲稿章节:2-08
附1.1.1(考核知识点解释)
占位运算符类似于C语言中sprintf或printf函数中使用的占位符,在字符串中可以给出一些占位符用来表示不同类型的数据,而实际的数据值在字符串之外给出。下表为3个常用占位符的描述。

2、下列选项中,计算结果为True的表达式包括(  ABC  )。
A、15>=8  B、not 15<8  C、15>=8 or 15<8  D、15>=8 and 15<8
★考核知识点: 赋值运算符、比较运算符和逻辑运算符
参见讲稿章节:2-09
附1.1.2(考核知识点解释)
逻辑运算可以将多个比较运算连接起来形成更复杂的条件判断。逻辑运算符如下表所示。

例如:
n=80,a=100
print(n>=0 and n<=a)#输出“True”,判断n是否大于等于0且小于等于a
print(n<0 or n>a) #输出“False ”,判断n是否小于0或大于a
print(not(n>=0 and n<=a)) #输出“False ”
3、下列选项中,可以用于判断x和y是否对应同样存储单元的语句是(  BC  )。
A、x==y   B、x is y   C、id(x)==id(y)  D、not x!=y
★考核知识点: 身份运算符和成员运算符
参见讲稿章节:2-11
附1.1.3(考核知识点解释)
身份运算用于比较两个对象是否对应同样的存储单元。

x is y等价于id(x)==id(y),即判断x和y的内存首地址是否相同;x is not y等价于id(x)!=id(y),即判断x和y的内存首地址是否不相同。
4、下面关于pass的说法中,正确的是(  AC  )。
A、pass表示一个空操作,只起到占位作用
B、pass只能用在条件语句中
C、if的分支语句中可以只包括pass
D、pass能够跳出循环语句
★考核知识点: 条件语句实现和pass
参见讲稿章节:2-14
附1.1.4(考核知识点解释)
pass表示一个空操作,只起到一个占位作用,执行时什么都不做。例如:
score=eval(input('请输入成绩(0~100之间的整数):')
if score>=60:
    pass #什么都不做
else:
    print('不及格')
提示:
(1)在某些必要的语句(如条件语句中的各语句序列)还没有编写的情况下,如果要运行程序,则可以先在这些必要语句处写上“pass”,使得程序不存在语法错误、能够正常运行。
(2)实际上,pass与条件语句并没有直接关系,在程序中所有需要的地方都可以使用pass作为占位符。比如,在循环语句中,也可以使用pass作为占位符。
5、已知有代码“for x in y:”,则y的数据类型可以是(  ABD  )。
A、列表   B、元组   C、数值   D、字符串
★考核知识点: 循环语句概述和for循环
参见讲稿章节:2-15
附1.1.5(考核知识点解释)
用于遍历可迭代对象中的每一个元素,并根据当前访问的元素做数据处理,其语法格式为:
for 变量名 in 可迭代对象:
    语句序列。
6、如果希望用一个return语句结束函数但不返回任何数据,则可以写为(  BC  )。
A、return False    B、return
C、return None    D、return 0
★考核知识点: 返回值
参见讲稿章节:3-06
附1.1.6(考核知识点解释)
如果希望能够将一个函数的运算结果返回到调用函数的位置,以使得可以继续用该运算结果再去参与其他运算,此时则应使用return语句。
我们在前面写的函数中虽然都没有显式地写return语句,但实际上这些函数都有一个隐式的什么数据都不返回的return语句,即return None(或直接写为return)。
7、下面关于包的叙述中,正确的是(  ABD  )。
A、利用包可以将多个关系密切的模块组织在一起
B、定义一个包就是创建一个文件夹并在该文件夹下创建一个名为__init__.py的文件
C、一个包下面只能包含模块
D、一个包下面还可以包含子包
★考核知识点: 包
参见讲稿章节:3-10
附1.1.7(考核知识点解释)
Python中的包(Package)的作用与操作系统中文件夹的作用相似,利用包可以将多个关系密切的模块组织在一起,一方面方便进行各脚本文件的管理,另一方面可以有效避免模块命名冲突问题。
定义一个包,就是创建一个文件夹并在该文件夹下创建一个__init__.py文件,文件夹的名字就是包名。
另外,可以根据需要在该文件夹下再创建子文件夹,子文件夹中创建一个__init__.py文件,则又形成了一个子包。
模块可以放在任何一个包或子包中,在导入模块时需要指定所在的包和子包的名字。例如,如果要导入包A中的模块B,则需要使用“import A.B”。
8、下列选项中,描述正确的是(  ACD  )。
A、构造方法是类的内置方法之一
B、构造方法在定义类时自动执行
C、构造方法在创建对象时自动执行
D、构造方法可以设置默认参数值
★考核知识点: 构造方法
参见讲稿章节:4-06
附1.1.8(考核知识点解释)
构造方法是Python类中的内置方法之一,它的方法名为__init__,在创建一个类对象时会自动执行,负责完成新创建对象的初始化工作。
9、如果一个类C1通过继承已有类C而创建,则将C称作(  BCD  )。
A、子类   B、基类   C、父类   D、超类
★考核知识点: 继承的概念
参见讲稿章节:4-09
附1.1.9(考核知识点解释)
继承允许开发者基于已有的类创建新的类。如果一个类C1通过继承已有类C而创建,则将C1称作子类(sub class),将C称做基类、父类或超类(base class、super class)。
10、使用集合的update方法,传入的实参可以是(  BCD  )。
A、数字   B、元组   C、列表   D、字符串
★考核知识点: 集合的创建和插入元素
参见讲稿章节:5-08
附1.1.10(考核知识点解释)
集合中提供了两种插入元素的方法,分别是add和update。add方法的语法格式为:
s.add(x)
其作用是把x作为一个新的元素插入到集合s中,其中x必须是一个可哈希对象。
update方法的语法格式为:
s.update(x)
其作用是把x拆分成多个元素后再将这多个元素插入到集合中,其中x必须是一个可迭代对象。
11、字符串检索时,检索失败时不会引发异常的方法包括(  AB  )。
A、find   B、rfind   C、index   D、rindex
★考核知识点: 字符串检索和替换
参见讲稿章节:6-04
附1.1.11(考核知识点解释)
index与find作用相同,rindex与rfind作用相同,只是find和rfind在检索不到字符串sub时返回-1,而index和rindex会引发ValueError异常。
12、如果要替换字符串中与指定正则表达式匹配的子串,可以使用re模块的(  CD  )函数。
A、replace   B、split   C、sub    D、subn
★考核知识点: re模块使用-split、sub和subn
参见讲稿章节:6-13
附1.1.12(考核知识点解释)
(1)re模块的sub函数用于替换字符串中与正则表达式匹配的子串。re.sub函数的语法格式为:
re.sub(pattern, repl, string, count=0, flags=0)
其中,pattern是正则表达式;repl是要将匹配子串替换成的字符串;string是待做替换操作的字符串;count是最大替换次数,默认为0表示不限制替换次数(即将所有符合正则表达式的子串都替换成repl);flags与re.match等函数中的flags参数含义相同。
(2)re模块中的subn函数与re.sub函数功能完全相同,只是re.subn函数会以一个元组的形式同时返回替换匹配子串后得到的新字符串和替换的次数。re.subn函数的语法格式为:
re.subn(pattern, repl, string, count=0, flags=0)
各参数含义与re.sub函数相同。

(三)、判断部分
1、Matplotlib是一款Python编程环境下免费使用的绘图工具包,其工作方式和绘图命令几乎和MATLAB类似。 (√)
★考核知识点: Python简介
参见讲稿章节:1-01
附1.2.1(考核知识点解释)
Matplotlib:一款Python编程环境下免费使用的绘图工具包,其工作方式和绘图命令几乎和MATLAB类似。
2、Python是一种弱类型的语言,变量的类型由其值的类型决定。 (√)
★考核知识点: 变量的定义
参见讲稿章节:2-01
附1.2.2(考核知识点解释)
Python是一种弱类型的语言,变量的类型由其值的类型决定。Python变量在使用前不需要先定义,为一个变量赋值后,则该变量会自动创建。
3、二进制数转十进制数的规则是“按权展开求和”。 (√)
★考核知识点: 位运算符
参见讲稿章节:2-10
附1.2.3(考核知识点解释)
二进制数转十进制数的规则是“按权展开求和”,即将二进制数的每一位写成数码乘以位权的形式,再对乘积求和。
4、伪代码必须符合Python语言的语法要求。 (×)
★考核知识点: 条件语句概述
参见讲稿章节:2-13
附1.2.4(考核知识点解释)
在解决一个实际问题时,可以先使用流程图、自然语言或伪代码等形式描述数据处理流程(即算法设计),再按照设计好的流程(即算法)编写程序。这样,在设计算法时可以忽略具体代码实现、而专注于如何解决问题,有利于避免程序的逻辑错误。
5、在for循环和while循环后面可以跟着else分支,退出循环后必然会执行else后面的语句序列。 (×)
★考核知识点: break、continue和else
参见讲稿章节:2-17
附1.2.5(考核知识点解释)
在for循环和while循环后面可以跟着else分支,当for循环已经遍历完列表中所有元素或while循环的条件为False时,就会执行else分支。
6、Python中的函数定义通过define关键字完成。 (×)
★考核知识点: 函数的定义与调用
参见讲稿章节:3-01
附1.2.6(考核知识点解释)
例:
def CalCircleArea(): #定义名字为CalCircleArea的函数
    s=3.14*3*3 #计算半径为3的圆的面积
    print('半径为3的圆的面积为:%.2f'%s) #将计算结果输出
CalCircleArea() #调用函数CalCircleArea
7、对于没有默认参数值的形参,在函数调用时必须为其指定实参。(√)
★考核知识点: 默认参数和关键字参数
参见讲稿章节:3-03
附1.2.7(考核知识点解释)
函数的默认参数就是缺省参数,即当调用函数时,如果没有为某些形参传递对应的实参,则这些形参会自动使用默认参数值。
例:带默认参数的函数的定义和调用方法示例。
def StudentInfo(name,country='中国'): #参数country的默认参数值为'中国’
    print('姓名:%s,国家:%s'%(name,country))
StudentInfo('李晓明') #这里没有给country传实参值,但因为有默认参数所以不会出错
StudentInfo('大卫','美国') #给country传了实参,则不再使用默认参数
注意:name并没有默认参数,所以在调用函数时必须为其指定实参,否则运行程序会报错。例如,当执行StudentInfo()时,系统会给出如下报错信息:
TypeError: StudentInfo() missing 1 required positional argument: 'name'
8、使用“import M1; M2; M3”可以一次导入M1、M2和M3这3个模块。 (×)
★考核知识点: 模块概述和import语句
参见讲稿章节:3-07
附1.2.8(考核知识点解释)
当要使用一个模块中的某些功能时,我们可以通过import方式将该模块导入。
语法格式:
import module1
import module2

import moduleN

import module1, module2, ..., module
9、已知MyModule模块中有一个无参函数fun,且在脚本文件N.py中有“import MyModule as M”,则在N.py中要调用MyModule模块中的fun函数应使用“M.fun()”。 (√)
★考核知识点: from...import
参见讲稿章节:3-09
附1.2.9(考核知识点解释)
无论是利用import导入模块、还是用from import导入模块中的标识符,在导入的同时都可以使用as为模块或标识符起别名。
例如:
testfibo4.py脚本文件的代码如下:
import fibo as f #导入fibo模块,并为fibo起了个别名f
f.PrintFib(5) #调用fibo模块中的PrintFib函数,输出斐波那契数列前5项
10、装饰器的作用是在不修改已有函数情况下向已有函数注入代码。 (√)
★考核知识点: 装饰器
参见讲稿章节:3-18
附1.2.10(考核知识点解释)
利用装饰器,可以在不修改已有函数的情况下向已有函数中注入代码,使其具备新的功能。一个装饰器可以为多个函数注入代码,一个函数也可以注入多个装饰器的代码。利用装饰器可以将日志处理、执行时间计算等较为通用的代码注入到不同的函数中,从而使得代码更加简洁。
11、利用一个类可以创建多个对象,且每个对象可以存储不同的数据。 (√)
★考核知识点: 面向对象概述
参见讲稿章节:4-01
附1.2.11(考核知识点解释)
类和对象是面向对象程序设计的两个重要概念。类和对象的关系即数据类型与变量的关系,根据一个类可以创建多个对象,而每个对象只能是某一个类的对象。类规定了可以用于存储什么数据,而对象用于实际存储数据,每个对象可存储不同的数据。
12、一个类属性只能通过类名访问。  (×)
★考核知识点: 类属性定义及其访问
参见讲稿章节:4-03
附1.2.12(考核知识点解释)
对类属性的访问,既可以直接通过类名访问,也可以通过该类的对象访问,访问方式为:
类名或对象名.属性名
13、已知类的普通方法func有3个形参且都没有默认参数值,则调用该方法时必须传入对应的3个实参。 (×)
★考核知识点: 类中普通方法定义及调用
参见讲稿章节:4-04
附1.2.13(考核知识点解释)
在定义类的普通方法时,要求第一个参数需要对应调用方法时所使用的实例对象(一般命名为self,但也可以改为其他名字)。
当使用一个实例对象调用类的普通方法时,其语法格式为:
实例对象名.方法名(实参列表)
提示:在通过类的实例对象调用类中的普通方法时,并不需要传入self参数的值,self会自动对应调用该方法时所使用的对象。
14、已知Student类有一个属性__id,stu是Student类的对象,则通过“stu.__id='1810101'”可以将stu对象中的__id属性赋值为字符串'1810101'。 (×)
★考核知识点: 私有属性
参见讲稿章节:4-05
附1.2.14(考核知识点解释)
私有属性,是指在类内可以直接访问、而在类外无法直接访问的属性。Python中规定,在定义类时,如果一个类属性名是以__(两个下划线)开头,则该类属性为私有属性。
15、__str__方法的返回值可以是整数。  (×)
★考核知识点: 常用内置方法
参见讲稿章节:4-08
附1.2.15(考核知识点解释)
调用str函数对类对象进行处理时或者调用Python内置函数format()和print()时自动执行,__str__方法的返回值必须是字符串。
16、如果一个子类有两个或更多父类,则这种继承关系称为多重继承。(√)
★考核知识点: 继承的概念
参见讲稿章节:4-09
附1.2.16(考核知识点解释)
如果一个子类只有一个父类,则将这种继承关系称为单继承;如果一个子类有两个或更多父类,则将这种继承关系称为多重继承。
17、Python中的多态是借助鸭子类型实现的。 (√)
★考核知识点: 方法重写和鸭子类型
参见讲稿章节:4-11
附1.2.17(考核知识点解释)
在鸭子类型中,关注的不是对象所属的类,而是一个对象能够如何使用。在Python中编写一个函数,传递实参前其参数的类型并不确定,在函数中使用形参进行操作时只要传入的对象能够支持该操作程序就能正常执行。
提示:实际上,Python中的多态也是借助鸭子类型实现,与C++、Java等语言中的多态并不是同一含义。
18、已知B是A的父类,b是B类的对象,则“A==type(b)”返回结果为True。(×)
★考核知识点: 内置函数isinstance、issubclass和type
参见讲稿章节:4-13
附1.2.18(考核知识点解释)
isinstance函数用于判断一个对象所属的类是否是指定类或指定类的子类;issubclass函数用于判断一个类是否是另一个类的子类;type函数用于获取一个对象所属的类。
如果我们要判断一个对象的类型是否是指定类或该类的子类,则可以使用isinstance函数。如果我们要判断一个对象的类型是否是指定类,则可以使用“type(对象名)==类名”的方式。
19、对于可变类型的对象a,通过“a=b”可以修改a的值,但赋值前和赋值后a所对应的内存地址可能会发生变化。 (√)
★考核知识点: 可变类型与不可变类型
参见讲稿章节:5-01
附1.2.19(考核知识点解释)
可变类型的对象和不可变类型的对象的区别在于是否可修改对象中的元素值。对于可变类型的对象,如果对可变类型对象中的元素做修改,则不会创建新对象;而如果直接对其赋值,则也会创建一个新的对象。
20、通过“max(t)”可以得到元组t中最大元素的值。 (√)
★考核知识点: 元组的操作
参见讲稿章节:5-07
附1.2.20(考核知识点解释)
如果使用()创建的元组中只包含单个元素,则需要在这唯一的一个元素后面添加逗号,否则小括号会被系统认为是括号运算符、而不会被认为是在创建元组。
21、已知s1和s2是两个集合,则执行“s1.union(s2)”后,s1中的元素是原来s1和s2两个集合中的元素的并集。 (×)
★考核知识点: 集合的运算
参见讲稿章节:5-09
附1.2.21(考核知识点解释)
集合中的union方法可以用于计算一个集合与另一个集合的并集,语法格式为:
s1.union(s2)
其作用是计算s1和s2的并集并返回。union方法不会修改s1和s2本身的值。
22、已知执行“d=dict(sno='1810100', name='李晓明', age=19)”,则执行“r=d.pop('age')”后,r的值为19。 (√)
★考核知识点: 字典元素的修改、插入和删除
参见讲稿章节:5-11
附1.2.22(考核知识点解释)
使用del可以删除某个元素,也可以使用字典中的pop方法删除指定键的元素。pop方法的语法格式为:
d.pop(key[, default])
其作用是从字典d中删除键为key的元素并返回该元素的值;如果d中不存在键为key的元素,则返回default参数的值。
23、os.path.join('.','src','tools')与'.{0}src{0}tools'.format(os.sep)返回的字符串相同。(√)
★考核知识点: os模块的使用-获取绝对路径、路径分离和连接
参见讲稿章节:7-03
附1.2.23(考核知识点解释)
使用os.path.join函数一个路径的多个组成部分用系统路径分隔符(即os.sep)连接在一起,其语法格式为:
os.path.join(path, *paths)
其作用是将各参数用系统路径分隔符连接得到的结果返回。
24、如果一个except子句捕获多个异常,则多个异常名应写为元组的形式。 (√)
★考核知识点: 异常处理-try except
参见讲稿章节:7-11
附1.2.24(考核知识点解释)
(1)except子句后面的异常类型,既可以是单个异常类型,如“except ValueError:”;
(2)也可以是由多个异常类型组成的元组,如“except (TypeError, ZeroDivisionError):”;
(3)还可以为空,即“except:”,表示捕获所有的异常。

二、主观部分:

(一)、程序题
1、请写出下面程序的运行结果。
test='Python'
Test=27.5
print(test)
test=15
print(Test)
★考核知识点:变量的定义
参见讲稿章节:2-01
参考答案:
(1)Python
(2)27.5

2、下面程序运行结果为“10 5”,请将程序补充完整(每个空只能填写一条语句)。
x=5
y=10
____(1)____
print(x,y)
★考核知识点:C++与C的主要差异 – 引用和返回引用的函数
参见讲稿章节:1-15
参考答案:
(1)x,y=y,x

3、请写出下面程序的输出结果。
s1='大家\
好!'
s2='It\'s a book!'
print(s1)
print(s2)
★考核知识点:String数据类型
参见讲稿章节:2-03
参考答案:
(1)大家好!
(2)It's a book!

4、下面程序运行结果为:
大家好!
我是李晓明!
请将程序补充完整(每个空只能填写一条语句)。
____(1)____
print(s)
★考核知识点:String数据类型
参见讲稿章节:2-03
参考答案:
(1)s="大家好!\n我是李晓明!"

5、请写出下面程序的输出结果。
ls=[1, 2.5, 'test', 3+4j, True, [3,1.63], 5.3]
print(ls[3:5])
print(ls[-3])
★考核知识点:List数据类型
参见讲稿章节:2-04
参考答案:
(1)[(3+4j), True]
(2)True

6、下面程序运行结果为:
张三
95
请将程序补充完整。
info={'name':'张三', 'age':19, 'score':{'python':95,'math':92}}
print(info____(1)____)
print(info____(2)____)
★考核知识点:Dictionary数据类型
参见讲稿章节:2-07
参考答案:
(1)['name']
(2)['score']['python']

7、请写出下面程序的输出结果。
x,y=[1,2,3],[1,2,3]
print(x==y)
print(x is y)
★考核知识点:身份运算符和成员运算符
参见讲稿章节:2-11
参考答案:
(1)True
(2)False

8、请写出下面程序的输出结果。
x,y,z=3,5,7
if y>x:
    print(y)
    if y>z:
        print(y)
    else:
        print(z)
else:
    print(x)
    if x>z:
        print(x)
    else:
        print(z)
★考核知识点:条件语句实现和pass
参见讲稿章节:2-14
参考答案:
(1)5
(2)7

9、下面程序的功能是使用for循环实现1到n直接按所有奇数的求和,请将程序补充完整。
n=eval(input('请输入一个大于0的整数:'))
____(1)____
for i in range(____(2)____):
    sum+=i
print(sum)
★考核知识点:循环语句概述和for循环
参见讲稿章节:2-15
参考答案:
(1)sum=0
(2)1,n+1,2

10、请写出下面程序的输出结果。
m,n=24,36
while m!=n:
    while m>n:
        m-=n
    while n>m:
        n-=m
print(m)
★考核知识点:while循环和索引
参见讲稿章节:2-16
参考答案:
(1)24
(2)12

11、请写出下面程序的输出结果。
def ModifyVal(x,y):
    x=y
def ModifyListElement(ls,idx,val):
    ls[idx]=val
c=[1,3,5]
ModifyVal(c,[4,5,6])
print(c)
c=[2,4,6,8]
ModifyListElement(c,2,20)
print(c)
★考核知识点:形参和实参
参见讲稿章节:3-01
参考答案:
(1)[1, 3, 5]
(2)[2, 4, 20, 8]

12、请指出下面程序中存在的错误并改正。
def StudentInfo(country='中国', chineselevel='良好', name):
    print('姓名:%s,中文水平:%s,国家:%s'%(name,chineselevel,country))
StudentInfo(country='美国', chineselevel='一般', name='约翰')
★考核知识点:默认参数和关键字参数
参见讲稿章节:3-03
参考答案:
带默认参数值的形参应在不带默认参数值的形参后面,可将“def StudentInfo(country='中国', chineselevel='良好', name):”改为“def StudentInfo(name, country='中国', chineselevel='良好'):”

13、下面程序输出结果是:10 (15, 20) {'a': 25, 'b': 30}。请将下面程序补充完整。
def Fun(x, ____(1)____, ____(2)____):
    print(x, args1, args2)
Fun(10, 15, 20, a=25, b=30)
★考核知识点:不定长参数
参见讲稿章节:3-04
参考答案:
(1)*args1
(2)**args2

14、请指出下面程序中存在的错误并改正。
def Sum(a,b,c):
    print(a+b+c)
t=(1,2,3)
Sum(**t)
★考核知识点:拆分参数列表
参见讲稿章节:3-05
参考答案:
t是元组,拆分时应使用一个*,因此应将“**t”改为“*t”

15、请写出testM.py运行后的输出结果。
M.py中的代码:
def PrintSum(m,n):
    print(m+n)
PrintSum(10,15)

testM.py中的代码:
import M
M.PrintSum(1,2)
★考核知识点:派生类构造函数和析构函数、函数重定义和派生类的继承方式
参见讲稿章节:3-03、3-05
参考答案:
(1)25
(2)3

16、将下面代码放在test.py脚本文件中。当执行“python test.py 5”时输出15,当执行“python test.py 10”时输出55。请将下面程序补充完整。
import ____(1)____
n=int(____(2)____)
sum=0
for i in range(1,n+1):
    sum+=i
print('求和结果:%d'%sum)
★考核知识点:全局变量__name__和系统模块
参见讲稿章节:3-08
参考答案:
(1)sys
(2)sys.argv[1]

17、请指出下面程序中存在的错误并改正。
M.py中的代码:
def PrintSum(m,n):
    print(m+n)

testM.py中的代码。
import M as m
M.PrintSum(3,5)
★考核知识点:from...import
参见讲稿章节:3-09
参考答案:
import导入模块时通过“as”为模块起了别名,则在使用该模块时只能使用别名而不能用原模块名,因此应将“M.PrintSum(3,5)”改为“m.PrintSum(3,5)”

18、请写出下面程序的输出结果。
def f1():
    print('f1函数被调用!')
def f2():
    print('f2函数被调用!')
f1=f2
f1()
f2()
★考核知识点:猴子补丁和第三方模块获取安装
参见讲稿章节:3-11
参考答案:
(1)f2函数被调用!
(2)f2函数被调用!

19、请指出下面程序中存在的错误并改正。
def f1():
    print(x)
def f2():
    x=50 #将全局变量x的值修改为50
    print(x)
x=10
f2()
f1()
★考核知识点:全局变量和global关键字
参见讲稿章节:3-13
参考答案:
在一个函数中修改一个全局变量的值必须使用global关键字,因此应在f2函数的开始加上“global x”

20、下面程序输出结果为50,请指出下面程序中存在的错误并改正。
def f1():
    x=10
    def f2():
        x=50
    f2()
    print(x)
f1()
★考核知识点:nonlocal关键字
参见讲稿章节:3-14
参考答案:
在内层函数中修改外层函数局部变量的值必须使用nonlocal关键字,因此应在f2函数的开始加上“nonlocal x”

21、请写出下面程序的输出结果。
def FunAdd(f,x,y):
    return f(x)+f(y)
print(FunAdd(lambda x:x*2+1,3,-5))
print(FunAdd(lambda x:x**2+1,3,-5))
★考核知识点:高阶函数和lambda函数
参见讲稿章节:3-16
参考答案:
(1)-2
(2)36

22、下面程序输出结果为25,请将下面程序补充完整。
def outer(x):
    def inner(y):
        ____(1)____
        return x+y
    return ____(2)____
f=outer(5)
print(f(20))
★考核知识点:闭包
参见讲稿章节:3-17
参考答案:
(1)nonlocal x
(2)inner

23、请将下面程序补充完整。
class Student:
    pass
if __name__=='__main__':
    stu1=Student()
    stu2=Student()
    ____(1)____='unknown'
    ____(2)____=19
    print(stu1.name) #输出unknown
    print(stu2.name) #输出unknown
    print(stu1.age) #输出19
    #print(stu2.age) #取消前面的注释符则会报错
★考核知识点:类属性定义及其访问
参见讲稿章节:4-03
参考答案:
(1)Student.name
(2)stu1.age

24、请将下面程序补充完整。
class Student:
    def ____(1)____(self,____(2)____):
        self.name=name
    def PrintInfo(self):
        print('姓名:%s'%self.name)
if __name__=='__main__':
    stu1=Student()
    stu2=Student('李晓明')
    stu1.PrintInfo() #输出“姓名:unknown”
    stu2.PrintInfo() #输出“姓名:李晓明”
★考核知识点:构造方法
参见讲稿章节:4-06
参考答案:
(1)__init__
(2)name='unknown'

25、请将下面程序补充完整。
class A:
    ____(1)____:
        print('A类的方法被调用!')
____(2)____:
    def fb(self):
        print('B类的方法被调用!')
if __name__=='__main__':
    b=B()
    b.fa()
    b.fb()
★考核知识点:子类的定义
参见讲稿章节:4-10
参考答案:
(1)def fa(self)
(2)class B(A)

26、请将下面程序补充完整。
d=dict(a=1,b=2)
for ____(1)____:
    print(k,v)
for ____(2)____:
    print(k,d[k])
★考核知识点:字典的其他常用操作
参见讲稿章节:5-14
参考答案:
(1)k,v in d.items()
(2)k in d.keys()或k in d

27、请将下面程序补充完整。
____(1)____
pattern=____(2)____(r'<[^<]*>')
result=pattern.match('<h1>南开大学</h1>')
print('result:',result)
★考核知识点:re模块使用-compile和match
参见讲稿章节:6-09
参考答案:
(1)import re
(2)re.compile

28、编写程序实现以下功能:对于数值x,如果x在区间(1,2]上,则输出x+2.5;如果x在区间[-1,1]上,则输出4.35x;如果x在区间[-2,-1)上,则输出x;如果x为其他值,则输出“无效值”。
★考核知识点:条件语句实现和pass
参见讲稿章节:2-14
参考答案:
x=eval(input('请输入一个数值:'))
if x>1 and x<=2:
    print(x+2.5)
elif x>=-1 and x<=1:
    print(4.35*x)
elif x>=-2 and x<-1:
    print(x)
else:
    print('无效值')

29、编写程序实现以下功能:判断ax^2+bx+c=0(这里用^表示乘方)是否是一元二次方程,如果是的话再判断是否有两个实根、一个实根或没有实根,并将判断结果输出。
★考核知识点:条件语句实现和pass
参见讲稿章节:2-14
参考答案:
a=eval(input('请输入a的值:'))
b=eval(input('请输入b的值:'))
c=eval(input('请输入c的值:'))
t=b*b-4*a*c
if a==0:
    print('不是一元二次方程')
elif t>0:
    print('有两个实根')
elif t==0:
    print('有一个实根')
else:
    print('无实根')

30、使用for循环编写程序实现以下功能:计算1!+2!+…+n!。
★考核知识点:循环语句概述和for循环
参见讲稿章节:2-15
参考答案:
n=eval(input('请输入一个大于0的整数:'))
sum=0
rlt=1
for i in range(1,n+1):
    rlt*=i
    sum+=rlt
print('结果为:%d'%sum)

31、使用while循环编写程序实现以下功能:把一张100元人民币换成10元、5元、1元面额,将所有可能的换法及换法总数输出。
★考核知识点:while循环和索引
参见讲稿章节:2-16
参考答案:
n,i=0,0
while i<=100//10:
    j=0
    while j<=(100-i*10)//5:
        print('10元%d张,5元%d张,1元%d张'%(i,j,100-i*10-j*5))
        n+=1
        j+=1
    i+=1
print('总共有%d种换法'%n)

32、使用while循环编写程序实现以下功能:输入一个整数,判断其是否是素数,并输出判断结果。
★考核知识点:break、continue和else
参见讲稿章节:2-17
参考答案:
n=eval(input('请输入一个大于1的整数:'))
m=int(n**0.5)
i=2
while i<=m:
    if n%i==0:
        break
    i+=1
if i<=m:
    print('不是素数')
else:
    print('是素数')

33、编写程序实现以下功能:输入若干整数(输入0结束),每个整数输入完毕后,马上输出该整数是否为素数。要求判断一个整数是否为素数的功能用一个函数实现。
★考核知识点:形参和实参
参见讲稿章节:3-02
参考答案:
def IsPrime(n):
    m=int(n**0.5)
    i=2
    while i<=m:
        if n%i==0:
            print('%d不是素数'%n)
            break
        i+=1
    else:
        print('%d是素数'%n)

while True:
    n=eval(input('请输入一个整数(输入0结束程序):'))
    if n==0:
        break
    elif n<2:
        print('输入的整数必须大于1,请重新输入!')
        continue
    else:
        IsPrime(n)

34、编写程序实现以下功能:输入若干个整数(输入0结束),将不能被3整除的整数相加,并将求和结果输出。要求判断一个整数n是否能被另一个整数m整除的功能用一个函数实现。
★考核知识点:返回值
参见讲稿章节:3-06
参考答案:
def IsMultiple(n,m):
    if n%m==0:
        return True
    return False
sum=0
while True:
    n=eval(input('请输入一个整数(输入0结束程序):'))
    if n==0:
        break
    if IsMultiple(n,3)==False:
        sum+=n
print('所有不能被3整除的整数之和为:%d'%sum)

35、编写程序实现以下功能:运行程序时指定一个整数参数,程序运行后输出该数的阶乘。例如,程序存放在脚本文件test.py中,则执行“python test.py 5”会输出120(即5!),执行“python test.py 3”会输出6(即3!)。
★考核知识点:全局变量__name__和系统模块
参见讲稿章节:3-08
参考答案:
import sys
n = int(sys.argv[1])
if n<1:
    print('输入整数必须大于0!')
else:
    fac=1
    for i in range(1,n+1):
        fac*=i
    print(fac)

36、请定义一个Circle类,具体要求为:(1)每个Circle类对象可以存储圆心和半径信息;(2)具有设置圆心和半径的方法SetCenter和SetRadius;(3)具有输出圆信息的方法PrintInfo;(4)具有计算圆面积的方法GetArea。
★考核知识点:类中普通方法定义及调用
参见讲稿章节:4-04
参考答案:
class Circle:
    x,y,r=0,0,1
    def SetCenter(self,x,y):
        self.x=x
        self.y=y
    def SetRadius(self,r):
        self.r=r
    def PrintInfo(self):
        print('圆心:(%f,%f),半径:%f'%(self.x,self.y,self.r))
    def GetArea(self):
        return 3.14*self.r*self.r
if __name__=='__main__':
    c=Circle()
    c.SetCenter(3.2,5.5)
    c.SetRadius(1.5)
    c.PrintInfo()
    print('面积为:%f'%c.GetArea())

37、请定义一个Time类,具体要求为:(1)每个Time类对象可以存储一个时间(包括时、分、秒);(2)具有设置当前时间的方法SetTime;(3)具有每次增加1秒的方法AddOneSec;(4)具有输出当前时间的方法PrintTime。
★考核知识点:C++与C的主要差异 – 引用和返回引用的函数
参见讲稿章节:4-04
参考答案:
class Time:
    h,m,s=0,0,0
    def SetTime(self,h,m,s):
        self.h=h
        self.m=m
        self.s=s
    def AddOneSec(self):
        self.s+=1
        if self.s==60:
            self.m+=1
            self.s=0
        if self.m==60:
            self.h+=1
            self.m=0
        if self.h==24:
            self.h=0
    def PrintTime(self):
        print('当前时间:%02d:%02d:%02d'%(self.h,self.m,self.s))
if __name__=='__main__':
    t=Time()
    t.SetTime(23,58,59)
    for i in range(100):
        t.PrintTime()
        t.AddOneSec()

38、请定义一个Cylinder类,具体要求为:(1)每个Cylinder类对象可以存储一个圆柱体(包括半径和高);(2)具有用于初始化半径和高的构造方法;(3)具有输出圆柱体信息的方法PrintInfo;(4)具有计算圆柱体体积的方法GetVolume。
★考核知识点:构造方法
参见讲稿章节:4-06
参考答案:
class Cylinder:
    r,h=1,1
    def __init__(self,r,h):
        self.r=r
        self.h=h
    def GetVolume(self):
        return 3.14*self.r*self.r*self.h
    def PrintInfo(self):
        print('半径:%f,高:%f'%(self.r,self.h))
if __name__=='__main__':
    c=Cylinder(3.1,2.5)
    c.PrintInfo()
    print('圆柱体体积为:%f'%c.GetVolume())

39、编写程序实现以下功能:根据指定值从一个列表中查找所有匹配元素的位置,要求使用列表中的index方法进行查找。
★考核知识点:列表元素的最大值、最小值、出现次数和列表长度
参见讲稿章节:5-05
参考答案:
def findall(ls,x):
    beg=0
    total=ls.count(x)
    rlt=[]
    for i in range(total):
        pos=ls[beg:].index(x)
        rlt.append(pos+beg)
        beg=pos+beg+1
    return rlt
if __name__=='__main__':
    r=findall([1,3,3,5,2,3,6,3,7,9,3],3)
    print('匹配的元素下标为:',r)

40、编写程序实现以下功能:在字符串s1中检索指定字符串s2,获取所有匹配字符串的起始字符位置,要求使用字符串的find方法进行检索。
★考核知识点:字符串检索和替换
参见讲稿章节:6-04
参考答案:
def findsubstr(str,sub):
    beg=0
    rlt=[]
    while True:
        pos=str.find(sub,beg)
        if pos==-1:
            break
        rlt.append(pos)
        beg=pos+1
    return rlt
if __name__=='__main__':
    r=findsubstr('cat dog cat dog cat cat dog','cat')
    print('匹配字符串的起始字符下标为:',r)

41、编写程序实现以下功能:利用正则表达式对象的search方法,查找一个字符串中的所有HTML标记(即由一对尖括号<>括起来的内容)。
★考核知识点:re模块使用-匹配对象
参见讲稿章节:6-11
参考答案:
import re
def findhtmlmarks(str):
    pattern=re.compile(r'<[^<]*>')
    beg=0
    ls=[]
    while True:
        rlt=pattern.search(str,beg)
        if rlt==None:
            break
        ls.append(rlt)
        beg=rlt.end()
    return ls
ls=findhtmlmarks('<body><h1>南开大学</h1></body>')
print(ls)

42、编写程序实现以下功能:在字符串s1中检索指定字符串s2,获取所有匹配字符串的起始字符位置,要求使用字符串的index方法进行检索。
★考核知识点:异常处理-try except
参见讲稿章节:7-11
参考答案:
def findsubstr(str,sub):
    beg=0
    rlt=[]
    while True:
        try:
            pos=str.index(sub,beg)
            rlt.append(pos)
            beg=pos+1
        except ValueError:
            break
    return rlt
if __name__=='__main__':
    r=findsubstr('cat dog cat dog cat cat dog','cat')
    print('匹配字符串的起始字符下标为:',r)

------分隔线----------------------------
发表评论
请自觉遵守互联网相关的政策法规,严禁发布色情、暴力、反动的言论。
评价:
表情:
用户名: 验证码:点击我更换图片
栏目列表
推荐内容