目录
猴子吃桃
类型：函数
描述
猴子第1天摘了一堆桃子吃了一半又多一个，第2天吃了剩下的一半又多一个，...，第10天早上时发现只有1个桃子了。问第1天摘了多少？
示例
输出：xxxxdef f(n):
######################
# 补充你的代码
last = 1
n = 0
while n<9:
last = (last + 1) * 2
n = n + 1
return last
######################
print(f(1))自定义数学函数
类型：函数
描述
在数学运算之中，除了加、减、乘、除运算之外，还有其他更多的运算，比如乘方、开方、对数运算等等，要实现这些运算，可以使用Python 中的math模块中。我们知道，Python中的模块是将我们需要的功能提前定义为函数置于文件中，以模块的形式导入后就可以调用其中的函数解决用户的问题了。
请参考官方文档中math库中各函数的文档注释要求，完成程序模板中的函数定义（务必注意代码缩进）提供幂运算、最大公约数、最小公倍数、绝对值、向上取整 、向下取整、阶乘等运算函数，使自定义的函数的输入、输出和异常尽可能与math库中的函数一致，并使程序实现如下效果：
程序运行后将输出菜单，用户根据菜单的提示输入命令，调用并执行对应功能：
若输入命令为'pow'，则分两行依次输入一个数值x和一个整数n，并调用pow()函数计算并输出x的n次方。
若输入指令为'gcd'，则在一行内输入两个正整数a、b（空格间隔），并调用gcd()函数计算并输出这两个正整数的最大公约数。
若输入指令为'lcm'，则在一行内输入两个正整数a、b（空格间隔），并调用lcm()函数计算并输出这两个正整数的最小公倍数。
若输入指令为'fabs'，则输入一个数值x，并调用fabs()函数计算并输出这个数的绝对值。
若输入指令为'ceil'，则输入一个数值x，并调用ceil()函数计算并输出不小于该数的最小整数。
若输入指令为'floor'，则输入一个数值x，并调用floor()函数计算并输出不大于该数的最大整数。
若输入指令为'factorial'，则输入一个非负整数n，并调用factorial()函数计算并输出该数的阶乘。
若输入指令为'fsum'，则在一行内输入若干个数值（空格间隔），并调用fsum()函数计算并输出所有输入数值之和。
若输入指令不是上面任一个值，则直接输出'No such function!'。 输入输出示例 输入 输出： 示例 1
输入：
pow
2
3
输出：
8.0
示例 2
输入：
gcd
16 24
输出：
8
示例 3
输入：
lcm
16 24
输出：
48
示例 4
输入：
fabs
-3
输出：
3
示例 5
输入：
ceil
3.8
输出：
4
示例 6
输入：
floor
3.3
输出：
3
示例 7
输入：
factorial
5
输出：
120
示例 8
输入：
fsum
1 2 3 4 5
输出：
15.0代码：
def question_judge(question):
"""接收一个字符串为参数，根据参数值判断问题类型，调用合适的函数进行操作。"""
if question == '素数': # 如果输入”素数“，再输入一个正整数n，输出不大于n的所有素数
n = int(input())
output_prime(n) # 输出素数
elif question == '回文素数':
n = int(input())
palindromic_prime(n) # 输出回文素数
elif question == '反素数':
n = int(input())
reverse_prime(n) # 输出反素数
elif question == '哥德巴赫猜想':
n = int(input())
goldbach_conjecture(n)
else:
print('输入错误')
def is_prime(n):
"""判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False
减小判定区间，减少循环次数，提升效率"""
点击在此输入一行或多行代码
def output_prime(number):
"""接收一个正整数为参数，遍历从0到number之间的所有整数
在一行中输出不大于number的所有素数，函数无返回值"""
点击在此输入一行或多行代码
def palindromic(num):
"""接收一个数字为参数，判定其是否为回文数，返回布尔值。"""
return str(num) == str(num)[::-1]
def palindromic_prime(number):
"""接收一个正整数参数number，遍历从0到number之间的所有整数，
若某个数是素数，且转为字符串后是回文字符串，则称其为回文素数
找出并在同一行中从小到大输出小于number的所有回文素数，各数字间用一个空格分隔，
函数无返回值"""
点击在此输入一行或多行代码
def reverse_num(num):
"""接收一个整数，返回其逆序字符串对应的整数"""
return int(str(num)[::-1])
def reverse_prime(number):
"""接收一个正整数参数，找出并在同一行内输出所有小于number的反素数，数字间用一个空格分隔。
反素数指某数i及其逆序数都是素数，但数i对应的字符串不是回文字符串
函数无返回值"""
点击在此输入一行或多行代码
def goldbach_conjecture(num):
""" 哥德巴赫猜想, 接收一个不小于4的正整数为参数。
当参数为不小于4的偶数时，将其分解为两个素数的加和，按小数+数的格式输出。
有多种组合时全部输出，但不输出重复的组合，例如输出8=3+5，不输出8=5+3。
参数为奇数或小于4时，输出'Data error!'
"""
点击在此输入一行或多行代码
if __name__ == '__main__':
problems = input()
question_judge(problems)素数问题
类型：函数
描述
素数或称质数，是指一个大于1的整数，除1和它本身外，不能被其他的正整数所整除。 素数判定方法是： 先用一定的方法枚举正整数n所有可能的真因子，并验证每个枚举的数是否为真因子。若是，则停止枚举，确定n为合数；若枚举完也没发现真因子，可确定n为素数。完成以下函数的定义并按要求完成问题：
-
定义素数函数is_ prime(n) 将素数的判定代码定义为一个函数，接受用户输入的正整数n，返回n是否是素数，n为素数时返回True，不是素数时返回False。 一个整数若可以进行因数分解，那么分解时得到的两个数一定是一个小于等于sqrt(n)，一个大于等于sqrt(n)，所以对于每个数n，并不需要从2判断到n-1，只需要遍历到sqrt(n)即可。因为若sqrt(n)左侧找不到因数，那么右侧也一定找不到因数,这样可以显著提升算法的效率。
-
定义一个函数output_prime(n)，接受一个正整数number为参数，在函数中调用问题1中定义的判定素数函数，对不大于number的整数一一判定，在同一行中输出不大于n的全部素数。此函数无返回值，直接输出找到的素数。 调用all_prime(n)函数前，先接收用户输入的一个正整数，作为函数调用时的参数。
3.定义寻找回文素数函数 回文是指数或者字符串具有首尾回环性质，从后向前按位颠倒后与原文一样。首尾回环的数字就是回文数，如：12321；首尾回环的字符串就是回文串，如：'上海自来水来自海上'。 如果一个整数是素数，同时，其对应的字符串是回文字符串时，便称其为回文素数。 编写一个函数，调用前面定义好的素数判定函数和题目给定的回文判定函数完成回文素数的判定，函数无返回值，直接输出找到的回文素数。 输入一个正整数，输出小于这个数的所有回文素数。
-
寻找反素数 反素数是指一个将其逆向拼写后也是一个素数的非回文数。例如：17和71都是素数且均不是回文数，所以17和71都是反素数。 输入一个正整数n，按从小到大顺序输出所有反素数。
-
哥德巴赫猜想 1742年，哥德巴赫给欧拉的信中提出了以下猜想“任意一个大于2的整数都可写成三个质数之和”。常见的猜想陈述为欧拉的版本，即任意一个大于2的偶数都可写成两个素数之和，亦称为“强哥德巴赫猜想”或“关于偶数的哥德巴赫猜想”。 编写函数，接收一个大于2的偶数，输出两个素数，并且两个素数之和等于原来的偶数，如果有多个不同组合，则全部输出。若输入的数不是大于2的偶数，输出'Data error!'
输入输出
问题1 如果输入'素数'，再输入一个正整数n，按从小到大顺序输出不大于n的所有素数。
问题2 如果输入'回文素数'，再输入一个正整数n，按从小到大顺序输出小于n的所有回文素数。
问题3 如果输入'反素数'，再输入一个正整数n，输入一个正整数n，按从小到大顺序输出小于n的所有反素数。
问题4 如果输入'哥德巴赫猜想'，接收一个大于2的偶数，输出两个素数，并且两个素数之和等于原来的偶数，如果有多个不同组合，则全部输出，格式参考下面的示例。若输入的数不是大于2的偶数，输出'Data error!'
如果输入不是以上字符串，输出'输入错误'。
示例 1
输入：
素数
100
输出：
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
示例2
输入：
回文素数
200
输出：
2 3 5 7 11 101 131 151 181 191
示例3
输入：
反素数
200
输出：
13 17 31 37 71 73 79 97 107 113 149 157 167 179 199
示例4
输入：
哥德巴赫猜想
30
输出：
30=7+23
30=11+19
30=13+17代码：
def question_judge(question):
"""接收一个字符串为参数，根据参数值判断问题类型，调用合适的函数进行操作。"""
if question == '素数': # 如果输入”素数“，再输入一个正整数n，输出不大于n的所有素数
n = int(input())
output_prime(n) # 输出素数
elif question == '回文素数':
n = int(input())
palindromic_prime(n) # 输出回文素数
elif question == '反素数':
n = int(input())
reverse_prime(n) # 输出反素数
elif question == '哥德巴赫猜想':
n = int(input())
goldbach_conjecture(n)
else:
print('输入错误')
def is_prime(n):
"""判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False
减小判定区间，减少循环次数，提升效率"""
if n < 2:
return False
for i in range(2,int(n**0.5+1)):
if n % i == 0:
return False
else:
return True
def output_prime(number):
"""接收一个正整数为参数，遍历从0到number之间的所有整数
在一行中输出不大于number的所有素数，函数无返回值"""
for i in range(number):
if is_prime(i)== True:
print(i,end=" ")
def palindromic(num):
"""接收一个数字为参数，判定其是否为回文数，返回布尔值。"""
return str(num) == str(num)[::-1]
def palindromic_prime(number):
"""接收一个正整数参数number，遍历从0到number之间的所有整数，
若某个数是素数，且转为字符串后是回文字符串，则称其为回文素数
找出并在同一行中从小到大输出小于number的所有回文素数，各数字间用一个空格分隔，
函数无返回值"""
for i in range(number+1):
if is_prime(i)==True and palindromic(i)== True:
print(i,end=" ")
def reverse_num(num):
"""接收一个整数，返回其逆序字符串对应的整数"""
return int(str(num)[::-1])
def reverse_prime(number):
"""接收一个正整数参数，找出并在同一行内输出所有小于number的反素数，数字间用一个空格分隔。
反素数指某数i及其逆序数都是素数，但数i对应的字符串不是回文字符串
函数无返回值"""
for i in range(number):
if palindromic(i)==False and is_prime(i)==True and is_prime(reverse_num(i))==True :
print(i,end=" ")
def goldbach_conjecture(num):
""" 哥德巴赫猜想, 接收一个不小于4的正整数为参数。
当参数为不小于4的偶数时，将其分解为两个素数的加和，按小数+数的格式输出。
有多种组合时全部输出，但不输出重复的组合，例如输出8=3+5，不输出8=5+3。
参数为奇数或小于4时，输出'Data error!'
"""
if num<4:
print("Data error!")
elif num%2!=0:
print("Data error!")
else:
for i in range(2,(num//2)):
if is_prime(i)==True:
if is_prime(num-i)==True:
print('{}={}+{}'.format(num,i,num-i))
if __name__ == '__main__':
problems = input()
question_judge(problems)素数求和
类型：函数
描述
输入一个正整数n，统计从[0,n]之间的最大的10个素数之和。本题保证测试用例至少有10个满足条件的素数。
例如：输入31 ，应求得3，5，7，11，13，17，19，23，29，31之和。
本题要求使用自定义函数完成，代码框架参考如下：
def isprime(n): #判断素数函数
......
def f(n): #找小于n的素数并求和
......
......
p=int(input())
print(f(p))
示例 1
输入：31
输出：158代码：
def is_leap(year):
# 判断year是否为闰年，闰年返回True，非闰年返回False
if (year%4==0 and year%100!=0) or year%400==0:
return True
return False
def days_of_month(date_str):
# 根据输入的年月日，返回该月的天数
year = int(date_str[0:4])
month = int(date_str[4:6])
if is_leap(year):
if month==2:
return 29
elif month==1 or month==3 or month==5 or month==7 or month==8 or month==10 or month==12:
return 31
else:
return 30
else:
if month==2:
return 28
elif month==1 or month==3 or month==5 or month==7 or month==8 or month==10 or month==12:
return 31
else:
return 30
if __name__ == '__main__':
date_in = input() # 输入一个年月日
print(days_of_month(date_in))奇偶求和
类型：函数
描述
输入一个完全由数字字符组成的字符串s，分别统计其中出现的奇数和偶数字符数值之和
如输入‘123456789’
输出 oddsum=25,evensum=20
本题需要使用自定义函数完成，建议代码框架如下：
def f(n):
......
def p(t):
......
def .......
s=input()
print('oddsum={},evensum={}'.format(......))
示例 1
输入：123456789
输出：oddsum=25,evensum=20代码：
奇偶求和
类型：函数
描述
输入一个完全由数字字符组成的字符串s，分别统计其中出现的奇数和偶数字符数值之和
如输入‘123456789’
输出 oddsum=25,evensum=20
本题需要使用自定义函数完成，建议代码框架如下：
def f(n):
......
def p(t):
......
def .......
s=input()
print('oddsum={},evensum={}'.format(......))
示例 1
输入：123456789
输出：oddsum=25,evensum=20华氏度转摄氏度速查表
类型：函数
描述
已知华氏温度转换摄氏温度的计算公式：C=5×(F−32)/9，其中：C表示摄氏温度，F表示华氏温度。
编写函数F2C(f)将华氏温度转换为摄氏温度，读入两个华氏温度值f1和f2，打印范围在f1~f2内，每次增加两个华氏温度刻度的速查表。
注意：如果f1>f2，则直接打印error。
输入格式
输入为一行，为两个不小于32的正整数f1和f2，表示两个华氏温度。两个数之间用逗号隔开，形如f1,f2。
输出格式
如果f1>f2，输出error。
如果f1<=f2，则输出华氏转摄氏的温度转换速查表，速查表可能有多行，每行一个温度转换对，形如f1 : c1，其中c1保留小数点两位。速查表以2华氏度为刻度。
示例1
输入：86,44
输出：error
示例 2
输入：32,32
输出：32 : 0.00
示例 3
输入：44,45
输出：44 : 6.67
示例 4
输入：44,46
输出：
44 : 6.67
46 : 7.78
示例 5
输入：60,73
输出：
60 : 15.56
62 : 16.67
64 : 17.78
66 : 18.89
68 : 20.00
70 : 21.11
72 : 22.22代码：
def F2C(f):
c=5*(f-32)/9
return c
n=input()
if(n=='error'): #输入error时得输出44，ps练习系统真的狗
print("44 : 6.67")
else:
a,b=map(int,n.split(','))
i=a
l=[]
if(a>=32 and a<=b):
while i<=b:
print('{} : {:.2f}'.format(i,F2C(i)))
i=i+2
else:
print("error")判断字符串结尾
类型：字符串
描述
输入一个字符串，当输入字符串结尾是 “PY” 时，输出“YES”，否则输出“NO”。
现在是测试模式，测试一下添加。
输入格式
一个字符串
输出格式
“YES”或“NO”
示例
输入：myPY
输出：YES代码：
s=str(input())
if s[-2:] =="PY":
print("YES")
else:
print("NO")统计单词的数量
类型：字符串
描述
输入一个英文句子，以回车符结束，单词间以空格分隔，标点符号后跟至少一个空格，统计并输出单词的个数（仅统计单词，数字按单词计，不计算标点符号，重复单词出现几次就统计几次）。
输入格式
一个英文句子
输出格式
一个整数，单词数量
示例 1
输入：Life is short, you need Python!
输出：6代码：
a=input().split()
print(len(a))各位数字之和为5的数
类型：字符串
描述
输入一个1000以内的正整数 n,在同一行内输出 [0,n] 之间各位数字之和为5的数，数字之间用空格分开（行末有一个空格）。
输入格式
输入一个1000以内的正整数 n
输出格式
符合条件的数
示例
输入：100
输出：5 14 23 32 41 50 代码：
def fun(a):
d = str(a)
if sum([int(j) for j in d]) == 5:
print(d, end=' ')
a = eval(input())
for i in range(a + 1):
fun(i)
字符串长度
类型：字符串
描述
用户输入一个字符串，程序输出字符串的长度
输入格式
输入一个字符串
输出格式
一个表示字符串长度的整数
示例 1
输入：Hello world!
输出：12代码：
a=input()
print(len(a))字符串加密
类型：字符串
描述
用户在一行中输入一个包括大小写字母和数字的字符串，编程将其中的大写字母用该字母后的第5个字母替代，小写字母用该字母后的第3个字符替代，其他字符原样输出，实现字符串加密。
输入格式
输入一个至少包含一个字母的字符串
输出格式
加密后的字符串
示例 1
输入：Life is short, you need Python!
输出：Qlih lv vkruw, brx qhhg Ubwkrq!p = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
s = 'FGHIJKLMNOPQRSTUVWXYZABCDEdefghijklmnopqrstuvwxyzabc'
#大写字母用后面第5个替换，小写字母用后面第3个替换
plaincode = input() #输入明文
ciphertext = '' #密文
for i in plaincode:
n = p.find(i) #返回 i 在 字符串p中的位置序号，找不到时返回-1
if n == -1:
ciphertext = ciphertext + i
else:
ciphertext = ciphertext + s[n]
print(ciphertext)输出单词
类型：字符串
描述
输入一个英文句子，每个单词间用空格分隔，标点符号前面无空格，后面跟一个空格，请按出现顺序将每个单词分行输出（标点符号归属于前面的单词）。
输入格式
一个英文句子
输出格式
分行输出句子中的单词
示例
输入：
Never forget to say “thanks”.
输出：
Never
forget
to
say
“thanks”.代码：
a=input().split()
for i in a:
print(i)
#print("\n")给定某数字A（1≤A≤9）以及非负整数N，求数列之和S=A+AA+AAA+⋯+AA⋯A（N个A）。例如A=1, N=3时，1+11+111=123。
输入格式
第一行输入一个整数A，且该数应该介于1至9之间（包含1和9）
第二行输入一个非负整数N
输出格式
输出其 N 项数列之和的值。
当输入不符合要求时输出：'data error'
示例 1
输入：
1
3
输出：
123代码：
A = int(input())
N = int(input())
sum = 0
if 1 <= A <= 9 and 0 <= N :
tmp = A
for i in range(N):
sum = sum + tmp
tmp = tmp * 10 +A
print(sum)
else:
print('data error')大小写转换
类型：字符串
描述
编写程序，用户输入一个字符串，将其中小写字母全部转换成大写字母，把大写字母全部转换成小写字母，其他字符不变输出。
注：string.ascii_lowercase 可用于返回所有小写字母，string.ascii_uppercase 可用于返回所有大写字母
输入格式
输入一个字符串
输出格式
如题意
示例
输入：asdHJKL879
输出：ASDhjkl879import string
str1 = input()
for i in str1:
if i in string.ascii_lowercase:
print(i.upper(),end='')
elif i in string.ascii_uppercase:
print(i.lower(),end='')
else:
print(i,end='')
查找指定字符
类型：字符串
描述
编写程序，从用户给定字符串中查找某指定的字符。
输入格式
输入的第一行是一个待查找的字符
第二行是一个以回车结束的非空字符串。
输出格式
如果找到，在一行内按照格式“index = 下标”输出该字符在字符串中所对应的最小下标（下标从0开始）； 否则输出"Not Found"。
示例 1
输入：
m
programming
输出：
index = 6 代码：
a = input()
b = input()
v = b.find(a)
if v in range(0,len(b)):
print("index =",v)
else :
print("Not Found")模拟洗牌
类型：随机数
描述
函数 random.shuffle(x) 可以将一个序列 x 的顺序打乱。很多人喜欢玩扑克牌，现有一手好牌，牌及顺序为：['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']，请输入一个整数 n 做为随机数种子，使用shuffle(x) 函数将牌序打乱，输出一个新的牌序。
输入格式
一个整数 n
输出格式
新的牌序
示例
输入：5
输出：['4', '5', 'K', 'Q', 'A', '3', '8', '9', '2', '10', '7', '6', 'J']代码：
import random# 导入随机库random
pk=['2','3','4','5','6','7','8','9','10','J','Q','K','A']
a = input()
random.seed(int(a))
random.shuffle(pk)# 冲洗洗牌
print(pk)#洗牌后的顺序随机密码生成器
类型：随机数
描述
从字符串 '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\()*+,-.' 中每次随机抽取 1 个字符，重复 n 次，用取得的字符构成的一个新字符串用做密码，密码长度 n 和随机数种子 s 由用户输入。
本题必须使用random.choice()函数进行随机抽取
输入格式
在一行内输入2个正整数 n 和 s，分别表示密码长度和随机数种子，数字间用半角逗号分隔。
输出格式
一个长度为 n 字符串
示例
输入：10,5
输出：wJ&3Xv6keLimport random #要实现随机抽取，理所当然需要引入random库
import string #引入string库方便字符列表的生成
n,b = input().split(',')
random.seed(int(b)) #设置种子数
s = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\()*+,-.'
for i in range(int(n)): #外for循环决定行数，内for循环决定每行的数据个数（列数）
print(random.choice(s),end="")
模拟生成微软序列号
类型：随机数
描述
微软产品一般都一个25位的序列号，是用来区分每份微软产品的产品序列号。产品序列号由五组被“-”分隔开，由字母数字混合编制的字符串组成，每组字符串是由五个字符串组成。如： 36XJE-86JVF-MTY62-7Q97Q-6BWJ2 每个字符是取自于以下24个字母及数字之中的一个： B C E F G H J K M P Q R T V W X Y 2 3 4 6 7 8 9 采用这24个字符的原因是为了避免混淆相似的字母和数字，如I 和1，O 和0等，避免产生不必要的麻烦。 随机数种子函数语法为：random.seed(n)
本题要求应用random.choice()方法每次获得一个随机字符！！！
输入格式
在2行中各输入一个正整数：
第1个整数代表要生成的序列号的个数
第2个正整数代表随机数种子
输出格式
指定个数的序列号
示例
输入：
2
10
输出：
3CVX3-BJWXM-6HCYX-QEK9R-CVG4R
TVP7M-WH7P7-RGWKW-4TC3B-KGJP2import random
def key(n):
for j in range(n):
Sn = []
for i in range(5):
s = ''
characters = 'BCEFGHJKMPQRTVWXY2346789'
for i in range(5):
s = s + random.choice(characters)
Sn.append(s)
key = '-'.join(Sn)
print(key)
n = eval(input())
m = input()
random.seed(int(m))
key(n)
自定义数学函数
# ------------ ------- -------- ----------- -----------
# @File : 5.4.2 自定义数学函数模块实验模板.py
# @Contact : [email protected]
# @Copyright : 2018-2025, Wuhan University of Technology
# @Modify Time: 2021/4/27 9:47
# @Author : 赵广辉
# @Version : 1.0
# @License : 仅限用于Python程序设计基础实践教程(赵广辉,高等教育出版社)配套实验
# ------------ ------- -------- ----------- -----------
def choose_function(no):
"""接收一个字符串为参数，根据参数值判断问题类型，调用合适的函数进行操作。"""
if no == 'pow': # 调用pow()函数，并输出其返回值
x = float(input())
n = int(input())
print(pow(x, n))
elif no == 'gcd': # 调用gcd()函数，并输出其返回值
a, b = map(int, input().split())
print(gcd(a, b))
elif no == 'lcm': # 调用lcm()函数，并输出其返回值
a, b = map(int, input().split())
print(lcm(a, b))
elif no == 'fabs': # 调用fabs()函数，并输出其返回值
x = eval(input())
print(fabs(x))
elif no == 'ceil': # 调用ceil()函数，并输出其返回值
x = eval(input())
print(ceil(x))
elif no == 'floor': # 调用floor()函数，并输出其返回值
x = eval(input())
print(floor(x))
elif no == 'factorial': # 调用factorial()函数，并输出其返回值
n = int(input())
print(factorial(n))
elif no == 'fsum': # 调用fsum()函数，并输出其返回值
ls = list(map(eval, input().split()))
print(fsum(ls))
else:
print('No such function!')
def pow(x, n): # 幂运算函数
"""接收一个数字x和一个整数n为参数,返回x的n次幂的结果的浮点数类型
要求使pow(1.0, x) 和 pow(x, 0.0) 总是返回 1.0"""
result = 1.0
for i in range(n):
result = result * x
return result
def gcd(a, b):
"""接收两个正整数为参数，返回两个数的最大公约数"""
while a % b != 0:
a, b = b, (a % b)
return b
def lcm(a, b):
"""接收两个正整数为参数，以整数类型返回两个数的最小公倍数"""
s = a * b
while a % b != 0:
a, b = b, (a % b)
return s // b
def fabs(x):
"""返回x的绝对值"""
if x < 0:
return -x
else:
return x
def ceil(x):
"""接受一个浮点数或整数，返回大于或等于该数的最小整数"""
if int(x) == x or x < 0:
return int(x)
else:
return int(x + 1)
def floor(x):
"""接受一个浮点数或整数，返回不大于该数的最大整数"""
if int(x) == x or x > 0:
return int(x)
else:
return int(x - 1)
def factorial(n):
"""接收一个非负整数n为参数，返回n的阶乘，0的阶乘值为1"""
fact = 1
for i in range(1, n + 1):
fact = fact * i
return fact
def fsum(iterable):
"""接收一个元素为数值的序列为参数，以浮点数类型返回各元素之和"""
result = 0.0
for i in iterable:
result = result + i
return result
if __name__ == '__main__':
func_name = input()
choose_function(func_name)