Python(期末题库)

1计算机基础

2Python编程环境搭建

3Python程序设计入门1

4Python程序设计入门2

5程序控制1

6程序控制2

7列表、元组

8集合、字典

9函数1

10函数2

11模块

12面向对象

1 计算机基础

1.1 概述

1.视频学习材料一般在哪里

A、实训作业的每章节第一个实训项目里

B、课程资源里

C、公告里

D、普通作业里

1.2 计算机是什么

1.以下哪些不是计算机的4个组成部分

A、输入设备

B、输出设备

C、处理器

D、存储器

E、显示器

F、鼠标键盘

1.3 数据和二进制

1.计算机能处理的最小单位?

A、二进制位(bit)

B、十六进制位

C、字节(Byte)

D、八进制位

2.我们在表示字符时,常用一种叫做ASCII码的编码方式,将所见字符表示为一个整数存入计算机中,例如,字符a的编码值为十进制97。字符b的编码值为98。如果采用1个字节(8个位)对这些字符进行二进制编码,则字符e的ASCII编码二进制表示为:

A、1100100

B、1100101

C、1100

D、0101

3.如果采用1个二进制位来表示声音,那么只能表示2个状态,0没有声音,1表示有声音。如果采用16个二进制位来表示声音,则可以表示多少种声音?

A、16

B、32

C、128

D、65536

1.4 电路与逻辑、软件与硬件

1.常见的操作系统有哪些?

A、AutoCad

B、Windows

C、Linux

D、Office

2.计算机的所有运行数据都是从内存里读取的,所以计算机程序运行前都需要将数据从硬盘里读入到内存中,这个过程是哪个部分在控制呢?

A、操作系统

B、编程软件

C、CPU

D、应用软件自己

3.Python是一种编程语言,它运行在操作系统之上,我们通过编写Python代码可以控制计算机为我们服务,查阅参考资料,以下适合使用Python来完成的任务有:

A、编写网站后台

B、大数据处理

C、科学运算

D、人工智能

1.5 Python语言简介

1.以存储程序原理为基础的冯·诺依曼结构的计算机,一般都由五大功能部件组成,它们是( )。

A、运算器、控制器、存储器、输入设备和输出设备

B、运算器、累加器、寄存器、外围设备和主机

C、加法器、控制器、总线、寄存器和外围设备

D、运算器、存储器、控制器、总线和外围设备

2.关于中央处理器,下列说法错误的是( )。

A、包括运算器

B、是计算机处理信息的核心

C、包括 CPU 和 ROM

D、又称 CPU

3.以下不是高级语言的是( )。

A、汇编语言

B、C

C、PASCAL

D、Python

4.以下不属于解释型语言的是( )。

A、BASIC

B、C

C、JavaScript

D、Python

5.目前,在人工智能领域使用最广泛的语言是( )。

A、R

B、C

C、MATLAB

D、Python

6.以下关于二进制整数的定义,正确的是( )

A、0bC3F

B、0B1019

C、0B1010

D、0b1708

2 Python环境搭建

2.1 Anaconda编译环境安装搭建

1.Anaconda中主要的Python编程工具是Spyder

A、对

B、错

2.官网的Python下载安装后无需配置即可使用

A、对

B、错

3.当前Python主要分为python2和python3两大版本,相互之间兼容。我们任选一个版本即可。

A、对

B、错

4.Anaconda下载版本中除了适合安装在windows系统上的版本,还有适合苹果系统和Linux系统的安装程序。

A、对

B、错

5.Anaconda包含了很多工具包,Anaconda的功能之一就是对这些包进行管理。

A、对

B、错

2.2 使用Spyder进行编译

1.打开Spyer后我可以在以下图片的哪个窗口输入代码?

A、1

B、2

C、3

2.打开Spyder后没有看到变量列表窗口是什么原因?该如何操作?

A、集成开发环境没有提供,重装一下

B、还没有定义变量,因此看不到,定义变量后就可以看到

C、该窗口当前显示的是Help页面,需要在Variable explorer\File explorer\help单击Variable explorer标签即可看到

2.3 在实训平台编译调试

#任务要求:编写一个能计算5个数值平均值的小程序,结果保留1位小数
#读入第一个测试集数据
a=eval( input( ) )
#########以下开始你的程序##########
b=eval(input())
c=eval(input())
d=eval(input())
e=eval(input())
f=(a+b+c+d+e)/5
print(f)
#########你的程序结束##############

2.4 Python小结

1.在 Python 语言中,可以作为源文件后缀名的是( )

A、py

B、pdf

C、png

D、ppt

2.在 Python 语言中,包含矩阵运算的第三方库是( )。

A、PyQt5

B、NumPy

C、wxPython

D、wordcloud

3.在 Python 语言中,能处理图像的第三方库是( )。

A、pyinstaller

B、pyserial

C、pil

D、requests

4.在 Python 语言中,不属于 Web 开发框架的第三方库是( )。

A、Mayavi

B、pyamid

C、django

D、flask

5.在 Python 语言中,用于数据分析的第三方库是( )。

A、Django

B、flask

C、PIL

D、pandas

6.在 Python 语言中,不属于机器学习领域的第三方库是( )。

A、PyTorch

B、Arcade

C、MXNet

D、Tensorflow

7.在 Python 语言中,属于网络爬虫领域的第三方库是( )。

A、PyQt5

B、NumPy

C、openpyxl

D、scrapy

8.以下不属于 Python 机器学习领域第三方库的是( )。

A、pandas

B、pygame

C、NumPy

D、Scikit-learn

9.在 Python 语言中,用来制作安装包的第三方库的工具是( )。

A、PyQt5

B、pyinstaller

C、pygame

D、pip

10.以下不属于 Python 数据分析领域第三方库的是( )。

A、scarpy

B、NumPy

C、matplotlib

D、pandas

11.以下不属于 Python 开发用户界面第三方库的是( )

A、PyQt

B、turtle

C、pygtk

D、wxPython

3 Python程序设计入门1

3.1 标识符、关键字和基本数据类型

1.以下变量名称中,合法的是:

A、3www

B、w2w

C、True

D、tom-age

2.由于以下变量名使用了关键字,会被解释器提示错误信息,错误信息如下:

SyntaxError: can't assign to keyword

以下选项中有哪些不是关键字呢? 可以在Spyder中使用kwlist来查看。(多选!)

A、None

B、true

C、If

D、false

E、else

3.找出代码中的错误修改程序得到正确结果(是否是关键字)

'''
代码中含有错误行,请改正错误,并按提示补充完成后续代码行程序,实现以下功能。
(1)从测试集中取出两个字符串
(2)判断这两个字符串是否是关键字,并输出真假(是关键字为真,否则为假)
(3)输出全部关键字
'''
#######以下一行代码中包含错误的变量名命名######
class2=input()         #从测试集中获取第一个字符串,此行错误参考相关知识“避免使用关键字的方法”
class1=input()         #从测试集中获取第二个字符串
import keyword        #导入keyword模块
#############从以下开始编写你的代码############
print( keyword.kwlist  )            #输出全部关键字,参考左侧相关知识的keyword.kwlist的用法
print( keyword.iskeyword(class2)  )     #输出第一个字符串是否是关键字,参考左侧相关知识的keyword.iskeyword的用法
print( keyword.iskeyword(class1)  )      #输出第二个字符串是否是关键字,同上
#############从以下开始编写你的代码############

4.选出以下变量是整型的选项

A、a=10-3/1

B、b=9.14-0.14

C、c=(3>4)+1

D、d=9-1j

E、e=3<2-1

5.选出以下变量为布尔型的是

A、a=true

B、b=3 and 4

C、c=3<4<5

D、d=not(3-15/5)

6.选出以下语句有错误的是

A、a=3+4/20-2**3

B、b=4%9+6//7

C、a=’3’ c=34+a

D、d=”3” e=”4” d=d+e+d

7.哪个选项中的代码中能够输出以下结果:

a=10    b=20
a+b=30

===选项:===

A、print(“a=10\ b=20\na+b=30”)

B、print(“a=10\tb=20\na+b=30”)

C、print(“a=10 b=20 a+b=30”)

D、print(“a=10b=20a+b=30”)

8.选出能够输出以下结果的选项

myname is zhangsan

===选项:===

A、a=”zhangsan” print (“my name is “+ a)

B、a=’zhangsan’ print (“my name is “+ a)

C、a=”zhangsan” print (“””my name is “””+ ‘’’a’’’)

D、a=”zhangsan” print (my name is + ‘’’a’’’)

9.判断变量数据类型并输出

"""
#本关的任务是请编写代码查看从测试集中读入数据的类型!
"""
my_data=input()            #从测试集获取数据给my_data,此时获取的数据应为字符串型
#############完成第9、11、13行等号后面的代码########
new_data=eval(my_data)            #使用eval函数将my_data的类型转换为应有的数据类型变量new_data
new_data_type=type(new_data)        #使用type函数获取new_data的数据类型
print(  new_data_type )                #打印这个数据类型new_data_type
#############请在此之前完成你的编码#################

结果:

测试集1:
测试输入:12.45
预期输出:<class 'float'>
测试集2:
测试输入:1+5
预期输出:<class 'int'>
测试集3:
测试输入:3>4
预期输出:<class 'bool'>

10.数据类型转换(实型、浮点型之间的转换)

#本关任务:编写一个程序完成以下任务:
#(1)以四舍五入方式输出保留n位有效小数的值。
#(2)以直接舍去的方式输出保留2位有效小数的值
#############完成第10、11、12、13行代码实现程序功能####
my_num=input()                #从测试集获取浮点型数字
my_n=input()                #从测试集获要保留的位n
my_num_float=float(my_num)     #使用float函数将my_num转换为小数
my_n_int=int(my_n)             #使用int函数将my_n转换为整数
my_num_float1=round(my_num_float,my_n_int)   #采用round函数四舍五入取整
my_num_float2=(int(my_num_float*100))/100    #巧妙采用将小数放大后取整再缩小的方式可以获取直接截取
print(my_num_float1)        #输出结果1
print(my_num_float2)        #输出结果2        
###################end################################

结果:

测试输入:31.415926,3;
表示要求
(1)输出31.415926以四舍五入方式保留3位小数的值。
(2)输出31.415926以直接舍去方式保留2位小数的值。
预期输出:
31.416
31.41
第一个输出为四舍五入输出
第二个为直接舍去输出

3.2 运算符与表达式

1.正确写出表达式

##根据提示,在右侧编辑器补充代码,写出正确的表达式。
#(1)从测试集获取整数数值a,b,c,d,e
a=int(input())             #输入a并转换为整型    
b=int(input())             #输入b并转换为整型    
c=int(input())             #输入c并转换为整型    
d=int(input())             #输入d并转换为整型    
e=int(input())             #输入e并转换为整型    
#(2)写出以下算术表达式:
x1=    b/a*c                #- x1为a分之b的c倍
x2=    (b/a)**c             #- x2为a分之b的c次方
x3=    d%e                  #- x3求d除以e的余数
x4=    d//e                 #- x4求d除以e的整数部分
#(3)输出以上计算结果
print(x1)
print(x2)
print(x3)
print(x4)
#(4)复杂表达式运算
x5=    c<d<e               #(4)输出c、d、e是否按从小到大顺序排列
x6=    e%6==0              #(5)输出e是否同时能被2、3整除
x7=    d>=(a+b+c+d+e)/5    #(6)输出d是否高于或等于这5个数的平均值
#(5)输出以上结果
print(x5)
print(x6)
print(x7)

结果:

测试输入:2,3,3,37,13;
预期输出:
4.5
3.375
11
2
False
False
True

测试输入:4,1,5,36,12;
预期输出:
0.75
0.015625
0
3
False
True
True

2.华氏度转摄氏度和进制转换

'''
1、输入一个华氏温度,输出对应的摄氏温度
2、进制转换,输入8位二进制数,分别将其转换为八进制、十进制、十六进制输出
'''
############以下为需补充完成的程序#############################
f=input()                        #第1题测试用例输入华氏度
bin_value=input()                #第2题测试用例输入二进制数值
f=    float(f)                    #将输入的字符串型f转为数字型
c=    round((f-32)*5/9,2)         #按公式根据f计算摄氏度,四舍五入保留2位小数,要求使用round函数
print( c )                        #输出摄氏度。
#第二题计算部分
#已从测试用例读入bin_value值,分别计算十进制:int_value,八进制:oct_value和十六进制:hex_value
int_value=int(bin_value,2)      #根据输入的bin_value求十进制int_value的值
oct_value=oct(int_value)        #根据十进制int_value求八进制oct_value的值
hex_value=hex(int_value)        #根据十进制int_value求16进制hex_value的值
print( int_value )                        #输出十进制数
print( oct_value )                        #输出八进制数
print( hex_value )                        #输出十六进制数

结果:

测试输入:
98.2345 00101001
预期输出:
36.8
41
0o51
0x29

3.注释

# ********** Begin ********** #
a=3       #定义一个整型变量a并赋值为3
b=4       #定义一个整型变量b并赋值为4
c='这是注释吗?'
'''
以下全部为注释
以下全部为注释
'''
print(a)
print(b)
print(c)
# ********** End ********** #

结果:

3
4
这是注释吗?

4.if-else

# ********** Begin ********** #
a=3
b=4
c=a+b
if c>a:
    print("b>0")
    print(b)
else:
    print("b<0")
    print(b)
# ********** End ********** #

结果:

b>0
4

5.变量值的交换

'''
本关任务:按提示补充程序语句,完成变量值的交换。
'''
################开始完成代码补充############
a=eval(input())            #获取测试集a的值
b=eval(input())            #获取测试集b的值
x=a                        #将a的值赋值给x
y=a+b                      #将a+b的值赋值给y
#使用传统方式进行x、y值互换
t=    x                    
x=  y
y=  t
print(x,y)                #输出交换后的值
#使用多变量赋值方式交换a,b
a,b=b,a                        #在a后补全该行代码
print(a,b)                #输出交换后的值
################END########################

结果:

测试输入:4,91;
预期输出:
95    4
91    4
第一行为4+91和4在交换后的输出
第二行为输入两个数交换后的输出

测试输入:22,100;
预期输出:
122    22
100    22

4 Python程序设计入门2

4.1 指导

1.print(5,6,7)的输出结果是()

A、5,6,7

B、5 6 7

C、18

2.print(‘5,6,7’)的输出结果是()

A、5,6,7

B、5 6 7

C、18

3.(3^12+〖24〗^5−7)/(23×45) “计算结果保留2位小数”“(不四舍五入,直接舍去后面的小数)”
x=eval((3**12+24**5-7)/(23*45))

A、print(“{%.2f}”.format(x))

B、print(“{:.2f}”.format(x))

C、print(“{:.2f}”format(x))

4.print(r’hello\nworld’)的结果是()

A、hello\nworld

B、hello world

C、helloworld

5.print(‘hello\nworld’)的结果是()

A、hello\nworld

B、hello world

C、helloworld

6.print(divmod(5.0,2))的结果是()

A、(2, 1)

B、(2.0, 1.0)

C、(2.0, 1.5)

7.print(round(96.32451,3))的结果是()

A、96

B、96.325

C、96.324

8.python当计算器

 #(1)a,b为两个整数
a=int(input())
b=int(input())
print('{}+{}={}'.format(a,b,a+b))             #去掉【】补充代码已实现输出a加b的值
print('{}-{}={}'.format(a,b,a-b))                #去掉【】补充代码已实现输出a减b的值
print('{}*{}={}'.format(a,b,a*b))                #去掉【】补充代码已实现输出a乘以b的值
print('{}/{}={}'.format(a,b,a/b))                #去掉【】补充代码已实现输出a除以b的值
#(1)a,b为两个小数
a=float(input())
b=float(input())
print('{:.2f}+{:.2f}={:.2f}'.format(a,b,a+b))        #去掉【】补充代码已实现输出a加b的值均保留为2位小数
print('{:.2f}-{:.2f}={:.2f}'.format(a,b,a-b))       #去掉【】补充代码已实现输出a减b的值均保留为2位小数
print('{:.2f}*{:.2f}={:.2f}'.format(a,b,a*b))       #去掉【】补充代码已实现输出a减b的值均保留为2位小数
print('{:.2f}/{:.2f}={:.2f}'.format(a,b,a/b))       #去掉【】补充代码已实现输出a减b的值均保留为2位小数

结果:

测试输入:
35
45
1.4
2.9
预期输出:
35+45=80
35-45=-10
35*45=1575
35/45=0.7777777777777778
1.40+2.90=4.30
1.40-2.90=-1.50
1.40*2.90=4.06
1.40/2.90=0.48

4.2基本输入输出、字符串、内置函数实训

1.python输出

N = eval(input())   # N取值范围是0—100,整数
print('{:>3}%@{}'.format(N,'='*(N//5)))   

结果:

测试输入:10
预期输出:
 10%@==
测试输入:20
预期输出:
 20%@====
测试输入:100
预期输出:
100%@==================== 

2.字符变量统计

s = "学而时习之,不亦说乎?有朋自远方来,不亦乐乎?人不知而不愠,不亦君子乎?"
n = 0  # 汉字个数
m = 0  # 标点符号个数
# 在以下补充代码,可以多行
#****begin*****#
m=s.count(',')+s.count('?')
n=len(s)-m
#****end*****# 
print("字符数为{},标点符号数为{}。".format(n, m))

结果:

测试输入:
预期输出:
字符数为30,标点符号数为6。

3.身体质量指数(BMI)

#不要修改其他代码
h,w = eval(input()) # 请输入身高(m)和体重(kg),英文逗号隔开,
print("BMI是{:.1f}".format(w/(h**2)))   

结果:

测试输入:1.6,50‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬
预期输出:BMI是19.5
测试输入:1.85,90‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬
预期输出:BMI是26.3

4.含字符串、内置函数、特殊要求的输出

#(1)从键盘输入一个整数和一个字符,以逗号隔开,在屏幕上显示输出一条信息。
a,x = input().split(',')     # 去掉【】补充代码,请输入1个整数和1个符号,逗号隔开
print(x*eval(a),a,x*eval(a))   # 去掉【】补充代码
#(2)如何对3.1415926进行输出,输出为3.14%
print("{:.2f}%".format(3.1415926))   #去掉【】补充代码已实现输出3.14%

结果:

测试输入:10,@‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬
预期输出:
@@@@@@@@@@ 10 @@@@@@@@@@
3.14%
测试输入:8,?‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬
预期输出:???????? 8 ????????
3.14%

4.3 练习

1.input()函数的返回值是()类型。

A、字符串

B、整数

C、浮点数

D、字符

2.以下代码的输出结果是() x=’A\0B\0C’ print(len(x))

A、3

B、5

C、6

D、7

3.在Python语言中,IPO模式不包括()

A、Input(输入)

B、Process(处理)

C、Program(程序)

D、Output(输出)

4.按要求输出

#(1)区分/和//
print(5/2)     #去掉【】补充以实现5除以2
print(5//2)     #去掉【】补充以实现5整除2
#(2)理解字符串切片
s='abcdefg'
print(s[3])   #去掉【】补充以实现结果d
print(s[3:5])  #去掉【】补充以实现结果de
#(3)输入a,b,c,d4个整数,计算a+b-c*d的值
a=eval(input())    #去掉【】补充以实现输入得到整数a
b=eval(input())     #去掉【】补充以实现输入得到整数b
c=eval(input())     #去掉【】补充以实现输入得到整数c
d=eval(input())     #去掉【】补充以实现输入得到整数d
print("{}+{}-{}*{}={}".format(a,b,c,d,a+b-c*d)) #去掉【】补充以实现输出a+b-c*d的值,使用format,输出结果例如:10+2-4*5=-8

结果:

测试输入:
10
2
4
5
预期输出:
2.5
2
d
de
10+2-4*5=-8

5.华氏温度转换为摄氏温度

#华氏温度转换成摄氏温度,从华氏温度转换为摄氏温度,转换公式为C=5/9*(F-32)
F=eval(input())
C=5/9*(F-32)                             #去掉【】补充代码以实现温度转换
print('华氏温度{}转换为摄氏温度为{:.2f}'.format(F,C))   #去掉【】补充代码以实现结果,例如:华氏温度110转换为摄氏温度为43.33

结果:

测试输入:100
预期输出:
华氏温度100转换为摄氏温度为37.78
测试输入:110
预期输出:
华氏温度110转换为摄氏温度为43.33

6.求圆周长和圆面积

#输入圆半径,求圆周长和圆面积
r=eval(input())    #去掉【】补充代码以实现获取输入半径的值
PI=3.1415926
L=2*PI*r             #去掉【】补充代码以实现计算圆周长
S=PI*(r*r)             #去掉【】补充代码以实现计算面积
print("圆周长为{:.2f},面积为{:.2f}".format(L,S))     #去掉【】补充代码以实现输出:保留两位小数的圆周长和圆面积
#例如:输出结果示例1:圆周长为113.10,面积为1017.88

结果:

测试输入:
6
预期输出:
圆周长为37.70,面积为113.10
测试输入:
18
预期输出:
圆周长为113.10,面积为1017.88

5 程序控制1

5.1 选择结构

1.关于计算机程序的基本结构,下列选项中描述错误的是()

A、循环结构

B、选择(分支)结构

C、goto 跳转

D、顺序结构

2.关于Python的分支结构,以下选项中描述错误的是()

A、分支结构使用if关键字

B、Python中if-else语句用来构成二分支结构

C、Python中if-elif-else语句构成多分支结构

D、分支结构可以向已经执行过的语句部分跳转

3.下列Python语句正确的是()

A、min = x if x < y else y

B、max = x > y ? x : y

C、if (x > y) print x

D、while True: pass

4.Python的if_else语句中,下列哪个选项可以作为“True”的条件表达式()

A、0

B、1

C、空串

D、None

5.关于if_elif_else选择结构,以下选项中描述正确的是()

A、算数表达式不可以作为if判断的条件

B、if_elif_else在特定情况下,可以执行多个分支

C、else可以省略

D、if_elif_else不能用if嵌套改写

6.计算身体质量指数(BMI)

############################### 程序开始 ###############################
#从测试集获取身高(单位:米)数据赋给height并利用eval()类型转换为数值型
height=eval(input())
#从测试集获取体重(单位:公斤)数据赋给weight并利用eval()类型转换为数值型
weight=eval(input())
#变量dom表示身材状况,初始时设置为空串
dom=""               
############ 完成第12行,以及第14行开始的if多分支判断程序的代码 ###########
bmi=weight/height**2                 #计算身体质量指数bmi
if bmi<18.5:
    dom="偏瘦"
elif bmi<24:
    dom="正常"
elif bmi<27:
    dom="偏胖"
elif bmi<30:
    dom="肥胖"
else:
    dom="重度肥胖"                   #根据bmi的数值判断身材状况
#输出BMI指数和身材状况
print("BMI指数:{0:.2f},身材:{1}".format(bmi,dom))
############################### 程序结束 ###############################

结果:

测试输入:1.65
测试输入:45
预期输出:BMI指数:16.53,身材:偏瘦

5.2 while循环结构

1.关于Python循环结构,以下选项中描述错误的是()

A、while循环可以多层嵌套使用

B、while可以构造无限循环

C、算术表达式不可以用作while循环的条件表达式

D、break语句可以使整个while循环结束

2.关于while语句,以下选项中描述错误的是()

A、while语句在执行时,先计算条件表达式再判断是否执行循环体

B、while循环的循环次数可能为0

C、while循环在嵌套使用时,通过缩进的方式来表明不同层级的循环

D、while语句在执行时,先执行一次循环体之后再判断条件表达式是否成立

3.下列程序中有两处while循环,请说出各自循环了几次()

m=1000
  n=1000
  while m>1:
   print(m)
   m=m/2
  while n>1:
   print(n)
   n=n//2

A、9次,9次

B、9次,10次

C、10次,9次

D、10次,10次

4.下列程序的执行结果是什么()

n = 0
while n < 101:
  n += 1
  temp = n % 2
  if temp == 0:
   continue
  else:
   print(n)
  n = n + 1

A、1-100中所有的偶数

B、1-101中所有的偶数

C、1-100中所有的奇数

D、1-101中所有的奇数

5.使用下列哪个语句(),可以跳过当前循环的剩余语句,继续下一轮循环?

A、break

B、pass

C、continue

D、以上都不是

6.计算1-2+3-4+5…99的值

###################### 程序开始 ######################
n = 1   # n表示当前项的数值
s = 0   # s是累加求和变量
############### 编写下面的while循环代码 ###############
while n<=99:
    s=s+n*((-1)**(n-1))
    n=n+1    
print(s)  #输出计算结果s
###################### 程序结束 ######################

结果:

50

7.计算正整数n的阶乘

###################### 程序开始 ######################
n = int(input())  # 从测试集读取正整数n
p = 1             # p为阶乘结果,初始值=1
i = 1             # i为循环变量
############### 编写下面的while循环代码 ###############
while i<=n:
    p=p*i
    i=i+1
print("%d!=%d"%(n,p))   #输出n的阶乘
###################### 程序结束 ######################

结果:

测试输入:5
预期输出:5!=120

5.3 if和while典型例题讲解

1.计算m和n的最大公约数和最小公倍数

###################### 程序开始 ######################
# 令变量m和n表示从测试集读取的两个正整数
# 令变量gy表示m和n的最大公约数
# 令变量gb表示m和n的最小公倍数
m = eval(input())  # 从测试集读取正整数m
n = eval(input())  # 从测试集读取正整数n
# 令x=m,y=n,这样在后面的计算过程中保留m和n原来的数值,只让x和y发生变化
x,y = m,n
r = x % y          # 令r表示余数,先计算一次x和y的余数
############### 编写下面的while循环代码 ###############
while r>0:
    x=y
    y=r
    r=x%y
# while循环结束后,就可以得到两数的最大公约数
gy = y
# 在求得最大公约数的条件下,继续计算最小公倍数
gb = int(m*n/gy)
print("{0}和{1}的最大公约数:{2},最小公倍数:{3}".format(m,n,gy,gb))
###################### 程序结束 ######################

结果:

测试输入:25
测试输入:15
预期输出:25和15的最大公约数:5,最小公倍数:75

2.求10000以内的所有完全数

# 要求:
# 1.求出10000以内的所有完全数
# 2.将下面程序中的【】补上合适的代码,使得程序可以正确求出10000以内的全部完全数
# 3.补全程序后,一定要将【】删除,否则程序无法运行
###################### 程序开始 ######################
n = 1         # 设变量n表示当前要判断的正整数,初值为1
############ 补全下面的while循环嵌套的代码 ###########
while n <= 10000:
    i = 1       # 变量i是内循环控制变量,用来遍历n中的所有因子
    sum = 0  # 变量sum是用来将n中的所有真因子累加求和
    while i<n: # 该层while循环用来求当前n值的全部真因子之和
        if n%i==0:
            sum = sum + i
        i = i +1
    if n ==sum:  # 判断当前n的值是否为完全数
        print("%d是一个完全数"%(n))
    n =n+1       # 变量n变为下一个要考察的正整数
###################### 程序结束 ######################

结果:

预期输出:
6是一个完全数
28是一个完全数
496是一个完全数
8128是一个完全数

6 程序控制2

6.1 for循环结构

1.以下构成python循环结构的方法,正确的是:( )

A、do…while

B、loop

C、if

D、while

E、for

2.下面选项中,输出1 2 3的是( )

A、for i in range(3): print(i,end=’ ‘)

B、for i in range( 4): print(i,end=’ ‘)

C、i=1 while i<4: print(i,end=’ ‘) i+=1

D、i=0 while i<4: i+=1 print(i,end=’ ‘)

3.在for i in range(5)语句中,i的取值是( )

A、【1,2,3,4,5】

B、【0,1,2,3,4,5】

C、【1,2,3,4】

D、【0,1,2,3,4】

4.语句

for i in range(0, -10, -1) :
     print(i,end=",")      #注意输出结束后附加的字符串

输出结果是( )

A、0,-1,-2,-3,-4,-5,-6,-7,-8,-9

B、0,-1,-2,-3,-4,-5,-6,-7,-8,-9,

C、-1,-2,-3,-4,-5,-6,-7,-8,-9,-10,

D、-1,-2,-3,-4,-5,-6,-7,-8,-9,-10

5.以下Python语句,最后输出的结果是( )

i = 0
count = 0
num = "hello python\n"
for i in num:
    count += 1
print(count)

A、12

B、13

C、14

D、15

6.

for i in range(1, 10, 2):
    s = "*" * i
    print(s.center(9, ' ')) # 利用str.center方法居中

该段程序输出的图形为( )

A、空心矩形

B、实心三角形

C、空心梯形

D、实心菱形

7.使用for语句进行求和运算

# -*- coding: utf-8 -*-
#请去掉【】区域并补全代码
s=0        #为变量s赋值一个初始值
####################以下区域请使用for循环结构############################
for i in range(2021):
    s=s+i
########################################################################
print(s)     #输出求和结果

结果:

2041210

8.测试集中获取字符串并按要求打印

# -*- coding: utf-8 -*-
s=input()        #读取测试数据
# 注意上一语句已经从测试集中读取测试数字n
#********** Begin **********#
str=""
for i in s:
    str=str+i+","
print(str[0:-1])
#********** End **********#

结果:

测试数据为:
python
运行结果为:
p,y,t,h,o,n

9.计算N的阶乘

# -*- coding: utf-8 -*-
######【】处为你需要改动的代码区域,去掉后补充完整#######
###################代码分割线##########################
result = 1               #阶乘公式:n!=1×2×3×...×n
n = int(input())         #从测试集中获取数据并转换成int型赋值给变量n
for i in range(1,n+1):   #确定range函数的start参数及stop参数,step默认为1
    result =result*i     #类似于上一关卡的累计求和,此处为累乘
print(result)            #输出结果
######################################################

结果:

测试集1:5
预期输出:120
测试集2:10
预期输出:3628800
测试集3:20
预期输出:2432902008176640000

6.2 break、continue、pass语句及循环嵌套

1.以下保留字不属于分支或者循环逻辑的是( )

A、elif

B、in

C、while

D、for

2.可以使用( )语句跳过当前循环的剩余语句,继续进行下一轮循环。

A、break

B、pass

C、continue

D、以上都可以

3.以下关于Python循环结构的描述中,错误的是( )

A、while可以使用break和continue

B、for循环中使用pass语句,则什么事都不会做,只是空的占位语句

C、Python通过for,while等保留字构建循环结构

D、break用来结束当前当次语句,但不跳出当前循环体

4.三个程序输出结果分别为( )( )( )

第一段:

for i in range(10):
    if i == 5:
        break
print(i)

第二段:

for i in range(10):
    if i == 5:
        continue
print(i)

第三段:

for i in range(10):
    if i == 5:
        exit()
print(i)

A、5

B、7

C、8

D、9

E、无输出

5.以下代码输出的结果是( )

for s in "pythonNCRE":
    if(s=="n"):
        continue
    else:
        print(s,end=',')

A、p,y,t,h,o

B、p,y,t,h,o,n,N,C,R,E

C、p,y,t,h,o,N,C,R,E,

D、p,y,t,h,o,

6.该程序输出的图形为( )

#内置函数abs(x)可求绝对值,详见教材3.8.1 Python数学函数
for i in range(-6, 7):
    for j in range(-6, 7):
        if abs(i) + abs(j) == 6:
            print('*', end='')
        else:
            print(' ', end='')

A、矩阵

B、三角形

C、等腰梯形

D、菱形

7.计算100以内的偶数和

# -*- coding: utf-8 -*-
##################代码分割线###############
s=0
#********** Begin **********#
for i in range(2,101):
    if i%2!=0:
        continue
    s=s+i
#********** End **********#
print(s)
##################代码分割线###############

结果:

2550

8.统计测试集中字符出现的个数

# -*- coding: utf-8 -*-
#从测试集中读入测试字符串,并统计字符串中‘.’字符出现之前,‘a’出现的次数和‘*’出现的次数。
s=input()        #读取测试数据
# 注意上一语句已经从测试集中读取测试数字n
#********** Begin **********#
a_num=0
b_num=0
for i in s:
    if i==".":
        break
    elif i=="a":
        a_num=a_num+1
    elif i=="*":
        b_num=b_num+1
print("%d,%d"%(a_num,b_num))
#********** End **********#

结果:

测试字符为:abca*a*adef.a*b*c
运行输出为:4,2
测试字符为:a*b*c.*abc
运行输出为:1,2

9.打印九九乘法表

# -*- coding: utf-8 -*-
n=int(input())        #读取测试数据
# 注意上一语句已经从测试集中读取测试数字n
#********** Begin **********#
for i in range(1,n+1):
    s=""
    for j in range(1,i+1):
        s=s+str(j*i)+","
    print(s[0:-1])
#********** End **********#

结果:

测试数据为:
5
输出形式为:
1
2,4
3,6,9
4,8,12,16
5,10,15,20,25

10.找出3到N之间的所有素数

# -*- coding: utf-8 -*-
n=int(input())        #读取测试数据
# 注意上一语句已经从测试集中读取测试数字n
#********** Begin **********#
#外层循环使用for,去掉【】处后补全代码实现从奇数中遍历即可#
###内层循环使用for或while均可###
for i in range(3,n+1):
    k=0
    for j in range(2,i):
        if i%j==0:
            k=1
###判断输出###
    if k==0:
        print(i,end=" ")
#********** End **********#

n=int(input())       #读取测试数据
for i in range(3,n+1):
    m=2
    while(m<i):
        if i%m==0:
            break
        m+=1
    if m==i:
        print(i,end=" ")

结果:

测试数据为:
10
运行结果为:
3 5 7
测试数据为:
30
运行结果为:
3 5 7 11 13 17 19 23 29

7 列表、元组

7.1 列表01 列表的创建、删除、元素提取

1.列表变量 lista 共包含 10 个元素,lista 索引号的取值范围是( )。

A、-1 到-9(含)的整数

B、1 到 10(含)的整数

C、0 到 10(含)的整数

D、0 到 9(含)的整数

2.设列表 Letter=[‘a’,’b’,’c’,’d’,’e’],以下关于列表的切片操作,能正常输出结果的是( )。

A、Letter[‘a’:’b’:2]

B、Letter[:3:2]

C、Letter[1:3:0]

D、Letter[-4:-1:-1]

3.假设列表对象aList的值为[3, 4, 5, 6, 7, 9, 11, 13, 15, 17],那么通过切片aList[3:7]得到的值是()

A、[5, 6, 7, 9, 11 ]

B、[5, 6, 7, 9]

C、[6, 7, 9, 11]

D、[ 6, 7, 9, 11, 13]

4.已知 x = list(range(10)),则表达式 x[-4:] 的值为()

A、[5, 6, 7, 8 ]

B、[ 6, 7,8, 9]

C、[6, 7, 8,9, 10]

D、[ 7, 8,9, 10]

5.设列表对象aList的值为[3, 4, 5, 6, 7, 9, 11, 13, 15, 17],则print(alist[10])的输出结果是()

A、15

B、17

C、报错

D、0

2.实践题:列表元素的访问

#########请按照注释要求完成相应的功能############
tempStr = input()     
lista = list(eval(tempStr))   #将输入的多个数据转换为列表 lista
#####完成以下功能#####
#用一个语句输出列表的第一个元素和最后一个元素,元素之间用默认的空格分隔
print("%d %d"%(lista[0],lista[-1])) 
#用一个语句输出第3~6个元素(4个)组成的子列表,默认最最左边的为第一个元素
print(lista[2:6])
#用一个语句输出列表中索引号为奇数的元素列表
print(lista[1::2])
######### 程序结束 ########

结果:

测试输入:80,30,50,60,70,80,90,95,100,85;
预期输出:
80 85
[50, 60, 70, 80]
[30, 60, 80, 95, 85]

7.2 列表02 列表元素的添加、删除、修改及常用操作函数

1.以下代码的输出结果是( )

lista=[“2020”,”20.20”,”Python”] 
lista.append([2020,”2020”]) 
print(lista)

A、[‘2020’, ‘20.20’, ‘Python’, [2020, ‘2020’]]

B、[‘2020’,’20.20’,’Python’,2020,[‘2020’]]

C、[‘2020’,’20.20’,’Python’,2020]

D、[‘2020’,’20.20’,’Python’,2020,’2020’]

2.设列表 names=[‘Lucy’,’Lily’,’Tom’,’Mike’,’David’],以下关于列表的操作,正确的是( )。

A、names.append(‘Helen’,’Mary’)

B、names.remove(1)

C、del names[‘Tom’]

D、names[2]=’Jack’

3.以下描述中,错误的是( )。

A、Python 语言通过索引来访问列表中元素,索引可以是负整数

B、Python 语言的列表类型能够包含其他的组合数据类型

C、列表用方括号来定义,继承了序列类型的所有属性和方法

D、Python 列表是各种类型数据的集合,列表中的元素不能够被更改

4.以下代码的输出结果是( )

s=[4,2,9,1] 
s.insert(2,3)
print(s)

A、[4,3,2,9,1]

B、[4,2,9,2,1]

C、[4,2,3,9,1]

D、[4,2,9,1,2,3]

5.以下代码的输出结果是( )。

lista=[[1,2,3],[[4,5],6],[7,8]] 
print(len(lista))

A、4

B、8

C、3

D、1

6.已知列表 x = [1, 2, 3],那么执行语句 x.pop(1) 之后,x的值为()

A、[2,3]

B、[1,3]

C、[1,2]

D、[1,2,3]

7.列表元素的添加、删除、提取等

###任务:已知列表x =[20,30,40,10,8,5],编程实现以下功能:###
x =[20,30,40,10,8,5]
##### 在以下位置填写语句 #####
#(1)输入一个整数m
m=eval(input())
#(2)将m添加到列表的末尾
x.append(m)
#(3) 将m插入索引号为3的位置 
x.insert(3,m)
#(4) 删除列表中首个值为m的元素
x.remove(m)
#(5)用一个语句输出索引号为4~6的元素组成的列表,
print(x[4:7])
#(6)输出列表。
print(x)
#####  程序结束 #####

结果:

测试输入:100 ;
预期输出:
[8, 5, 100]
[20, 30, 40, 10, 8, 5, 100]
提示:
用eval(s) 可以将输入的字符串s转换为数值类型

8.列表常用操作函数/方法的使用

'''
输入有一个关于苹果价格的列表,比如 x =[2,3.5,3,1.8,7.5,8,6.5,10],
编程实现以下功能:
'''
tempStr = input()
x = list(eval(tempStr))    #将输入的数据转换为列表
###### 请按要求完成以下功能 #####
#(1)用一个语句输出最高/低价格,保留2位小数
print("最高价格:%0.2f,最低价格:%.2f"%(max(x),min(x))) 
#(2)将价格按降序排序,输出排序后的列表
x.sort(reverse=True)
print(x)
#(3)求平均价格,并输出
aver=sum(x)/len(x)     
print('平均价格:',aver)

结果:

测试输入:2,3.5,3,1.8,7.5,8,6.5,10;
预期输出:
最高价格:10.00,最低价格:1.80
[10, 8, 7.5, 6.5, 3.5, 3, 2, 1.8]
平均价格: 5.2875

7.3 列表03 列表的综合应用

1.用range()函数快速生成列表

'''任务:输入一个整数num,用range()函数产生一个从num开始的10个整数组成的列表listx;
将列表listx中的每个元素的值乘以2,形成一个新的列表listy,输出两个列表。
'''
#####请在下面标有序号的注释后面填写程序#####
#(1)输入整数num
num=eval(input())
#(2)用range()函数产生列表 listx
listx=list(range(num,num+10))
#输出列表 
print(listx) 
#(3)将列表listx中的每个元素的值乘以2,形成一个新的列表listy
listy=[x*2 for x in listx]
#输出列表
print(listy) 
##### 程序结束  #####

结果:

测试输入:1;
预期输出:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

2.列表生成式:筛选符合条件的元素

'''
任务:输入一个班的学生的身高,找出能作为升旗手的学生身高有哪些? 共多少人? 
'''
##### 请在下面标注序号的位置填写程序#####
#输入多个身高(单位:cm),用逗号分隔
highList = list(eval(input()))
#(1) 找出身高在170~175之间的
a=[x for x in highList if (x>=170 and x<=175)]
#(2)输出可选身高列表 
print(a)
#(3) 输出可选身高人数
print(len(a))
#####  程序结束  #####

结果:

测试输入:165,175,180,168,172,178,182,173,169,170,174;
预期输出:
[175, 172, 173, 170, 174]
5

7.4 元组

1.以下说法正确的是()

A、在Python中元组的值是不可变的,因此,已知x = ([1], [2]),那么语句x[0].append(3)是无法正常执行的。

B、元组与列表、字符串一样,是Python中的有序序列。

C、列表与元组不能互相转换。

D、设元组x =(20, 31, 32, 2),则执行x[0] = 5 后,元组x的值为(5, 31, 32, 2)

2.以下说法错误的是()

A、字符串属于Python有序序列,和列表、元组一样都支持双向索引。

B、创建只包含一个元素的元组时,必须在元素后面加一个逗号,例如(3,)

C、列表可以作为元组的元素。

D、只能对列表进行切片操作,不能对元组和字符串进行切片操作。

3.设 tuple1 和 tuple2 是两个元组,以下关于元组的操作,正确的是( )

A、tuple1[0]=’A’

B、tuple1+tuple2

C、tuple1.sort()

D、tuple1.extend(tuple2)

4.菜单选择

'''任务:用元组定义游戏菜单,提示用户输入菜单选择,提示信息为“请输入菜单项对应的数
字,1. 游戏设置 2. 选择游戏级别 3. 我的装备 4. 我的积分 0. 退出”,当用户输入数字后,
输出相应的菜单项名称,若输入 0,则显示“谢谢使用!”。
'''
##### 请在下面标注序号的注释处填写程序 #####
#(1)定义菜单的元组menuTup,每个菜单项为一个元素
menuTup=('1.游戏设置','2.选择游戏级别','3.我的装备','4.我的积分','0.退出')
#(2)显示游戏菜单,每行显示一项
for i in menuTup:
    print(i)
#输出提示信息
print('请输入菜单项对应的数字:') 
#(3)输入数字num,并转换为整型
num=eval(input())
#(4)输出数字对应的菜单项
if num==0:
    print("谢谢使用!")
else:
    print(menuTup[num-1])
 ##### 程序结束#####

结果:

测试输入:0;
预期输出:
1.游戏设置
2.选择游戏级别
3.我的装备
4.我的积分
0.退出
请输入菜单项对应的数字:
谢谢使用!

测试输入:1;
预期输出:
1.游戏设置
2.选择游戏级别
3.我的装备
4.我的积分
0.退出
请输入菜单项对应的数字:
1.游戏设置

7.5 列表与元组的综合应用

1.表达式“[3] in [1, 2, 3, 4]”的值为(), 表达式 3 in [1, 2, 3, 4]”的值为()

A、True True

B、False True

C、True False

D、False False

2.以下语句不能实现“生成包含10个数字5的列表”的是()

A、[5]*10

B、[5 for i in range(10)]

C、for i in range(10): lista.append(5)

D、[5,5,5,5,5]+[5,5,5,5,5]

3.

1.已知列表 x = [1, 2],执行语句 y = x 后,表达式 x is y 的值为()

2.已知列表 x = [1, 2],执行语句 y = x[:] 后,表达式 x is not y 的值为()

A、True True

B、False False

C、False True

D、True False

4.设有元组 tup1 = (6,8,10,2,9,10,12),表达式tup1[::2]的值是()

A、(8, 2, 10)

B、(6, 8)

C、(10, 12)

D、(6, 10, 9, 12)

5.以下创建元组的语句,错误的是()

A、tuple( )

B、tuple([1,2,3])

C、tup3 = (6)

D、tuple(‘678’)

E、tup4 = 1,2,3,4

6.字符串转换为列表、元组

#### 输入一个字符串,转换成列表、元组,请在下面标注序号的位置填写程序####
#输入一串字符,比如‘I am a student’, 
tempStr = input()
#(1)转换为列表1:['I', 'am', 'a', 'student']
list1=tempStr.split(' ')
print(list1)
#(2)转换为元组1: ('I', 'am', 'a', 'student')
tuple1=tuple(list1)
print(tuple1)
#(3)转换为列表2:['I', ' ', 'a', 'm', ' ', 'a', ' ', 's', 't', 'u', 'd', 'e', 'n', 't']
list2=list(tempStr)
print(list2)
##### 程序结束#####

结果:

测试输入:
I am a student
预期输出:
['I', 'am', 'a', 'student']
('I', 'am', 'a', 'student')
['I', ' ', 'a', 'm', ' ', 'a', ' ', 's', 't', 'u', 'd', 'e', 'n', 't']

7.向量运算

##### 输入两个向量,进行加法运算,输出结果列表,请按注释要求完成程序#####
#(1)输入第一个向量,数据之间用逗号分隔,然后转换为列表lista,元素为数值类型
lista=[int(x) for x in input().split(',')]
#(2)输入第二个向量,数据之间用逗号分隔,然后转换为列表listb,元素为数值类型
listb=[int(x) for x in input().split(',')]
#(3)两个向量相加,得到元组listc
listc=[i1+i2 for i1,i2 in zip(lista,listb)]
#输出结果向量列表
print(listc)
##### 程序结束#####

结果:

测试输入:
1,2,3
4,5,6;
预期输出:
[5, 7, 9] 

提示:
zip()函数的返回值是zip类型,比如:
a=[1,2,3]
b=[4,5,6]
zip(a,b) 的结果是3个元组:(1,4)(2,5)(3,6)
若要得到列表,需用list()进行转换。

8 集合、字典

8.1 字典

1.以下说法错误的是()

A、Python字典中的“键”不允许重复。

B、Python字典中的“值”不允许重复。

C、Python字典中的“键”可以是元组。

D、Python字典 属于无序序列。

2.以下说法错误的是()

A、Python支持使用字典的“键”作为下标来访问字典中的值。

B、列表可以作为字典的“键”。

C、元组可以作为字典的“键”。

D、字典的“键”必须是不可变的。

3.字典类型的()方法能够返回字典中的“键-值对”列表

A、keys()

B、values()

C、items()

D、update()

4.已知 x = {1:2},那么执行语句 x[2] = 3之后,x的值为()

A、{1:3}

B、{2:3}

C、{1:2:3}

D、{1:2,2:3}

5.已知 x = {‘a’:’b’, ‘c’:’d’},那么表达式 ‘a’ in x 的值为()

A、True

B、False

6.字典的基本操作编程

#######字典的基本操作,请按序号说明填写程序######
#(1)创建一个字典,包含以下内容:'北京' : '北京' , '山东' : '济南' 
provinceDict={'北京' : '北京' , '山东' : '济南' }
#(2)输入一个省份名称和对应的省会名称,每行输入一个
province=input()
city=input()
#(3)将上面输入的省份名称和省会名称添加到字典中
provinceDict[province]=city
#  输出字典的内容
print(provinceDict)
#(4)输入一个省份名称,查找其省会城市,若查不到,则输出”**不存在“
province=input()
if province in provinceDict:
    print(provinceDict[province])
else:
    print('**不存在')
 ##### 程序结束#####

结果:

测试输入:
河南
郑州
山东
预期输出:
{‘北京’: ‘北京’, ‘山东’: ‘济南’, ‘河南’: ‘郑州’}

7.设字典 dict_1={2:’two’,3:’three’,1:’one’},进行操作 dict_1[1]=’One’后,字典 dict_1 的值可能会变成( )。

A、{1: ‘One’, 2: ‘two’, 3: ‘three’}

B、{2:’two’,3:’One’,1:’one’}

C、{2:’two’,3:’three’,1:’one’,1:’One’}

D、{2:’One’,3:’three’,1:’one’}

8.以下代码的输出结果是( )。 d={“大海”:“蓝色”,“天空”:“灰色”,“大地”:“黑色”} print(d[“大地”],d.get(“大地”,”黄色”))

A、黑色 蓝色

B、黑色 灰色

C、黑色 黄色

D、黑色 黑色

9.设字典变量d={‘food’:{‘cake’:1,’egg’:5},’cake’:2,’egg’:3} ,则能够输出数字 5 的语句是()。

A、print(d['food'][‘egg’])

B、print(d['cake'][1])

C、print(d['food'][-1])

D、print(d[‘egg’])

10.字典的典型应用:统计字符出现的次数

##### 统计一行字符中每个字符出现的次数。请在下面标注序号的下面填写程序#####
#(1)输入一行字符
message=input()
#(2)创建空字典,用于表示统计结果
count={} 
#(3)统计每个字符出现的次数,用字典表示(字符:次数)
for character in message:
    count.setdefault(character,0)
    count[character]=count[character]+1
#输出统计结果,即字典的内容
print(count)
##### 程序结束#####

结果:

测试输入:apple;
预期输出:
{‘a’: 1, ‘p’: 2, ‘l’: 1, ‘e’: 1}

8.2 集合

1.以下说法正确的是()

A、集合中的元素可以通过下标访问。

B、集合可以作为字典的键。

C、集合可以作为字典的值。

D、Python集合支持双向索引。

2.以下说法正确的是()

A、Python集合可以包含相同的元素。

B、运算符+不仅可以实现数值的相加,而且能实现字符串连接,以及列表、元组的合并和集合的并集运算。

C、可以使用del删除集合中的部分元素。

D、Python字典和集合属于无序序列。

3.若要获取两个集合 A 和 B 的交集,以下表达式正确的是( )

A、A+B

B、A&B

C、A|B

D、A^B

4.设集合set2 = {20,30,50,60}, 以下()不能实现:给集合set2添加一个元素35.

A、set2.add(35)

B、set2.update({35})

C、set2.remove(35)

5.设 set1 = {20,30,40,50}, 执行set1.add(30)后,set1的值为()

A、{20,30,30,40,50}

B、{20,30,40,50}

C、{20,40,50}

6.集合的基本操作

######集合的基本操作,请在下面标注序号的位置添加程序#####
#在一行内输入5个整数,用逗号分隔
temp = eval(input())
#(1)创建集合seta,参数为元组temp
seta=set(temp)
print('创建的集合:',seta)
#(2)输入一个整数n,添加到集合seta中
n=int(input())
seta.add(n)
print('添加元素后的集合:',seta)
#(3)输入一个整数n,从集合seta中删除元素n。若成功删除,则输出删除后的集合seta,否则给出提示: n  '不存在”
n=int(input())
if n in seta:
    seta.remove(n)
    print('删除元素后的集合:',seta)
else:
    print(n,'不存在')
###### 程序结束 #####

结果:

测试输入:
1,2,3,4,5
7
5
预期输出:
创建的集合:{1,2,3,4,5}
添加元素后的集合:{1,2,3,4,5,7}
删除元素后的集合:{1,2,3,4,7}

7.集合运算

#######输入两个字符串a和b,分别实现以下功能。请在序号标注添加程序 #######
#定义函数,将集合转换为列表并将元素按升序排序,返回排序后的列表
def charSort(charSet):
    charList = list(charSet)
    charList.sort()
    return charList 
#输入两个字符串a和b,并转换为两个集合seta 和setb
stra = input()
strb = input()
seta = set(stra)
setb = set(strb)
#(1) 求a中包含而b中不包含的字符,赋给s1
s1 = seta-setb
print(charSort(s1))   #将结果集合转换为列表后输出
#(2) a和b中包含的所有字符(重复的字符算一个),赋给s2
s2 =  seta|setb
print(charSort(s2))   #将结果集合转换为列表后输出
#(3) a和b中都包含了的字符,赋给s3
s3 =  seta&setb
print(charSort(s3))   #将结果集合转换为列表后输出
#(4) 不同时包含于a和b中的字符,赋给s4
s4 =  seta^setb
print(charSort(s4))   #将结果集合转换为列表后输出
##### 程序结束 ######

结果:

测试输入:
hello 
well
预期输出:
['h','o']
['e','h','l','o','w']
['e','l']
['h','o','w']

8.3 综合应用

1.统计一行字符重不同的字符及其个数

#######统计一行字符重不同的字符及其个数,请在下面标注序号的位置添加程序######
#(1)输入一行字符,用temp表示
temp=input() 
#(2)将字符串temp转换为集合
temp=set(temp)  
#(3)输出不同字符的个数,即集合的长度
print('不同字符的个数:',len(temp)) 
#(4)输出去掉重复字符后的字符列表,字符按升序排序
lista=list(temp)
lista.sort()
print(lista) 
##### 程序结束 #####

结果:

测试输入:hello world
预期输出:
不同字符的个数: 8
[‘ ’, ‘d’, ‘e’, ‘h’, ‘l’, ‘o’, ‘r’, ‘w’]

2.统计投票结果

###### 统计投票结果,请在下面标注序号的位置添加程序 #####
#输入一行姓名,用空格分隔
nameStr = input()
nameStr=nameStr.split(' ')
#(1)将字符串转换为列表nameList,每个姓名为一个元素
nameList=list(nameStr)
print(nameList)
#(2)创建一个空字典 count
count={} 
#(3)统计列表中每个姓名出现的次数,用字典表示(name:num)
for name in nameList:
    count.setdefault(name,0)
    count[name]=count[name]+1
#输出统计结果,每行输出一个: 姓名:票数
for item in count:
    print('%s:%d'%(item,count[item]))
###### 程序结束#####

结果:

测试输入:王海 刘美含 李丽滢 王海 韩强 刘美含 康洋 王海
预期输出:
[‘王海’, ‘刘美含’, ‘李丽滢’, ‘王海’, ‘韩强’, ‘刘美含’, ‘康洋’, ‘王海’]
王海:3
刘美含:2
李丽滢:1
韩强:1
康洋:1

9 函数1

9.1 函数的基本结构

1.以下关于函数优点的描述中,正确的是( )

A、函数可以表现程序的复杂度

B、函数可以使程序更加模块化

C、函数便于阅读

D、函数可以提高代码重用性

2.在python中用户自定义函数的关键字为( )

A、define

B、function

C、defn

D、def

3.以下代码的输出结果是()

t=15
def above_zero(t):
    return t>0
above_zero(t)

A、15

B、False

C、提示报错

D、True

4.以下关于return语句描述正确的是( )

A、函数中最多只有一个return语句

B、return只能返回一个值

C、函数中可以没有return语句

D、return 0 返回一个None类型

5.以下代码的输出结果为( )

def func(a,b):
    a*=b
    return a
s=func(5,2)
print(s)

A、5

B、15

C、20

D、10

6.以下对于函数的描述中,正确的是( )

A、函数可以同时返回多个结果

B、函数必须要有返回值

C、函数中,即使参数为0个时,也不可以省略括号

D、定义完的函数不做任何操作可以直接调用执行

7.实践题:定义一个简单的函数实现阶乘

# -*- coding: utf-8 -*-
#####################begin#####################
#(1) 第一步:定义一个函数实现n的阶乘,函数名为fact
def fact(n):
    num=1
    for i in range(n):
        num=num*(i+1)
    return num
#(2)第二步:从平台测试集中获取实际参数并转换为整数赋值给变量1
var1=int(input())
#(3)第三步:使用从平台获取的测试集调用fact函数并赋值给变量2
var2=fact(var1)
#(4)第四步:打印输出变量2的值
print(var2)
###################end#####################

结果:

测试输入:3
预期输出:6
测试输入:5
预期输出:120

8.实践题:打印斜三角

# -*- coding: utf-8 -*-
#####################begin#####################
#特别注意,不需要写主程序,只需定义printstar函数即可!
def printstar(n):
    for i in range(n):
        print('*'*(n-i))
#####################end#####################

结果:

测试输入:5
预期输出:
*****
****
***
**
*

9.实践题:定义函数实现判断一个数是否能同时整除3和5

#####################begin#####################
#特别注意,不需要写主程序,只需定义myjudge函数即可!
def myjudge(n):
    if n%15==0:
        return 'True'
    else:
        return 'False'
#####################end#####################

结果:

测试输入:99
预期输出:
False

9.2 函数的参数传递

1.

def swap(a,b) :
    # 下面代码实现a、b变量的值交换
    a, b = b, a
    print("swap函数里,a的值是", a, ";b的值是", b)
a = 6
b = 9
swap(a,b)
print("交换结束后,变量a的值是", a , ";变量b的值是", b)

上述程序运行结果为( )

A、swap函数里,a的值是6;b的值是9 交换结束后,变量a的值是9;变量b的值是6

B、swap函数里,a的值是9;b的值是6 交换结束后,变量a的值是6;变量b的值是9

C、swap函数里,a的值是9;b的值是6 交换结束后,变量a的值是9;变量b的值是6

D、swap函数里,a的值是6;b的值是9 交换结束后,变量a的值是6;变量b的值是9

2.

num = [1, 2, 3]
def a(x):
  x = x + [4]
  print(x)
a(num)
print(num)

上述程序的输出结果为( )

A、[1,2,3,4] [1,2,3,4]

B、[1,2,3,4] [1,2,3]

C、[1,2,3] [1,2,3,4]

D、[1,2,3] [1,2,3]

3.

def printme(str):
   "打印任何传入的字符串"
   print('str')
   return
#调用printme函数
printme(str)

上述代码运行结果是( )

A、打印任何传入的字符串

B、None

C、str

D、报错

4.

def demo(num, *args):
   print(num)
   print(args)
demo(1, 2, 3, 4, 5)

A、1 2,3,4,5

B、1,2 (3,4,5)

C、1,2,3,4 5

D、1 (2,3,4,5)

5.下列哪个函数定义是正确的( )

A、def dis_str(str1=”hello”,str2,str3):

B、def dis_str(str1,str2=”hello”,str3):

C、def dis_str(str1,str2,str3=”hello”):

D、def dis_str(str1s,tr2=”hello”,str3=”hello”,):

6.关于函数调用过程的参数传递,以下正确的是( )

A、定义函数时,某些参数可以赋予默认值

B、调用函数时,必选参数必须以正确位置传入函数

C、定义函数时必须包含参数

D、可以定义函数接收可变数量的参数

7.实践题:不定长参数 —计算任意多个数字的和

"""多值参数 —— 计算任意多个数字的和
1. 定义一个函数 sum_numbers ,可以接收的任意多个整数参数。
2. 功能要求:将传递的所有数字累加,并且返回累加结果。
"""
num1 = int(input()) #获取要被求和数值
num2 = int(input())
num3 = int(input())
num4 = int(input())
# 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
##########Begin##########
# 第一步:创建一个函数 sum_numbers ,可以接收的任意多个整数参数。
def mysum(*var):
    num=0
    for var in var:
        num=num+var
    return num
# 第二步:在函数内部对获取数值进行遍历求和并返回数值和    
# 第三步:调用函数输出返回值
print(mysum(num1,num2,num3,num4))
##########End##########

结果:

测试输入:4,91,51,2
预期输出:148
测试输入:5,1,151,12
预期输出:169

10 函数2

10.1 匿名函数—lambda表达式

1.关于Python中的匿名函数,下列说法正确的是( )

A、lambda函数的主体是一段代码块

B、lambda用于定义简单的,能够在一行内表示的函数

C、在定义函数时,首选的方式是匿名函数

D、lambda只是一个表达式,函数体比def简单很多

2.已知

g=lambda x,y=3,z=5:x*y*z

则语句print(g(1))的输出结果为( )

A、g(1)

B、1

C、15

D、g(15)

3.请使用lambda表达式将下列函数转变为匿名函数:( )

def fun_A(x,y=3):
    return x*y

A、lambda x,y:x**3y

B、lambda x,y:x*y

C、lambda x:x**3

D、lambda x,y=3:x*y

4.下列语句的输出结果为:( )

b=lambda x:x if x%2==0 else None
print(b(3))
print(b(8))

A、3 8

B、3 None

C、None 8

D、None None

5.

#sorted()函数对所有可迭代的对象进行排序操作
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list = sorted(example_list, key=lambda x: x*-1)
print(result_list)

上述语句的运行结果为( )

A、[5, 0, 6, 1, 2, 7, 3, 4]

B、[0, 1, 2, 3, 4, 5, ,6, 7]

C、[0, 7, 6, 5, 4, 3, 2, 1]

D、[7, 6, 5, 4, 3, 2, 1, 0]

6.实践题:lambda表达式

# -*- coding: utf-8 -*-
"""
任务:给定两个列表,编写一个匿名函数实现比较两个列表中对应下标位置的元素的大小,
将大的元素组成一个新的列表,函数参数通过 input 获取。
"""
# 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
########## Begin ########## 
# 请使用map函数和lambda表达式实现本关任务
#第一步使用eval函数将从测试集中获取的字符串类型转换为应有的数据类型并赋值给变量1
var1=eval(input())
#第二步使用eval函数将从测试集中获取的字符串类型转换为应有的数据类型并赋值给变量2
var2=eval(input())
#第三步使用map函数结合lambda表达式实现本比较两列表中对应下标位置并将大的元素组成的新列表返回
map1=map(lambda x,y:max(x,y),var1,var2)
#第四步使用list函数将结果进行转换并打印输出
print(list(map1))
########## End ##########

结果:

测试输入:
[1,3,4,54,576,4,45,3] [4,6,23,5,235,356,7,5]
预期输出:
[4,6,23,54,576,356,45,5]
测试输入:
[65,34,64,788,97,9,765,99,0] [32,87,97,37,100,57,43,98,0]
预期输出:
[65,87,97,788,100,57,765,99,0]

10.2 局部变量和全局变量+内置函数

1.[多选题]以下关于全局变量和局部变量的描述中,正确的是( )

A、使用global关键字声明后,变量可以作为全局变量被函数使用

B、当函数退出时,局部变量依然存在,下次调用函数可以继续使用

C、全局变量一般指定义在函数外的变量

D、局部变量在函数内部创建和使用,函数退出后变量被释放

2.list类型变量需要定义在函数外部,在函数内部可直接被使用。 以下代码输出结果是( )

ls=['car','truck']
def func(a):
    ls.append(a)
    return
func('bus')
print(ls)

A、None

B、[‘car’, ‘truck’]

C、[‘car’, ‘truck’, ‘bus’]

D、[‘bus’] [‘car’, ‘truck’, ‘bus’]

3.对一个非列表、字典的变量,对与全局变量同名的局部变量进行修改,不会影响全局变量。如果使用外部全局变量则应使用global关键字 以下程序运行结果为( )

a=10
def func(x):
    global a
    a+=x
    return a
b=func(10)
print (a,b)

A、10 20

B、20 20

C、20 10

D、10 10

4.关于以下代码描述错误的是( )

def fact(n):
    s=1
    for i in range(1,n+1):
        s=s*i
    return s

A、fact(n)函数功能是求n的阶乘

B、s是局部变量

C、代码中的 n 是可选参数

D、range( )函数是python的内置函数

5.

a = 2
def func1():
    a = 1
    print(a, end=" ")
func1()
print(a)

上述程序的输出为( )

A、1 2

B、2 2

C、1 1

D、2 1

6.

A = 100
def func():
  global A
  A = 200
  print(A, end=" ")
func()
print(A)

上述程序的输出结果为( )

A、100 200

B、200 200

C、100 100

D、200 100

7.实践题:全局变量与局部变量练习1

"""
任务:使用作用域中相关的关键字修改下列 begin-end 中的代码,使函数average实现计算平均分的功能
"""
# 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
##########Begin##########
# 请使用作用域中相关的关键字修改下列代码,实现计算平均分的功能
score = 0
def average(*args):
    sum_numbers(args)
    return score/len(args)
def sum_numbers(b):
    global score        # 在此处添加代码
    for a in b:
        score += a
##########End##########
result = average(55, 66, 89, 98, 52, 45, 63, 43,100,44)
print(result)

结果:

预期输出:
65.5

8.实践题:全局变量与局部变量练习2

# -*- coding: utf-8 -*-
"""
任务:使用变量作用域相关的关键字修改下方 Begin-End 之间的代码,使 max_value 函数实现求最大值的功能。
"""
# 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
########## Begin ##########
# 使用变量作用域相关的关键字修改代码,使max_value函数实现求最大值的功能
def compare(x,y):
    return x if x > y else y
def max_value(*list_data):
    global value          # 在此处添加代码
    value = list_data[0]
    for x in range(1,len(list_data)):
        value = compare(list_data[x],value)
########## End ##########
value = 0
max_value(42323,457,4245,6,3,5463,6,7,45,725,723,7,3,46,86,7,56,8,567,5,5745,26,34,63,412,35,4,76585,67,3,45,4,5,34,5,47,5686)
print(value)

结果:

预期输出:
76585

11 模块

11.1 模块基本概念和导入方式

1.下列关键字中,用来引入模块的是()。

A、include

B、from

C、import

D、continue

2.关于引入模块的方式,错误的是()。

A、import math

B、from fib import fibnacci

C、form math import *

D、from * import fib

3.关于__name__的说法,下列描述错误的是()。

A、它是Python提供的一个方法

B、每个模块内部都有一个__name__ 属性

C、当它的值为__name__ 时,表示模块自身在运行

D、当它的值不为__name__ 时,表示模块被引用

4.Python解释器会优先查看默认的路径搜索模块的位置是。()

A、当前目录

B、c:/windows

C、python安装目录

D、上级目录

5.下列说法正确的是:

A、为了更好地组织模块,通常会把多个模块放在一个包中

B、我们可以用__name__ 属性来使该程序块仅在该模块自身运行时执行

C、模块是一个包含所有你定义的函数和变量的文件,其后缀名是.py。

D、Python 本身带着一些标准的模块库

E、包是一种管理 Python 模块命名空间的形式,采用”点模块名称”。

6.模块导入和使用,输入直角三角形的两个直角边的边长a和b,计算出其斜边边长

# coding=utf-8
import math
# 输入正整数a和b
a = float(input())
b = float(input())
# 请在此添加代码,输入直角三角形的两个直角边的边长a和b,计算出其斜边边长
########## Begin ##########
print('%.3f'%math.sqrt(a**2+b**2))
########## End ##########

结果:

测试输入:
3
4
预期输出:
5.000

7.模块的导入方式2,要求判断是否存在两个整数,它们的和为a,积为b

# coding=utf-8
# 导入math模块
from math import *
# 输入两个整数a和b
a = int(input())
b = int(input())
# 请在此添加代码,要求判断是否存在两个整数,它们的和为a,积为b
########## Begin ##########
c=min(a,b)
flag=False
for i in range(1,c):
    d=c-i
    if i*d==b:
        flag=True
if flag:
    print('Yes')
else:
    print('No')
########## End ##########

结果:

测试输入:
9
15
预期输出:
No
测试输入:
9
20
预期输出:
Yes

11.2 标准模块和第三方库

1.输入出生日期,求从你出生日开始到今天已经过去多少天了

import datetime
def countdays(birthday):  #birthday由测试程序在评测数据中读取并传入一个字符串,格式为yyyymmdd,例如:'19991010'
    #根据传入的birthday字符串获取年、月、日的整数值y,m,d
    y=birthday[:4]
    m=birthday[4:6]
    d=birthday[6:]
    d_now=datetime.date.today()     #获取当前日期类型值
    d_bir=datetime.date(int(y),int(m),int(d))                             #求生日的日期类型值
    d=d_now-d_bir             #求天数差(timedelta类型)
    return (d.days)           #返回天数

2.matplotlib应用1-商品房销售价格统计图

import matplotlib
matplotlib.use("Agg")
# 请编写代码绘制住宅商品房平均销售价格柱状图
#1、导入模块:
import matplotlib.pyplot as plt
#2、数据:xstring为年份字符串,ystring为每年评价价格字符串
xstring = '2015 2014 2013 2012 2011 2010 2009 2008 2007 2006 2005 2004 2003 2002 2001 2000'
ystring = '12914 11826 12997 12306.41 12327.28 11406 10608 8378 8667.02 8052.78 6922.52 5744 4196 4336 4588 4751'
#请在此添加实现代码  根据上述字符串计算x轴和y轴数据  实现柱状图显示 #(参考左侧编程要求中的提示完成)
# ********** Begin *********#
x=list(map(eval,xstring.split()))
y=list(map(eval,ystring.split()))
#通过reverse函数将列表逆序存放
x.reverse()
y.reverse()
index=list(range(len(x)))
index=list(range(len(y)))
#使用xticks给柱状图添加横轴标签,倾斜45°
plt.xticks(index, x , rotation = 45) 
#plt.yticks(range(start,end,step))来指定y轴坐标的开始值、终止值和间隔值
plt.yticks(range(4000,13000+1000,1000))
#通过plt.ylim(begin,end)来指定 y 轴的显示的起始和结束。
plt.ylim(4000,13500)
plt.bar(index,y,color ='#800080')
# ********** End **********#
#图片保存
plt.savefig('picture/step1/fig1.png')

结果:

3.matplotlib应用2-2010全国人口普查数据分析

import matplotlib
matplotlib.use("Agg")
# 请绘制育龄妇女的受教育程度分布饼图
#* (1)受教育妇女人数数据从测试数据中读入并转换为整数列表
#---提示:通过input()读入,通过split进行分割,通过列表生成式转换为整数列表
#* (2)突出教育程度为`初中`的楔形,偏移占比设为`0.1` ;
#---提示:通过设置 explode 参数实现。
#* (3)饼图为等长等宽,有阴影;
#* (4)楔形标签列表为`['none', 'primary', 'junior', 'senior', 'specialties', 'bachelor', 'master']`
#* (5)楔形的颜色分别为`['red','orange','yellow','green','purple','blue','black']`
#1、导入模块
import matplotlib.pyplot as plt
#请在此添加实现代码  #
# ********** Begin *********#
data=input()
labels=['none', 'primary', 'junior', 'senior', 'specialties', 'bachelor', 'master']
colors=['red','orange','yellow','green','purple','blue','black']
explode=[0,0,0.1,0,0,0,0]
data=data.split(',')
data=[eval(x) for x in data]
plt.pie(data, explode=explode, labels=labels,colors =colors,shadow=True) # shadow表示添加阴影,startangle表示旋转角度
plt.axis('equal')  # 用于显示为一个长宽相等的饼图
# ********** End **********#
plt.savefig('picture/step3/fig3.png')

结果:

11.3 Turtle模块的应用

1.绘制三个叠加的等边三角形

#********* Begin *********#
import turtle
t=turtle.Turtle()
t.pencolor('red')
for i in range(3):
    t.forward(200)  
    t.left(120)     
t.up()
t.forward(100)
t.pencolor('blue')
t.fillcolor('yellow')  
t.begin_fill()    
t.down() 
t.left(60) 
for i in range(3):
    t.forward(100)  
    t.left(120) 
t.end_fill()
t.up()
t.forward(50)
t.down()
t.pencolor('red')
t.fillcolor('white')
t.begin_fill()
t.left(60)
for i in range(3):
    t.forward(50)
    t.left(120)
t.right(120)
t.end_fill()
#********* End *********#
#保存屏幕图片
ts = turtle.getscreen()
ts.getcanvas().postscript(file="Python/src1/py1-3/yourimg/sj.ps")

结果:

12 面向对象

12.1 面向对象入门1

1.封装一个学生类,有姓名,有年龄,有性别,有英语成绩,数学成绩,语文成绩,封装方法,求总分,平均分,以及打印学生的信息。 请补全代码() () Student:

A、def

B、self

C、class

D、inport

2.请根据任务要求补全代码()

class Student:
    def index(【】):
        name=None
        age=None
        gender=None
        English_achievements=None
        mathematics=None
        chinese_achievement_test=None

A、def

B、self

C、name

D、none

3.创建一个Cat类,属性:姓名,年龄 方法:抓老鼠 创建老鼠类,属性:姓名,型号。 一只猫抓一只老鼠,再创建一个测试类:创建一个猫对象,再创建一个老鼠对象,打印观察猫抓的老鼠的姓名和型号。

例如:一个5岁的名叫tom的猫抓到了一只名叫jerry的小老鼠。 在【】中补全代码,以下选项代码正确的是()

class 【】:
    def __init__(self):
        name=None
        age=None
class Mouse:
    def 【】(self):
        name=None
        model=None
class Test:
    def Catch_a_Mouse(self):
        print('一个%s岁的名叫%s的猫抓到了一个名叫%s的小老鼠'%(cat.age,cat.name,mouse.name))
cat=Cat()
cat.name='tom'
cat.age=5
mouse=Mouse()
mouse.name='jerry'
mouse.module=1
test=【】
【】

A、【cat 】,【 init 】,【 Test() 】,【 test.Catch_a_Mouse()】

B、【Cat 】,【 init 】,【Test(Cat(),Mouse()) 】,【test.Catch_a_Mouse()】

C、【Cat】,【 init 】 ,【Test() 】,【 test.Catch_a_Mouse()】

D、【Cat 】,【init 】,【Test(Cat,Mouse) 】,【 Catch_a_Mouse()】

4.关于重载,以下说法正确的是()

A、子类和父类有同名的方法时,系统会报错

B、子类和父类有同名的方法时,子类调用父类的方法

C、子类和父类有同名的方法时,方法都不能使用

D、子类和父类有同名的方法时,子类调用自己的方法

12.2 面向对象入门2

1.类的声明与定义

# 请在下面填入定义Book类的代码
#********** Begin *********#
class Book:
#********** End *********#
    # '书籍类'
    def __init__(self,name,author,data,version):
        self.name = name
        self.author = author
        self.data = data
        self.version = version
    def sell(self,bookName,price):
        print("%s的销售价格为%d" %(bookName,price))

2.类的属性与实例化

class People:
    # 请在下面填入声明两个变量名分别为name和country的字符串变量的代码
    #********** Begin *********#
    def __init__(self):
        name=None
        country=None
    #********** End **********#
    def introduce(self,name,country):
        self.name = name
        self.country = country
        print("%s来自%s" %(name,country))
name = input()
country = input()
# 请在下面填入对类People进行实例化的代码,对象为p
#********** Begin *********#
p=People()
#********** End **********#
p.introduce(name,country)

结果:

预期输入:
jim
中国
预期输出:
jim来自中国

3.类的导入

关的测试文件DataChangetest.py中定义了一个类DataChange,这个类实现了将八进制转换为十进制然后输出,这个功能由这个类中的eightToten(self,p)方法实现。

Datachange类实现:

class DataChange:
    def eightToten(self,p):
        n = 0
        for i in range(len(p)):
            n = n * 8 + ord(p[i]) - ord('0')
        print(n)

本关的编程任务是补全DataChange.py文件中的导入DataChangetest模块并调用方法实现数制转换功能,具体要求如下:

  • 输入调用DataChange模块中eightToten(self,p)的代码,以实现将输入的八进制转换成十进制输出。

本关涉及的代码文件DataChange.py的代码框架如下

# 请在下面输入调用DataChange模块中eightToten(self,p)的代码,以实现将输入的八进制转换成十进制输出
#********** Begin *********#
import DataChangetest
dc = DataChangetest.DataChange()
p = input()
dc.eightToten(p)
#********** End **********#

结果:

预期输入:
12
预期输出:
10
预期输入:
45
预期输出:
37

4.TOM猫原型 类

class Cat:
    def __init__(self,name):
        self.name=name
    def cry(self,n):
        print('%s %s'% (self.name,'miao~'*n))
###############  begin: 完成cat类##################
class Tomcat(Cat):
    ph=100
    money=0
    def work(self):
        self.money+=20
    def eat(self):
        self.ph=100
    def play(self):
        self.ph-=5
    def show(self):                #展示方法show
        print(self.name,'money=',self.money,'ph=',self.ph)
###############  end   ##############################
mytomcat=Tomcat('XXXZhy')
mytomcat.work ()
mytomcat.work ()
mytomcat.work ()
mytomcat.eat()
mytomcat.play ()
mytomcat.show()

结果:

XXXZhy money= 60 ph= 95
打赏
  • 版权声明: 本博客所有文章除特别声明外,著作权归作者所有。转载请注明出处!

客官,赏一瓶怡宝吧。

支付宝
微信