【2023Python程序设计期末复习】选择题题型整理（带解析）

Lacszer

已于 2023-12-24 23:32:44 修改

阅读量4.3k

点赞数 33

文章标签： python

于 2023-12-22 23:25:39 首次发布

本文链接：https://blog.csdn.net/m0_50957668/article/details/135162882

版权

选择题

下列选项中，python 提供的内置数学类函数库是（）

A. turtle

B. requests

C. random
D. math

答案：D
解析：
turtle是海龟画图的函数库，我们的小学计算机课还有在教这玩意；
requests库是一个常用的 HTTP 请求库；
random库是一个随机数函数库

使用 While 循环语句时，如果想要使程序无限循环运行，则下列哪个选项可作为循环的条件判断语句（）

A. 3.1 < 2.3

B. 3.1 > 2.3

C. False

D. X = Y
```
答案：B
解析：
要使While语句无限循环，让While语句的循环条件保持为真即可，三个选项中只有B选项的逻辑永远为True
```

若 x 是一个浮点数，能得到 x 整数部分的表达式是（）

A. int(x)

B. int x

C. (int)x

D. ceil(x)

答案：A
解析：B和C并不是Python的语法，D是向下取整，但存在于math包中，正确语法应为math.ceil(x)

若有一个字符串 s='20200819'，下列选项中可以得到字符串‘2020’的表达式是（）

A. s[1:4]

B. s[:4]

C. s[0,4]

D. s[0,3]

答案：B
解析：本题考查字符串切片操作，
A选项的语法正确，但索引从1开始，提取到的字符串是020故错误；
CD选项语法错误，切片应该用:而不是,表示

以下字典变量的定义，错误的是（）

A. d = {'张三':1, '李四':2}

B. d = {1:[1,2], 3:[3,4]}

C. d = {[1,2]:1, [3,4]:3}

D. d = {(1,2):1, (3,4):3}

答案：C
解析：对于字典，每个键（key）必须是唯一且可哈希的对象，而值（value）可以是任意类型的对象，在C中，列表不能作为字典的键，因为列表不是可哈希的

运行以下程序，输出结果是（）

a = {1, 2, 3, 2, 1}
print(sum(a))

A. 9

B. 6

C. 3

D. 0

答案：B
解析：此题考察集合，题目中存在误导：{}在其他语言中是列表，故A选项具有迷惑性，在Pyhton语言中{}表示集合，集合的元素不会重复，因此实际上a内只有{1,2,3}，故求和后结果为B选项

运行以下程序，下列说法正确的是（）

a = 1
a = {'dj1':"A", 'jc2':"B"}
a['dj3'] = "C"
print(a)

A. 输出为 1

B. 输出为 {'dj1': 'A', 'jc2': 'B', 'dj3': 'C'}

C. 输出为 {'dj1':'A','jc2':'B'}

D. 输出为运行时出现错误提示

答案：B
解析：在字典中对一个字典中不存在的键进行赋值时，python会新建一个键值对并存入字典

len('123/n2') 的计算结果是（）

A. 3

B. 4

C. 5

D. 6

答案：D
解析：此题存在误导，如果将/n认为是\n（后者才是真正的换行符）可能会认为答案是C

若有函数定义def f(x, y=1, *z): print(x, y, z)，执行f(1, 2, 3, 4, 5)的结果是（）

A. 1 2 (3, 4, 5)

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

C. 1 2 3

D. 1 1 2

答案：A
解析：参数y为一个带默认值的参数，如果此处的参数被给出，则默认值失效；参数z为一个收集位置参数的元组，多出的多余参数会被合并成元组并被z接收

运行以下语句，输出的结果是（）

for i in 'Python':
	print(i,end=',')

A. P y t h o n

B. Python

C. P,y,t,h,o,n

D. P,y,t,h,o,n,

答案：D
解析：代码中`end=','`的意思是每次输出的末尾加上一个`,`，此时每次输出的元素只有遍历的单个字符，故结果中所有字符的后面都会有一个,

运行以下程序，下列说法正确的是（）

a = b = 3
a = 100
b = "你好"
print(a, b)

A. 输出为 3 3

B. 输出为 100 3

C. 输出为 100 你好

D. 运行时出现错误提示

答案：C
解析：此时a和b是不同的独立变量，后面的再次赋值和输出都没什么毛病

如果确定一个字符串 s 是否包含某个字符串 sub，下列选项中最合适的表达式是（）

A. s.index(sub)

B. str.index(sub)

C. str.find(sub)

D. s.findstr(sub)
```
答案：A
解析：需要确定s是否包含子串，必须引用s的成员函数，因此BC排除，D选项中的函数在python中不存在，因此选A
```
表达式 [1, 2, 3]*3 的执行结果为（）

A. [1, 2, 3, 1, 2, 3, 1, 2, 3]

B. [1, 2, 3]

C. [1, 2, 3], [1, 2, 3], [1, 2, 3]

D. [3, 6, 9]
```
答案：A
解析：本题展示的是python中list的运算特性，当对list进行乘法操作时，它会超级加倍:D
```
下列数据中属于列表的是（）

A. {11, 22, 33, 44，55}

B. ('a', 'b', 'c', 'd', 'e')

C. ['abd', 123, 3.14, 'A', 1]

D. "Python, Hello, 23er"
```
答案：C
解析：A是集合，B是元组，C是列表，D是字符串
```

运行以下Python代码时，如果你准备通过键盘输入的数字是-2，那么运行程序后得到的结果是（）

r = float(input("请你输入一个数字："))
if r >= 0:
    s = 3.14 * r * r
    print(s)
else:
    print("请输入一个正数！")

A. 6.28

B. 12.56

C. 请输入一个正数！

D. 程序无法得到正确结果

答案：C
解析：请输入一个正数！
别在酒吧点炒饭:(

运行下列代码时如果你输入的数字依次是4、5、6，那么程序运行结果是（）

a=input("请你输入一个数字：")
b=input("请你输入一个数字：")
c=input("请你输入一个数字：")
if a < b:
    a = b
if a < c:
    a = c
print(a)

A. 4

B. 5

C. 6

D. 以上都有可能

答案：C
解析：首先排除D，这不是量子编程，走个捷径，不管前面有没有被赋值a都一定小于c，那最后a=c一定执行

数学式(2a-b)/(2a+b)在Python中的正确写法是

A. (2*a-b)/(2a+b)

B. (2*a-b)/2*a+b

C. (2a-b)/(2a+b)

D. (2*a-b)/(2*a+b)
```
答案：D
解析：和2黏一起的全排除，不用括号的一眼假
```

为表示“a和b都不等于0”，应使用的Python语言表达式是（）

A. (a!=0)and(b!=0)

B. a or b

C. !(a=0) and (b!=0)

D. a 并且 b

答案：A
解析：B选项里其中一个等于0表达式仍然可以为True；C里混进去一个赋值语句，判断等于应该是==而不是=；D这面向自然语言编程太抽象了，谁选D我笑谁

以下程序输入5的运行结果是（）

import math
b = input("输入一个整数")
print(math.sqrt(b))

A. 出错

B. 2

C. 2.23606797749979

D. 5

答案：A
解析：想不到吧！输入的数据会被input读取为string而不是int，哥们在这等着坑你呢:D

以下程序段的输出结果是（）

for i in 'xyzabcxyz':
    print(i,end='')
    if i=='c':break

A. xyzabcxyz

B. xyzabxyz

C. xyzabc

D. xyzab

答案：C
解析：由于对c这个字符的判断在输出之后，所以会输出一次c然后停止循环

以下程序的输出结果是（）

def f(b=2, a=4):
        global z
        z += 3*a + 5*b
        return z
z = 10
print(z, f(4, 2))

A. 10 36

B. 32 32

C. 36 36

D. 10 32

答案：A
解析：首个输出是10，因为此时函数还未被调用执行；由于z在函数内被声明为全局变量，因此首个输出后10被参与运算，注意此处a和b的位置和传参的位置，实际上a传入的是2，b传入的是4，因此第二个输出是36

下面程序的运行结果是（）

x,y,z=10,15,5
if x>y:
    x,y=y,x
if x>z:
     x,z=z,x
if y>z:
    y,z=z,y
print("{}<{}<{}".format(x,y,z))

A. 5<10<15

B. {}<{}<{}

C. {5}<{10}<{10}

D. 15<10<5

答案：A
解析：首先输出字符串内的{}是变量的占位符，不会被输出，因此排除BC，这个程序的作用是通过互换把xyz按从小到大排序，因此选A，不过这py的互换属实简单，过程搞跟三仙归洞一样的

若有列表t1=[1,8]，t2=[9,2]，则 t1+t2 的值是

A. [10,20]

B. [1,2,8,9]

C. [1,8,9,2]

D. [9,8,2,1]

答案：C
解析：此题考查list的加法运算，很简单，就是把他们连起来，没了

运行以下程序的输出结果是（）

s=0
for i in range(1,10,6):s+=i
print(s)

A. 0

B. 8

C. 17

D. 55

答案：B
解析：此段代码中range的意义是：从1开始，每次加6，直到超过10为止，因此循环到的i有1,7两个取值

运行以下语句，输出的结果是（）

a = [6,1,3,4]
print(sorted(a,reverse = True))

A. [1, 3, 4, 6]

B. [6, 1, 3, 4]

C. [6, 4, 3, 1]

D. [4, 3, 1, 6]

答案：C
解析：sorted函数是排序函数，故BD这种乱序的排除，指定了reverse参数为True，则表示逆向排序（默认是正序，即从小到大），因此选择C

已知列表 lst 中有一组整数，要将所有为奇数的元素置 0，所有为偶数的元素保持不变，生成新一个列表，以下列表推导式正确的是（）

A. [0 for i in lst if i%2!=0]

B. [i for i in lst if i%2==0 ]

C. [0 for i in lst if i%2!=0 else i]

D. [0 if i%2!=0 else i for i in lst]
```
答案：D
解析：A选项是首先筛选出奇数，再把奇数全部置为0，但生成的列表中没有偶数项；B选项和A选项类似，但是只筛出了偶数项，生成的列表没有奇数项；C选项语法错误，如果有else应该像D这样写
```

下面程序运行结果是（）

list1=['alibaba','tencent','baidu']
list2=[857,345,692]
print(max(list1),min(list2))

A. tencent 345

B. alibaba 857

C. baidu 692

D. tencent 857

答案：A
解析：对于字符串会按字典序和字符串的长度来排序，老生常谈的规则了

下面if语句统计满足“性别 (gender) 为男、职称(rank) 为副教授、年龄(age)小于40岁”条件的人数，正确的语句为（）

A. if(gender=="男" or age<40 and rank=="副教授"): n+=1

B. if(gender=="男" and age<40 and rank=="副教授"): n+=1

C. if(gender=="男" and age<40 or rank=="副教授"): n+=1

D. if(gender=="男" or age<40 or rank=="副教授"): n+=1
```
答案：B
解析：题目很长但是很简单，三个愿望同时满足肯定要都用and
```

运行以下程序，输出结果是（）

a=[10,1,100,1000]
b=sorted(a,reverse=True)
print(b)

A. [10,1,100,1000]

B. [1000, 100, 10, 1]

C. [1,10,100,1000]

D. [1000, 100, 1, 10]

答案：B
解析：和上面的25题逆序排序异曲同工，懒得多写一遍了，哥们打字也是按时间算钱的:P，自己网页ctrl f找吧

以下程序的运行结果是：（）

a,b=23,48
print("%d+%d=%f" %(a,b,a+b))

A. 出错

B. 23+48=71

C. 23+48=71.000000

D. 23.0000+48.0000=71.000000

答案：C
解析：老生常谈的格式控制字符，%f表示浮点小数，%d代表整数

以下程序段中的 print(i) 执行了（）次

for i in range(10):
        print(i)
        i+=2

A. 10

B. 9

C. 6

D. 5

答案：A
解析：就是问你循环了几次，无脑填10

对于字符串 s='storybook'，以下可得字符串 'or' 的表达式是（）

A. s[3:4]

B. s[3:5]

C. s[2:3]

D. s[2:4]

答案：D
解析：考的字符串切片，记住前面是包含的后面是不包含的[)关系就行，还有索引从0开

以下程序段的输出结果是（）

for i in range(3,9):
    if i%2 == 0:
        continue
    print(i,end =' ')

A. 3 5 7 9

B. 3 5 7

C. 3

D. 3 4 5 6 7 8 9

答案：B
解析：程序目的是筛选奇数，同时注意range也是[)的关系，前包后不包

运行以下语句，输出的结果是（）
```
f=[{'name':'zs','age':20},{'name':'ls','age':30},{'name':'ww','age':25}]
fs = sorted(f,key = lambda x:x['age'])
print(fs)
```
A. [{'age': 20,'name': 'zs' }, { 'age': 25,'name': 'ww' }, {'age': 30,'name': 'ls' }]

B. [{'name': 'zs', 'age': 20}, {'name': 'ww', 'age': 25}, {'name': 'ls', 'age': 30}]

C. [{'age': 30, 'name': 'ls'}, {'age': 25,'name': 'ww' }, {'age': 20,'name': 'zs' }]

D. 关于此，我确信已发现了一种美妙的选项，可惜这里空白的地方太小，写不下
```
答案：B
解析：这是一个套着字典的列表，lambda表达式的意思是将这些玩意按字典里的age键来排序，也就是自定义排序规则，排序排的是字典整体不会动到里面的顺序
```

运行时输入数据为：96,则下面程序的运行结果是（）

n=int(input("输入2位数的整数："))
k=n%10*10+n//10
print(k)

A. 96

B. 9 6

C. 0

D. 69

答案：D
解析：这个程序的目的是用数学手段将个位十位互换，其中//表示整除

关于字典中元素”键”和”值”，以下说法正确的是（）

A. ”值”允许重复，但”键”必须是唯一的。

B. ”键”允许重复，但”值”必须是唯一的。

C. ”键”不能是整数，但”值”允许是整数。

D. ”键”和”值”都允许重复
```
答案：A
解析：纯理论我没骚话可以扯，背就完事了
```
为了判定整型变量 age 是否大于 18 并且小于 22 ，以下表达式错误的是

A. 18 < age < 22

B. age > 18 and age < 22

C. 22 > age > 18

D. age > 18 and < 22
```
答案：D
解析：D这个一眼错，没有编程语言会用这样抽象的规则
```

对于正确的表达式 a[2]，a 不可能是（）

A. 列表

B. 元组

C. 字典

D. 集合

答案：D
解析：列表和元组都支持下标访问，字典和集合都不支持，但是为啥字典可以呢？字典相信大家都很熟悉，但是字典不是正确答案是怎么回事呢，下面就让小编带大家一起了解吧。
字典可以，其实是因为那个2可以是个键，比如{2:'value'}，大家可能会很惊讶，但是就是这么一回事，小编也感到很惊讶

运行以下代码的输出结果是（）

for i in range(6):
    if i % 2 == 0: continue
    elif i % 3:
        print(i,end=' ')
        break
    else:
        print('end')

A. 1

B. 1 end

C. 1 5 end

D. 1 5

答案：A
解析：和C语言一样，1可以在Python内被表示为True，当刚开始循环时，1 % 3 = 1为 True，于是直接输出并中断循环

有程序如下，请问输出结果为（）

k = 100
def fun():
  k = 50
fun()
print("k2:", k)

A. 100

B. 50

C. k:100

D. k2:100

答案：D
解析：函数里的k是局部变量，不影响外面作为全局变量的k，因此函数无效

下面程序运行结果是（）

l1 = [11, 22, 33]
l2 = [22, 33, 44]
l3=[]
for i1 in l1:
    for i2 in l2:
        if i1 == i2:
                l3.append(i1)
print(l3)

A. [11, 22, 33, 44]

B. [22, 33]

C. [11, 44]

D. [22, 33, 44]

答案：B
解析：上面程序的作用是找l1l2里的相同元素，将它添加进l3内

已知 x=2;y=3 ,复合赋值语句 x*=y+5 执行后，x 变量中的值是（）

A. 11

B. 16

C. 13

D. 26
```
答案：B
解析：难得来个小学数学题，(3+5)*2=16，小学3年级都会算
```

下面代码实现的功能描述的是（）

def fun(n):
    if n==0:
        return 1
    else:
        return n * fun(n-1)
num =eval(input("请输入一个整数："))
print(fun(abs(int(num))))

A. 接受用户输入的整数n，输出n绝对值的阶乘值

B. 接受用户输入的整数n，判断n绝对值是否是素数并输出结果

C. 接受用户输入的整数n，判断n绝对值是否是水仙花数并输出结果

D. 接受用户输入的整数n，判断n绝对值是否是完数并输出结果

答案：A
解析：难得来个算法相关，多bb一点
简单入门算法里看到递归一眼阶乘了都不用过多少脑子；
素数判断的朴素算法可能还能和递归沾点边，它的辨识特征是对1和2的特判，此处没有因此pass；
水仙花数涉及每位数的判断，此处没看到提取单个数码的语句，因此pass；
完数，完数是一个纯粹数学家很喜欢的完美的数值，估计他们看它的眼神都像看涩图，咳咳，一个数恰好等于它的真因子之和，此处没看到因子分解，故pass

Python 语句 f= lambda x，y:x* y;f(12, 34) 的程序运行结果是（）

A. 12

B. 22

C. 56

D. 408

答案：D
解析：lambda这玩意能不能理解全靠个人理解能力了，这里只能告诉你这是一个函数的简洁写法，函数的功能是x*y，因此结果是12*34

字典对象的（）方法返回字典的“值”列表

A. values()

B. keys()

C. items()

D. sort()

答案：A
解析：
values 
/ˈvæljuːz/
n.价值观;(商品)价值;(与价格相比的)值，划算程度;用途;积极作用
v.重视;给…估价;给…定价;珍视
value的第三人称单数和复数

输入d后程序运行的结果是：（）

a=input("输入一个字母：")
print("%d"%ord(a))

A. d

B. D

C. 100

D. 出错

答案：C
解析：python我也不精，这函数我是真没见过，但是根据选项可以猜出来这玩意大概是把字母转为ascii码，d对应100，没毛病
有小键盘的可以按住alt然后小键盘打个100看看，有惊喜

Python 中，for 和 while 可以有 else 语句？（）

A. for 和 while 都没有 else 语句

B. for 和 while 都可以有 else 语句。

C. 只有 for 才有 else 语句。

D. 只有 while 才有 else 语句。
```
答案：B
解析：就算不懂python也知道这俩连体婴儿，有肯定都有，else好像用来判断循环是否正确结束用的，用的不经常没怎么记
```

阅读下列程序, 运行时输入3 4 5，则输出结果（）

from math import *
a1,a2,a3 =map(int,input('输入a,b,c空格隔开:').split())
s=(a1+a2+a3)/2
s=sqrt(s*(s-a1)*(s-a2)*(s-a3))
print("%.2f %.2f %.2f %-10.3f"%(a1,a2,a3,s))

A. 3.00 4.00 5.00 6.000

B. 3 4 5 6

C. 3.0 4.0 5.0 6.0

D. 出错无法运行

答案：A
解析：本题考查格式控制字符的运用，这里.2是保留两位小数，不对，知道这点就能选到正确答案了，这题选项不够给力啊

若执行语句b=[2*x for x in range(10,30,10)]，b的结果是

A. [10, 20, 10, 20]

B. [10, 20, 30, 10, 20, 30]

C. [20, 40]

D. [20, 40, 60]

答案：C
解析：这段程序的意思是从10开始，到30之前每次+10的x值乘2放入列表内，那就只有10和20，分别乘2后就是20和40

已知列表 x=[1,2,3]，那么执行语句 x.insert(1，4) 后，x 的值是

A. [1, 2, 3, 4]

B. [4, 2, 3]

C. [1, 4, 2, 3]

D. [4, 1, 2, 3]
```
答案：C
解析：这题重点在4插入的位置，索引从1开始，因此4会插在第二个位置
```
若已执行import math,可用于计算方程a*x*x+b*x+c=0一个实根的是（）

A. x=(-b+sqrt(b*b-4*a*c))/2/a

B. x=-b+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
```
答案：C
解析：无奖问答，在座诸位大学生有几个还记得这个-b+-√b^2-4ac/2a这个不知道初中还是高中的知识点
```
若执行语句 b=[x for x in a if x % 2 == 1] 后 b 为 [7, 1, 3]，则 a 可能是（）

A. [7,4,5,1,6,3]

B. [3,6,7,2,1,8]

C. [8,7,2,1,3,5]

D. [6,7,2,1,3]
```
答案：D
解析：根据if表达式可以看出，b是a中筛出的所以奇数，因此a除了7,1,3外不能有任何奇数
```

若有字符串 s='程序设计Python'，能得到字符串 'Python' 的是

A. s[4:9]

B. s[8:14]

C. s[-1:-7]

D. s[-6:]

答案：D
解析：此题考查负索引切片，负索引是从右往左索引，从-1开始，如s[-7]代表'计'，因此C选项多切了一个

下列程序运行后，在键盘输入100，则程序的运行结果是（）

x = eval (input('Please input x:'))
if x<0 or x>=20:
    print(x//10)
elif 0<=x<5:
    print(x)
elif 5<=x<10:
    print(3*x-5)
elif 10<=x<20:
    print(0.5*x-2)

A. 10

B. 100

C. 295

D. 48

答案：A
解析：100>=20，故执行第一个分支

当元组中只有一个元素时，下面哪个语句表达是正确的（）

A. a=(‘abc’)

B. a=(‘abc’,)

C. a=()

D. a=(1)

答案：B
解析：python的元组本体好像是这个逗号，没有逗号的单个括号括起的东西不能算元组

下列选项中，使用随机数的Python标准库是（）

A. turtle

B. requests

C. random

D. math

答案：C
解析：温故知新了属于是，第一题就给过解析
random:
adj. 随机的，随意的;大小不一的，规格不一的，无规则的;（人）辨认不出的，不认识的;<口>与众不同的，出人意料的;仰角发射的;不受管束的
n. 任意行动，随机过程;>印>（排字工人的）斜面改样工作台
adv. 胡乱地，任意地，规格不一地

若有字符串 s = '20' ，则 s * 3 的值是

A. '60'

B. '202020'

C. 60

D. 202020

答案：B
解析：字符串必须用引号括起，所以CD排除，字符串和list一样，本体乘法就是超级加倍而不是数学运算

已知 x = [1, 2, 3, 2, 3]，执行语句 x.remove(2) 之后，x的值是

A. [1, 3, 3]

B. [1, 3, 2, 3]

C. [1, 2, 2, 3]

D. [1, 2, 3, 3]
```
答案：B
解析：remove函数会移除从左到右找到的第一个匹配元素，因此第一个出现的2被移除
```
对于for i in s:......语句，以下说法不正确的是（）

A. 如果s为字典，则该循环执行时，i取值会对字典中的每个键值对进行遍历

B. 如果s为列表，则该循环执行时，i取值会对列表中的每个元素进行遍历

C. 如果s为字符串，则该循环执行时，i取值会对字符串中的每个字符进行遍历

D. 如果s为集合，则该循环执行时，i取值会对集合中的每个元素进行遍历
```
答案：A
解析：对于字典，for-each循环会遍历字典的所有键，如果需要对值进行操作你得自己上
```

若 list=['Python ', ' Java', 'Html', 'C++']，则 list[-2] 的值是（）

A. Java

B. Python

C. C++

D. Html

答案：D
解析：list的负数索引表示从右往左遍历，从-1开始，则-2索引指向的就是Html

给出如下代码 s = 'PyThon is beautiful!' 可以输出 ”python” 的是（）

A. print(s[:–14])

B. print(s[0:6])

C. print(s[0:6].lower)

D. print(s[-20:-14].lower())

答案：D
解析：注意需要输出的是小写，除了切片正确外还需要将其转换为小写，啊前两个压根没操作啊那没事了；lower是个函数，因此C也排除，最后就剩个D，都不用验证切片逻辑了直接无脑选

指令 print(“{:*^21,.3f}”.format(1234567890.1278)) 执行结果为

A. ****1234567890.128***

B. ^^^^1234567890.12^^^^

C. **1,234,567,890.128**

D. **1,234,567,890.127**

答案：C
解析：此处不仅考核了格式控制字符，还考核了，呃，这算啥来着，前后加修饰字符的偷懒方法
先看.3f，表示保留三位小数，B可以滚蛋了，然后看*^2，表示只有两个*，A也可以领盒饭了，最后看CD，D没保留小数（保留的同时需要四舍五入），于是选C

Python 语句 fl=lambda x:x*2; f2= lambda x:x**2;print(fl(f2(2))) 的程序运行结果为（）

A. 2

B. 4

C. 6

D. 8

答案：D
解析：又是lambda表达式，还套两个，还只在一句里写，难度++
可以得知f2的效果是给参数开平方，f1的效果是参数x2，于是2^2*2 = 8
顺带一提在python中可以用**来表示幂

以下选项中，作为函数定义开头部分有错误的是（）

A. def vfunc(a,b = 2 ):

B. def vfunc (a, b):

C. def vfunc(c,*a, b):

D. def vfunc(a, *b):

答案：C
解析：怎么有个写C语言的偷偷混进来在这里放了个指针
A是参数默认值，没毛病，B更没毛病了，D里末尾的*b表示多余参数的元组处理，可以且只能在末尾

运行以下语句，输出的结果是（）

def demo (a,b,c=7,d=10):
    return a+b+c+d
print(demo(1,2,3,4),end=',')
print(demo(1,2,d=3))

A. 20,13

B. 20,16

C. 10,16

D. 10,13

答案：D
解析：第一次调用全给了值，就按给的值来，因此答案为10
第二次调用c没给，c会按默认值赋值为7，因此答案为1+2+7+3=13

Lacszer

关注

33
点赞
踩
60

收藏

觉得还不错? 一键收藏
2
评论
【2023Python程序设计期末复习】选择题题型整理（带解析）

仅供班级复习使用，无含金量
复制链接

扫一扫

【2023Python程序设计期末复习】选择题题型整理（带解析）

选择题

“相关推荐”对你有帮助么？