一、问答题
（1）使用函数的好处是什么？
1.提升代码的复用性
2.提升代码的可维护性
3.增强代码的可读性
4.提高代码的灵活性
5.方便进行单元测试
（2）如何定义一个函数？如何调用一个函数？
在Python中如何定义函数，语法结构：
def 函数名(参数列表): 函数体 return 返回值 def sum(a, b): return a + b
- def ：定义函数的关键字
- 函数名：自定义的函数名称，规则与标识符一致的；所有单词字母小写，单词之间用下划线分隔。
- 参数列表：就是给函数传递的一些原始数据，函数根据这些数据去做具体的计算。参数可以不指定数据类型。
- 函数体：就是上述说的具体的计算，今后在编写函数时，一定要注意缩进的问题
- return：直译 返回，实际上表示结束函数（将函数进行弹栈操作），如果有返回值的话则将结果返回给函数的调用者，如果没有返回值的话return可以不写，但不代表不存在，它是隐藏的
- 返回值：就是程序计算的结果，需要给调用者传递结果的话，就将结果写在return之后即可。
在C语言中：
int sum(int a, int b) { return a + b; }
- int：返回值类型 就是计算结果的数据类型
- sum：函数名
- int a, int b：参数列表，表示传递两个整数数字 -> 形式参数
- return a + b：结束函数同时将计算的结果返回给调用者的
（3）给术语函数头、形参、实参的定义
函数头是函数定义的起始部分，它声明了函数的基本信息，主要作用是让编译器或解释器了解函数的名称、参数和返回值类型等关键信息。函数头一般包含函数名、参数列表和返回值类型（某些语言可能不要求显式声明返回值类型）。
形参即形式参数，是在函数定义时声明的参数。形参就像函数内部的变量占位符，用于接收调用函数时传递进来的数据。它规定了函数期望接收的数据类型和数量。
实参也就是实际参数，是在调用函数时传递给函数的具体数据。实参是形参的具体值，函数在执行时会使用这些实参来完成特定的任务。
（4）无返回值函数能不能有return语句？下面语句中的return函数是否会造成语法错误？
def xFunction(x,y):
print(x + y)
return
无返回值可以有return语句，实际上它的返回的是none
（5）编写下面函数的函数头（并指出函数是否有返回值）
-
给定销售额和提成率，然后计算销售提成。
def sales_commission(sales_value:float, roya_yate:float) -> float: return sales_value * roya_yate -
给定年份和月份，然后打印该月的日历。
def Pri(year, month): print(f'{year}年{month}月') -
计算平方根
def square_root(x, y): return x ** y -
判断一个数是不是偶数，如果是则返回true。
def is_evennum(num): if num % 2 == 0: return True else: return False -
按指定次数打印一条消息。
def pri(message, n): for _ in range(n): print(message) -
给定贷款额、还款年数和年利率，然后计算月支付额
def pay_month(loan, years, year_rote): #计算月利率 r = year_rote / 12 #计算还款总月 n = years * n #计算月支付额 M = loan * r * (1 + r) ** n / ((1 + r) ** n - 1) return M -
对于给定的小写字母，给出相应的大写字母。
def conver_letter(small_letter): return small_letter - 32
（6）确定并改正下面程序中的错误
def function1(n,m):
function2(3.4)
def function2(n):
if n > 0:
return 1
elif n == 0:
return 0
elif n < 0:
return -1
function1(2，3)
error：function2(3.4)这条语句属于f1里的内容，缩进错误
if elif 语句缩进错误
修改后
def function1(n,m): function2(3.4) def function2(n): if n > 0: return 1 elif n == 0: return 0 elif n < 0: return -1 function1(2，3)
（7）下面代码的输出是什么？
def main():
print(min(5，6))
def min(n1,n2):
smallest = n1
if n2 < smallest:
smallest = n2
main()#Call the main function
输出结果：none
因为min函数有返回值，但是没有用return返回，min（5，6）就无法得到返回值，所以是空
（8）运行下面程序时会出现什么错误？
def main():
print(min(min(5,6),(51,6)))
def min(n1,n2):
smallest =n1
if n2 < smallest:
smallest =n2
main()# Call the main function
第二次调用min函数的时候，传过去的实参是none
（9）形参和实参能同名吗？
能，它们的作用域不同，是相互独立的变量
（10）显示下面函数的结果
# 代码A
def main():
max=0
getMax(1，2，max)
print(max)
def getMax(value1,value2,max):
if value1 > value2:
max = vauel
else:
max = value2
main()
# 代码B
def main():
i=1
while i <= 6:
print(function1(i，2))
i+= 1
def functionl(i. num):
line = ""
for j in range(1，i):
line += str(num) + " "
num *= 2
return line
main()
# 代码C
def main():
# Initialize times
times= 3
print("Before the call,variable","times is", times)
#Invoke nprintin and display times
nPrint("welcome to Cs!",times)
print("After the call,variable","times is",times)
# Print the message n times
def nPrint(message,n):
while n>0:
print("n="，n)
print(message)
n -= 1
main()
# 代码D
def main():
i=0
while i <= 4:
function1(i)
i+ 1
print("i is”,i)
def function1(i):
line = " "
while i >= 1:
if i % 3 != 0:
line += str(i) + " "
i -= 1
print(line)
main()
#代码A
2
#代码B
none
2
2 4
2 4 8
2 4 8 16
2 4 8 16 32
#代码C
Before the call,variabletimes is3
n = 3
welcome to Cs!
n = 2
welcome to Cs!
n = 1
welcome to Cs!
After the call,variabletimes is3
#代码D
none
"1 "
"2 1 "
死循环
（11）下面代码的打印结果什么？
# 代码A
def function(x):
print(x)
x = 4.5
y = 3.4
print(y)
x=2
y=4
function(x)
print(x)
print(y)
# 代码B
def f(x，y=1，z=2):
return x+y+Z
print(f(1，1,1))
print(f(y=1，x=2，z=3))
print(f(1，z=3))
代码A
2
3.4
2
4
#代码B
3
6
5
（12）下面的代码有什么错误？
def function():
x = 4.5
y= 3.4
print(x)
print(y)
function()
print(x)
print(y)
输出结果：
4.5
3.4
然后报错
x, y 在函数外面没有被定义，出了函数它的作用域就结束了
（13）下面代码能运行吗？如果能，打印结果是什么？
x= 10
if x < 0:
y = -1
else:
y = 1
print("y is", y)
y is 1
（14）显示下面代码的打印结果
def f(w=1，h=2):
print(w，h)
f()
f(w = 5)
f(h = 24)
f(4，5)
1，2
5，2
1，24
4，5
（15）确定下面程序的错误并改正
def main():
nPrintln(5)
def nPrintln(message = "Welcome to Python!",n):
for i in range(n):
print(message)
main() #Call the main function
错误：n放在了message后面
规则：默认参数必须放在非默认参数之后（message必须放在n后面）
修改后：
def main(): nPrintln(5) def nPrintln(n, message = "Welcome to Python!"): for i in range(n): print(message) main() #Call the main function
（16）如果在同一模块里定义两个同名的函数会发生什么？
后面定义的函数会覆盖前面的函数
def pri(): print("这是第一个函数") def pri(): print("这是第二个函数") pri() #输出：这是第二个函数
（17）阐述函数的内存运行机制，举例代码并画图说明
函数的运行是基于栈内存的，栈就是一个先进后出的线性表
我们可以把一个函数当成是栈当中的一个元素：栈帧 -> 函数本身需要占用的内存
都包含哪些内容呢：
- 函数名-引用关系
- 参数列表
- 函数内容：函数体 return 返回值
接着来看，具体的运行机制是这样的：
（1）函数被调用时，会从堆内存中将函数的代码加载进栈内存：进栈
（2）哪个函数在栈顶，哪个函数就有限执行
（3）直到栈顶函数遇到return时，结束函数并将返回值传递给调用者：出栈
（4）在栈顶函数运行期间，如果又调用了其他函数，则当前函数暂停运行，直到成为新的栈顶则继续执行。
def pow(a, b): c = sum(a,b) ** b return c def sum(a,b): c = a + b return c a = 1 b = 2 ret = pow(a,b) print(ret)
总结：
- 局部变量是随着函数的进栈而创建的，随着函数的出栈而消亡
- 全局变量是随着程序的执行而创建的，随着程序的技术而消亡
num = 10 def show(): # 函数内部寻找变量或函数的逻辑：就近原则 print(num) show()一般不建议在函数中直接使用全局变量，而是作为参数进行传递，为啥？一旦改变全局变量的值，那么直接调用该变量的函数在运行时就会出现有任务逻辑问题。
二、编程题
（18） 回文素数【录屏讲解】
视频链接：录制: 录制1
录制文件：https://meeting.tencent.com/cw/KnwALpgMa7
回文素数是指一个数既是素数又是回文数，例如131既是素数也是回文数
输出显示前100个回文素数，每行显示10个
"""
2 3 4 5 7 11 101 131 151 181
191 313 353 373 383 727 757 787 797 919
929 10301 10501 10601 11311 11411 12421 12721 12821 13331
13831 13931 14341 14741 15451 15551 16061 16361 16561 16661
17471 17971 18181 18481 19391 19891 19991 30103 30203 30403
30703 30803 31013 31513 32323 32423 33533 34543 34843 35053
35153 35353 35753 36263 36563 37273 37573 38083 38183 38783
39293 70207 70507 70607 71317 71917 72227 72727 73037 73237
73637 74047 74747 75557 76367 76667 77377 77477 77977 78487
78787 78887 79397 79697 79997 90709 91019 93139 93239 93739
"""
#回文素数
#判断素数
def is_prim(num):
for i in range(2, num // 2):
if num % i == 0:
return False
return True
#判断回文数
def is_pal(num):
arr = []
while num != 0:
arr.append(num % 10)
num //= 10
#遍历数组
left = 0
right = len(arr) - 1
# print(arr)
while left <= right:
if arr[left] == arr[right]:
if left == right:
return True
left += 1
right -= 1
if arr[left] != arr[right]:
return False
if left > right and arr[left] == arr[right]:
return True
count = 0
i = 2
while count < 100:
if is_prim(i) and is_pal(i):
count += 1
print(i, end = " ")
if count % 10 == 0:
print()
i += 1
print()
（19） 反素数
题目描述
反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数
输出显示前100个反素数，每行显示10个
"""
13 17 31 37 71 73 79 97 107 113
149 157 167 179 199 311 337 347 359 389
701 709 733 739 743 751 761 769 907 937
941 953 967 971 983 991 1009 1021 1031 1033
1061 1069 1091 1097 1103 1109 1151 1153 1181 1193
1201 1213 1217 1223 1229 1231 1237 1249 1259 1279
1283 1301 1321 1381 1399 1409 1429 1439 1453 1471
1487 1499 1511 1523 1559 1583 1597 1601 1619 1657
1669 1723 1733 1741 1753 1789 1811 1831 1847 1867
1879 1901 1913 1933 1949 1979 3011 3019 3023 3049
"""
#判断素数
def is_prim(num):
for i in range(2, num // 2):
if num % i == 0:
return False
return True
#判断回文数
def is_pal(num):
arr = []
while num != 0:
arr.append(num % 10)
num //= 10
#遍历数组
left = 0
right = len(arr) - 1
# print(arr)
while left <= right:
if arr[left] == arr[right]:
if left == right:
return True
left += 1
right -= 1
if arr[left] != arr[right]:
return False
if left > right and arr[left] == arr[right]:
return True
#得到反素数
def rever_pri(i):
arr = []
num = 0
while i != 0:
arr.append(i % 10)
i //= 10
left = 0
right = len(arr) - 1
while right >= 0 and left <= len(arr) - 1:
num += arr[left] * 10 ** right
left += 1
right -= 1
return num
#反素数
count = 0
i = 2
while count < 100:
if is_prim(i) and not is_pal(i):
if is_prim(rever_pri(i)):
count += 1
print(i, end = " ")
if count % 10 == 0:
print()
i += 1
（20） 双素数
题目描述
双素数是指一对差值为2的素数，例如3和5就是一对双素数，5和7也是一对双素数
输出显示小于1000的双素数
"""
(2, 4) (3, 5) (5, 7) (11, 13) (17, 19) (29, 31) (41, 43) (59, 61) (71, 73) (101, 103)
(107, 109) (137, 139) (149, 151) (179, 181) (191, 193) (197, 199) (227, 229) (239, 241) (269, 271) (281, 283)
(311, 313) (347, 349) (419, 421) (431, 433) (461, 463) (521, 523) (569, 571) (599, 601) (617, 619) (641, 643)
(659, 661) (809, 811) (821, 823) (827, 829) (857, 859) (881, 883)
"""
#双素数
#判断素数
def is_prim(num):
for i in range(2, num // 2):
if num % i == 0:
return False
return True
#判断是否是双素数
def is_pait_prim(a, b):
if is_prim(a) and is_prim(b) and b - a == 2:
return True
else:
return False
i = 2
count = 0
while i < 1000:
j = 2
while j < 1000:
if is_pait_prim(i, j):
count += 1
print((i, j), end = " ")
if count % 10 == 0:
print()
j += 1
i += 1
（21） 梅森素数
如果一个素数可以写成 2 p − 1 2^p-1 2p−1的形式，其中p是某个正整数，那么这个素数就称作梅森素数
输出p≤31的所有梅森素数
#梅森素数
#判断素数
def is_prim(num):
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
return False
return True
p = 2
while p <= 31:
mersenne_prime = 2 ** p - 1
if is_prim(mersenne_prime):
print(mersenne_prime, end = " ")
p += 1
（22） 对三个数排序
提示用户输入三个数字，最后按照升序输出三个数字
def sort_numbers(num1, num2, num3):
if num1 > num2 > num3:
print(num3, num2, num1)
elif num1 > num3 > num2:
print(num2, num3, num1)
elif num2 > num1 > num3:
print(num3, num1, num2)
elif num2 > num3 > num1:
print(num1, num3, num2)
elif num3 > num1 > num2:
print(num2, num1, num3)
elif num3 > num2 > num1:
print(num1, num2, num3)
x, y, z = map(float,input("请输入三个数字:").split(" "))
sort_numbers(x, y, z)
（23）显示模式【录屏讲解】
视频链接：录制: 录制2
录制文件：https://meeting.tencent.com/cw/2Vap6DLP42
编写函数显示如下模式：
1
2 1
... 3 2 1
n n-1 ... 3 2 1
"""
1
2 1
3 2 1
4 3 2 1
5 4 3 2 1
6 5 4 3 2 1
7 6 5 4 3 2 1
8 7 6 5 4 3 2 1
9 8 7 6 5 4 3 2 1
10 9 8 7 6 5 4 3 2 1
"""
def display_pattern(n):
for i in range(1, n + 1):
#空格
for k in range(n - i):
print(" " * 2, end = " ")
#数据
for j in range(i, 0, -1):
print(f'{j:>2d}',end = " ")
print()
display_pattern(10)
（24）数列求和【录屏讲解】
视频链接：录制: 录制3
录制文件：https://meeting.tencent.com/cw/2yjdLa5bd1
编写一个函数计算下面的数列：
m ( i ) = 1 2 + 2 3 + . . . + i i + 1 m(i) = \frac{1}{2} + \frac{2}{3} + ... + \frac{i}{i + 1} m(i)=21+32+...+i+1i
并输出测试结果：
i m(i)
1 0.50
2 1.16
...
19 16.40
20 17.35
"""
m(i) = 1/2 + 2/3 + ... + i/(i + 1)
请输入一个整数:20
i m(i)
1 0.50
2 1.17
3 1.92
4 2.72
5 3.55
6 4.41
7 5.28
8 6.17
9 7.07
10 7.98
"""
def func(i):
#分子
fenzi = 1
#分母
fenmu = 2
#累加
the_sum = 0
for j in range(i):
num = fenzi / fenmu
the_sum += num
fenzi += 1
fenmu += 1
return the_sum
n = int(input("请输入一个整数:"))
i = 1
print(" i m(i)")
while i <= n:
print(f'{i:>2d} {func(i):.2f}')
i += 1
