题库
判断题

下面Python程序是错误的（T）

s="hello python!"
s[5]="I”



Python 3.x默认使用ASCII编码（F）


3+4j不是合法的Python表达式（F）


Python字典和集合属于无序序列（T）


Python中“4”+“6”的结果为“10”（F）


Python 3.X完全兼容Python 2.X（F）


Python中的元组是不可变的（T）


Python中，转义字符以“\”开头（T）


char是Python不支持的数据类型（T）


Python程序设计语言的标识符对大小写不敏感，python和Python是两个相同的名字（F）


使用Python内置的open函数打开某个文件的时候，如果该文件不存在，则可能产生异常。所以一定要使用try except对其进行处理（F）


print是Python的关键字（F）


Python语言的输出函数是input（F）


Python 函数名与变量命名规则一样（T）


python的函数只能有一个返回值（F）


列表对象是可变对象 （T）


只有Python扩展库才需要导入以后才能使用其中的对象，Python标准库不需要导入即可使用其中的所有对象和方法（F）


Python中类的属性一般来说是通过类名来访问，通过对象名无法访问类的属性（F）


Python中，一个对象只能有一个实例变量（F）


面向对象是基于面向过程的（T）


Python在类定义中，隐藏对象的细节称为实例化（F）


Python中一切内容都可以称为对象（T）


对于Python类中的私有成员，可以通过对象名._类名__私有成员名的方式来访问（T）


在Python中，可以为自定义类的对象动态增加新成员（T）


Python列表长度可变，列表对象可以直接修改（T）


Python中基类object提供了一系列可以用于实现同类对象进行“比较”的方法，可以用于同类对象的不同实例进行比较，包括__lt、gt、le、ge()、eq和ne__六个方法，又称为“富比较”(“rich comparison”)方法（T）


在 Python 中,对象的属性必须在构造方法内初始化（F）


Python 中任何数值都是对象，整数 2、字符串’hello’等都是对象（T）


在Python循环中，对于带有else子句的循环，如果因为执行了break语句而退出的话，会执行else子句的代码（F）


选择题


给出如下代码 s = 'PyThon is beautiful!' 可以输出“python”的是（C）
A.print(s[:–15])
B.print(s[0:6])
C.print(s[0:6].lower())
D.print(s[–20: –15].lower)


关于Python语言的描述正确的是:Python是一种（D）
A.操作系统
B.数据库管理系统
C.结构化查询语言
D.高级程序设计语言


用户程序编写的Python程序，无需修改就可以在任何支持Python的平台上运行，这是Python的（ C）特性
A.面向对象
B.可扩展性
C.可移植性
D.可嵌入性


设s="Python Programming",那么print(s[-5:])的结果是（C）
A.Python i
B.mmin o
C.mming
D.Pytho


Python语句s='hello';print(s[1:3])的运行结果是（C）
A.hel
B.he
C.el
D.ell


Python字符串变量s的值是"Python 网络爬虫"，哪个选项是s[-9: 9].split()的值（C）
A.{'thon', '网络'}
B.'thon 网络'
C.['thon', '网络']
D.以上选项都不正确


下面一段代码的输出结果为（C）
info = {1: '小明', 2: '小黄', 3: '小兰'}
name1 = info.get(4, '小黄')
name2 = info.get(1)
name3 = info.get(3, '小明')
print(name1, name2, name3, sep=',')

A.小黄,小明,小明
B.小兰,小明,小兰
C.小黄,小明,小兰
D.小明,小明,小兰


以下代码的输出结果是（C）
def fun(n):
    if n==1 or n==2:
        res = 1
    else:
        res = fun(n-1)+fun(n-2)
    return res

print(fun(5))

A.2
B.3
C.5
D.8


函数定义中的第一行称为函数（A）
A.头
B.块
C.返回
D.参数


（C）函数是指直接或间接调用函数自身的函数。
A.匿名
B.lambda
C.递归
D.闭包


Python定义函数时，（A）参数类型。
A.不需要声明
B.必须声明（必须指定）
C.可声明也可不声明
D.设置


以下关于函数说法中正确的是（D）
A.函数的实际参数和形式参数必须同名
B.函数的形式参数既可以是变量也可以是常量
C.函数的实际参数不可以是表达式
D.函数的实际参数可以是其他函数的调用


关于函数的参数，以下选项中描述错误的是‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬（C）
A.一个元组可以传递给带有星号的可变参数
B.在定义函数时，可以设计可变数量参数，通过在参数前增加星号（*）实现
C.可选参数可以定义在非可选参数的前面
D.在定义函数时，如果有些参数存在默认值，可以在定义函数时直接为这些参数指定默认值


Python函数的定义如下：
#定义函数
def fun(a, b, c):
    print(a, b, c)

下面哪个函数调用形式不正确（D）
A.fun(1,2,3)
B.fun(1, b=2, c=3)
C.fun(1, c=2, b=3)
D.fun(1,a=2,b=2)


在一个函数中如局部变量与全局变量同名，则（A）
A.局部变量屏蔽全局变量
B.全局变量屏蔽局部变量
C.局部变量和全局变量都不可使用
D.程序出错，不能运行


阅读下面的代码，分析其执行结果（）
def demo(a, b, c=3, d=100):
    return sum((a, b, c, d))
print(demo(1, 2, 3, 4), end=',')
print(demo(1, 2, d=3))

A.106,9
B.106,6
C.10,6
D.10,9


执行下面代码的结果是（B）
def n(a,b):
    a=a**3
    b=b**3
    return a,b
def m(x=n(10,2),y=n(5,1)):
    return x+y
print(m())

A.((1000, 8), (125, 1))
B.(1000, 8, 125, 1)
C.(1008, 126)
D.1008126


print(type(lambda:3))的输出结果是（A）
A.<class 'function'>
B.<class 'int'>
C.<class 'NonType'>
D.<class 'float'>


Python 语句
f1=lambda x:x*2
f2=lambda x:x**2
print(f1(f2(2)))

的程序运行结果是（D）
A.2
B.4
C.6
D.8


下列Python语句的输出结果是 （C）
d=lambda p:p*2
t=lambda p:p*3
x=2
x=d(x)
x=t(x)
x=d(x)
print(x)

A.2
B.4
C.24
D.12


下列Python语句的输出结果是（A）
i= map(lambda x: x**2, (1, 2, 3))
for t in i:
    print(t,end=" ")

A.1 4 9
B.2 4 6
C.1 2 3
D.9


执行如下语句，执行结果为（A）
add=lambda x,y:x+y
print(add(1,2),add('1','2'))

A.3 12
B.12 3
C.3，12
D.报错


Python的设计具有很强的可读性，相比其他语言具有的特色语法有以下选项，不正确的是（D）
A.交互式
B.解释型
C.面向对象
D.服务端语言


下列选项中,不属于Python特点的是（B）
A.面向对象
B.运行效率高
C.可移植性
D.免费和开源


面向对象程序设计的三大特点包括：封装、继承和（A）
A.多态
B.结构
C.模板
D.泛型


Python是一种面向（B）的语言
A.过程
B.对象


以下不属于面向对象语言的是（D）
A.Python语言
B.Java语言
C.C++ 语言
D.C语言


Python语言中，运算对象最好都为整数的运算符是（C）
A.*
B./
C.//
D.%


python中，字符串对象的join方法用于将序列中的元素以指定的字符连接生成一个新的字符串，那么下列说法正确的是（B）
A.语句print(''.join('a','b')) 将打印出：ab
B.语句print(''.join(['a','b'])) 将打印出：ab
C.语句print(''.join([1,2,3])) 将打印出：123
D.语句print(''.join({1,2,3})) 将打印出：123


python内置函数( )可以返回列表、元组、字典、集合、字符串以及range对象中元素的个数（D）
A.length()
B.count()
C.size()
D.len()


Python 类中包含一个特殊的变量（A），它表示当前对象自身，可以访问类的成员。
A.self
B.me
C.this
D.there


以下代码段的运行结果的是（A）
for i in range(1, 4):
    for j in range(1, 4):
        if j%2 == 0:
            break
        print("{:3d}".format(i*j), end='')
    if i%2 == 0:
        break

A.1 2
B.1 2 3
C.1 2 3 2 4 6 3 6 9
D.没有正确答案


以下程序的运行结果是 （D）
i = 1
s = 0
while i < 10:
    if i % 2 == 0:
        continue
    else:
        s = s + i
    i = i + 1
print(s)

A.25
B.1
C.0
D.程序是个死循环，无输出


Python中的注释符号#和‘''的区别，以下说法正确的是（C）
A.'''和#在使用时需要在开头与结尾都标注
B.二者无区别
C.'''为多行注释，#为单行注释
D.以上都不对


有两个人做猜数字游戏，只有7次猜的机会，如果其中一个人猜的数字比另一个人预设的数字大，则会得到反馈“猜大了”，如果猜的数字比预设数字小，则会得到反馈“猜小了”，猜中了会得到反馈“你赢了“，如果7次都没有猜中，则会得到反馈“你输了”。仔细阅读下面这段代码，小明猜的数字分别为：35 10 14 16 28 25 23，请问小明共有几次猜大，几次猜小，最终有没有猜对（A）
count =1
a=2
b=4
while True:
      number=a**2+b**2+a*b/2+a*b%2
      guess=int(input())
      if guess>number:
            print("猜大了")
      elif guess<number:
            print("猜小了")
      elif guess==number:
            print("你赢了")
            break
      count=count+1
      if count>10:
           print("你输了") 
           break

A.没有猜对，猜大了3次，猜小了4次
B.猜对了，猜大了2次，猜小了3次
C.没有猜对，猜大了5次，猜小了2次
D.猜对了，猜大了1次，猜小了1次


函数题
7-1 使用面向对象的方法求长方形的周长
class Shape:
    def __init__(self, numLong, numWide):
        self.numLong = numLong
        self.numWide = numWide
    def commitAllLong(self):
        return (self.numLong + self.numWide) * 2
nums = input()
numList = nums.split()
numLong = float(numList[0])
numWide = float(numList[1])
s = Shape(numLong, numWide)
aLong = s.commitAllLong()
print("%.2f" % aLong)

7-2 优异生查询(类和对象)
class Student:
    def __init__(self, name, mscore, cscore, escore):
        self.name = name
        self.mscore = mscore
        self.cscore = cscore
        self.escore = escore
    def getSum(self):
        self.count = float(self.mscore) + float(self.cscore) + float(self.escore)
        return self.count
    def getBest(self):
        print(self.name, self.mscore, self.cscore, self.escore)
lst = []
classList = []
lst = []
for i in range(4):
    itemList = input().split()
    lst.append(itemList)
for i in range(len(lst[0])):
    stuList = []
    for j in range(4):
        stuList.append(lst[j][i])
    stu = Student(stuList[0], stuList[1], stuList[2], stuList[3])
    classList.append(stu)
maxStu = classList[0]
for stu in classList:
    if stu.getSum() > maxStu.getSum():
        maxStu = stu
maxStu.getBest()