def save(s):
f=open("test.txt","wt")
f.write(s["name"]+"\n")
f.write(s["sex"]+"\n")
f.write(s["age"]+"\n")
f.close()
def read():
f=open("test.txt","rt")
name=f.readline()
sex=f.readline()
age=f.readline()
print(name,sex,age,sep="")
f.close()
s={"name":"xxx","sex":"male","age":"20"}
save(s)
read()
结果是
- A
xxxmale20
- B
xxx male 20
- C
xxxmale20
- D
xxxmale20
下列语句打开文件的位置应该在（）
f=open('wenjian01.txt','w')
- A
c盘目录下
- B
d盘目录下
- C
Python安装目录下
- D
与源文件相同的目录下
python中用于释放类占用资源的方法是（）
- A
__int__
- B
__del__
- C
__del
- D
delete
下列选项中，符合类的命名规范的（）
- A
car
- B
cat
- C
Cat
- D
Holiday Resort
下列选项中，不能作为filter函数参数的是（）
- A
列表
- B
元组
- C
字符串
- D
整数
下列选项中，用于向文件中写内容的是（）
- A
open
- B
write
- C
close
- D
read
def save(s):
f=open("test.txt","wt")
f.write(s["name"]+"\n")
f.write(s["sex"]+"\n")
f.write(s["age"]+"\n")
f.close()
def read():
f=open("test.txt","rt")
name=f.readline().strip("\n")
sex=f.readline().strip("\n")
age=f.readline().strip("\n")
print(name)
print(sex)
print(age)
f.close()
s={"name":"xxx","sex":"male","age":"20"}
save(s)
read()
结果是
- A
xxxmale20
- B
xxxmale20
- C
xxx male 20
- D
错误
st=[["a","b"],"c"]
st[0][1]='d'
print(len(st),st)
结果是
- A
3 [['d', 'b'], 'c']
- B
2 [['d', 'b'], 'c']
- C
3 [['a', 'd'], 'c']
- D
2 [['a', 'd'], 'c']
下列选项中，用于触发异常的是（）
- A
catch
- B
try
- C
except
- D
raise
下列关键字中，用来引入模块的是（）
- A
include
- B
from
- C
import
- D
continue
假设文件不存在，如果用open函数打开文件会报错，那么该文件的打开方式是（）
- A
'r'
- B
'w'
- C
'a'
- D
'w+'
def test():
f=open("test.txt","wt+")
f.write("我abc")
f.seek(3,0)
f.write("xyz")
f.seek(1,0)
s=f.read()
print(s)
f.close()
test()
结果是
- A
axyz
- B
bxyz
- C
我xyz
- D
汉字乱码
class Student:
name="xxx"
@classmethod
def show(cls):
name="yyy"
print(name,cls.name)
s=Student()
s.show()
结果
- A
xxx yyy
- B
xxx xxx
- C
yyy xxx
- D
yyy yyy
关于抛出异常的说法中，描述错误的是（）
- A
显示的创建异常类的实例，可以使用raise直接引发
- B
当raise指定异常的类名时，会隐式的创建异常类的实例
- C
使用raise抛出异常时，无法指定描述信息
- D
不带参数的raise语句，只能引发刚刚发生过的异常
构造方法是类的一个特殊方法，python中它的名称为（）
- A
与类同名
- B
__construct
- C
__int__
- D
__init__
题目：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+222...2（此时共有5个数相加），几个数相加有键盘控制。
'''
需求：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。
思路：先计算出每一项的值。
'''
Tn = 0
Sn = []
n = int(input('n = :'))
a = int(input('a = :'))
for count in range(n):#先循环计算每一项的值
Tn = Tn + a
_______________
Sn.append(Tn)
print Tn
Sn = reduce(lambda x,y : x + y,Sn)#在计算和
print( Sn)
- A
a = a * 10
- B
a = a + 10
- C
a = a // 10
- D
a = a * *10
class Student:
name="xxx"
@staticmethod
def show():
name="yyy"
print(name,Student.name)
@staticmethod
def display():
show()
s=Student()
s.display()
结果：
- A
错误
- B
yyy xxx
- C
yyy yyy
- D
xxx xxx
class Student:
def __init__(self,n="xxx"):
self.name=n
@classmethod
def show(cls):
s=cls()
print(s.name)
s=Student("yyy")
Student.show(s)
结果：
- A
yyy
- B
xxx
- C
错误
- D
xxxyyy
假设file是文本文件对象，下列用于读取一行的（）
- A
file.read()
- B
file.read(200)
- C
file.readline()
- D
file.readlines()
下列程序执行的结果为（）
def foo():
a=1
def bar():
a+=1
return a
return bar
print(foo)
- A
1
- B
2
- C
程序出现异常
- D
没有输出结果
class Student:
name="yyy"
age=30
def __init__(self):
self.name="xxx"
self.age=20
s=Student()
Student.name="zzz"
print(s.name,s.age,Student.name,Student.age)
结果：
- A
yyy 20 xxx 30
- B
yyy 20 zzz 30
- C
xxx 20 yyy 30
- D
xxx 20 zzz 30
a=1
b=-2
print("#%3d#%-3d" %(a,b))
结果是：
- A
#1#-2
- B
# 1#-2
- C
#1 #-2
- D
#1# -2
构造方法的作用是（）
- A
一般成员方法
- B
类的初始化
- C
对象的初始化
- D
对象的建立
def save():
f=open("test.txt","wt",encoding="utf-8")
f.write("我abc\nxyz")
f.close()
save()
执行后test.txt文件长度是
- A
8字节
- B
9字节
- C
10字节
- D
1字节
class Student:
def __init__(self,n="xxx",s="男"):
self.name=n
self.sex=s
def show(self):
print(s.name,s.sex)
s=Student("yyy")
Student.show(s)
结果：
- A
yyy 男
- B
xxx 男
- C
Student.show(s)错误
- D
def __init__(self,n="xxx",s="男")错误
下列选项中，（）是唯一不在运行时发生的异常。
- A
KeyError
- B
ZeroDivisionError
- C
NameError
- D
SyntaxError
class Student:
def __init__(self,n="xxx",s="男"):
self.name=n
self.sex=s
def show(self):
print(s.name,s.sex,s.age)
s=Student("yyy")
s.age=20
s.show()
结果：
- A
yyy 男 0
- B
yyy 男 None
- C
yyy 男 20
- D
错误
class Student:
def __init__(self,n="xxx"):
self.name=n
@classmethod
def show(cls):
s=cls()
print(s.name)
s=Student("yyy")
Student.show(s)
结果：
- A
yyy
- B
xxx
- C
错误
- D
xxxyyy
class Student:
name="xxx"
@staticmethod
def show():
name="yyy"
print(name,Student.name)
@classmethod
def display(cls):
cls.show()
s=Student()
s.display()
结果
- A
xxx yyy
- B
yyy xxx
- C
xxx xxx
- D
错误
def save():
f=open("test.txt","wt")
f.write("abc\nxyz")
f.close()
def read():
f=open("test.txt","rt")
s=f.readline()
print(len(s))
f.close()
save()
read()
执行结果是
- A
3
- B
4
- C
5
- D
7
关于装饰器，下列说法错误的是（）
- A
装饰器是一个包裹函数
- B
装饰器只能有一个参数
- C
通过函数定义的前面加上@符号和装饰器名，使得装饰器函数生效
- D
如果装饰器带有参数，则必须在装饰器的外层再嵌套一层函数
当try语句中没有任何错误信息时，一定不会执行（）语句。
- A
else
- B
finally
- C
except
- D
try
一个文本文件test.txt的一行存储5个整数如下：
1 3 56 67 34
数之间用空格隔开，要读出这些整数的函数正确的是：
- A
def read(): f=open("test.txt","rt") while true: s=f.read() if s!="": print(s) else: break f.close()
- B
def read(): f=open("test.txt","rt") while true: s=f.readline() if s!="": print(s) else: break f.close()
- C
def read(): f=open("test.txt","rt") st=f.readlines() for s in st: print(s) f.close()
- D
def read(): f=open("test.txt","rt") s=f.readline() st=s.splist(" ") for s in st: print(s) f.close()
下列程序运行后，会产生（）异常。
abc
- A
IndexError
- B
SyntaxError
- C
NameError
- D
KeyError
class Student:
name="xxx"
def show(cls):
name="yyy"
print(name,cls.name)
s=Student()
s.show()
结果
- A
xxx yyy
- B
yyy yyy
- C
yyy xxx
- D
错误
class Student:
name="xxx"
def show(cls):
name="yyy"
print(name,cls.name)
s=Student()
s.show()
结果
- A
xxx yyy
- B
yyy yyy
- C
yyy xxx
- D
错误
Python中定义私有属性的方法是（）
- A
使用private关键字
- B
使用public关键字
- C
使用__XX__定义属性名
- D
使用__XX定义属性名
题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示,60-80分之间的用B表示，60分以下的用C表示。
'''
需求：利用条件运算符的嵌套来完成成绩表。
思路：(a>b)?a:b这是条件运算符的基本例子。
'''
score = int(input('input score:'))
if score >= 90:
grade = 'A'
______________
grade = 'B'
elif score >= 70:
grade = 'C'
elif score >= 60:
grade = 'D'
else:
grade = 'E'
print ('%d belongs to %s' % (score,grade))
- A
elif score > 80:
- B
elif score <= 80:
- C
elif score < 80:
- D
elif score >= 80:
class Student:
def __init__(self,n):
name=n
def show(self):
print(name)
s=Student("xxx")
s.show()
结果
- A
xxx
- B
错误
- C
None
- D
没有输出
def test():
f=open("test.txt","wt+")
f.write("abc")
f.seek(3,0)
f.write("xyz")
f.seek(2,0)
s=f.read()
print(s)
f.close()
test()
结果是
- A
c xyz
- B
bcxyz
- C
cxyz
- D
bc xyz
下列选项中，不能用于标识静态方法的是
- A
@classmethod
- B
@instancemethod
- C
@staticmethod
- D
@privatemethod
下列关于类属性和实例属性的说法中，描述不正确的是
- A
类属性既可以显式定义，又能在方法中定义
- B
公有类属性可以通过类和类的实例访问
- C
通过类可以获取实例属性的值
- D
类的实例只能获取实例属性的值
下列选项中，属于面向对象程序设计的三个特征的是（）
- A
抽象
- B
封装
- C
继承
- D
多态
运行下列语句，会有哪些异常
print(x+1)
open('haha.txt','r')
- A
NameError
- B
SyntaxError
- C
IndexError
- D
FileNotFoundError
关于类和对象的关系，下列描述不正确的是（）
- A
类是面向对象的核心
- B
对象是面向对象的核心
- C
类是现实中的个体
- D
对象是根据类创建的，并且一个类只能对应一个对象
装饰器应用于
- A
引入日志
- B
执行时间统计
- C
权限校验
- D
缓存
关于面向过程和面向对象，下列说法正确的是（）
- A
面向过程和面向对象都是解决问题的一种思路
- B
面向过程是基于面向对象的
- C
面向过程强调的是解决问题的步骤
- D
面向对象强调的是解决问题的对象
以下是Python读文件方式的
- A
look
- B
read
- C
readlines
- D
readline
以下是Python中闭包的条件为
- A
嵌套关系
- B
内部函数引用外部函数的变量
- C
外部函数将内部函数作为返回值
- D
外部函数将内部函数名作为返回值
关于_name_的说明，下列描述正确的是（）
- A
它是Python提供的一个方法
- B
每个模块内部有一个_name_属性
- C
当它的值为'_main_'时，表示模块自身在运行
- D
当它的值不为'_main_'时，表示模块被引用
Python中没有任何关键字区分公有属性和私有属性
- A) 正确
- B) 错误
子类通过重写继承的方法，覆盖掉跟父类同名的方法
- A) 正确
- B) 错误
如果类属性和实例属性重名，对象优先访问类属性的值
- A) 正确
- B) 错误
def fun(x,y):
global x
t=x
x=y
y=t
x=0
y=1
fun(x,y)
print(x,y)
结果是
1 1
- A) 正确
- B) 错误
要调用random模块的randint函数，书写形式为from random import randint
- A) 正确
- B) 错误
使用del语句删除对象，可以手动释放它所占的资源。
- A) 正确
- B) 错误
filter函数只能对序列执行过滤操作。
- A) 正确
- B) 错误
f=open("test.txt","wt")
f.write("abc")
f.close()
在test.txt文件不存在时会自动创建test.txt
- A) 正确
- B) 错误
实际开发中，文件或文件夹的操作都要用到os模块。
- A) 正确
- B) 错误
要想使用with语句，前提是要有上下文管理器。
- A) 正确
- B) 错误
Python的类成员变量一般使用类名称限定访问
- A) 正确
- B) 错误
如果except字句没有指明任何异常类型，则表示捕获所有异常。
- A) 正确
- B) 错误
方法和函数的格式是完全一样的。
- A) 正确
- B) 错误
f=open("test.txt","at")
f.write("abc")
f.close()
新写入的"abc"在文件的尾部
- A) 正确
- B) 错误
f=open("test.txt","wt")
f.write("abc")
f.seek(2,0)
f.write("123")
f.close()
程序时错误的，因为seek只能用在二进制文件操作中
- A) 正确
- B) 错误
装饰器是一个变量。
- A) 正确
- B) 错误
创建类的对象时，系统会自动调用构造方法进行初始化。
- A) 正确
- B) 错误
默认状态下，系统检测到错误后会终止程序。
- A) 正确
- B) 错误
面向对象是基于面向过程的。
- A) 正确
- B) 错误
def fun(x,y):
t=x
x=y
y=t
x=0
y=1
fun(x,y)
print(x,y)
结果是
1 0
- A) 正确
- B) 错误
无论程序是否捕获到异常，一定会执行finally语句。
- A) 正确
- B) 错误
当_name_属性的值为_main_时，代表模块自身在运行。
- A) 正确
- B) 错误
每个Python文件就是一个模块。
- A) 正确
- B) 错误
包目录下，必须有一个_init_.py文件。
- A) 正确
- B) 错误
若map函数中传入的两个序列长度不同，则较长的序列会将多余的元素删除。
- A) 正确
- B) 错误
使用write写入文件时，数据会追加到文件的末尾。
- A) 正确
- B) 错误
所有的except子句一定在else和finally前面。
- A) 正确
- B) 错误
read方法只能一次性读取文件中所有数据。
- A) 正确
- B) 错误
一个try语句只能对应一个except字句。
- A) 正确
- B) 错误
打开一个可读写的文件，如果文件存在会被覆盖。
- A) 正确
- B) 错误
为了更好的组织模块，通常会把多个模块放在一个
中。
-
填空一
- 填空一： 包
当程序中需要引入外部模块时，需要从外面下载并。
-
填空一
- 填空一： 安装
os模块中的mkdir方法用于创建
-
填空一
- 填空一： 文件夹
子类通过（）可以成功地访问父类的成员
-
填空一
- 填空一： super
当约束条件不满足时，语句会触发AssertionError
-
填空一
- 填空一： assert
在函数定义的前面添加装饰器名和符号，实现对函数的包装。
-
填空一
- 填空一： @
seek方法用于移动指针到指定位置，该方法中参数表示要偏移的字节数。
-
填空一
- 填空一： offset
在现有的基础上构建新类，新的类称为，现有的类称为
-
填空一
-
填空二
- 填空一： 子类
- 填空二： 父类
一个try语句只能对应一个子句
-
填空一
- 填空一： finally
每个Python文件都可以作为一个模块，模块的名字就是的名字。
-
填空一
- 填空一： 文件
关于抛出异常的说法中，描述错误的是（）
- A
显示的创建异常类的实例，可以使用raise直接引发
- B
当raise指定异常的类名时，会隐式的创建异常类的实例
- C
使用raise抛出异常时，无法指定描述信息
- D
不带参数的raise语句，只能引发刚刚发生过的异常
下列选项中，（）是唯一不在运行时发生的异常。
- A
KeyError
- B
ZeroDivisionError
- C
NameError
- D
SyntaxError
Python类中包含一个特殊变量（），可以访问类的成员。
- A
me
- B
self
- C
this
- D
at
关于装饰器，下列说法错误的是（）
- A
装饰器是一个包裹函数
- B
装饰器只能有一个参数
- C
通过函数定义的前面加上@符号和装饰器名，使得装饰器函数生效
- D
如果装饰器带有参数，则必须在装饰器的外层再嵌套一层函数
def save():
f=open("test.txt","wt",encoding="utf-8")
f.write("我abc\nxyz")
f.close()
save()
执行后，哪个read()函数可以读出全部内容
- A
def read(): f=open("test.txt","rt") for s in f.readlines(): print(s,end="") f.close()
- B
def read(): f=open("test.txt","rt",encoding="utf-8") for s in f.readlines(): print(s,end="") f.close()
- C
def read(): f=open("test.txt","rt",encoding="utf-8") for s in f.readlines(): print(s) f.close()
- D
def read(): f=open("test.txt","rt",encoding="utf-8") s=f.readline() print(s) f.close()
class Student:
name="xxx"
@classcmethod
def show(cls):
name="yyy"
print(name,cls.name)
Student.show()
结果：
- A
xxx yyy
- B
yyy xxx
- C
xxx xxx
- D
yyy yyy
class Student:
def __init__(self,n="xxx"):
self.name=n
@classmethod
def show(cls):
s=cls()
print(s.name)
s=Student("yyy")
Student.show(s)
结果：
- A
yyy
- B
xxx
- C
错误
- D
xxxyyy
若文本文件abc.txt中的内容如下：
abcdef
阅读下面的程序：
file=open('abc.txt','r')
s=file.readline()
s1=list(s)
print(s1)
- A
['abcdef']
- B
['abcdef\n']
- C
['a','b','c','d','e','f']
- D
['a','b','c','d','e','f','\n']
def save():
f=open("test.txt","wt",encoding="utf-8")
f.write("我abc\nxyz")
f.close()
save()
执行后test.txt文件长度是
- A
8字节
- B
9字节
- C
10字节
- D
1字节
在完整的异常语句中，语句出现的顺序正确的是（）
- A
try--else--except--finally
- B
try--except--else--finally
- C
try--finally--else--except
- D
try--else--finally--except
def f(n):
if n==0:
return 0
elif n==1:
return 1
return f(n-1)+f(n-2)
print(4)
结果是
- A
1
- B
4
- C
3
- D
2
class Student:
def __init__(self,n="xxx"):
self.name=n
def show(self):
print(self.name)
s=Student("yyy")
s.show()
结果
- A
yyy
- B
xxx
- C
None
- D
错误
假设file是文本文件对象，下列用于读取一行的（）
- A
file.read()
- B
file.read(200)
- C
file.readline()
- D
file.readlines()
下列函数中，用于使用函数对制定序列进行过滤的是（）
- A
map函数
- B
select函数
- C
filter函数
- D
reduce函数
假设文件不存在，如果用open函数打开文件会报错，那么该文件的打开方式是（）
- A
'r'
- B
'w'
- C
'a'
- D
'w+'
st=[["a","b"],"c"]
st[0][1]='d'
print(len(st),st)
结果是
- A
3 [['d', 'b'], 'c']
- B
2 [['d', 'b'], 'c']
- C
3 [['a', 'd'], 'c']
- D
2 [['a', 'd'], 'c']
class Student:
name="xxx"
@staticmethod
def show():
name="yyy"
print(name,Student.name)
@classmethod
def display(cls):
cls.show()
s=Student()
s.display()
结果
- A
xxx yyy
- B
yyy xxx
- C
xxx xxx
- D
错误
下列语句打开文件的位置应该在（）
f=open('wenjian01.txt','w')
- A
c盘目录下
- B
d盘目录下
- C
Python安装目录下
- D
与源文件相同的目录下
def save():
f=open("test.txt","wt")
f.write("abc\nxyz")
f.close()
def read():
f=open("test.txt","rt")
s=f.readline()
print(len(s))
f.close()
save()
read()
执行结果是
- A
3
- B
4
- C
5
- D
7
class Student:
name="xxx"
@staticmethod
def show():
name="yyy"
print(name,Student.name)
@staticmethod
def display():
show()
s=Student()
s.display()
结果：
- A
错误
- B
yyy xxx
- C
yyy yyy
- D
xxx xxx
以下C类继承A类和B类的格式中，正确的是（）
- A
class C A,B
- B
class C (A,B)
- C
class C(A,B):
- D
class C A and B
下列程序运行后，会产生（）异常。
abc
- A
IndexError
- B
SyntaxError
- C
NameError
- D
KeyError
class Student:
def __init__(self,n):
name=n
def show(self):
print(name)
s=Student("xxx")
s.show()
结果
- A
xxx
- B
错误
- C
None
- D
没有输出
下列选项中，符合类的命名规范的（）
- A
car
- B
cat
- C
Cat
- D
Holiday Resort
下列关键字中，用来引入模块的是（）
- A
include
- B
from
- C
import
- D
continue
构造方法的作用是（）
- A
一般成员方法
- B
类的初始化
- C
对象的初始化
- D
对象的建立
def test():
f=open("test.txt","wt+")
f.write("我abc")
f.seek(3,0)
f.write("xyz")
f.seek(1,0)
s=f.read()
print(s)
f.close()
test()
结果是
- A
axyz
- B
bxyz
- C
我xyz
- D
汉字乱码
下列方法中，不可以使用类名称访问的是
- A
实例方法
- B
类方法
- C
静态方法
- D
其他三项都不符合
下列错误信息中，（）是异常对象的名字。
ZeroDivisionError: division by zero
- A
IndexError
- B
ZeroDivisionError
- C
zero
- D
division
题目：暂停一秒输出。
'''
暂停以秒输入
'''
import time
myD = {1:'a', 2:'b', 3:'c', 4:'d', 5:'e', 6:'f', 7:'g'}
for key,value in dict.items(myD):
print(key,value)
___________________#暂停一秒
- A
time.sleep(1000)
- B
time.delay(1)
- C
time.delay(1000)
- D
time.sleep(1)
class Student:
name="xxx"
def show(cls):
name="yyy"
print(name,cls.name)
s=Student()
s.show()
结果
- A
xxx yyy
- B
yyy yyy
- C
yyy xxx
- D
错误
题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示,60-80分之间的用B表示，60分以下的用C表示。
'''
需求：利用条件运算符的嵌套来完成成绩表。
思路：(a>b)?a:b这是条件运算符的基本例子。
'''
score = int(input('input score:'))
if score >= 90:
grade = 'A'
______________
grade = 'B'
elif score >= 70:
grade = 'C'
elif score >= 60:
grade = 'D'
else:
grade = 'E'
print ('%d belongs to %s' % (score,grade))
- A
elif score > 80:
- B
elif score <= 80:
- C
elif score < 80:
- D
elif score >= 80:
def save(s):
f=open("test.txt","wt")
f.write(s["name"])
f.write(s["sex"])
f.write(s["age"])
f.close()
def read():
f=open("test.txt","rt")
s=f.read()
print(s)
f.close()
s={"name":"xxx","sex":"male","age":"20"}
save(s)
read()
执行结果是
- A
xxxmale20
- B
xxx male 20
- C
xxxmale20
- D
错误
当try语句中没有任何错误信息时，一定不会执行（）语句。
- A
else
- B
finally
- C
except
- D
try
一个文本文件test.txt的一行存储5个整数如下：
1 3 56 67 34
数之间用空格隔开，要读出这些整数的函数正确的是：
- A
def read(): f=open("test.txt","rt") while true: s=f.read() if s!="": print(s) else: break f.close()
- B
def read(): f=open("test.txt","rt") while true: s=f.readline() if s!="": print(s) else: break f.close()
- C
def read(): f=open("test.txt","rt") st=f.readlines() for s in st: print(s) f.close()
- D
def read(): f=open("test.txt","rt") s=f.readline() st=s.splist(" ") for s in st: print(s) f.close()
def test():
f=open("test.txt","wt+")
f.write("abc")
f.seek(3,0)
f.write("xyz")
f.seek(2,0)
s=f.read()
print(s)
f.close()
test()
结果是
- A
c xyz
- B
bcxyz
- C
cxyz
- D
bc xyz
构造方法是类的一个特殊方法，python中它的名称为（）
- A
与类同名
- B
__construct
- C
__int__
- D
__init__
下列选项中，用于向文件中写内容的是（）
- A
open
- B
write
- C
close
- D
read
打开一个已有文件，然后在文件末尾添加信息，正确的打开方式为（）
- A
‘r’
- B
'w'
- C
'a'
- D
'w+'
下列选项中，用于读取当前目录内容的是（）
- A
open
- B
write
- C
getcwd
- D
read
装饰器应用于
- A
引入日志
- B
执行时间统计
- C
权限校验
- D
缓存
下列关于类属性和实例属性的说法中，描述不正确的是
- A
类属性既可以显式定义，又能在方法中定义
- B
公有类属性可以通过类和类的实例访问
- C
通过类可以获取实例属性的值
- D
类的实例只能获取实例属性的值
关于类和对象的关系，下列描述不正确的是（）
- A
类是面向对象的核心
- B
对象是面向对象的核心
- C
类是现实中的个体
- D
对象是根据类创建的，并且一个类只能对应一个对象
关于_name_的说明，下列描述正确的是（）
- A
它是Python提供的一个方法
- B
每个模块内部有一个_name_属性
- C
当它的值为'_main_'时，表示模块自身在运行
- D
当它的值不为'_main_'时，表示模块被引用
下列选项中，不能用于标识静态方法的是
- A
@classmethod
- B
@instancemethod
- C
@staticmethod
- D
@privatemethod
以下是Python中闭包的条件为
- A
嵌套关系
- B
内部函数引用外部函数的变量
- C
外部函数将内部函数作为返回值
- D
外部函数将内部函数名作为返回值
运行下列语句，会有哪些异常
print(x+1)
open('haha.txt','r')
- A
NameError
- B
SyntaxError
- C
IndexError
- D
FileNotFoundError
关于面向过程和面向对象，下列说法正确的是（）
- A
面向过程和面向对象都是解决问题的一种思路
- B
面向过程是基于面向对象的
- C
面向过程强调的是解决问题的步骤
- D
面向对象强调的是解决问题的对象
下列选项中，属于面向对象程序设计的三个特征的是（）
- A
抽象
- B
封装
- C
继承
- D
多态
以下是Python读文件方式的
- A
look
- B
read
- C
readlines
- D
readline
当_name_属性的值为_main_时，代表模块自身在运行。
- A) 正确
- B) 错误
filter传入的函数可以为None。
- A) 正确
- B) 错误
使用write写入文件时，数据会追加到文件的末尾。
- A) 正确
- B) 错误
使用类名获取到的值一定是类属性的值
- A) 正确
- B) 错误
要想使用with语句，前提是要有上下文管理器。
- A) 正确
- B) 错误
子类能继承父类的一切属性和方法
- A) 正确
- B) 错误
包目录下，必须有一个_init_.py文件。
- A) 正确
- B) 错误
文件打开的默认方式是只读。
- A) 正确
- B) 错误
静态方法中一定不能访问实例属性的值
- A) 正确
- B) 错误
前面带有两个下划线的方法一定是私有方法
- A) 正确
- B) 错误
所有的except子句一定在else和finally前面。
- A) 正确
- B) 错误
f=open("test.txt","at")
f.write("abc")
f.close()
新写入的"abc"在文件的尾部
- A) 正确
- B) 错误
每个模块都有一个_name_属性，使代码块只能在模块自身运行时执行。
- A) 正确
- B) 错误
装饰器函数至少要接收一个参数。
- A) 正确
- B) 错误
f=open("test.txt","rt")
s=f.readline()
print(s)
f.close()
那么s一定以"\n"结尾
- A) 正确
- B) 错误
Python的类成员变量一般使用类名称限定访问
- A) 正确
- B) 错误
实际开发中，文件或文件夹的操作都要用到os模块。
- A) 正确
- B) 错误
继承会在原有类的基础上产生新的类，这个新类就是父类
- A) 正确
- B) 错误
方法和函数的格式是完全一样的。
- A) 正确
- B) 错误
如果except字句没有指明任何异常类型，则表示捕获所有异常。
- A) 正确
- B) 错误
当约束条件不满足时，assert语句会触发AssertionError异常。
- A) 正确
- B) 错误
在使用异常时必须先导入exceptions模块。
- A) 正确
- B) 错误
f=open("test.txt","wt")
f.write("abc")
f.close()
在test.txt文件不存在时会自动创建test.txt
- A) 正确
- B) 错误
创建类的对象时，系统会自动调用构造方法进行初始化。
- A) 正确
- B) 错误
创建完对象后，其属性的初始值是固定的，外界无法进行修改。
- A) 正确
- B) 错误
filter函数的返回值为字符串，它传入的序列中的元素一定也是字符串。
- A) 正确
- B) 错误
每个Python文件就是一个模块。
- A) 正确
- B) 错误
闭包是嵌套函数中的内层函数对外层函数的变量进行引用。
- A) 正确
- B) 错误
装饰器是一个变量。
- A) 正确
- B) 错误
filter函数只能对序列执行过滤操作。
- A) 正确
- B) 错误
类的方法中必须有一个参数，位于参数列表的开头。
-
填空一
- 填空一： self
为了更好的组织模块，通常会把多个模块放在一个中。
-
填空一
- 填空一： 包
Python中所有的异常类都是的子类
-
填空一
- 填空一： Exception
os模块中的mkdir方法用于创建
-
填空一
- 填空一： 文件夹
装饰器本质上是一个
-
填空一
- 填空一： 函数
当使用序列中不存在的索引时，会触发异常
-
填空一
- 填空一： IndexError
filter传入的函数的返回值是值（答案用中文描述）。
-
填空一
- 填空一： 布尔
当程序中需要引入外部模块时，需要从外面下载并。
-
填空一
- 填空一： 安装
在现有的基础上构建新类，新的类称为，现有的类称为
-
填空一
-
填空二
- 填空一： 子类
- 填空二： 父类
加法运算符重载是通过____方法完成的。
-
填空一
- 填空一： add
class Student:
def __init__(self,n="xxx"):
self.name=n
@classmethod
def show(cls):
s=cls()
print(s.name)
s=Student("yyy")
s.show()
结果：
- A
yyy
- B
xxx
- C
错误
- D
yyyxxx
下列选项中，（）是唯一不在运行时发生的异常。
- A
KeyError
- B
ZeroDivisionError
- C
NameError
- D
SyntaxError
下列程序运行后，会产生（）异常。
abc
- A
IndexError
- B
SyntaxError
- C
NameError
- D
KeyError
class Student:
def __init__(self,n):
name=n
def show(self):
print(name)
s=Student("xxx")
s.show()
结果
- A
xxx
- B
错误
- C
None
- D
没有输出
def save():
f=open("test.txt","wt",encoding="gbk")
f.write("我abc\nxyz")
f.close()
save()
执行后test.txt文件大小是
- A
8字节
- B
9字节
- C
10字节
- D
11字节
class Student:
def __init__(self,n="xxx",s="男"):
self.name=n
self.sex=s
def show(self):
print(s.name,s.sex,s.age)
s=Student("yyy")
s.age=20
s.show()
结果：
- A
yyy 男 0
- B
yyy 男 None
- C
yyy 男 20
- D
错误
a=1
b=-2
print("#%3d#%-3d" %(a,b))
结果是：
- A
#1#-2
- B
# 1#-2
- C
#1 #-2
- D
#1# -2
题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示,60-80分之间的用B表示，60分以下的用C表示。
'''
需求：利用条件运算符的嵌套来完成成绩表。
思路：(a>b)?a:b这是条件运算符的基本例子。
'''
score = int(input('input score:'))
if score >= 90:
grade = 'A'
______________
grade = 'B'
elif score >= 70:
grade = 'C'
elif score >= 60:
grade = 'D'
else:
grade = 'E'
print ('%d belongs to %s' % (score,grade))
- A
elif score > 80:
- B
elif score <= 80:
- C
elif score < 80:
- D
elif score >= 80:
以下C类继承A类和B类的格式中，正确的是（）
- A
class C A,B
- B
class C (A,B)
- C
class C(A,B):
- D
class C A and B
假设文件不存在，如果用open函数打开文件会报错，那么该文件的打开方式是（）
- A
'r'
- B
'w'
- C
'a'
- D
'w+'
class Student:
age=20
def __init__(self,n="xxx",s="男"):
self.name=n
self.sex=s
def show(self):
print(s.name,s.sex,s.age)
s=Student("yyy")
s.age=30
s.show()
结果：
- A
yyy 男 20
- B
yyy 男 30
- C
xxx 男 30
- D
xxx 男 20
下列选项中，符合类的命名规范的（）
- A
car
- B
cat
- C
Cat
- D
Holiday Resort
构造方法是类的一个特殊方法，python中它的名称为（）
- A
与类同名
- B
__construct
- C
__int__
- D
__init__
下列选项中，与class Person等价的是（）
- A
class Person （Object）
- B
class Person （object）
- C
class Person :Object
- D
class Person :object
class Student:
def __init__(self,n="xxx",s="男"):
self.name=n
self.sex=s
def show(self):
print(s.name,s.sex)
s=Student("yyy")
Student.show(s)
结果：
- A
yyy 男
- B
xxx 男
- C
Student.show(s)错误
- D
def __init__(self,n="xxx",s="男")错误
题目：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+222...2（此时共有5个数相加），几个数相加有键盘控制。
'''
需求：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。
思路：先计算出每一项的值。
'''
Tn = 0
Sn = []
n = int(input('n = :'))
a = int(input('a = :'))
for count in range(n):#先循环计算每一项的值
Tn = Tn + a
_______________
Sn.append(Tn)
print Tn
Sn = reduce(lambda x,y : x + y,Sn)#在计算和
print( Sn)
- A
a = a * 10
- B
a = a + 10
- C
a = a // 10
- D
a = a * *10
def save(s):
f=open("test.txt","wt")
f.write(s["name"]+"\n")
f.write(s["sex"]+"\n")
f.write(s["age"]+"\n")
f.close()
def read():
f=open("test.txt","rt")
name=f.readline().strip("\n")
sex=f.readline().strip("\n")
age=f.readline().strip("\n")
print(name)
print(sex)
print(age)
f.close()
s={"name":"xxx","sex":"male","age":"20"}
save(s)
read()
结果是
- A
xxxmale20
- B
xxxmale20
- C
xxx male 20
- D
错误
class Student:
name="xxx"
def show(cls):
name="yyy"
print(name,cls.name)
s=Student()
s.show()
结果
- A
xxx yyy
- B
yyy yyy
- C
yyy xxx
- D
错误
Python中定义私有属性的方法是（）
- A
使用private关键字
- B
使用public关键字
- C
使用__XX__定义属性名
- D
使用__XX定义属性名
def save():
f=open("test.txt","wt",encoding="utf-8")
f.write("我abc\nxyz")
f.close()
save()
执行后，哪个read()函数可以读出全部内容
- A
def read(): f=open("test.txt","rt") for s in f.readlines(): print(s,end="") f.close()
- B
def read(): f=open("test.txt","rt",encoding="utf-8") for s in f.readlines(): print(s,end="") f.close()
- C
def read(): f=open("test.txt","rt",encoding="utf-8") for s in f.readlines(): print(s) f.close()
- D
def read(): f=open("test.txt","rt",encoding="utf-8") s=f.readline() print(s) f.close()
class Person:
def __init__(self,n="xxx"):
self.name=n
class Student(Person):
def __init__(self,s="male"):
self.sex=s
def show(self):
print(self.name,self.sex)
s=Student("female")
s.show()
结果：
- A
xxx female
- B
xxx male
- C
结果错误
- D
xxx
下列语句打开文件的位置应该在（）
f=open('wenjian01.txt','w')
- A
c盘目录下
- B
d盘目录下
- C
Python安装目录下
- D
与源文件相同的目录下
假设file是文本文件对象，下列用于读取一行的（）
- A
file.read()
- B
file.read(200)
- C
file.readline()
- D
file.readlines()
def save():
f=open("test.txt","wt")
f.write("abc\nxyz")
f.close()
def read():
f=open("test.txt","rt")
s=f.readline()
print(len(s))
f.close()
save()
read()
执行结果是
- A
3
- B
4
- C
5
- D
7
def save(s):
f=open("test.txt","wt")
f.write(s["name"])
f.write(s["sex"])
f.write(s["age"])
f.close()
def read():
f=open("test.txt","rt")
s=f.read()
print(s)
f.close()
s={"name":"xxx","sex":"male","age":"20"}
save(s)
read()
执行结果是
- A
xxxmale20
- B
xxx male 20
- C
xxxmale20
- D
错误
下列选项中，用于向文件中写内容的是（）
- A
open
- B
write
- C
close
- D
read
class Student:
def __init__(self,n="xxx"):
self.name=n
@classmethod
def show(cls):
s=cls()
print(s.name)
s=Student("yyy")
Student.show(s)
结果：
- A
yyy
- B
xxx
- C
错误
- D
xxxyyy
class Student:
name="xxx"
def show(cls):
name="yyy"
print(name,cls.name)
s=Student()
s.show()
结果
- A
xxx yyy
- B
yyy yyy
- C
yyy xxx
- D
错误
下列选项中，用于触发异常的是（）
- A
catch
- B
try
- C
except
- D
raise
class Student:
def __init__(self,n="xxx"):
self.name=n
def show(self):
print(self.name)
s=Student("yyy")
s.show()
结果
- A
yyy
- B
xxx
- C
None
- D
错误
class Person:
def __init__(self,n="xxx"):
self.name=n
class Student(Person):
def __init__(self,n="aaa",s="male"):
Person.__init__(self)
self.sex=s
def show(self):
print(self.name,self.sex)
s=Student("yyy","female")
s.show()
结果：
- A
aaa male
- B
aaa female
- C
yyy female
- D
xxx female
下列关键字中，用来引入模块的是（）
- A
include
- B
from
- C
import
- D
continue
class Student:
name="yyy"
age=30
def __init__(self):
self.name="xxx"
self.age=20
s=Student()
Student.name="zzz"
print(s.name,s.age,Student.name,Student.age)
结果：
- A
yyy 20 xxx 30
- B
yyy 20 zzz 30
- C
xxx 20 yyy 30
- D
xxx 20 zzz 30
def test():
f=open("test.txt","wt+")
f.write("abc")
f.seek(3,0)
f.write("xyz")
f.seek(2,0)
s=f.read()
print(s)
f.close()
test()
结果是
- A
c xyz
- B
bcxyz
- C
cxyz
- D
bc xyz
def save():
f=open("test.txt","wt",encoding="utf-8")
f.write("我abc\nxyz")
f.close()
save()
执行后test.txt文件长度是
- A
8字节
- B
9字节
- C
10字节
- D
1字节
def save(s):
f=open("test.txt","wt")
f.write(s["name"]+"\n")
f.write(s["sex"]+"\n")
f.write(s["age"]+"\n")
f.close()
def read():
f=open("test.txt","rt")
name=f.readline()
sex=f.readline()
age=f.readline()
print(name,sex,age,sep="")
f.close()
s={"name":"xxx","sex":"male","age":"20"}
save(s)
read()
结果是
- A
xxxmale20
- B
xxx male 20
- C
xxxmale20
- D
xxxmale20
题目：暂停一秒输出。
'''
暂停以秒输入
'''
import time
myD = {1:'a', 2:'b', 3:'c', 4:'d', 5:'e', 6:'f', 7:'g'}
for key,value in dict.items(myD):
print(key,value)
___________________#暂停一秒
- A
time.sleep(1000)
- B
time.delay(1)
- C
time.delay(1000)
- D
time.sleep(1)
class Student:
name="xxx"
@classcmethod
def show(cls):
name="yyy"
print(name,cls.name)
Student.show()
结果：
- A
xxx yyy
- B
yyy xxx
- C
xxx xxx
- D
yyy yyy
class Student:
name="xxx"
@staticmethod
def show():
name="yyy"
print(name,Student.name)
@classmethod
def display(cls):
cls.show()
s=Student()
s.display()
结果
- A
xxx yyy
- B
yyy xxx
- C
xxx xxx
- D
错误
下列函数中，用于使用函数对制定序列进行过滤的是（）
- A
map函数
- B
select函数
- C
filter函数
- D
reduce函数
关于类和对象的关系，下列描述不正确的是（）
- A
类是面向对象的核心
- B
对象是面向对象的核心
- C
类是现实中的个体
- D
对象是根据类创建的，并且一个类只能对应一个对象
下列选项中，属于面向对象程序设计的三个特征的是（）
- A
抽象
- B
封装
- C
继承
- D
多态
关于面向过程和面向对象，下列说法正确的是（）
- A
面向过程和面向对象都是解决问题的一种思路
- B
面向过程是基于面向对象的
- C
面向过程强调的是解决问题的步骤
- D
面向对象强调的是解决问题的对象
以下是Python读文件方式的
- A
look
- B
read
- C
readlines
- D
readline
以下是Python中闭包的条件为
- A
嵌套关系
- B
内部函数引用外部函数的变量
- C
外部函数将内部函数作为返回值
- D
外部函数将内部函数名作为返回值
下列选项中，不能用于标识静态方法的是
- A
@classmethod
- B
@instancemethod
- C
@staticmethod
- D
@privatemethod
下列关于类属性和实例属性的说法中，描述不正确的是
- A
类属性既可以显式定义，又能在方法中定义
- B
公有类属性可以通过类和类的实例访问
- C
通过类可以获取实例属性的值
- D
类的实例只能获取实例属性的值
装饰器应用于
- A
引入日志
- B
执行时间统计
- C
权限校验
- D
缓存
关于_name_的说明，下列描述正确的是（）
- A
它是Python提供的一个方法
- B
每个模块内部有一个_name_属性
- C
当它的值为'_main_'时，表示模块自身在运行
- D
当它的值不为'_main_'时，表示模块被引用
运行下列语句，会有哪些异常
print(x+1)
open('haha.txt','r')
- A
NameError
- B
SyntaxError
- C
IndexError
- D
FileNotFoundError
若map函数中传入的两个序列长度不同，则较长的序列会将多余的元素删除。
- A) 正确
- B) 错误
read方法只能一次性读取文件中所有数据。
- A) 正确
- B) 错误
实际开发中，文件或文件夹的操作都要用到os模块。
- A) 正确
- B) 错误
每个Python文件就是一个模块。
- A) 正确
- B) 错误
方法和函数的格式是完全一样的。
- A) 正确
- B) 错误
f=open("test.txt","wb")
f.write("abc")
f.close()
程序正确写入"abc"
- A) 正确
- B) 错误
静态方法中一定不能访问实例属性的值
- A) 正确
- B) 错误
f=open("test.txt","rt")
s=f.readline()
print(s)
f.close()
那么s一定以"\n"结尾
- A) 正确
- B) 错误
一个try语句只能对应一个except字句。
- A) 正确
- B) 错误
map函数只能传递一个序列。
- A) 正确
- B) 错误
所有的except子句一定在else和finally前面。
- A) 正确
- B) 错误
要想使用with语句，前提是要有上下文管理器。
- A) 正确
- B) 错误
filter函数只能对序列执行过滤操作。
- A) 正确
- B) 错误
如果类属性和实例属性重名，对象优先访问类属性的值
- A) 正确
- B) 错误
f=open("test.txt","wt")
f.write("abc")
f.seek(2,0)
f.write("123")
f.close()
程序时错误的，因为seek只能用在二进制文件操作中
- A) 正确
- B) 错误
使用类名获取到的值一定是类属性的值
- A) 正确
- B) 错误
每个模块都有一个_name_属性，使代码块只能在模块自身运行时执行。
- A) 正确
- B) 错误
Python解释器会优先查看默认的路径模块位置（）
- A) 正确
- B) 错误
f=open("test.txt","at")
f.write("abc")
f.close()
新写入的"abc"在文件的尾部
- A) 正确
- B) 错误
外部模块都提供了自动安装的文件，直接双击安装就行。
- A) 正确
- B) 错误
无论程序是否捕获到异常，一定会执行finally语句。
- A) 正确
- B) 错误
子类能继承父类的一切属性和方法
- A) 正确
- B) 错误
当约束条件不满足时，assert语句会触发AssertionError异常。
- A) 正确
- B) 错误
通过类可以创建对象，有且只有一个对象实例。
- A) 正确
- B) 错误
Python中没有任何关键字区分公有属性和私有属性
- A) 正确
- B) 错误
包目录下，必须有一个_init_.py文件。
- A) 正确
- B) 错误
子类通过重写继承的方法，覆盖掉跟父类同名的方法
- A) 正确
- B) 错误
一个try语句只能对应一个finally子句。
- A) 正确
- B) 错误
当嵌套的外层函数执行结束时，其内部闭包引用的变量一定会释放。
- A) 正确
- B) 错误
Python的类成员变量一般使用类名称限定访问
- A) 正确
- B) 错误
如果要搜索模块的路径，可以使用sys模块的变量。
-
填空一
- 填空一： path
Python中所有的异常类都是的子类
-
填空一
- 填空一： Exception
在读写文件的过程中，方法可以获得当前的读写位置。
-
填空一
- 填空一： tell
map函数的两个序列的元素个数不一致，那么元素少的序列会以补齐。
-
填空一
- 填空一： None
内部函数引用了外部函数作用域的变量，那么内部函数叫做
-
填空一
- 填空一： 闭包
装饰器函数需要接收一个参数，这个参数表示
-
填空一
- 填空一： 被装饰的函数
os模块中的mkdir方法用于创建
-
填空一
- 填空一： 文件夹
一个try语句只能对应一个子句
-
填空一
- 填空一： finally
python提供了名称为____的构造方法，实现让类的对象完成初始化。
-
填空一
- 填空一： init
装饰器本质上是一个
-
填空一
- 填空一： 函数
当需要在字符串中使用特殊字符时，Python使用（）作为转义字符。
- A
/
- B
\
- C
#
- D
%
a=1
b="A"
print("|%3d|%3s|" %(a,b))
结果是：
- A
| 1|A |
- B
|1|A|
- C
|1| A|
- D
| 1| A|
题目：利用递归方法求5！。
'''
需求：利用递归方法求5！。
思路：递归公式：fn = fn_1*4!
'''
def fact(j):
sum = 0
if j == 0:
sum = 1
else:
sum = ______________
return sum
for i in range(5):
print ('%d! = %d' % (i,fact(i)))
- A
j * fact(j)
- B
(j-1) * fact(j - 1)
- C
j * fact(j - 1)
- D
(j+1) * fact(j + 1)
s=b"\x41\x42"
s=s+b"\x43"
print(s)
结果类型是：
- A
bytes
- B
str
- C
int
- D
不确定
执行下列操作后，b 的值为（）
a=[4,5,6]
b=a
a[2]=3
- A
[4,3,6]
- B
[4,5,6]
- C
[4,5,3]
- D
以上答案都不正确
下列选项中，用于触发异常的是（）
- A
catch
- B
try
- C
except
- D
raise
下列选项中，标识符合法的是
- A
2ndObj
- B
helloWorld
- C
hello#world
- D
^helloworld
题目：两个兵乓球队进行比赛，各出三人。甲队为a,b,c三人，乙对为x,y,z三人。以抽签决定比赛名单。有向队员打听比赛的名单。a说他不和x比，c说他不和x，z比，请编程找到三队赛手的名单。
'''
需求：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
思路：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。
'''
for i in range(ord('x'),ord('z') + 1):
for j in range(ord('x'),ord('z') + 1):
if i != j:
for k in range(ord('x'),ord('z') + 1):
if (i != k) and (j != k):
if (__________________________________________):
print( 'order is a -- %s\t b -- %s\tc -- %s' % (chr(i),chr(j),chr(k)))
- A
i != ord('x')) and (k != ord('x')) and (k != ord('z')
- B
i == ord('x')) and (k != ord('x')) and (k != ord('z')
- C
i != ord('x')) and (k == ord('x')) and (k != ord('z')
- D
i != ord('x')) and (k != ord('x')) and (k == ord('z')
已知a=10,b=20,c=30;以下语句执行后a,b,c的值为
if a<b:
c=a
a=b
b=c
- A
10,20,30
- B
20,10,10
- C
10,20,20
- D
20,10,30
题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。
x = int(input("input a number:"))
a = x // 10000
________________
c = x % 1000 // 100
d = x % 100 // 10
e = x % 10
if a != 0:
print ("there are 5 ",e,d,c,b,a)
elif b != 0:
print ("there are 4 ",d,c,b,a)
elif c != 0:
print ("there are 3 ",e,d,c)
elif d != 0:
print ("there are 2 ",e,d)
else:
print ("there are 1",e)
- A
b = x // 10000 // 1000
- B
b = x % 10000 // 1000
- C
b = x // 10000 % 1000
- D
b = x % 10000 % 1000
d={"Name":'xxx'}
d["Sex"]="male"
d["name"]="yyy"
print(d)
结果是
- A
{'name': 'yyy', 'Sex': 'male'}
- B
{'Name': 'yyy', 'Sex': 'male'}
- C
{'Name': 'xxx', 'Sex': 'male', 'name': 'yyy'}
- D
错误
输入一个字符串s,反向输出它，例如输入"abc"，输出"bca"
s=input()
__________
while i>=0:
print(s[i],end="")
print()
- A
i=len(s)
- B
i=len(s)-1
- C
i=len(s)+1
- D
都不对
题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示,60-80分之间的用B表示，60分以下的用C表示。
'''
需求：利用条件运算符的嵌套来完成成绩表。
思路：(a>b)?a:b这是条件运算符的基本例子。
'''
score = int(input('input score:'))
if score >= 90:
grade = 'A'
______________
grade = 'B'
elif score >= 70:
grade = 'C'
elif score >= 60:
grade = 'D'
else:
grade = 'E'
print ('%d belongs to %s' % (score,grade))
- A
elif score > 80:
- B
elif score <= 80:
- C
elif score < 80:
- D
elif score >= 80:
题目：将一个列表的数据复制到另一个列表中。
'''
将一个列表的数据复制到另一个列表里
'''
a = [1,2,3,4,5,6,7,8,9,0]
________
print(b)
- A
b = a[0:9]
- B
b = a[0:0]
- C
b = a[:]
- D
b = a
下列方法中，能够返回某个子串的字符串中出现次数的是（）
- A
index
- B
count
- C
length
- D
find
当try语句中没有任何错误信息时，一定不会执行（）语句。
- A
else
- B
finally
- C
except
- D
try
下列列表的说法，描述错误的是（）
- A
列表是一个有序集合，没有固定大小
- B
列表是不可变的数据类型
- C
列表可以存放任意类型的元素
- D
使用列表时，其下标可以是负数
st=[]
st.append({"name":"a","sex":"male"})
st.append({"name":"b","sex":"female"})
for s in st:
print(s["name"],s["sex"])
结果是
- A
a maleb female
- B
a male
- C
b female
- D
b femalea male
下列程序的输出结果为
for i in [0,1,2]
print(i)
- A
0
- B
1
- C
2
- D
0,1,2
- E
012
- F
0 1 2
题目：判断101-200之间有多少个素数，并输出所有素数。
'''
需求：判断101-200之间的所有素数，并输出
思路：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。
'''
h = 0
leap = 1
from math import sqrt
from sys import stdout
for m in range(0,201):
k = int(sqrt(m + 1))
for i in range(2,k + 1):
if______:
leap = 0
break
if leap == 1:
print ('%-4d' % m)
h += 1
if h % 10 == 0:
print ('')
leap = 1
print ('The total is %d' % h)
- A
m % i == 1
- B
m % i == 0
- C
i% m == 0
- D
i%m==1
下列选项中，符合Python命名规范的标识符的是
- A
if
- B
user-passw0rd
- C
setup.up
- D
_name
下列选项中，不属于Python语言特点的是？
- A
面向过程
- B
可移植性
- C
开源
- D
简单易学
def f(a,b):
t=a
a=b
b=t
a=1
b=2
f(a,b)
print(a,b)
结果是
- A
2 1
- B
1 2
- C
1 1
- D
2 2
题目：有5个人坐在一起，问第五个人多少岁？他说比第四个人大两岁。问第四个人岁数，他说比第三个人大两岁。问第三个人，又说比第二个人大两岁。问第二个人，说比第二个人大两岁。最后问第一个，他说是十岁。请问第五个人多大？
'''
需求：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？
思路：利用递归的方法，递归分为回推和递推两个阶段。要想知道第五个人岁数，需知道第四人的岁数，依次类推，推到第一人（10岁），再往回推。
'''
def age(n):
if n == 1:
c = 10
else:
______________
return c
print age(5)
- A
c = age(n-1) + 2
- B
c = age(n-1) + 1
- C
c = age(n-1) -1
- D
c = age(n) + 2
题目：利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。
'''
需求：利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。
'''
def output(s,l):
if l == 0:
return
print (s[l-1])
output(______)
s = input('Input a string:')
l = len(s)
output(s,l)
- A
l-1,s
- B
s,l+1
- C
s,l
- D
s,l-1
下列符号中，表示Python单行注释的是
- A
//
- B
#
- C
<!---->
- D
"""
创建自定义函数使用（）关键字
- A
function
- B
func
- C
def
- D
procedure
列表st=['a','b','c']，要删除'b'元素，正确的操作是
- A
st.remove(1)
- B
st.remove(2)
- C
del st[1]
- D
del st[2]
下列删除列表中最后一个元素的函数是（）
- A
pop
- B
del
- C
cut
- D
remove
for i in range(4):
for j in range(i,3):
if (i+j)%2==0:
print(i,j)
break
结果是
- A
1 12 2
- B
0 02 2
- C
0 01 1
- D
0 01 12 2
Python语言的特点
- A
解释性语言
- B
编译性语言
- C
解释与编译组合的语言
- D
自然语言
下列关于Python中的复数，描述错误的是
- A
虚部必须有小写的后缀j
- B
表示复数的语法是real + image j
- C
实部和虚部都是浮点数
- D
一个复数必须有表示虚部的实数和j
题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，有吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前天剩下的一半零一个。到第十天早上再想吃时，见剩下一个桃子了。求一天共摘了多少。
'''
需求：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
思路：采用逆向思维的方法，从后在往前推断
'''
x2 = 1
for day in range(9,0,-1):
___________________
x2 = x1
print x1
- A
x2 = (x1 + 1) * 2
- B
x1 = x2 * 2
- C
x1 = (x2 - 1) * 2
- D
x1 = (x2 + 1) * 2
st=[]
st.append({"name":"a","sex":"male"})
st.append({"name":"b","sex":"female"})
st[1]["age"]=23
for s in st:
print(s["name"],s["sex"],s["age"])
结果是
- A
a male Noneb female 23
- B
错误
- C
a male 0b female 23
- D
a male undefinedb female 23
a=0x12
print(a)
结果：
- A
0x12
- B
12
- C
0x
- D
18
使用（）关键字声明匿名函数。
- A
def
- B
func
- C
lambda
- D
print
for i in range(4):
if i%2==0:
print(i)
break
print(i)
结果是
- A
00
- B
01
- C
22
- D
02
下列数据中，不属于字符串的是（）
- A
“67nmkl”
- B
'wffff'
- C
hjk
- D
'''123'''
题目：有1、2、3、4个数字，能组成多少个相互不同且无重复的三位数？都是多少？
'''
可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条件的排列。
'''
for i in range(1,5):
for j in range(1,5):
for k in range(1,5):
if _________________:
print (i, j, k)
- A
(i != j) and (i != k) and (k != j)
- B
(i != j) && (i != k) &&(k != j)
- C
(i != j) or (i != k) or (k != j)
- D
(i != j) || d (i != k) || (k != j)
下列语句中，在Python中是非法的
- A
x , y =y , x
- B
x = y = z = 1
- C
x =(y = z + 1)
- D
x += y
Python中自定义函数的语法格式有
- A
def开头
- B
函数名圆括号后面冒号
- C
函数名不能以数字开头
- D
必须有return结束函数
以下是Python中时间日期格式化符号的
- A
Y%
- B
S%
- C
A%
- D
B%
以下用在Python循环语句中的是
- A
while
- B
for
- C
pass
- D
break
题目：一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
import math
for i in range(10000):
x = int(math.sqrt(i + 100))
y = int(math.sqrt(i + 168))
if ____________________________________:
print(i)
- A
(x * x == i + 100) and (y * y == i + 168)
- B
(x * x = i + 100) and (y * y = i + 168)
- C
(x * x == i + 100) && (y * y == i + 168)
- D
(x **2 == i + 100) and (y **2 == i + 168)
以下是Python中随机数函数的
- A
random.random()
- B
random.unifrom(a,b)
- C
random.randint(a,b)
- D
random.choice(sequence)
Python变量的类型包括
- A
数字类型
- B
字典类型
- C
字符串类型
- D
布尔类型
题目：一个球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
'''
需求：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
'''
Sn = 100.0
Hn = Sn / 2
for n in range(2,11):
_____________
Hn /= 2
print ('Total of road is %f' % Sn)
print ('The tenth is %f meter' % Hn)
- A
Sn = 2 * Hn
- B
Sn -= 2 * Hn
- C
Sn += 2 * Hn
- D
Sn = Sn+ 2 * Hn
下列表达式中，不是返回Ture的是
- A
Ture and False
- B
2!=2
- C
3>2>1
- D
a=2b=2a=b
python中列表的循环遍历有
- A
for
- B
at
- C
with
- D
while
关于函数的说法，正确的是（）
- A
函数可以减少代码的重复，使程序更加模块化
- B
在不同的函数中可以使用相同名字的变量
- C
函数体中如果没有return语句，也会返回一个None值
- D
调用函数时传入参数的顺序和函数定义时顺序一定相同
Python中只有一个字母的字符串属于字符类型。
- A) 正确
- B) 错误
type()可以查看变量的数据类型
- A) 正确
- B) 错误
def fun():
global x
x=x+1
x=0
fun()
print(x)
结果是 1
- A) 正确
- B) 错误
00001000>>3的结果是00000010
- A) 正确
- B) 错误
Python自带shell性能优于IPython。
- A) 正确
- B) 错误
通过下标索引可以修改和访问元组的元素。
- A) 正确
- B) 错误
在字典中，可以使用count方法计算键值对的个数。
- A) 正确
- B) 错误
使用下标可以访问字符串中的每一个字符。
- A) 正确
- B) 错误
每个if条件后面都要使用冒号
- A) 正确
- B) 错误
无论使用单引号还是使用双引号包含的字符，print打印输出的结果都是一样的。
- A) 正确
- B) 错误
在Python中，for循环可以遍历列表、字符串等任何序列
- A) 正确
- B) 错误
函数定义完后，系统会自动执行内部的功能。
- A) 正确
- B) 错误
浮点数1.2X表示105方法为1.2e5
- A) 正确
- B) 错误
列表的嵌套指一个列表的元素是另一个列表
- A) 正确
- B) 错误
while循环和if语句一样，都需要注意冒号和缩进
- A) 正确
- B) 错误
python自带的IDE是一个功能强大的IDE。
- A) 正确
- B) 错误
不带return的函数代表返回None。
- A) 正确
- B) 错误
def fun():
global x,y
t=x
x=y
y=t
x=0
y=1
fun()
print(x,y)
- A) 正确
- B) 错误
带有默认值的参数一定位于参数列表的末尾。
- A) 正确
- B) 错误
若a=2,b=1,那么（a or b）的值为1
- A) 正确
- B) 错误
Python中的条件语句有if语句和switch-case语句。
- A) 正确
- B) 错误
Python具有简单易学、可移植性强等优点，运行速度像C一样快。
- A) 正确
- B) 错误
无论程序是否捕获到异常，一定会执行finally语句。
- A) 正确
- B) 错误
函数体以冒号起始，并且是缩进格式。
- A) 正确
- B) 错误
比较运算符用于比较两个数，其返回的结果只能是Ture或False。
- A) 正确
- B) 错误
通过return结束函数，从而选择性的返回一个值给调用方。
- A) 正确
- B) 错误
如果希望循环是无限的，可以通过设置条件表达式永远为True来实现无限循环
- A) 正确
- B) 错误
如果except字句没有指明任何异常类型，则表示捕获所有异常。
- A) 正确
- B) 错误
center函数是返回一个宽度为width、原字符串居中、以fillchar填充左右两边。
- A) 正确
- B) 错误
要想使用with语句，前提是要有上下文管理器。
- A) 正确
- B) 错误
Python中所有的异常类都是的子类
-
填空一
- 填空一： Exception
若a=20,b=30,那么(a and b)的值为
-
填空一
- 填空一： 30
在函数内部定义的变量称为变量。
-
填空一
- 填空一： 局部
通过设置条件表达式永远为来实现无限循环
-
填空一
- 填空一： True
切片选取的区间是型的，不包含结束位的值
-
填空一
- 填空一： 左闭右开
Python的序列中不可变数据类型是
-
填空一
- 填空一： 字符串
在循环体中使用语句可以跳出循环体
-
填空一
- 填空一： break
若a=22,那么bin(a)的值为
-
填空一
- 填空一： 0b10110
下列程序的执行结果是：
def func():
x=200
def func2():
print(x)
func2()
x=100
func()
print(x)
-
填空一
- 填空一： 200,100
Python中用表示整数类型
-
填空一
- 填空一： int
当需要在字符串中使用特殊字符时，Python使用（）作为转义字符。
- A
/
- B
\
- C
#
- D
%
a=1
b="A"
print("|%3d|%3s|" %(a,b))
结果是：
- A
| 1|A |
- B
|1|A|
- C
|1| A|
- D
| 1| A|
题目：利用递归方法求5！。
'''
需求：利用递归方法求5！。
思路：递归公式：fn = fn_1*4!
'''
def fact(j):
sum = 0
if j == 0:
sum = 1
else:
sum = ______________
return sum
for i in range(5):
print ('%d! = %d' % (i,fact(i)))
- A
j * fact(j)
- B
(j-1) * fact(j - 1)
- C
j * fact(j - 1)
- D
(j+1) * fact(j + 1)
s=b"\x41\x42"
s=s+b"\x43"
print(s)
结果类型是：
- A
bytes
- B
str
- C
int
- D
不确定
执行下列操作后，b 的值为（）
a=[4,5,6]
b=a
a[2]=3
- A
[4,3,6]
- B
[4,5,6]
- C
[4,5,3]
- D
以上答案都不正确
下列选项中，用于触发异常的是（）
- A
catch
- B
try
- C
except
- D
raise
下列选项中，标识符合法的是
- A
2ndObj
- B
helloWorld
- C
hello#world
- D
^helloworld
题目：两个兵乓球队进行比赛，各出三人。甲队为a,b,c三人，乙对为x,y,z三人。以抽签决定比赛名单。有向队员打听比赛的名单。a说他不和x比，c说他不和x，z比，请编程找到三队赛手的名单。
'''
需求：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
思路：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。
'''
for i in range(ord('x'),ord('z') + 1):
for j in range(ord('x'),ord('z') + 1):
if i != j:
for k in range(ord('x'),ord('z') + 1):
if (i != k) and (j != k):
if (__________________________________________):
print( 'order is a -- %s\t b -- %s\tc -- %s' % (chr(i),chr(j),chr(k)))
- A
i != ord('x')) and (k != ord('x')) and (k != ord('z')
- B
i == ord('x')) and (k != ord('x')) and (k != ord('z')
- C
i != ord('x')) and (k == ord('x')) and (k != ord('z')
- D
i != ord('x')) and (k != ord('x')) and (k == ord('z')
已知a=10,b=20,c=30;以下语句执行后a,b,c的值为
if a<b:
c=a
a=b
b=c
- A
10,20,30
- B
20,10,10
- C
10,20,20
- D
20,10,30
题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。
x = int(input("input a number:"))
a = x // 10000
________________
c = x % 1000 // 100
d = x % 100 // 10
e = x % 10
if a != 0:
print ("there are 5 ",e,d,c,b,a)
elif b != 0:
print ("there are 4 ",d,c,b,a)
elif c != 0:
print ("there are 3 ",e,d,c)
elif d != 0:
print ("there are 2 ",e,d)
else:
print ("there are 1",e)
- A
b = x // 10000 // 1000
- B
b = x % 10000 // 1000
- C
b = x // 10000 % 1000
- D
b = x % 10000 % 1000
d={"Name":'xxx'}
d["Sex"]="male"
d["name"]="yyy"
print(d)
结果是
- A
{'name': 'yyy', 'Sex': 'male'}
- B
{'Name': 'yyy', 'Sex': 'male'}
- C
{'Name': 'xxx', 'Sex': 'male', 'name': 'yyy'}
- D
错误
输入一个字符串s,反向输出它，例如输入"abc"，输出"bca"
s=input()
__________
while i>=0:
print(s[i],end="")
print()
- A
i=len(s)
- B
i=len(s)-1
- C
i=len(s)+1
- D
都不对
题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示,60-80分之间的用B表示，60分以下的用C表示。
'''
需求：利用条件运算符的嵌套来完成成绩表。
思路：(a>b)?a:b这是条件运算符的基本例子。
'''
score = int(input('input score:'))
if score >= 90:
grade = 'A'
______________
grade = 'B'
elif score >= 70:
grade = 'C'
elif score >= 60:
grade = 'D'
else:
grade = 'E'
print ('%d belongs to %s' % (score,grade))
- A
elif score > 80:
- B
elif score <= 80:
- C
elif score < 80:
- D
elif score >= 80:
题目：将一个列表的数据复制到另一个列表中。
'''
将一个列表的数据复制到另一个列表里
'''
a = [1,2,3,4,5,6,7,8,9,0]
________
print(b)
- A
b = a[0:9]
- B
b = a[0:0]
- C
b = a[:]
- D
b = a
下列方法中，能够返回某个子串的字符串中出现次数的是（）
- A
index
- B
count
- C
length
- D
find
当try语句中没有任何错误信息时，一定不会执行（）语句。
- A
else
- B
finally
- C
except
- D
try
下列列表的说法，描述错误的是（）
- A
列表是一个有序集合，没有固定大小
- B
列表是不可变的数据类型
- C
列表可以存放任意类型的元素
- D
使用列表时，其下标可以是负数
st=[]
st.append({"name":"a","sex":"male"})
st.append({"name":"b","sex":"female"})
for s in st:
print(s["name"],s["sex"])
结果是
- A
a maleb female
- B
a male
- C
b female
- D
b femalea male
下列程序的输出结果为
for i in [0,1,2]
print(i)
- A
0
- B
1
- C
2
- D
0,1,2
- E
012
- F
0 1 2
题目：判断101-200之间有多少个素数，并输出所有素数。
'''
需求：判断101-200之间的所有素数，并输出
思路：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。
'''
h = 0
leap = 1
from math import sqrt
from sys import stdout
for m in range(0,201):
k = int(sqrt(m + 1))
for i in range(2,k + 1):
if______:
leap = 0
break
if leap == 1:
print ('%-4d' % m)
h += 1
if h % 10 == 0:
print ('')
leap = 1
print ('The total is %d' % h)
- A
m % i == 1
- B
m % i == 0
- C
i% m == 0
- D
i%m==1
下列选项中，符合Python命名规范的标识符的是
- A
if
- B
user-passw0rd
- C
setup.up
- D
_name
下列选项中，不属于Python语言特点的是？
- A
面向过程
- B
可移植性
- C
开源
- D
简单易学
def f(a,b):
t=a
a=b
b=t
a=1
b=2
f(a,b)
print(a,b)
结果是
- A
2 1
- B
1 2
- C
1 1
- D
2 2
题目：有5个人坐在一起，问第五个人多少岁？他说比第四个人大两岁。问第四个人岁数，他说比第三个人大两岁。问第三个人，又说比第二个人大两岁。问第二个人，说比第二个人大两岁。最后问第一个，他说是十岁。请问第五个人多大？
'''
需求：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？
思路：利用递归的方法，递归分为回推和递推两个阶段。要想知道第五个人岁数，需知道第四人的岁数，依次类推，推到第一人（10岁），再往回推。
'''
def age(n):
if n == 1:
c = 10
else:
______________
return c
print age(5)
- A
c = age(n-1) + 2
- B
c = age(n-1) + 1
- C
c = age(n-1) -1
- D
c = age(n) + 2
题目：利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。
'''
需求：利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。
'''
def output(s,l):
if l == 0:
return
print (s[l-1])
output(______)
s = input('Input a string:')
l = len(s)
output(s,l)
- A
l-1,s
- B
s,l+1
- C
s,l
- D
s,l-1
下列符号中，表示Python单行注释的是
- A
//
- B
#
- C
<!---->
- D
"""
创建自定义函数使用（）关键字
- A
function
- B
func
- C
def
- D
procedure
列表st=['a','b','c']，要删除'b'元素，正确的操作是
- A
st.remove(1)
- B
st.remove(2)
- C
del st[1]
- D
del st[2]
下列删除列表中最后一个元素的函数是（）
- A
pop
- B
del
- C
cut
- D
remove
for i in range(4):
for j in range(i,3):
if (i+j)%2==0:
print(i,j)
break
结果是
- A
1 12 2
- B
0 02 2
- C
0 01 1
- D
0 01 12 2
Python语言的特点
- A
解释性语言
- B
编译性语言
- C
解释与编译组合的语言
- D
自然语言
下列关于Python中的复数，描述错误的是
- A
虚部必须有小写的后缀j
- B
表示复数的语法是real + image j
- C
实部和虚部都是浮点数
- D
一个复数必须有表示虚部的实数和j
题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，有吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前天剩下的一半零一个。到第十天早上再想吃时，见剩下一个桃子了。求一天共摘了多少。
'''
需求：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
思路：采用逆向思维的方法，从后在往前推断
'''
x2 = 1
for day in range(9,0,-1):
___________________
x2 = x1
print x1
- A
x2 = (x1 + 1) * 2
- B
x1 = x2 * 2
- C
x1 = (x2 - 1) * 2
- D
x1 = (x2 + 1) * 2
st=[]
st.append({"name":"a","sex":"male"})
st.append({"name":"b","sex":"female"})
st[1]["age"]=23
for s in st:
print(s["name"],s["sex"],s["age"])
结果是
- A
a male Noneb female 23
- B
错误
- C
a male 0b female 23
- D
a male undefinedb female 23
a=0x12
print(a)
结果：
- A
0x12
- B
12
- C
0x
- D
18
使用（）关键字声明匿名函数。
- A
def
- B
func
- C
lambda
- D
print
for i in range(4):
if i%2==0:
print(i)
break
print(i)
结果是
- A
00
- B
01
- C
22
- D
02
下列数据中，不属于字符串的是（）
- A
“67nmkl”
- B
'wffff'
- C
hjk
- D
'''123'''
题目：有1、2、3、4个数字，能组成多少个相互不同且无重复的三位数？都是多少？
'''
可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条件的排列。
'''
for i in range(1,5):
for j in range(1,5):
for k in range(1,5):
if _________________:
print (i, j, k)
- A
(i != j) and (i != k) and (k != j)
- B
(i != j) && (i != k) &&(k != j)
- C
(i != j) or (i != k) or (k != j)
- D
(i != j) || d (i != k) || (k != j)
下列语句中，在Python中是非法的
- A
x , y =y , x
- B
x = y = z = 1
- C
x =(y = z + 1)
- D
x += y
Python中自定义函数的语法格式有
- A
def开头
- B
函数名圆括号后面冒号
- C
函数名不能以数字开头
- D
必须有return结束函数
以下是Python中时间日期格式化符号的
- A
Y%
- B
S%
- C
A%
- D
B%
以下用在Python循环语句中的是
- A
while
- B
for
- C
pass
- D
break
题目：一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
import math
for i in range(10000):
x = int(math.sqrt(i + 100))
y = int(math.sqrt(i + 168))
if ____________________________________:
print(i)
- A
(x * x == i + 100) and (y * y == i + 168)
- B
(x * x = i + 100) and (y * y = i + 168)
- C
(x * x == i + 100) && (y * y == i + 168)
- D
(x **2 == i + 100) and (y **2 == i + 168)
以下是Python中随机数函数的
- A
random.random()
- B
random.unifrom(a,b)
- C
random.randint(a,b)
- D
random.choice(sequence)
Python变量的类型包括
- A
数字类型
- B
字典类型
- C
字符串类型
- D
布尔类型
题目：一个球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
'''
需求：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
'''
Sn = 100.0
Hn = Sn / 2
for n in range(2,11):
_____________
Hn /= 2
print ('Total of road is %f' % Sn)
print ('The tenth is %f meter' % Hn)
- A
Sn = 2 * Hn
- B
Sn -= 2 * Hn
- C
Sn += 2 * Hn
- D
Sn = Sn+ 2 * Hn
下列表达式中，不是返回Ture的是
- A
Ture and False
- B
2!=2
- C
3>2>1
- D
a=2b=2a=b
python中列表的循环遍历有
- A
for
- B
at
- C
with
- D
while
关于函数的说法，正确的是（）
- A
函数可以减少代码的重复，使程序更加模块化
- B
在不同的函数中可以使用相同名字的变量
- C
函数体中如果没有return语句，也会返回一个None值
- D
调用函数时传入参数的顺序和函数定义时顺序一定相同
Python中只有一个字母的字符串属于字符类型。
- A) 正确
- B) 错误
type()可以查看变量的数据类型
- A) 正确
- B) 错误
def fun():
global x
x=x+1
x=0
fun()
print(x)
结果是 1
- A) 正确
- B) 错误
00001000>>3的结果是00000010
- A) 正确
- B) 错误
Python自带shell性能优于IPython。
- A) 正确
- B) 错误
通过下标索引可以修改和访问元组的元素。
- A) 正确
- B) 错误
在字典中，可以使用count方法计算键值对的个数。
- A) 正确
- B) 错误
使用下标可以访问字符串中的每一个字符。
- A) 正确
- B) 错误
每个if条件后面都要使用冒号
- A) 正确
- B) 错误
无论使用单引号还是使用双引号包含的字符，print打印输出的结果都是一样的。
- A) 正确
- B) 错误
在Python中，for循环可以遍历列表、字符串等任何序列
- A) 正确
- B) 错误
函数定义完后，系统会自动执行内部的功能。
- A) 正确
- B) 错误
浮点数1.2X表示105方法为1.2e5
- A) 正确
- B) 错误
列表的嵌套指一个列表的元素是另一个列表
- A) 正确
- B) 错误
while循环和if语句一样，都需要注意冒号和缩进
- A) 正确
- B) 错误
python自带的IDE是一个功能强大的IDE。
- A) 正确
- B) 错误
不带return的函数代表返回None。
- A) 正确
- B) 错误
def fun():
global x,y
t=x
x=y
y=t
x=0
y=1
fun()
print(x,y)
- A) 正确
- B) 错误
带有默认值的参数一定位于参数列表的末尾。
- A) 正确
- B) 错误
若a=2,b=1,那么（a or b）的值为1
- A) 正确
- B) 错误
Python中的条件语句有if语句和switch-case语句。
- A) 正确
- B) 错误
Python具有简单易学、可移植性强等优点，运行速度像C一样快。
- A) 正确
- B) 错误
无论程序是否捕获到异常，一定会执行finally语句。
- A) 正确
- B) 错误
函数体以冒号起始，并且是缩进格式。
- A) 正确
- B) 错误
比较运算符用于比较两个数，其返回的结果只能是Ture或False。
- A) 正确
- B) 错误
通过return结束函数，从而选择性的返回一个值给调用方。
- A) 正确
- B) 错误
如果希望循环是无限的，可以通过设置条件表达式永远为True来实现无限循环
- A) 正确
- B) 错误
如果except字句没有指明任何异常类型，则表示捕获所有异常。
- A) 正确
- B) 错误
center函数是返回一个宽度为width、原字符串居中、以fillchar填充左右两边。
- A) 正确
- B) 错误
要想使用with语句，前提是要有上下文管理器。
- A) 正确
- B) 错误
Python中所有的异常类都是的子类
-
填空一
- 填空一： Exception
若a=20,b=30,那么(a and b)的值为
-
填空一
- 填空一： 30
在函数内部定义的变量称为变量。
-
填空一
- 填空一： 局部
通过设置条件表达式永远为来实现无限循环
-
填空一
- 填空一： True
切片选取的区间是型的，不包含结束位的值
-
填空一
- 填空一： 左闭右开
Python的序列中不可变数据类型是
-
填空一
- 填空一： 字符串
在循环体中使用语句可以跳出循环体
-
填空一
- 填空一： break
若a=22,那么bin(a)的值为
-
填空一
- 填空一： 0b10110
下列程序的执行结果是：
def func():
x=200
def func2():
print(x)
func2()
x=100
func()
print(x)
-
填空一
- 填空一： 200,100
Python中用表示整数类型
-
填空一
- 填空一： int
使用（）关键字声明匿名函数。
- A
def
- B
func
- C
lambda
- D
print
题目：打印出如下图案（菱形） ：
*
***
*****
*******
*****
***
*
from sys import stdout
for i in range(4):
for j in range(2 - i + 1):
stdout.write(' ')
for k in range(______):
stdout.write('*')
for i in range(3):
for j in range(i + 1):
stdout.write(' ')
for k in range(4 - 2 * i + 1):
stdout.write('*')
- A
2 * i
- B
2 * i-1
- C
2 * i + 2
- D
2 * i + 1
for i in range(4):
if i%2==0:
print(i)
break
print(i)
结果是
- A
00
- B
01
- C
22
- D
02
创建自定义函数使用（）关键字
- A
function
- B
func
- C
def
- D
procedure
下列选项中，符合Python命名规范的标识符的是
- A
if
- B
user-passw0rd
- C
setup.up
- D
_name
以下程序的输出结果是（）
list_demo[1,2,3,4,5,6,'a','b','c']
print(list_demo[2],list_demo[7])
- A
2 a
- B
2 b
- C
3 b
- D
3 c
def f(*args,a):
print(a,args)
f(1,2,3)
结果是
- A
3 [1,2]
- B
3 (1,2)
- C
1 (2,3)
- D
错误
当需要在字符串中使用特殊字符时，Python使用（）作为转义字符。
- A
/
- B
\
- C
#
- D
%
下列程序的输出结果为
for i in [0,1,2]
print(i)
- A
0
- B
1
- C
2
- D
0,1,2
- E
012
- F
0 1 2
列表st=['a','b','c']，要删除'b'元素，正确的操作是
- A
st.remove(1)
- B
st.remove(2)
- C
del st[1]
- D
del st[2]
使用（）符号对浮点类型的数据进行格式化
- A
%s
- B
%d
- C
%f
- D
%c
字符串的strip方法的作用是（）
- A
删除字符串头部的指定字符
- B
删除字符串末尾的指定字符
- C
删除字符串头尾指定的字符
- D
通过指定分割符对字符串切片
x=float(input())
y=float(input())
m=y
if x>=m:
m=x
print(m)
那么m是x,y的______
- A
最小值
- B
最大值
- C
y
- D
x
下列选项中，幂运算的符号为
- A
++
- B
%
- C
**
- D
&
下列函数中，用于返回元组中元素最小值的是（）
- A
len
- B
max
- C
tuple
- D
min
下列选项中，不属于Python语言特点的是？
- A
面向过程
- B
可移植性
- C
开源
- D
简单易学
题目：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+222...2（此时共有5个数相加），几个数相加有键盘控制。
'''
需求：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。
思路：先计算出每一项的值。
'''
Tn = 0
Sn = []
n = int(input('n = :'))
a = int(input('a = :'))
for count in range(n):#先循环计算每一项的值
Tn = Tn + a
_______________
Sn.append(Tn)
print Tn
Sn = reduce(lambda x,y : x + y,Sn)#在计算和
print( Sn)
- A
a = a * 10
- B
a = a + 10
- C
a = a // 10
- D
a = a * *10
题目：输出9*9乘法口诀表。
'''
需求：99乘法口诀表
思路：分行与列考虑，共9行9列，i控制行，j控制列。
'''
for i in range(1,10):
______________________:
result = i * j
print ('%d * %d = % - 3d'% (i,j,result)) #循环的两个数相乘
print ('')#两个循环的间隔
- A
for j in range(10)
- B
for j in range(1,9)
- C
for j in range(9)
- D
for j in range(1,10)
print("Hi")
print("3*6")
程序输出结果：
- A
Hi 18
- B
Hi 3*6
- C
Hi3*6
- D
Hi18
题目：有一分数序列：2/1,3/2,5/3,8/5,13/8,21/13...求出这个数列的前20项之和。
a = 2.0
b = 1.0
s = 0.0
for n in range(1,21):
s += a / b
__________________
print( s)
- A
a,b = a , a + b
- B
b,a = a , a + b
- C
b,a = a , a- b
- D
b = a
已知a=10,b=20,c=30;以下语句执行后a,b,c的值为
if a<b:
c=a
a=b
b=c
- A
10,20,30
- B
20,10,10
- C
10,20,20
- D
20,10,30
下列符号中，表示Python单行注释的是
- A
//
- B
#
- C
<!---->
- D
"""
x=1
if x>=0:
print(-x)
else:
print(x)
结果：
- A
1
- B
0
- C
-1
- D
不确定
a=1
b="A"
print("|%3d|%3s|" %(a,b))
结果是：
- A
| 1|A |
- B
|1|A|
- C
|1| A|
- D
| 1| A|
def f(a,b):
t=a
a=b
b=t
a=1
b=2
f(a,b)
print(a,b)
结果是
- A
2 1
- B
1 2
- C
1 1
- D
2 2
关于抛出异常的说法中，描述错误的是（）
- A
显示的创建异常类的实例，可以使用raise直接引发
- B
当raise指定异常的类名时，会隐式的创建异常类的实例
- C
使用raise抛出异常时，无法指定描述信息
- D
不带参数的raise语句，只能引发刚刚发生过的异常
下列函数调用使用的参数传递方式是（）
result=sum(a,b,c)
- A
位置绑定
- B
关键字绑定
- C
变量类型绑定
- D
变量名称绑定
题目：判断101-200之间有多少个素数，并输出所有素数。
'''
需求：判断101-200之间的所有素数，并输出
思路：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。
'''
h = 0
leap = 1
from math import sqrt
from sys import stdout
for m in range(0,201):
k = int(sqrt(m + 1))
for i in range(2,k + 1):
if______:
leap = 0
break
if leap == 1:
print ('%-4d' % m)
h += 1
if h % 10 == 0:
print ('')
leap = 1
print ('The total is %d' % h)
- A
m % i == 1
- B
m % i == 0
- C
i% m == 0
- D
i%m==1
题目：利用递归方法求5！。
'''
需求：利用递归方法求5！。
思路：递归公式：fn = fn_1*4!
'''
def fact(j):
sum = 0
if j == 0:
sum = 1
else:
sum = ______________
return sum
for i in range(5):
print ('%d! = %d' % (i,fact(i)))
- A
j * fact(j)
- B
(j-1) * fact(j - 1)
- C
j * fact(j - 1)
- D
(j+1) * fact(j + 1)
for i in range(2):
print(i)
结果是
- A
012
- B
11
- C
01
- D
12
下列方法中，能够返回某个子串的字符串中出现次数的是（）
- A
index
- B
count
- C
length
- D
find
要把st变成st=['x','a','b']，那么操作是
st=['a','b']
_____
print(st)
- A
st.append('x')
- B
st.insert(1,'x')
- C
st.insert('x')
- D
st.insert(0,'x')
题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。
x = int(input("input a number:"))
a = x // 10000
________________
c = x % 1000 // 100
d = x % 100 // 10
e = x % 10
if a != 0:
print ("there are 5 ",e,d,c,b,a)
elif b != 0:
print ("there are 4 ",d,c,b,a)
elif c != 0:
print ("there are 3 ",e,d,c)
elif d != 0:
print ("there are 2 ",e,d)
else:
print ("there are 1",e)
- A
b = x // 10000 // 1000
- B
b = x % 10000 // 1000
- C
b = x // 10000 % 1000
- D
b = x % 10000 % 1000
下列关于Python的说法，错误的是
- A
Python是从ABC发展起来的
- B
Python是一门高级的计算机语言
- C
Python是一门只面向对象的语言
- D
Python是一门代表简单主义思想的语言
下列选项中，用于触发异常的是（）
- A
catch
- B
try
- C
except
- D
raise
d={"Name":'xxx'}
d["Sex"]="male"
d["name"]="yyy"
print(d)
结果是
- A
{'name': 'yyy', 'Sex': 'male'}
- B
{'Name': 'yyy', 'Sex': 'male'}
- C
{'Name': 'xxx', 'Sex': 'male', 'name': 'yyy'}
- D
错误
题目：打印出所有的“水印花数”，所谓“水印花数”是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个“水印花数”，因为153=1的三次方+5的三次方+3的三次方。
'''
需求：打印所有“水印数”，例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方
思路：利用for循环控制100-999个数，每个数分解出个位，十位，百位。
'''
for n in range(100,1000):
i = n // 100 #百位数
_________________ #十位数
k = n % 10 #个位数
if n == i ** 3 + j ** 3 + k ** 3:
print(n)
- A
j = (n / 10) % 10
- B
j = (n // 10) % 10
- C
j = (n % 10) % 10
- D
j = (n % 10) // 10
一元二次方程a*x*x+b*x+c=0的其中一个根是
- A
x=(-b+math.sqrt(b*b-4*a*c))/2*a
- B
x=-b+math.sqrt(b*b-4*a*c)/2*a
- C
x=(-b+math.sqrt(b*b-4*a*c))/2/a
- D
x=(-b+math.sqrt(b*b-4*a*c))*2/a
题目：一个五位数，判断他是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。
x = int(input("input a number:\n"))
x = str(x)
for i in range(len(x)/2):
if _______________:
print ('这不是一个回文数')
break
print ('这是一个回文数')
- A
x[i] != x[-i + 1]
- B
x[i] != x[i - 1]
- C
x[i] == x[-i - 1]
- D
x[i] != x[-i - 1]
题目：两个兵乓球队进行比赛，各出三人。甲队为a,b,c三人，乙对为x,y,z三人。以抽签决定比赛名单。有向队员打听比赛的名单。a说他不和x比，c说他不和x，z比，请编程找到三队赛手的名单。
'''
需求：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
思路：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。
'''
for i in range(ord('x'),ord('z') + 1):
for j in range(ord('x'),ord('z') + 1):
if i != j:
for k in range(ord('x'),ord('z') + 1):
if (i != k) and (j != k):
if (__________________________________________):
print( 'order is a -- %s\t b -- %s\tc -- %s' % (chr(i),chr(j),chr(k)))
- A
i != ord('x')) and (k != ord('x')) and (k != ord('z')
- B
i == ord('x')) and (k != ord('x')) and (k != ord('z')
- C
i != ord('x')) and (k == ord('x')) and (k != ord('z')
- D
i != ord('x')) and (k != ord('x')) and (k == ord('z')
题目：一个球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
'''
需求：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
'''
Sn = 100.0
Hn = Sn / 2
for n in range(2,11):
_____________
Hn /= 2
print ('Total of road is %f' % Sn)
print ('The tenth is %f meter' % Hn)
- A
Sn = 2 * Hn
- B
Sn -= 2 * Hn
- C
Sn += 2 * Hn
- D
Sn = Sn+ 2 * Hn
以下是Python函数类型的
- A
无参数有返回值
- B
有参数无返回值
- C
无参数无返回值
- D
有参数有返回值
下列表达式中，不是返回Ture的是
- A
Ture and False
- B
2!=2
- C
3>2>1
- D
a=2b=2a=b
python应用领域包括
- A
web应用开发
- B
游戏
- C
科学计算
- D
服务器软件
Python中在列表中增加元素的方法有
- A
append
- B
extend
- C
insert
- D
remove
以下用在Python循环语句中的是
- A
while
- B
for
- C
pass
- D
break
下列有关函数的说法中，错误的是（）
- A
函数的定义必须在程序的开头
- B
函数定义后需要调用才会执行
- C
函数定义后，其中的程序就可以自动执行
- D
函数体与关键字def必须左对齐
Python中在列表中删除元素方法有
- A
remove
- B
pop
- C
del
- D
sort
python中列表的循环遍历有
- A
for
- B
at
- C
with
- D
while
以下是字符串运算符的是
- A
*
- B
#
- C
in
- D
+
使用下标可以访问字符串中的每一个字符。
- A) 正确
- B) 错误
无论程序是否捕获到异常，一定会执行finally语句。
- A) 正确
- B) 错误
Python具有简单易学、可移植性强等优点，运行速度像C一样快。
- A) 正确
- B) 错误
在使用异常时必须先导入exceptions模块。
- A) 正确
- B) 错误
Python是开源的，简单易学，可以被移植到许多平台上。
- A) 正确
- B) 错误
00001000>>3的结果是00000010
- A) 正确
- B) 错误
元组使用圆括号存放元素，而列表使用方括号。
- A) 正确
- B) 错误
通过return结束函数，从而选择性的返回一个值给调用方。
- A) 正确
- B) 错误
Python的浮点数占2个字节
- A) 正确
- B) 错误
使用return语句可以返回函数值并退出函数。
- A) 正确
- B) 错误
在列表中查找元素可以用in和not in运算符
- A) 正确
- B) 错误
在字典中，可以使用count方法计算键值对的个数。
- A) 正确
- B) 错误
比较运算符用于比较两个数，其返回的结果只能是Ture或False。
- A) 正确
- B) 错误
在Python中，for循环可以遍历列表、字符串等任何序列
- A) 正确
- B) 错误
def fun(x):
x=x+1
x=0
fun(x)
print(x)
结果是 1
- A) 正确
- B) 错误
若使用字典中不存在的键访问值，程序会报错（keyerror）。
- A) 正确
- B) 错误
Python中只有一个字母的字符串属于字符类型。
- A) 正确
- B) 错误
Python中字符串的下标是从1开始的，并且标点不算。
- A) 正确
- B) 错误
所有的except子句一定在else和finally前面。
- A) 正确
- B) 错误
带有默认值的参数一定位于参数列表的末尾。
- A) 正确
- B) 错误
Python中可变数据类型有列表和字典。
- A) 正确
- B) 错误
PyCharm是开发Python的集成开发环境。
- A) 正确
- B) 错误
使用下标能够修改列表的元素
- A) 正确
- B) 错误
在if判断语句中，“判断条件”成立指的是判断结果为True
- A) 正确
- B) 错误
Python中的条件语句有if语句和switch-case语句。
- A) 正确
- B) 错误
默认情况下，参数值和参数名称是跟函数声明定义的顺序匹配的。
- A) 正确
- B) 错误
字典中的值只能是字符串类型。
- A) 正确
- B) 错误
def fun():
global x,y
t=x
x=y
y=t
x=0
y=1
fun()
print(x,y)
- A) 正确
- B) 错误
st=["a","b"]
st[0]="c"
print(st)
程序结果是：
['c','b']
- A) 正确
- B) 错误
函数体以冒号起始，并且是缩进格式。
- A) 正确
- B) 错误
在Python中表示空语句的是
-
填空一
- 填空一： pass
Python源代码被解释器转换后的格式为
-
填空一
- 填空一： 字节码
Python的序列中不可变数据类型是
-
填空一
- 填空一： 字符串
如果想在函数中修改全局变量，需要在变量的前面加上关键字。
-
填空一
- 填空一： global
在函数内部定义的变量称为变量。
-
填空一
- 填空一： 局部
如果将列表中的元素由大到小排列，需要将sort方法中的参数的值设为
-
填空一
-
填空二
- 填空一： reverse
- 填空二： True
Python中所有的异常类都是的子类
-
填空一
- 填空一： Exception
如果在没有的try语句中使用else语句，会引发语法错误
-
填空一
- 填空一： except
语句可以在循环体中跳出本次循环后面的代码，重新开始下一次循环
-
填空一
- 填空一： continue
若a=20,b=30,那么(a and b)的值为
-
填空一
- 填空一： 30
