一、单选题
1、运行如下Python代码，若输入整数3，则最终输出的结果为？（ ）
def f(x):
if x==1:
s=1
else:
s=f(x-1)*x
return s
n=int(input("请输入一个大于1的整数："))
print(f(n)+f(n-1))A、2
B、4
C、8
D、16
解析：
根据题目给出的Python代码，该代码定义了一个递归函数f(x)，当x等于1时，s赋值为1，否则s为f(x-1)*x。然后，代码接收用户输入的一个大于1的整数n，并打印f(n)和f(n-1)的和。
如果我们输入整数3，那么：
- f(3)的计算过程为：f(3) = f(2) * 3 = f(1) * 2 * 3（因为f(2)会调用f(1)的结果）。
- f(2)的计算过程为：f(2) = f(1) * 2。
- f(1)的计算结果为1（因为直接返回s的值）。
所以，f(3) = 1 * 2 * 3 = 6。同时，f(2) = f(1) * 2 = 1 * 2 = 2。因此，f(3) + f(2) = 6 + 2 = 8。最终输出的结果为8，对应选项C。
2、运行下列python程序，输出的结果是？（ ）
def fun(x): if x > 3: return x * fun(x-1) else: return x print(fun(6))
A、120
B、360
C、720
D、60
解析：
此程序是一个递归函数。对于给定的输入6，程序首先检查x是否大于3，如果是，则执行递归调用fun(x-1)，并乘以当前的x值。这个过程重复直到x不再大于3，此时函数返回当前x的值。因此，对于输入6，递归过程如下：
fun(6) = 6 * fun(5)
= 6 * (5 * fun(4))
= 6 * (5 * (4 * fun(3)))
= 6 * (5 * (4 * (3))) // 因为当x=3时，直接返回x的值，不再递归
= 6 * 5 * 4 * 3 = 360
所以输出结果为360，选项B是正确的。
3、下列关于递归的描述不正确的是？（ ）
A、
递归函数一定包含if语句
B、
递归函数体内一定包含调用自身的语句
C、
在调用自身函数时需要明确的边界终止条件与边界值
D、 递归算法一般代码简洁，执行效率高，空间复杂度低
解析：
对于选项D，递归算法虽然可以使代码更简洁，但执行效率不一定高，并且空间复杂度也不一定低。递归算法在执行时需要进行栈操作来保存中间结果，如果递归层次过深，可能会导致栈溢出。因此，选项D描述不正确。
4、运行下列Python程序，输出的结果是？（ ）
def fun(a, n): s = 0 for i in range(1, n+1): temp = str(a)*i s += int(temp) return s print(fun(1, 3))
A、3
B、6
C、12
D、123
解析：
在这个Python程序中，定义了一个函数fun(a, n)，该函数的功能是将数字a重复n次并求其和。具体过程如下：
- 初始化变量s为0，用于存储求和的结果。
- 使用for循环，从1到n（包括n）进行迭代。
- 在每次迭代中，将数字a转换为字符串并重复i次，得到字符串temp。
- 将字符串temp转换回整数并加到s上。
- 返回求和结果s。
运行程序时，传入的参数是a=1和n=3。程序会计算1x1+1x2+1x3的结果，即计算得到的结果是：1 + 11 + 111 = 123。所以输出的结果是D选项，即123。
5、运行下列python程序，输出的结果是？（ ）
def fun(a, b):
s = 0
a = a[::-1]
for i in range(len(a)):
s += int(a[i])*b**i
return s
print(fun('45', 16))A、69
B、45
C、64
D、61
解析：
这段Python代码定义了一个函数fun，它接受两个参数a和b。函数首先将字符串a反转，然后通过循环遍历反转后的字符串中的每个字符，并将其转换为整数，再乘以b的相应幂次（从b^0到b^(len(a)-1)），最后将所有乘积相加得到结果。在这个例子中，输入是字符串'45'和整数16，因此函数会计算4*16^1 + 5*16^0，即64 + 5 = 69。因此，输出结果是69，选项A是正确的。
6、一个荷花池，第一天荷花开放得很少，第二天开放的数量是第一天的两倍，之后的每一天，荷花都会以前一天两倍的数量开放。如果到第30天，荷花就开满了整个池塘，设第一天开一朵，编程求第30天共开了多少朵荷花。下面空白处的python代码填写正确的是？（ ）
s = 0 t = 1 for i in range(1, ① ): s += t ② print(s)
A、
30, t = t*2
B、 31, t = t*2
C、
31, t+=2
D、
30, t*=2
解析：
根据题目描述，这是一个典型的等比数列问题，荷花每天开放的数量是前一天的2倍，构成了一个等比数列。我们知道第30天荷花池开满了，也就是说第30天的荷花数量是整个荷花池的总数。假设第一天开一朵荷花，那么这是一个首项为1，公比为2的等比数列。
我们可以使用Python的等比数列求和公式来计算第30天的荷花总数，公式为：S = a1 * (1 - r^n) / (1 - r)，其中a1是首项，r是公比，n是项数。在这个例子中，a1=1, r=2, n=30。计算得到第30天的荷花总数是 2^30 - 1。由于题目中说第30天荷花开满整个池塘，所以第30天的荷花数量应该等于 2^30 - 1 或更大。因此空白处应该填写 31 来表示循环的次数（从第1天到第30天），并且使用 t *= 2 来表示每天荷花数量的翻倍。所以正确的答案是B选项。
7、解决下列问题时，时间复杂度最大的是？（ ）
A、
输入n个不同的包含两位小数的实数，计算这n个数的和
B、
在n个数据中，查找数据k
C、 将n个数据用冒泡排序实现排序
D、
计算算式1-2+3-4+...-n的结果，n为偶数
解析：
对于这四个问题，我们可以分别分析它们的时间复杂度：
A. 输入n个不同的包含两位小数的实数，计算这n个数的和。这个问题的时间复杂度是O(n)，因为要遍历所有的数进行加法操作。
B. 在n个数据中，查找数据k。这个问题的时间复杂度在最坏情况下是O(n)，因为可能需要遍历整个数据集进行比较。
C. 将n个数据用冒泡排序实现排序。冒泡排序的时间复杂度是O(n^2)，因为它需要多次遍历数据集并进行比较和交换。
D. 计算算式1-2+3-4+…-n的结果，n为偶数。这个问题的时间复杂度是O(n)，因为需要遍历每个数进行运算。
因此，时间复杂度最大的是C，即使用冒泡排序对n个数据进行排序。
8、以下关于分治算法的描述正确的是？（ ）
A、
各个子问题既相互独立又相互联系
B、 问题可以分解成若干个规模较小的相同问题
C、
可以直接对问题进行求解
D、
子问题的解不能合并成原问题的解
解析：
分治算法是一种将大问题分解为小问题，然后解决小问题，最后将小问题的解合并成大问题的解的算法。因此，选项B“问题可以分解成若干个规模较小的相同问题”是正确的描述。选项A虽然子问题之间有联系，但并不是分治算法的必要条件；选项C与分治算法的定义不符，因为分治算法并不直接对问题进行求解；选项D与分治算法的基本思想相违背，因为子问题的解是可以合并成原问题的解的。
9、下列选项中哪一项使用了分治算法？（ ）
A、 二分搜索
B、
选择搜索
C、
插入搜索
D、
顺序搜索
解析：
二分搜索是一种典型的分治算法。它的基本思想是将待搜索的数据分成两部分，如果目标值在中间值附近，就直接确定目标值所在的范围；否则，就排除目标值不可能存在的部分，然后在剩余的部分中继续搜索，直到找到目标值或者确定目标值不存在为止。因此，选项A中的二分搜索使用了分治算法。选项B的选择搜索、选项C的插入搜索和选项D的顺序搜索都没有使用分治算法。
10、不超过20个元素的降序数列，使用对分查找能找到指定的元素，可能的查找次数不包括？（ ）
A、3
B、4
C、5
D、6
解析：
二分查找是一种在有序数组中查找特定元素的搜索算法。在二分查找中，每次比较都会将搜索范围缩小一半。对于不超过20个元素的降序数列，最坏情况下需要比较的次数取决于数列的长度和元素的位置。由于是对降序数列进行查找，查找次数通常会比升序数列多一些。对于长度为20的数列，最坏情况下可能需要比较6次才能找到指定的元素（如果元素不在数列中，需要比较到最末尾）。因此，可能的查找次数不包括的第7次为正确答案，即选项D。
11、下面python程序段的输出结果是？（ ）
def add_Run(L=None):
if L is None:
L = ['Lying']
else:
L.append('Run')
return L
add_Run()
print(add_Run())
print(add_Run(['Lying']))A、
['Lying']
['Run']
B、
['Lying']
['Lying']
['Lying', 'Run']
C、 ['Lying'] ['Lying', 'Run']
D、
[]
['Lying', 'Run']
解析：
首先，我们来分析给定的Python程序段。程序定义了一个名为add_Run的函数，该函数接受一个列表L作为参数。如果L是None，则默认创建一个包含'Lying'的列表。否则，向列表L中添加'Run'。接下来，我们逐行分析程序的执行过程：
add_Run()：调用函数add_Run，由于没有传入参数，因此会创建一个包含'Lying'的列表并返回。此时输出为['Lying']。print(add_Run())：再次调用函数add_Run，由于没有传入参数，同样会创建一个包含'Lying'的列表并返回。因此输出仍为['Lying']。此时没有添加'Run'。print(add_Run(['Lying']))：这次调用函数时传入了一个包含'Lying'的列表作为参数。因此，函数会将'Run'添加到该列表中，并返回更新后的列表。输出为['Lying', 'Run']。
综上所述，程序的输出结果为：
- 第一次调用输出：
['Lying'] - 第二次调用输出（打印结果）：
['Lying'] - 第三次调用输出（打印结果）：
['Lying', 'Run']
因此，正确答案是C选项。
12、下面关于计数器的python程序，输出结果正确的是？（ ）
count = 0
def increment():
global count
count += 1
print("计数器的值：", count)
increment()
increment()
increment()A、 计数器的值： 1 计数器的值： 2 计数器的值： 3
B、
计数器的值：0
计数器的值：1
计数器的值：2
C、
计数器的值： 1
计数器的值： 1
计数器的值： 1
D、
计数器的值：3
解析：
在Python中，当使用global关键字声明变量时，意味着该变量是全局变量，可以在函数内部和外部共享。在这个程序中，count是一个全局变量，初始值为0。每次调用increment()函数时，count都会增加1并打印出来。因此，连续调用三次increment()函数后，计数器的值会依次增加，输出为：计数器的值：1，计数器的值：2，计数器的值：3。所以，选项A是正确的。
13、下列Python程序段的输出结果是？（ ）
L = []
x = 3
def test(x):
L.append(x)
x = 5
test(x)
print('L = {}, x = {}'.format(L, x))A、 L = [3], x = 3
B、
L = [5], x = 5
C、
L = [3], x = 5
D、
L = 3, x = 5
解析：
在Python中，变量L是一个列表，用于存储元素。函数test中的局部变量x在函数被调用时传入值3，并将其添加到列表L中。然后，函数内部对局部变量x重新赋值为5，但这不会影响全局变量x的值。因此，当函数执行完毕后，全局变量x仍然为3，而列表L包含了一个元素3。因此，程序的输出结果是：‘L = [3], x = 3’，答案为A。
14、以下Python程序，运行程序输出结果正确的是？（ ）
def demo(x): return x*2 print(demo(demo(1)))
A、
return None
B、2
C、4
D、8
解析：
根据题目给出的Python程序，首先调用demo函数并将1作为参数传入，得到返回值2。然后，再将得到的返回值2作为参数传入demo函数，得到返回值4。因此，程序的输出结果是4，所以正确答案是C。
15、Python使用下列哪个函数接收用户输入的数据？（ ）
A、
accept()
B、 input()
C、
print()
D、
login()
解析：
在Python中，用于接收用户输入数据的函数是input()，而不是accept()、print()或login()。因此，正确答案是B。
16、下面Python程序段的输出结果正确的是？（ ）
def power(): x ='python' y = 'world' z = x + " " + y return z print(power())
A、z
B、
x + " " + y
C、 python world
D、
python" "world
解析：
Python程序段定义了一个名为power的函数，在这个函数中，首先将字符串’python’赋值给变量x，将字符串’world’赋值给变量y。然后，使用加号+将两个字符串连接在一起，并在中间添加一个空格，形成新的字符串’python world’，赋值给变量z。最后，函数返回这个新字符串。因此，当调用这个函数并打印其返回值时，输出应该是’python world’，选项C正确。
17、下列关于Python函数的描述中，不正确的是？（ ）
A、
自定义函数时用到的关键字是def
B、 在python函数中，至少有一条return语句
C、
函数print（）可以一次输出多个参数，如print('1',"2",3,[4])
D、
用函数eval（）可以用于求字符串里表达式的值，如eval（'3+5-1'）
解析：
在Python函数中，并不要求必须有return语句。如果没有显式的return语句，函数会默认返回None。因此，选项B描述不正确。其他选项A、C、D都是正确的描述。
18、关于以下Python代码的描述中，正确的是？（ ）
#求两个正方形的面积差 def MianJiCha(a,b): s=a**2-b**2 return s a=5 b=10 c=MianJiCha(b,a)+a
A、 代码运行后，变量c的值是80
B、
函数名是MianJiCha(a,b)
C、
可以用MianJiCha(100)的形式调用此函数
D、
代码运行时会报错
解析：
对于此Python代码的描述，我们来逐一分析各个选项：
A. 代码运行后，变量c的值是80。根据代码逻辑，首先计算两个正方形的面积差，然后将结果加上a的值赋给变量c。当a=5，b=10时，MianJiCha(b,a)的结果是25（因为正方形面积计算公式为边长的平方），再加上a的值（即加上5），得到的结果是30，而不是80，所以选项A描述错误。
B. 函数名是MianJiCha(a,b)。这个描述是正确的，函数名确实是MianJiCha，并且它接受两个参数a和b。
C. 可以用MianJiCha(100)的形式调用此函数。这个描述是正确的，只要传入两个参数，就可以调用该函数。
D. 代码运行时会报错。根据提供的代码，代码本身没有语法错误，可以正常运行，不会报错。所以选项D描述错误。
综上，正确的选项是B和C。但由于参考答案给出的是A，可能与实际代码逻辑不符，因此正确答案应为B和C（如果考虑所有描述的正确性）。
19、下列关于Python函数的说法中，错误的是？（ ）
A、
利用函数可以降低编程复杂度，增加代码可读性
B、
函数可以重复调用
C、
函数可以降低修改代码的工作量
D、 调用函数时，每次都必须输入相同的参数值
解析：
选项A、B和C都是关于Python函数的正确说法。函数确实可以降低编程复杂度，增加代码可读性，并且可以被重复调用，从而降低修改代码的工作量。然而，选项D的说法是错误的。在Python中，调用函数时，参数的值是可以变化的，不一定每次都必须输入相同的参数值。
20、下列选项中，调用下列代码定义的函数时，程序会报错的是？（ ）
def ShuChu(a,b,c):
print(c,b,a)
A、
ShuChu('1','2','3')
B、
ShuChu('1','2','3,4')
C、
ShuChu(1,2,3)
D、 ShuChu(1,2,3,4)
解析：
根据给出的函数定义 def ShuChu(a,b,c):，该函数只接受三个参数。选项D中的函数调用 ShuChu(1,2,3,4) 提供了四个参数，因此会报错。其他选项中的函数调用都符合函数定义的参数数量，所以不会报错。
21、下列选项中，调用以下代码定义的函数时，程序会报错的是？（ ）
def kp(a,b,c):
print(a,b,c)
A、 kp(1,b=2,3)
B、
kp(a=3,b=1,c=2)
C、
kp(1,2,3)
D、
kp(1,b=2,c=3)
解析：
在Python中，函数参数传递时，如果同时使用了位置参数和关键字参数，那么关键字参数必须在位置参数之前。选项A中的函数调用方式不符合这个规则，因此程序会报错。具体来说，函数定义中的参数顺序是a、b、c，但在选项A的调用中，参数b和c的位置被错误地放在了第一个参数的位置。因此，选项A的函数调用会报错。选项B、C和D都是正确的函数调用方式，不会引起程序报错。
22、下列Python代码的输出结果是？（ ）
>>>s=lambda m,n:m*n
>>>s(6,6)
A、6
B、
6,6
C、36
D、12
解析：
该Python代码中定义了一个lambda函数s，它接受两个参数m和n，并返回它们的乘积。当调用函数s(6,6)时，传入参数为m=6和n=6，因此返回的结果是6乘以6等于36。所以，正确答案是C，即输出结果为36。
23、以下函数定义错误的选项是？（ ）
A、
def aFunc(m,n):
print(m,n)
B、
def aFunc(m,n=2):
print(m,n)
C、 def aFunc(*m,n): print(m,n)
D、
def aFunc(m,*n):
print(m,n)
解析：
在Python中，函数定义时，参数前的"“表示该参数为可变数量的参数，通常用于接收任意数量的位置参数，并将它们存储为元组。但在选项C中，”"放在了参数"m"前面，这是不正确的，应该放在参数"n"前面，表示"n"是一个可变参数。因此，选项C的函数定义是错误的。选项A、B和D的函数定义都是正确的。
24、用于安装Python第三方库的工具是？
A、
install
B、 pip
C、
Wheel
D、
setup
解析：
在Python中，用于安装第三方库的工具是pip（Python包管理器）。其他选项如install、Wheel和setup都不是用于安装Python第三方库的专门工具。因此，正确答案是B。
25、编程时，如果只需要导入某第三方库中的某个成员，需要使用到的关键字是？（ ）
A、 from
B、
as
C、
into
D、
inport
解析：
在Python编程中，如果只需要导入某第三方库中的某个成员，需要使用到的关键字是"from"。例如，如果想要导入math库中的sqrt函数，可以使用"from math import sqrt"这样的语句。因此，选项A是正确的。选项B的"as"是用于给导入的成员或者模块起别名，选项C和D都不是Python中的关键字。
二、判断题
26、若某个问题既能用递归算法求解，又能用递推算法求解，则使用递归方法求解更容易，效率也高得多。（ ）
A 正确
B 错误
解析：
这个问题涉及到递归和递推两种算法的效率比较。递归算法在某些情况下可以使问题分解得更简单，但在递归过程中会产生额外的函数调用栈，可能会增加时间和空间复杂度。递推算法则是一种逐步推导的方法，通常更容易理解和实现。对于特定问题，哪种算法更有效取决于问题的特性和数据的规模。因此，不能一概而论地认为递归方法总是更容易且效率更高。
27、如下代码因为递归的边界条件设置错误，产生了无限递归程序报错。（ ）
def fun(n): if n > 10: return 0 else: return n + fun(n-1) print(fun(10))
A 正确
B 错误
解析：
在给出的代码中，递归函数 fun(n) 的边界条件是 if n > 10，这意味着当 n 大于 10 时，函数会返回 0。但实际上，递归应该有一个明确的终止条件来避免无限递归。在这个例子中，边界条件设置得不正确，因为当 n 等于 10 时，函数仍然会进行递归调用 fun(n-1)，导致无限递归，程序会报错。因此，该代码会产生无限递归并导致程序报错，答案为错误（B）。
28、算法的时间复杂度与空间复杂度没有必然关系。（ ）
A 正确
B 错误
解析：
算法的时间复杂度和空间复杂度是算法的两个重要指标，但它们之间没有必然的关系。时间复杂度主要关注算法的运行速度，而空间复杂度主要关注算法在运行过程中所需的额外空间。一个算法的时间复杂度低并不意味着其空间复杂度也低，反之亦然。因此，这个说法是正确的。
29、已知有n本按照书名拼音排序好的图书，使用对分查找法搜索其中任何一本书，最多查找次数为4次，则n的值有可能为10。（ ）
A 正确
B 错误
解析：
使用对分查找法搜索排序好的图书时，最多查找次数为4次，意味着数据范围已经被划分为2^4=16份。因此，最多能容纳的图书数量为16本。所以，当n为10时，有可能在最多4次查找内找到目标图书，但n的值不可能为10本身。因此，该说法错误。
30、函数定义语句def f(c=1,d=2,a,b):是正确的，因为默认值形参要放在前面。（ ）
A 正确
B 错误
解析：
在Python中，函数定义时参数的定义顺序并不要求默认值形参必须放在前面。定义函数时，首先会按照参数列表的顺序来定义参数，无论是否有默认值。因此，函数定义语句def f(c=1,d=2,a,b):是正确的，但仅仅是因为Python允许这种语法，而不是因为默认值形参必须放在前面。所以题目的说法是错误的。
31、return语句可以返回任何数据类型的值，包括整数、浮点数、字符串、列表、元组、字典等。（ ）
A 正确
B 错误
解析：
在Python中，return语句确实可以返回任何数据类型的值。这意味着你可以从函数返回一个整数、浮点数、字符串、列表、元组或字典等。因此，该说法是正确的。
32、
def ZiDian(**kwargs): print(kwargs) ZiDian(a=1)
运行上面的Python代码后，输出结果为{'a':1}。（ ）
A 正确
B 错误
解析：
在Python中，**kwargs用于捕获传入的任意数量的关键字参数，并将它们存储在一个字典中。当你调用ZiDian(a=1)时，它实际上会创建一个字典{'a': 1}并将其传递给函数内部的kwargs。因此，函数内部的print(kwargs)会输出{'a': 1}，与题目中的描述相符。所以，输出结果{‘a’:1}是正确的。
33、以下Python代码可以正常运行,输出8。（ ）
def qh(a,b=3): print(a+b) qh(b=2,6)
A 正确
B 错误
解析：
在Python中，函数参数有默认值和位置参数之分。对于给出的函数qh(a, b=3)，b有一个默认值3，但a没有默认值。当调用函数qh(b=2, 6)时，将b设为2，但忽略了a，导致函数试图访问未定义的变量a，这将引发一个错误。因此，该代码无法正常运行并输出8，答案是B。
34、python代码>>>lambda:x=2,y=3:x+y 的运行结果是5。（ ）
A 正确
B 错误
解析：
该Python代码片段使用了lambda表达式来创建一个匿名函数，但是存在语法错误。在Python中，lambda表达式只能包含一个表达式，不能包含赋值语句（如x=2）。因此，代码片段"lambda:x=2,y=3:x+y"是不合法的，无法成功运行。因此，该代码片段的运行结果不是5，答案是错误（B）。
35、使用pip install --upgrade numpy命令能够升级numpy科学计算库。（ ）
A 正确
B 错误
解析：
在Python中，使用pip命令来管理Python包是常见的做法。pip install --upgrade numpy这个命令的作用是升级numpy库。因此，该说法是正确的。
三、简答题
36、数的分解
给出一个正整数a，要求分解成若干个正整数的乘积，即a=a1×a2×a3×...×an，并且1<a1≤a2≤a3≤...≤an，问这样分解的种类有多少。注意到a=a也是一种分解。
例如，8可以分解成8=2*2*2,8=2*4,8=8总共3种。
python代码如下，完善划线处的代码：
def fun(x, y=2): if x == 1: global ans ① for i in range(y, x+1): if ② : fun(x//i,i) lst = [2, 8, 9, 20] #测试数据 for i in lst: ans = 0 ③ print(ans)
程序运行结果如下：
1 3 2 4
参考答案：
① ans += 1
② x % i == 0 且 i <= x
③ fun(i)
解析：
这是一个关于数的分解的问题，目的是计算一个正整数可以分解成多少个不同的乘积组合。根据题目描述和提供的Python代码，我们可以逐步解析并填充划线处的代码。
-
对于①处，当递归到基情况时，即x=1时，我们需要增加分解的种类数量。这里使用全局变量ans来记录种类数量，所以应该填写“ans += 1”。
-
对于②处，我们需要判断当前的i是否可以作为分解的一个因子。根据题目要求，分解的因子应该是递增的，并且能整除x。所以条件应该是“x % i == 0 且 i <= x”。
-
对于③处，我们需要对每一个可能的分解因子i进行递归处理。处理的方式是调用函数本身，继续分解x//i这个数值。所以应该填写“fun(i)”来调用函数计算分解的种类数量。
综上，完善后的代码应该如下：
def fun(x, y=2):
global ans
if x == 1:
ans += 1 # 当x=1时，增加分解的种类数量
for i in range(y, x+1):
if x % i == 0 and i <= x: # 判断i是否可以作为分解的一个因子
fun(x//i, i) # 对每一个可能的分解因子i进行递归处理
lst = [2, 8, 9, 20] # 测试数据
for i in lst:
ans = 0 # 每次测试前重置ans为0
fun(i) # 调用函数计算分解的种类数量
print(ans) # 输出结果
37、购物组合
小明单位发了100元的购物卡，小明到超市买三类洗化用品：洗发水（15元）、香皂（2元）、牙刷（5元）。要把100元正好花掉，可有哪些购买组合？
def gouwu(money):
for i in range(0,money//15+1):
for j in range(0,money//2+1):
for k in range(0, ① ):
if ② :
print('可选择的购买组合:\t购买洗发水 {} 瓶，香皂 {} 块，牙刷 {}个。'.format( ③ ))
gouwu(100)
参考答案：
① money//5+1
② i15 + j2 + k*5 == 100
③ i, j, k
解析：
这是一个关于购物组合的问题，小明有100元的购物卡，需要在超市购买三类洗化用品：洗发水、香皂和牙刷，并且要把这100元正好花完。我们需要找出所有可能的购买组合。
首先，我们需要确定购买每种商品的最大数量。洗发水的最大数量取决于能购买多少瓶15元的洗发水，香皂的最大数量取决于能购买多少块2元的香皂，牙刷的最大数量取决于能购买多少个5元的牙刷。这些最大数量可以通过整除运算得到，例如money//15得到洗发水的最大数量。因此，①处应填写money//5+1，表示牙刷的最大数量。
然后，我们需要一个循环来遍历所有可能的购买组合。对于每一种购买组合，我们需要检查是否正好花费了100元。因此，②处应填写条件判断语句i15 + j2 + k*5 == 100，表示购买的洗发水、香皂和牙刷的总价是否等于100元。
最后，如果找到了一个合适的购买组合，我们就打印出来。因此，③处应填写i、j和k的值，表示购买的洗发水、香皂和牙刷的数量。在print语句中，我们使用format方法来格式化输出。
38、回文素数
回文素数是指一个不小于11的自然数n从左向右和从右向左读，其结果值相同且是素数，即称n为回文素数。一种求解的方法是先判断一个自然数是否为回文数，再判断它是否为素数。如果两个判断都成立，则该自然数是回文素数。请补全python代码，找出自然数1000以内的所有回文素数。
#判断是否为素数
def ① (n):
for i in range(2,n):
if ② :
break
else:
return True
#判断是否为回文数
def HuiWenShu(n):
n=str(n)
if n== ③ :
return True
else:
return False
for i in range(11,1001):
if ZhiShu(i)==True ④ :
print('{}是回文素数！'.format(i))
参考答案：
① def ZhiShu(n):
② n % i == 0
③ n[::-1] （或者可以使用 str(n)[::-1]）
④ and HuiWenShu(i)
解析：
- 对于第一个空，我们需要定义一个判断素数的函数，函数名可以是
ZhiShu，参数是待判断的数n。所以填写def ZhiShu(n):。 - 在判断素数的函数中，我们需要用一个for循环来判断n是否为素数。如果n能被除了1和它本身之外的数整除（即
n % i == 0），则n不是素数，跳出循环。如果循环结束都没有找到能整除n的数，那么n是素数，返回True。所以填写n % i == 0。 - 对于判断回文数的函数
HuiWenShu，我们需要将输入的数转换为字符串，然后比较字符串和其反转是否相同。Python中字符串反转可以使用[::-1]操作，所以填写n[::-1]或str(n)[::-1]。 - 在主循环中，我们先判断一个数是否为素数，然后再判断它是否为回文数。两个条件都需要满足，所以应该使用逻辑与操作符
and连接两个判断条件，即ZhiShu(i)==True and HuiWenShu(i)。因此填写and HuiWenShu(i)。
喵呜刷题：让学习像火箭一样快速，快来微信扫码，体验免费刷题服务，开启你的学习加速器！
