python25_在线真题试卷与模拟练习_python25

更新时间：试题数量：购买人数：提供作者：

有效期：个月

章节介绍：共有个章节

我的练习

我的错题
(0道)

我的收藏
(0道)

我的斩题
(0道)

我的笔记
(0道)

专项练习

顺序练习 0 / 0

随机练习 自定义设置练习量

题型乱序 按导入顺序练习

模拟考试 仿真模拟

题型练习 按题型分类练习

易错题 精选高频易错题

学习资料 考试学习相关信息

搜索

题库预览

根据提示，在右侧编辑器 Begin-End 区间补充代码，接收用户输入的两个数 a 和 b，对其进行加减乘除四则运算，通过print函数打印四次运算结果，使结果输出形式与预期输出保持一致。

本关任务：改正程序中的错误，并输出 Python3 的所有保留字。

本关任务：修改程序，得到正确的结果。

求解一元二次方程 x*x+5*x+6=0的

编程计算并输出表达式的值。（结果保留3位小数）

单分支选择结构的语法格式 if 表达式 : 语句块执行过程：首先计算表达式的值，如果表达式结果为True，则执行语句块；否则跳过语句块，继续执行其后的其他语句。编程要求判断输入的数是否是整数。题目描述键盘输入1个数据，判断输入的数是否是整数，是则输出“你输入的数是整数！”，不是整数则什么都不输出。输入输出样例输入 99 输出你输入的数是整数！输入 44.3 输出

双分支选择结构的语法格式 if 表达式 : 语句块1 else: 语句块2 执行过程：首先计算表达式的值，如果表达式结果为True，则执行语句块1中所有语句，否则执行语句块2中所有语句。编程要求判断输入的数是否是整数。题目描述键盘输入1个数据，判断输入的数是否是整数，输出判断结果。输入输出样例输入 99 输出你输入的数是整数！输入 44.3 输出你输入的数不是整数！

多分支选择结构的语法格式 if 表达式1 : 语句块1 elif 表达式2: 语句块2 …… elif 表达式N: 语句块N [else: 语句块N+1］执行过程： ①计算表达式1的值，若结果为True，则执行语句块1； ②否则计算表达式2的值，若结果为True，则执行语句块2； ③以此类推……只要执行了一个分支就不会执行其他分支，结束if选择结构。 ④若表达式1至表达式N的计算结果都为False，则执行else部分的语句块N+1。编程要求根据公式计算 y 值，x 从键盘输入。题目描述根据公式计算 y 值，x 从键盘输入。公式如下。 Description 输入输出样例输入 0 输出当x=0时，y=0 输入 4 输出当x=4时，y=16 输入 -3 输出当x=-3时，y=-6

选择结构嵌套在if子句或else子句中又包含一个或多个if语句，单分支、双分支、多分支可相互嵌套。编程要求闰年判断题目描述从键盘任意输入一个公元年份（大于等于1），判断它是否是闰年。要求对输入数据进行合法性判断。已知符合下列条件之一者是闰年：能被4整除，但不能被100整除；或者能被400整除。分析从键盘输入年份year，如果year不是整数或者小于1，则显示“您输入的不是有效的年份！”；否则，判断year是否满足闰年的条件，如果满足则是闰年，否则不是闰年。输入输出样例输入 2020 输出 2020是闰年！输入 2025 输出 2025不是闰年！输入 90.4 输出您输入的不是有效的年份！

for循环主要应用于循环次数确定的场合，特别适合于遍历可迭代对象中的元素。 for循环结构的语法格式 for 循环变量 in 可迭代对象：循环体执行过程：取出可迭代对象的第1个元素存放在“循环变量”中，并执行循环体；取出第2个元素存放在“循环变量”中，再一次执行循环体，以此类推，遍历完可迭代对象中所有元素，结束循环。 range()函数内置函数range( )可用来创建数值型可迭代对象。例如： for i in range(1,6): print(i,end=′ ′) 输出： 1 2 3 4 5 编程要求1：利用for循环，计算1+2+3+…+99+100。输入输出样例输出 5050 编程要求2：利用for循环，计算2+4+6+…+98+100。输入输出样例输出 2550 编程要求3：在下面编写代码计算1+2+3+…+n 输入输出样例输入 10 输出 55 编程要求4：利用for循环，求 n! 的值。输入输出样例输入 5 输出 5!=120

continue语句 continue语句的作用是结束本次循环，跳过当前循环的剩余语句，并返回到循环的起始处，重新计算循环条件，如果循环条件满足就继续进入下一轮循环。编程要求从键盘输入10个数，求其中非负数之和。题目分析当输入的数小于0时，跳过累加求和语句，进入下一次循环，重新接收键盘的输入。输入输出样例输入 5 5 5 -5 5 -8 -11 5 5 5 输出输入的非负数之和：35

break语句 break语句用来终止循环，即使循环条件还没有为 False 或者序列还没被完全遍历，也会停止执行循环语句。编程要求输入正整数m和n，求m以内能被n整除的最大正整数。题目分析生成m~1的序列，对每一数判断是否能被n整除，如果能整除，则输出该数并终止循环。输入输出样例输入 30 7 输出 30以内能被7整除的最大正整数为28。

else子句 for循环可以与else子句结合使用，当循环正常退出时执行else子句。 for循环中else子句的语法格式 for 变量 in 可迭代对象循环体语句块1 else: 语句块2 执行过程：当for循环已遍历完可迭代对象中所有的元素后，执行else后面的语句块2。如果循环被break语句中止，则不会执行else后面的语句块2。程序举例1： city=['Beijing','Shanghai','Shenzhen'] for c in city: print(c) else: print('中国一线城市！') 输出： Beijing Shanghai Shenzhen 中国一线城市！程序举例2： city=['Beijing','Shanghai','Shenzhen'] for c in city: if 'S' in c: break print(c) else: print("中国一线城市！") 输出： Shanghai 【注：这里写错了，应该是Beijing】编程要求从键盘输入一个正整数，判断它是否为素数，若是素数，输出“是素数”，否则输出“不是素数”。题目分析素数即质数，它除了能被1和它本身整除外，不能被其他任何整数整除（1不是素数）。例如，7是素数，除了1和7以外，它不能被2~6之间的任何整数整除。判断素数的方法：把 n 作为被除数，i=2~n-1依次作为除数，判断 n 与 i 相除的结果，若都除不尽，即余数都不为0，则 n 为素数；反之，只要有一次能除尽（余数为0），则说明 n 存在一个1和它本身以外的因子，它就不是素数。输入输出样例输入 9 输出 9 不是素数！输入 7 输出 7 是素数！注意：输出的数字后有一个空格。

while 循环语句是按条件执行循环体，其一般形式为： while 表达式: 循环体执行过程：先计算表达式的值，如果表达式为True，执行一次循环体；接着重新计算表达式的值，如果表达式为True，再一次执行循环体……这个过程持续进行直到表达式为False，结束循环。分析下面程序的运行结果： i=1 while i<10: print(i) i=i+3 print(i) 运行结果： 1 4 7 10 编程要求1：利用while循环，计算1+2+3+…+99+100。输入输出样例输出 1+2+3+…+99+100=5050 编程要求2：求［x, y］之间所有自然数之和，其中 x<y。输入输出样例输入 100 500 输出［100,500］之间所有自然数之和为120300 编程要求3：利用while循环，计算1~100之间所有偶数之和。输入输出样例输出 1~100之间所有偶数之和为2550

continue语句的作用是结束本次循环，跳过当前循环的剩余语句，并返回到循环的起始处，重新计算循环条件，如果循环条件满足就继续进入下一轮循环。 break语句用来终止循环，即使循环条件还没有为 False 或者序列还没被完全遍历，也会停止执行循环语句。分析程序程序1 i=1 while i<10: i=i+1 if i % 2==0: continue print(i) 输出 3 5 7 9 程序2 i=1 while i<10: i=i+1 if i % 3==0: break print(i) 输出 2

else子句 while循环、for循环可以与else子句结合使用，当循环正常退出时执行else子句。 while循环中else子句的语法格式 while 表达式：循环体语句块1 else: 语句块2 执行过程：当while循环中表达式为False时，执行else后面的语句块2。如果循环被break语句中止，则不会执行else后面的语句块2。编程要求素数判断（使用while结构实现）从键盘输入一个正整数，判断它是否为素数，若是素数，输出“是素数”，否则输出“不是素数”。题目分析素数即质数，它除了能被1和它本身整除外，不能被其他任何整数整除（1不是素数）。例如，7是素数，除了1和7以外，它不能被2~6之间的任何整数整除。判断素数的方法：把 n 作为被除数，i=2~n-1依次作为除数，判断 n 与 i 相除的结果，若都除不尽，即余数都不为0，则 n 为素数；反之，只要有一次能除尽（余数为0），则说明 n 存在一个1和它本身以外的因子，它就不是素数。输入输出样例输入 9 输出 9 不是素数！输入 7 输出 7 是素数！

循环嵌套：一个循环语句的循环体中又包含了另一个完整的循环结构。 while循环体中可嵌套while循环或者for循环，for循环体中也可嵌套for循环或者while循环。分析程序的运行结果。 x=0 y=0 for i in range(1,6,2): x=x+1 for j in range(2): y=y+1 print("x=",x,"y=",y) 输出 x= 3 y= 6 编程要求编程输出100~200之间所有的素数和素数的个数。输入输出样例输出素数列表，每个数字后有一个空格 num=素数个数

打印如图所示的九九乘法表。注意：输出语句使用end参数，end=“\t”，使每个表达式后有一个tab符号，从而使乘法表每列对齐。可参考下面补充知识。补充知识 print() 函数的参数说明如下： print()函数是Python中用于输出内容的内置函数，它可以接受多个参数并将它们打印到标准输出（通常是控制台）。下面是print()函数的参数说明： print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False) *objects：要打印的对象，可以是一个或多个参数。它们将按顺序打印在一行上。使用逗号分隔多个对象。 sep=’ ‘（可选）：用于分隔多个对象之间的字符串。默认情况下，它是一个空格字符。 end=’\n’（可选）：用于表示打印结束的字符串。默认情况下，它是一个换行符 \n，表示在输出内容的末尾打印一个换行符，使下一行输出位于新的一行。 file=sys.stdout（可选）：指定要将输出发送到的文件对象。默认情况下，输出被发送到标准输出流（通常是控制台）。你可以将其设置为一个文件对象，以将输出写入文件。 flush=False（可选）：控制是否刷新输出缓冲区。默认情况下，缓冲区会自动刷新。如果将其设置为True，则立即刷新缓冲区，将内容输出到目标文件或终端。通过使用这些参数，你可以控制打印输出的格式、分隔符和结束字符。下面是几个示例： print("Hello", "World") # 输出：Hello World print("Hello", "World", sep=" ") # 输出：Hello World print("Hello", "World", end="!") # 输出：Hello World! print("Hello", "World", sep="-", end="!") # 输出：Hello-World!

字符串：用单引号‘或双引号“或三个单引号或三个双引号括起来的任何字符。字符串的拼接：在很多情况下，我们需要将两个字符串拼接起来。任务描述：本关任务是将两个不同的字符串，拼接形成一个字符串，并将新字符串输出来。例如，一个人的姓名，通常是由“姓氏”+“名字”组成的。在很多程序中，为了方便后续处理，通常将姓氏和名字分别存在两个变量中。然后在显示时，要将姓氏和名字拼接起来，按全名显示。 first_name = 'Zhang' last_name = 'san' 输出如下： full_name = 'Zhang san' 相关知识字符串拼接方法在Python中，有多种方式可以进行字符串拼接。以下是几种常见的方法： 1.使用加号（+）运算符： first_name = "John" last_name = "Doe" full_name = first_name + " " + last_name print(full_name) # 输出：John Doe 2.使用逗号（,）将多个字符串作为参数传递给print()函数： first_name = "John" last_name = "Doe" print(first_name, last_name) # 输出：John Doe 3.使用字符串的format()方法： first_name = "John" last_name = "Doe" full_name = "{} {}".format(first_name, last_name) print(full_name) # 输出：John Doe 4.使用f-string（格式化字符串）： first_name = "John" last_name = "Doe" full_name = f"{first_name} {last_name}" print(full_name) # 输出：John Doe 注意 Python 2.6及更高版本中使用字符串的 format() 方。 Python 3.6及更高版本中，推荐使用更简洁的f-string来进行字符串格式化。程序举例 # 将姓氏和名字分别保存在两个变量中 first_name = 'Zhang' last_name = 'san' # 将姓氏和名字拼接，将结果存储在full_name变量中 full_name = first_name + " " + last_name print(full_name) 输出结果： Zhang san 输入字符串的读入由于我们写的程序需要处理不同的姓氏和名字，因此有必要从系统读入用户提供的相关字符串，下面介绍输入字符串的读入方法： first_name = input() last_name = input() 上面两行程序的含义是：读入第一行输入对应的字符串，并保存到first_name变量中。读入第二行输入对应的字符串，并保存到last_name变量中。编程要求本关的编程任务是补全代码，实现如下功能：将存放姓氏的字符串变量和存放名字的字符串变量拼接起来，中间用一个空格隔开，并将结果存储在full_name变量中；打印输出full_name变量。以下是样例测试集：测试输入： Hu dong 预期输出： Hu dong

对给定的字符串进行处理，包括字符串长度计算、大小写转换以及去除字符串前后空格等。在字符串处理中，经常需要统计字符串的长度、进行大小写转换以及去除字符串前后空格等操作。例如，在基于关键词的搜索引擎中，要查询关键词是否在文档或者网页中出现，搜索引擎并不需要区分关键词中字符的大小写以及关键词前后的空格等。这时就需要对字符串进行处理，将其中的大写字符都转换为小写，并剔除字符串开头和结尾处的空格，然后再统一进行字符串匹配。相关知识:Python 标准库提供了一系列关于字符串处理的函数。本关的小目标是让大家学习并掌握 Python 常用字符串方法中的len()、lower()和strip()函数的用法，并完成相应字符串处理任务。字符串长度获取:Python 提供了len()函数来计算，并返回字符串的长度，即字符串中单个元素的个数。其基本语法如下： length = len(target_string) 其中： target_string: 目标字符串变量； length: 保存字符串长度的变量； len: 获取字符串长度的语法关键词。下面给出了具体的使用示例： # 创建一个字符串变量，获取其长度并打印出来 color = 'It is red' length = len(color) print (length) # 直接在len函数中引入字符串内容获得其长度，然后打印出来 print(len('This is a circle!')) 输出结果： 9 17 注意：从输出结果可以看到，空格也占一个字符元素的位置。大小写转换 Python 提供了upper()和lower()方法，来对字符串进行大小写转换。其中，upper()会将字符串中的所有字符都转换为大写，lower()则将所有字符转换为小写。除此之外，Python 还贴心的提供了title()方法，将字符串所有单词的首字母变成大写，而其他字母依然小写。各个方法的具体语法如下： # 将源字符串转换为大写并存入upper_string变量 upper_string = source_string.upper() # 将源字符串转换为小写并存入lower_string变量 lower_string = source_string.lower() # 将源字符串每个词首字母转换为大写并存入title_string变量 title_string = source_string.title() 其中，source_string为待处理的源字符串。具体使用示例如下： # 创建一个字符串say_hello say_hello = 'Dear my Daughter' # 使用upper()方法对say_hello字符串进行处理 upper_say_hello = say_hello.upper() # 使用lower()方法对say_hello字符串进行处理 lower_say_hello = say_hello.lower() # 使用title()方法对say_hello字符串进行处理 title_say_hello = say_hello.title() # 打印输出四个字符串 print (say_hello+ "\n") print (upper_say_hello+ "\n") print (lower_say_hello+ "\n") print (title_say_hello+ "\n") 输出结果： Dear my Daughter DEAR MY DAUGHTER dear my daughter Dear My Daughter 注意：由上述打印结果可以看出，上述方法的调用，并不会对原始的 say_hello字符串产生影响，转换后的字符串会存入新的变量中。去除字符串首尾空格:Python 提供了strip()方法，可以去除字符串两侧（不包含内部）全部的空格。使用该方法，也可以通过指定参数，去除两侧指定的特定字符。注意：在指定参数时，如果参数是多个字符，则该方法会将多个字符逐个去比对，进行删除（区分大小写），直到首尾两侧没有匹配的字符为止。但是，该方法对字符串中间的字符没有影响。其基本语法如下： strip_string1 = source_string.strip() string_strip2 = source_string.strip(target_char) 其中： source_string：待处理的源字符串； strip_string1和strip_string2：处理后的字符串； target_char：需要从源字符串首尾去除的特定字符。具体使用示例如下： # 创建一个字符串hello_world hello_world = ' **The world ** is big!* ' # 利用strip()方法处理hello_world字符串 blank_hello_world = hello_world.strip() char_hello_world = hello_world.strip('TH *') # 打印输出转换后的字符串 print(blank_hello_world) print(char_hello_world) 输出结果： **The world ** is big!* he world ** is big! 输出结果分析：从第一行打印结果可以看到，strip()方法去除了源字符串首尾的所有空格，但是并没有去除字符串中间的空格；从第二行打印结构可以看出，strip()方法将源字符串首尾所有空格、* 以及字符T去掉了，而源字符串中头部的h因为是小写并没有去除。编程要求本关的编程任务是，补全代码，实现给定字符串的转换功能，具体要求如下： step1 ：将输入的源字符串source_string首尾的空格删除； step2 ：将 step1 处理后的字符串的所有单词的首字母变为大写，并打印输出； step3 ：将 step2 转换后的字符串的长度打印输出。样例测试集：测试输入： Where there is a will 预期输出： Where There Is A Will 36

本关的任务是，给定一个字符串，要利用 Python 提供的字符串处理方法，从该字符串中，查找特定的词汇，并将其替换为另外一个更合适的词。例如，给定一个字符串Where there are a will, there are a way，我们发现这句话中存在语法错误，其中are应该为is，需要通过字符串替换将其转换为Where there is a will, there is a way。在大家日常工作使用 Word 编写文档的过程中，经常会遇到一个问题，发现前面写的文档中某个词用错了，需要换为另外一个词来表达。Word 提供了全文查找与替换的功能，可以帮助用户很方便的处理这一问题。那么，这一功能最基础和核心的就是字符替换，如果我们要自己基于 Python 来实现，该怎么做呢？编程要求：本关的编程任务是，补全代码，实现如下功能： step1 ：查找输入字符串source_string中，是否存在day这个子字符串，并打印输出查找结果； step2 ：对输入字符串source_string执行字符替换操作，将其中所有的 day替换为time，并打印输出替换后的字符串； step3 ：对 step2 进行替换操作后的新字符串，按照空格进行分割，并打印输出分割后的字符列表。样例测试集：测试输入： All day is no day when it is past. 预期输出： 4 All time is no time when it is past. ['All', 'time', 'is', 'no', 'time', 'when', 'it', 'is', 'past.'] 第一行输出结果即为"day"在source_string字符串中的位置; 第二行输出结果即为将其中所有的 day替换为time后的字符串；第三行输出结果即为对 step2 进行替换操作后的新字符串，按照空格进行分割后的字符列表。

字符串是一个字符序列，字符序列中所有元素都有相应的编号或索引（从左往右从0开始递增，从右往左从-1开始递减）。举例 words='Python' print(words[1]) print(words[-1]) print('Python'[0]) 输出 y n P 字符串的切片字符串是不可变序列，不能更改其中的元素，但可以通过切片操作来访问特定范围内的元素。使用两个索引，并用冒号分隔。采用左闭右开方式描述切片范围。两个字符串可以拼接起来组成一个新的字符串举例 s='python programming' print(s[0:4]) print(s[7:-4]) print(s[-11:-4]) print(s[:6]) 输出 pyth program program python【缺少答案，请补充】

Python的序列 Python中基本的数据结构是序列。序列中的每个元素都有位置编号,即元素的索引。其中,第一个元素的索引号为0,之后的索引号为1,2,3,…。 Python序列主要有字符串( str),列表(list),元组(tuple)。这三种序列的示例如下: #字符串示例: 'Hello' #列表示例: [12, 33.5, 'abc', 7] #元组示例: ('kk',99.7,75) 从这些示例可以看出,字符串是用引号括起来的一串字符(可以是单引号,双引号、三引号),这些字符有先后顺序,也就是有索引。列表和元组从表面上看，一个是用中括号括起来，一个是用圆括号括起来,但是它们有本质的差别。还可以看到列表或元组中不要求元素的类型相同。通用序列操作适用于所有序列的操作主要有索引、切片、相加、相乘和成员资格检查等。通用序列常用操作符入下图所示： Description 索引序列中的索引正方向从0开始递增,反方向从一1开始递减。设t = ['a','b','c','d'],其元素的索引值如下图所示。其可以用索引来访问序列中的元素,也可以用切片来访问序列中连续的若干元素。 Description 切片序列切片设置左边界和右边界来截取序列中的一段。其基本格式为: 序列名[左边界:右边界:步长] 其中,左边界、右边界和步长均可以省略。步长的默认值为1,具体意义可以参照下面列表索引与切片的例子。 Description 下面是元组和字符串索引与切片的例子。 Description 加法与乘法序列的加法表示序列连接,序列的乘法表示序列重复。 Description 成员资格检查判定某元素是否在一个序列中,使用in或者not in，计算结果为布尔型true或false。 Description 通用序列函数序列的内置函数主要有len() , min() , max() , sum() , sorted()等。其中len()函数返回序列包含的元素个数, min()和 max()函数分别返回序列中的最小元素和最大元素, sum()函数返回数值型序列中所有元素的和。另外, range()函数是一个与序列非常相关,也很常用的函数。 Description sorted()函数是将一个序列排序,排序后形成一个列表,返回列表,但是原序列不变。 Description 遍历序列 for循环可以遍历可迭代对象中的元素。字符串、列表、元组这样的序列是可迭代对象。 for循环结构的语法格式 for 循环变量 in 可迭代对象：循环体程序举例 for i in 'abc': print(i) 输出 a b c 程序举例 for i in [1,2,'a']: print(i) 输出 1 2 a【缺少答案，请补充】

输入一个字符串，将字符串中所有的数字字符取出来产生一个新的字符串例如：输入’abc1xyz23’ 输出：‘123’。输入输出样例输入 abc1xyz23 输出 123 提示：判断一个字符是否是数字，可以判断’0’<=字符<=‘9’,或者使用字符串的内置函数：isdigit()判断，格式：字符.isdigit()。

补全代码，实现相应的功能。具体要求如下： step 1：将guests列表末尾的元素删除，并将这个被删除的元素值保存到deleted_guest变量； step 2：将deleted_guest插入到 step 1 删除后的guests列表索引位置为2的地方； step 3：将 step 2 处理后的guests列表索引位置为1的元素删除；打印输出 step 1 的deleted_guest变量；打印输出 step 3 改变后的guests列表。本关涉及的代码文件src/Step1/guests.py的代码框架如下： # 创建并初始化Guests列表 guests = input().split(',') # 请在此添加代码，对guests列表进行插入、删除等操作

本关任务是利用合适的方法快速创建数值列表，并能够对列表中的元素数值进行简单的统计运算。在数据可视化的背景下，数值列表在 Python 列表中的应用十分广泛，列表十分适合存储数字集合。本关目标是让学习者掌握一些处理数字列表的基本方法，主要包括数字列表的创建、对数字列表进行简单的统计运算等。例如，我们要创建一个从2到10的偶数的数字集合，然后计算出该集合的数值之和： data_set = [2,4,6,8,10] sum=30 相关知识：本关可以利用range()、list()、sum()等函数方法来实现我们的目标。 range()函数 Python 提供了range()函数，能够用来生成一系列连续增加的数字。其基本使用语法有如下三种： range(lower_limit,upper_limit,step) 其中： lower_limit: 生成系列整数的下限整数，不填该参数则默认为从0开始，生成的整数从此数开始，包括该数； upper_limit：生成系列整数的上限整数，必填参数，生成的整数要小于该上限； step：在下限和上限之间生成系列整数之间的间隔步长，不填该参数则默认步长为1。注意：range()函数的三个参数都只能为整数。如果range()函数中仅一个参数，则该参数表示upper_limit，如果仅两个参数，则分别表示lower_limit和upper_limit。例如，要生成1~6之间步长为2的系列整数： for i in range(1,6,2): print(i) 输出结果： 1 3 5 基于range()函数创建数字列表我们可以通过range()函数，利用 Python 列表提供的append()插入功能创建一个列表。例如，我们要创建一个包含10个0~9整数的平方的列表： # 声明一个列表变量 numbers = [] # 利用append()函数和range()函数向列表插入目标元素 for i in range(10): number = i**2 numbers.append(number) print(numbers) 输出结果： [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 使用list()函数和range()函数创建数字列表我们可以利用list()函数将range()生成的系列数字直接转为列表，这时range()函数的返回值将会作为list()函数的参数，输出为一个数字列表。其基本使用语法如下： data_list = list(range(lower_limit,upper_limit,step)) 其中： list：列表函数的语法关键词； range：函数语法关键词； data_list：最终生成的列表变量。例如，我们要生成并输出1~5的数字列表： data_list = list(range(1,6)) print(data_list) 输出结果： [1,2,3,4,5] 对数字列表进行简单的统计运算 Python 中有一些专门处理数字列表简单的统计运算的函数，利用这些函数可以轻松找到数字列表的最小值、最大值及进行总和等一系列统计运算。其基本语法如下： min_value = min(data_list) max_value = max(data_list) sum_value = sum(data_list) 其中： min：数字列表求最小值的语法关键字； max：数字列表求最大值的语法关键字； sum：数字列表求和的语法关键字。具体使用示例如下： numbers = [2,4,11,1,21,32,5,8] print('The min number is',min(numbers)) print('The max number is',max(numbers)) print('The sum is',sum(numbers)) 输出结果： The min number is 1 The max number is 32 The sum is 84 编程要求编程任务是补全文件的代码，实现如下功能： step1：根据给定的下限数lower, 上限数upper以及步长step,利用range函数生成一个列表； step2：计算该列表的长度； step3：求该列表中的最大元素与最小元素之差。本关的代码文件代码框架如下： # 创建并读入range函数的相应参数 lower = int(input()) upper = int(input()) step = int(input()) # 请在此添加代码，实现编程要求评测说明样例测试集：测试输入： 25 90 4 预期输出： 17 64

我们在前三关中学习了如何处理单个列表元素和所有列表元素，在这一关中我们还将学习如何处理部分列表元素（Python 中称为切片）。例如，当我们去餐馆吃饭点菜时，你的菜单和我的菜单有些时候是一模一样，也有些时候是部分菜名一样。那么如何根据我已经点好的菜单生成你的菜单呢？本关将通过菜名列表的部分复制，让学习者了解并掌握列表切片的基础知识。相关知识：Python 切片是对一个列表取其部分元素获得一个子序列的常见操作，切片操作的返回结果类型与被切片的对象一致。要创建一个已有列表的切片，通过指定切片的第一个列表元素和最后一个列表元素的索引号即可。其基本语法如下： list_slice = source_list[start:end:step] 其中： source_list：被切片的源列表； list_slice：切片后生成的子序列列表； start：切片起始索引位置，省略则从头开始； end：切片结束索引位置，省略则切至列表末尾； step：切片步长，可选参数，表示每N个元素取一个，默认为1。注意：切片和range()函数一样，Python 会自动到达所指定切片结束索引位置的前面一个元素停止。例如，下面是我已经点好的菜名列表，现在朋友点的菜单中包含我的前三个菜名，输出朋友的菜单： my_menu = ['fish','pork','pizza','carrot'] print(my_menu[1:4:2]) print(my_menu[:3]) print(my_menu[2:]) 输出结果： ['pork','carrot'] ['fish','pork','pizza'] ['pizza','carrot'] 负数索引返回的是离列表末尾相应间隔的元素，列表末尾元素的索引是从-1开始的。例如，朋友的菜单是包含我的菜单最后3个菜名： my_menu=['fish','pork','pizza','carrot'] print(my_menu[-3:]) 输出结果： ['pork','pizza','carrot'] 编程要求：本关的编程任务是补全文件的代码内容，实现如下功能：利用切片方法从my_menu列表中每3个元素取1个，组成子序列并打印输出；利用切片方法获取my_menu列表的最后三个元素组成子序列并打印输出。本关涉及的代码框架如下： # 创建并初始化my_munu列表 my_menu = input().split(',') # 请在此添加代码，对my_menu列表进行切片操作

元组看起来犹如列表，但元组使用圆括号（）而不是[]来标识，而且列表的元素可以修改，但元组的元素不能修改。本关介绍元组的常见使用方法以及元组和列表的使用区别。下面用饭店菜单的例子来说明列表和元组使用的应用场景：现在有一个餐馆要向每个包厢都投放两份菜单，菜单上有4种菜名。我们想将两个菜单上最后一道菜名互换一下，也想快速知道改变后的两份菜单上单词首字母最大的菜名。而我们首先需要判断该用列表的方法还是元组的方法实现这个目标。为了实现这个目标，我们需要先学习元组的相关使用知识以及元组与列表的区别。相关知识元组与列表元组与列表很相似，两者之间的差别在于：列表在初始化后其中的元素还可以进行增删改等操作，但是元组在初始化后其中的元素不能进行更改；列表在赋值时使用方括号[]，而元组在赋值时使用小括号()。因为元组具有不可变的特性，所以在能用元组替代列表的地方最好都使用元组，这样代码更安全。创建元组：元组创建很简单，只需要在括号()中添加元素，元素之间用逗号隔开。元组中只包含单个元素时，需要在该元素后面添加逗号。例如： menu1 = ('meat','fish','chicken') menu2 = ('meat',) 访问元组元组和列表一样，可以使用下标索引来访问元组中的值。例如: menu = ('meat','fish','chicken','carrot') print(menu[0]) print(menu[1:3]) 输出结果： meat ('fish', 'chicken') 修改元组元组中的元素值是不可以修改的，如果强行修改会报错。例如我们想修改元组menu中的某个值： menu = ('meat','fish','chicken','carrot') menu[0] = 'pizza' print(menu[0]) 输出结果： TypeError: 'tuple' object does not support item assignment 系统会自动报错，元组中的元素值不支持修改。元组内置函数：元组和列表一样，都有一些内置函数方便编程。例如： len(tuple)：计算元组中元素个数； max(tuple)：返回元组中元素的最大值； min(tuple)：返回元组中元素的最小值； tuple(seq)：将列表转换为元组。元组中的元素是不能改变的，它也没有append()、insert()这样的方法，但其他获取元素的方法和列表是一样的。编程要求本关的编程任务是补全文件的代码内容，实现如下功能：将输入的菜单menu_list转换为元组类型；打印输出生成的元组；打印输出元组中首字母最大的元素。本关涉及的代码文件的代码框架如下： # 创建并初始化munu_list列表 menu_list = input().split(',') # 请在此添加代码，对menu_list进行元组转换以及元组计算等操作，并打印输出元组及元组最大的元素

a和b是两个长度相同的列表变量，列表a为［3,6,9］，从键盘输入列表b，计算a中元素与b中对应元素的和形成新的列表c，在屏幕上输出。例如，从键盘输入列表b为［1,2,3］，屏幕输出计算结果为［4,8,12］。

从键盘输入一组人员的姓名、性别、年龄信息，信息间采用空格分隔，每人一行，空行回车结束录入。计算并输出这组人员的平均年龄(保留2位小数)和其中女性人数。

字典和列表一样，都是 Python 中十分重要的可变容器模型，都可以存储任意类型元素。我们将以菜单的例子来说明字典使用的基本知识，餐馆的菜单上不仅包含菜名，菜名后面还必须包含该道菜的价格。如果要用列表实现，就需要两个列表，例如： list_menu = ['fish','pork','potato','noodles'] list_price = [40,30,15,10] 给定一个菜名，要查找相应的价格，就先要在list_menu中找到相应的位置，再在list_price中找到相应的价格。这种方式效率低下，那么我们是否可以将菜名和价格都存储在一个可变容器中呢？答案是可以的。在本关中，我们将学习和掌握能够将相关信息关联起来的 Python 字典的相关知识，并完成对包含菜名和价格的菜单的处理操作。相关知识:字典是 Python 最强大的数据类型之一，通过键-值对的方式建立数据对象之间的映射关系。字典的每个键-值对用冒号:分割，每个键-值对间用逗号,分隔开，字典则包含在{}中。列表格式如下： d = { key1 : value1, key2 : value2 } 每个键都与一个值相关联，我们可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何Python 对象用作字典中的值。访问字典中的值:要获取与键相关联的值，可依次指定字典名和放在方括号内的键，如下所示： # 创建并初始化menu字典 menu = {'fish':40, 'pork':30, 'potato':15, 'noodles':10} # 获取并返回menu字典中键'fish'键对应的值 print(menu['fish']) 输出结果： 40 添加键-值对字典是一种动态数据结构，可随时在字典中添加键-值对。要添加键-值对时，可依次指定字典名、键和键对应的值。下面在字典menu中添加两道菜的菜名和价格： # 创建并初始化menu字典 menu = {'fish':40, 'pork':30, 'potato':15, 'noodles':10} # 向menu字典中添加菜名和价格 menu['juice'] = 12 menu['egg'] = 5 # 输出新的menu print(menu) 输出结果： {'fish': 40,'pork': 30,'potato': 15,'noodles': 10, 'juice': 12,'egg': 5} 新的menu字典包含6个键-值对，新增加的两个键-值对（菜名和对应价格）添加在了原有键-值对的后面。注意：字典中键-值对的排列顺序和添加顺序没有必然联系。Python 不关心字典中键-值对的排列顺序，而只关心键与值的对应关系。同理，字典和列表一样，可以先创建一个空字典，然后可以不断向里面添加新的键-值对。修改字典中的值:字典和列表一样，里面的值都是可以修改的。要修改字典中的值，可直接指定字典中的键所对应的新值。例如，将menu中的fish价格改为50： # 创建并初始化menu字典 menu = {'fish':40, 'pork':30, 'potato':15, 'noodles':10} # 修改menu字典中菜fish的价格 menu['fish'] = 50 # 打印输出新的menu print(menu) 输出结果： {'fish': 50, 'pork': 30, 'potato': 15, 'noodles': 10} 删除键-值对我们可以通过del方法删除字典中不需要的键-值对。使用del方法时，要指定字典名和要删除的键。例如，在menu菜单中删除键noodles和它的值： # 创建并初始化menu字典 menu = {'fish':40, 'pork':30, 'potato':15, 'noodles':10} # 删除noodles键值对 del menu['noodles'] # 打印输出新的menu print(menu) 输出结果： {'fish': 40, 'pork': 30, 'potato': 15} 编程要求本关的编程任务是补全文件的代码，实现相应的功能。具体要求如下: 向menu_dict字典中添加一道菜名lamb，它的价格是50；获取menu_dict字典中的fish的价格并打印出来；将menu_dict字典中的fish的价格改为100；删除menu_dict字典中noodles这道菜；输出新的menu_dict菜单。本关涉及的代码框架如下： # 创建并初始化munu_dict字典 menu_dict = eval(input()) # 请在此添加代码，实现对menu_dict的添加、查找、修改等操作，并打印输出相应的值测试说明平台自动编译并运行stu.py，并以标准输入方式提供测试输入；平台获取程序输出，并将其输出与预期输出对比。如果一致则测试通过，否则测试失败。样例测试集：测试输入： {'pizza': 40, 'noodles':30,'carrot': 20, 'turkey': 34, 'fish': 37} 预期输出： 37 {'pizza': 40, 'carrot': 20, 'turkey': 34, 'fish': 100, 'lamb': 50}

Python 字典中包含大量数据，它和列表一样，支持遍历操作。 Python有多种遍历字典的方式，可以遍历字典的所有键-值对、键或值。例如，餐馆的菜单包含了菜名和价格等信息，餐馆需要将菜名和价格都展示给顾客，但也有些时候只需要将菜名都展示给厨师，还有些时候只需要将价格展示给收银员，这三种情况就用到了字典不同的遍历方式。本关的目标是让学习者掌握字典遍历的相关知识和用法，并基于这些知识实现对菜单不同的查找和展示处理。相关知识:遍历字典中的键-值对 Python 为字典类型提供了items()方法，items()方法会将字典里的所有的键与值一起返回。例如，餐馆有一个菜单包含了菜名和价格信息，菜名和价格顾客都需要知道，可以通过遍历输出menu字典的键和值来实现： # 创建并初始化menu菜单字典 menu={'fish':40,'pork':30,'potato':20,'lamb':50} # 利用items()方法遍历输出键和值 for key,value in menu.items(): print('key:',key) print('value:',value) 输出结果： key: fish value: 40 key: pork value: 30 key: potato value: 20 key: lamb value: 50 输出结果表示，items()方法每次都将对应的键和值指定到key和value变量中，然后用for循环输出。遍历字典中的键对于餐馆中的厨师来说，他们并不想要知道菜的价格，只需要知道菜名然后将其做出来就行。所以对于厨师来说，我们需要遍历menu字典中的所有菜名。 Python 为字典类型内置了keys()方法，该方法会将字典里的键遍历出来。例如： # 创建并初始化menu菜单字典 menu={'fish':40,'pork':30,'potato':20,'lamb':50} # 利用keys()方法遍历输出键 for key in menu.keys(): print('food_name:'+key) 输出结果： food_name:fish food_name:pork food_name:potato food_name:lamb 输出结果表示，keys()方法每次都是将menu菜单中的键输出，显示菜名。遍历字典中的值对于餐馆中的收银员来说，他们可能并不想知道菜单的菜名，只需要知道菜的价格，然后收账即可。所以对于收银员来说，我们需要遍历menu字典中的所有菜的价格。 Python 为字典类型内置了values()方法，该方法会将字典里的值遍历出来。例如： # 创建并初始化menu菜单字典 menu={'fish':40,'pork':30,'potato':20,'lamb':50} # 利用values()方法遍历输出值 for value in menu.values(): print('food_price:',value) # 可以对values()方法返回值使用max、min、sum等函数计算。 print(max(menu.values())) print(min(menu.values())) print(sum(menu.values())) 输出结果： food_price:40 food_price:30 food_price:20 food_price:50 50 20 140 输出结果表示，values()方法每次都是将menu菜单中的值输出，显示菜的价格。编程要求:本关的编程任务是补全代码，实现相应的功能。具体要求如下：将menu_dict菜单的键遍历输出；将menu_dict菜单的值遍历输出。本关涉及的代码框架如下： # 创建并初始化munu_dict字典 menu_dict = eval(input()) # 请在此添加代码，实现对menu_dict的遍历操作并打印输出键与值，最后打印所有价格的和、最大值和最小值样例测试集：测试输入： {'Spring Rolls':40,'pork':30,'Fried Wonton':15} 预期输出： Spring Rolls pork Fried Wonton 40 30 15 85 40 15

Python 的列表和字典可以存储任意类型的元素，所以我们可以将字典存储在列表中，也可以将列表存储在字典中，这种操作称为嵌套。例如，餐馆中的菜单不仅仅包含菜名和价格，可能还会包含很多其他信息，这时候我们可能就需要采取嵌套的存储方式。本关任务是让学习者利用嵌套方式存储菜单，让读者掌握 Python 嵌套的基本操作。相关知识:列表中存储字典餐馆中已经有了3份菜单，每份菜单都会有菜名和价格。我们要将这些信息存储在一起，可以采取如下方法：将3份菜单用字典的方式存储菜名和价格，然后将这3份菜单字典存储在一个列表中，例如： # 创建3个菜单字典，包含菜名和价格 menu1 = {'fish':40, 'pork':30, 'potato':20,'noodles':15} menu2 = {'chicken':30, 'corn':55, 'lamb':65,'onion':12} menu3 = {'bacon':36, 'beaf':48, 'crab':72,'eggs':7} # 将3个菜单字典存储到列表menu_total中 menu_total = [menu1,menu2,menu3] # 输出列表 print(menu_total) 输出结果： [{'fish': 40, 'pork': 30, 'potato': 20, 'noodles': 15}, {'chicken': 30, 'corn': 55, 'lamb': 65, 'onion': 12}, {'bacon': 36, 'beaf': 48, 'crab': 72, 'eggs': 7}] 字典中存储列表我们也可以在字典中存储列表。比如我们对于一份菜单，菜名作为键，而值我们想是这道菜的配料，那么我们就可以将这些配料作为列表存储，然后作为值存储在字典中。例如： # 初始化menu菜单，里面包含配料列表 menu = {'fish':['vinegar','soy','salt'], 'pork':['sugar','wine']} # 输出pork这道菜的配料 print('The burding of pork is:',menu['pork']) 输出结果： The burding of pork is: ['sugar', 'wine'] 字典中存储字典我们也可以在字典中存储字典。例如我们有一份总菜单，包含2个子菜单，每个子菜单都包含菜名和价格。例如： # 创建一个字典menu_sum，里面包含两个子菜单字典menu1和menu2 menu_sum = { 'menu1':{'fish':40, 'pork':30, 'potato':20,'noodles':15}, 'menu2':{'chicken':30, 'corn':55, 'lamb':65,'onion':12} } # 输出menu1和menu2中的菜名和价格 print(menu_sum['menu1']) print(menu_sum['menu2']) 输出结果： {'fish': 40, 'pork': 30, 'potato': 20, 'noodles': 15} {'chicken': 30, 'corn': 55, 'lamb': 65, 'onion': 12} 编程要求本关的编程任务是补全代码，实现相应的功能。具体要求如下： menu_total列表中初始时只包含menu1字典，menu1字典中包含两道菜和两道菜的价格；编程要求是向menu_total列表中添加另外一个菜单字典menu2，menu2菜单中的菜名和menu1菜单一样，菜的价格是menu1菜的价格的2倍；输出新的menu_total列表。本关涉及的代码框架如下： # 初始化menu1字典，输入两道菜的价格 menu1 = {} menu1['fish']=int(input()) menu1['pork']=int(input()) # menu_total列表现在只包含menu1字典 menu_total = [menu1] # 请在此添加代码，实现编程要求 # 输出menu_total列表 print(menu_total)

一个四位数，各位数字互不相同，所有数字之和等于6，并且这个数是11的倍数。满足这种要求的四位数有多少个？各是什么？

美国数学家维纳(N.Wiener)智力早熟，11岁就上了大学。他曾在1935~1936年应邀来中国清华大学讲学。一次，他参加某个重要会议，年轻的脸孔引人注目。于是有人询问他的年龄，他回答说：“我年龄的立方是个4位数。我年龄的4次方是个6位数。这10个数字正好包含了从0到9这10个数字，每个都恰好出现1次。” 请编程输出当年维纳的年龄。

本关的编程任务是补全文件的代码，实现相应的功能。具体要求如下: 编写函数，判断年份 n 是否是闰年。若是闰年，返回True，否则返回False。满足下面条件之一就是闰年：能被4整除但不能被100整除，能被400整除。本关涉及的代码框架如下： # 请在此添加代码，定义isleapyear(n)函数，判断年份 n 是否是闰年。若是闰年，返回True，否则返回False。 n=int(input()) #输入年份，int()将字符串转换为整型数据 print(isleapyear(n)) #输出函数调用结果测试输入：2025 预期输出： 37 False

当函数定义里有多个参数时，其参数的传递形式主要有以下五种：位置传递、关键字、默认值传递、包裹传递和解包裹传递。默认情况下，参数可以按位置或显式关键字传递给 Python 函数。为了让代码易读、高效，最好限制参数的传递方式，这样，开发者只需查看函数定义，即可确定参数项是仅按位置、按位置或关键字，还是仅按关键字传递。 1 位置传递位置固定，参数传递时按照形式参数定义的顺序提供实际参数。其优点是使用方便，缺点是当参数数目较多时，参数对应容易混淆。且要求传入参数的数量必须和定义函数时参数的数量相同。 def fun(name, city, hobby): '''接收三个字符串作为参数，返回一个进行自我介绍的字符串''' return '我的名字是{}，来自{}，我的爱好是{}。 '.format(name, city, hobby) n,c,h = input().split() # 根据空格切分输入字符串，分别赋值给n,c,h print(fun(n,c,h)) # 根据实参变量n,c,h的顺序传递参数或值给形参name, city, hobby 在定义fun()函数时，参数name、city、hobby尚未绑定对象，没有值。只有经过函数调用，才会把调用时的参数值赋值给形式参数，函数体中的变量才有了值。定义一个求解一元二次方程根的函数 def solve(a, b, c): """接收三个参数，返回一元二次方程的根""" d = b ** 2 - 4 * a * c if d > 0: disc = d ** 0.5 root1 = (-b + disc) / (2 * a) root2 = (-b - disc) / (2 * a) return root1, root2 elif d == 0: return -b / (2 * a) else: return "此方程无实数根" # 输入系数 a,b,c = map(float,input("请输入一元二次方程的系数（空格分隔）：").split()) # 输出结果 print(solve(a,b,c)) 2 关键字传递关键字传递是指，在函数调用时提供实际参数所对应的形式参数的名称，根据参数名称来传递参数。关键字并不需要遵守位置的对应关系。其优点是明确标示实际参数和形式参数的对应关系，参数的书写顺序更灵活。缺点是增加了函数调用时的代码书写量。 def fun(name, city, hobby): return '我的名字是{}，来自{}，我的爱好是{}'.format(name, city, hobby) n,c,h = input().split() # 切分字符串，分别赋值给n,c,h print(fun(hobby = h, city = c,name = n)) # 根据关键字name, city, hobby来传递参数，关键字传递时顺序无关位置传递和关键字传递可以混用。但要注意的是，混用时，按位置传递的参数要出现在按关键字传递的参数之前。否则，编译器无法明确知道除关键字以外的参数出现的顺序。 def fun(name, city, hobby): return '我的名字是{}，来自{}，我的爱好是{}'.format(name, city, hobby) n,c,h = input().split() # 切分字符串，分别赋值给n,c,h print(fun(n, hobby = h, city = c)) # 位置参数n出现在关键字参数h和c之前 3 默认值传递在定义函数的时候，使用形如city='武汉’的方式，可以给形式参数赋予_默认值(default)__。在函数调用时，如果该参数得到传入值，按传入值进行计算，否则使用默认值。 def fun(name, city, hobby='唱歌'): return '我的名字是{}，来自{}，我的爱好是{}。'.format(name, city, hobby) n,c = input().split() # 切分字符串，分别赋值给n,c，例如输入：夏琪武汉 print(fun(n, c)) # 默认值参数可以不传值 # 输出：我的名字是夏琪，来自武汉，我的爱好是唱歌。 print(fun(n, c, '游泳')) # 传值时，默认值会被传入的值替换 # 输出：我的名字是夏琪，来自武汉，我的爱好是游泳。需要注意的是，默认值参数必须放在必选参数之后。当函数的参数有多个时，默认值参数必须在后面，非默认值参数在前面。也就是说，一旦出现了带默认值的参数，后面的其他参数都必须带默认值了。 def fun(name='夏琪', city, hobby='唱歌'): #语法错误，city 是非默认值参数，出现在默认值参数hobby的前面了 return '我的名字是{}，来自{}，我的爱好是{}。'.format(name, city, hobby) # 以下为主程序，观察输出结果 n,c,h = input().split() # 切分字符串，分别赋值给n,c,h print(fun(n,c,h)) # 调用函数 4 包裹传递包裹传递也称为不定参数传递，用于在定义函数时不能确定函数调用时会传递多少个参数时使用。函数每次调用时，传递的参数数量可以不同。 1）当传入参数是位置传递时，所有传入参数被收集打包合并成一个元组，再传递给函数。 def add(*number): """接收不确定数量位置传递的参数，合并为一个元组number在函数体内使用""" print(number) # 输出传入的对象，查看参数类型，元组，形如(1,3,5,7, 9) result = 0 # 定义一个变量，用于存储求和结果 for i in number: # 遍历元组中的每个元素 if type(i) in (int, float): # 对参数进行了类型检查（数值型的才能求和） result = result + i # 求和 return result # 返回求和结果 # 以下为主程序，调用函数add传入不同参数，观察输出结果 print(add(1,3,5,7, 9)) # 输出25 print(add(1,2,3,4,5,6,7,8,9, 10)) # 输出55 print(add(1,2, 'hello',3.45, 6)) # 输出12.45 2）当传入参数是关键字传递时，所有传入的关键字参数被收集打包合并成一个字典，再传递给函数。 def add(**number): """接收不确定数量的关键字参数，合并为字典number在函数体内使用""" print(number) # 输出形如{'a': 1, 'b': 3, 'c': 5}的字典 return sum(number.values()) # 对字典的值求和，返回结果 # 以下为主程序，调用函数add传入不同参数，观察输出结果 print(add(a=1, b=3, c=5)) # 输出9 print(add(m=1, n=2, o=3, p=4, q=5, i=6, j=7, k=8)) # 输出36 下面例子中，参数列表中的**kwargs可以接收0个或任意多个关键字参数调用函数时传入的关键字参数会组装成一个字典（参数名是字典中的键，参数值是字典中的值）如果一个关键字参数都没有传入，那么kwargs会是一个空字典 def foo(*args, **kwargs): print(args) print(kwargs) foo(3,2.1, True, name='骆昊', age=43, gpa=4.95) #运行后，输出下面内容： #(3,2.1, True) # {'name': '骆昊', 'age': 43, 'gpa': 4.95} 5 解包裹传递 *和**也可以在函数调用时使用，此时称为解包裹传递。 def add(a, b, c): """接收三个位置传递参数，返回其加和""" return a + b + c # 返回三个参数的加和 # 以下是主程序，调用函数，传递参数 num1 = (1,3, 5) # 位置传递参数 print(add(*num1)) # 调用函数，传递参数，输出结果9 num2 = {'a': 1, 'b': 2, 'c': 3} # 关键字传递参数 print(add(**num2)) # 调用函数，传递参数，输出结果6【缺少答案，请补充】

def myName(): print(general_name) # 函数内部访问全局变量general_name，打印其值赵云 general_name = '赵云' # 定义全局变量general_name myName() # 调用函数myName() print(general_name) # 函数外部访问全局变量general_name，打印其值赵云

现有列表ls = [3,8,-3,-1,0,-2,-9]，请（1）将列表ls中的元素按升序排序输出；（2）再按照绝对值的大小进行降序排序输出。

斐波那契数列前n项 0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,…… Image 斐波那契数列又称黄金分割数列，这个数列从第3项开始，后一项的值总是与他前面两项的和的值相等。在数学上，以递推的方法定义： F(1)=0 F(2)=1 F(n)=F(n - 1)+F(n - 2) (n ≥ 2，n ∈ N*) 在数学上，也可以给出归纳方法定义： f(n) = 0 (n=0) f(n) = 1 (n=1) f(n) = f(n - 1) + f(n - 2) (n ≥ 2，n ∈ N*) 很明显这是一个分段函数，可以用二分支来实现： def fibonacci(n): """定义递归函数，接收非负整数n，返回斐波那契数列的第n项""" if n == 0: # 第一项为1 return 0 elif n == 1: # 第二项为1 return 1 else: return fibonacci(n - 1) + fibonacci(n - 2) # 其他项等于前两项之和 num = int(input()) # 输入非负整数 print(fibonacci(num)) # 调用递归函数求斐波那契数列的第n项并输出需要注意的是，在else分支下面，程序的返回值中再次调用了函数fibonacci()，只是参数值变小了。修改一下描述： f(n) = n (n≤1) f(n) = f(n - 1) + f(n - 2) (n ≥ 2，n ∈ N*) def fibonacci(n): """定义递归函数，接收非负整数n，返回斐波那契数列的第n项""" if n <= 1: # 前两项为0或1 return n else: return fibonacci(n - 1) + fibonacci(n - 2) # 其他项等于前两项之和 num = int(input()) # 输入非负整数 print(fibonacci(num)) # 调用递归函数求斐波那契数列的第n项并输出【缺少答案，请补充】

递归也常用于计算阶乘。 def factorial(n): if n == 1: return 1 else: return n * factorial(n-1)

汉诺塔问题是一个经典的递归问题。 def hanoi(n, source, target, auxiliary): if n > 0: hanoi(n - 1, source, auxiliary, target) print('Move disk from {} to {}'.format(source, target)) hanoi(n - 1, auxiliary, target, source)

问题描述如下：五个人在夜间捕到一堆鱼，约定第二天分鱼。第二天早上，第一个人醒来，将鱼分为五份，发现多了一条，就扔掉这条，拿走自己的一份。后来第二个、第三个、第四个、第五个人都是这样分鱼的【每个人都不知道前面有人分过，所以仍然分5份】。问他们至少捕到多少条鱼？ def fish(n, total): #n个人分total条鱼，有解的话返回解；无解的话返回False # n是还未分鱼的人数，total是当前的鱼数 if n == 0: # 所有的人都已经分过鱼了 return total # 返回最后的鱼数 elif total % 5 == 1: # 当前的鱼数可以被5整除，并且还剩一条鱼 # 递归调用fish函数，n减1，total更新为剩下的鱼数 return fish(n - 1, (total - 1) * 4 / 5) else: # 当前的鱼数不能被5整除，或者不剩一条鱼 return False # 返回False，表示这个鱼数不符合条件 total = 1 # 从1开始尝试 while True: # 不断尝试，直到找到一个符合条件的鱼数 if fish(5, total): # 如果这个鱼数符合条件 print(f"五人至少合伙捕到{total}条鱼") # 输出这个鱼数 break # 结束循环 total += 1 # 尝试下一个鱼数(可以每次+5)

有一座八层宝塔，每一层都有一些琉璃灯，每一层的灯数都是上一层的二倍，已知共有765盏琉璃灯，求解每层各有多少。 def lamps(n, total): if n == 1: # 如果只有一层 return [total] # 返回总灯数 else: # 第一层的灯数是总灯数除以(2^n - 1) first = total // (2 ** n - 1) # 返回第一层的灯数和剩下层的灯数 return [first] + lamps(n - 1, total - first) print(lamps(8, 765)) # 输出每层的灯数

猴子摘下了n个桃子，第一天吃了一半又多吃了一个，第二天也是吃了剩下的一半又多吃了一个，到了第十天想再吃时，发现只剩下一个桃子了。问猴子第一天共摘了多少个桃子？ def peaches(day): #计算第day天的桃子数 if day == 10: # 第10天只剩下一个桃子 return 1 else: # 第day天的桃子数是第day+1天的桃子数加一后的两倍 return (peaches(day + 1) + 1) * 2 print(peaches(1)) # 输出第一天的桃子数

Python 运算符号里的//指的是什么？

Python中的运算符中，%指的是？

已知a=2,b=4，想通过变量的运算来计算2的4次方,下列代码你觉得能实现的是

以下哪个变量标识符是错误的

以下选项中可用作Python标识符的是( )

Python中的标识符中，下面所列举的标识符是合法的（）。

下列标识符中，合法的是（）。

下列选项中，Python不支持的数据类型有( )。

关于Python的变量管理，下列说法错误的是（）。

下面（）不是有效的变量名。

以下不是python中的数据类型的是( )。

以下不是python中的关键字（）。

下列关于Python变量名的定义，下列选项不正确的是（）。

下面代码的输出结果是 x = 12.34 print(type(x))

下面代码的输出结果是 x=3.1415926 print(round(x,2) ,round(x))

以下选项中描述正确的是：

下列哪个内置函数用于读取键盘上键入的数字:

round(3.5738,2)-round(0.4)的结果是

Python 运算符号里的/指的是什么？

世界上公认的第一台电子计算机ENIAC于______年诞生在美国宾夕法利亚大学。

Python的创始人为______。

Python语言中单行注释使用符号______开头。

Python语言中多行注释使用符号______把注释内容括起来。

下列程序运行后，变量x的输出结果是（） x=7 y=2 x=x-1 x=x+y y=x-y print(x)

下列程序运行后，变量y的输出结果是（） x=7 y=2 x=x-1 x=x+y y=x-y print(y)

执行下面程序产生的结果是____。 X=2;y=2.0 if (x==y): print("相等") else: print("不相等")

执行下列 Python语句将产生的结果是____。 x=1 if x: print(True) else: print(False)

执行下列python语句将产生的效果是（） x="0" if x:print(True) else:print(False)

执行下列python语句将产生的效果是（） x=0 if x:print(True) else:print(False)

关于分支结构以下描述错误的是

实现多路分支的最佳控制结构是

选择下面程序的运行结果 x = 0 y = 10 if x > 0 else -10 print(y)

选择下面程序的运行结果 x,y,z=1,-1,1 if x > 0: if y > 0: print("x > 0 and y > 0") elif z > 0: print("x < 0 and z > 0")

Python过程化程序设计的三种基本程序控制结构是( ) 。

for i in range(10): …… 中，i的循环终值是____。

下面____语句不能完成1到10的累加功能, total初值为0。

以下for语句执行后，“print(i)”共被执行了（）次？ for i in range(3,5,-1):print(i)

以下for语句执行后，“print（i）”共被执行了（）次？ for i in range(5,3,-1):print(i)

在for循环的迭代过程中，变量num包含哪些值？ for num in range(2, 9, 2):

执行以下代码后，结果是什么？ total = 0 for count in range(1,4): total += count print(total)

执行以下代码，结果是什么？ total = 0 for count in range(4,6): total += count print(total)

执行以下代码后，结果是什么？ for num in range(0, 20, 5): num += num print(num)

执行循环语句for i in range(1,5,2):print(i),循环执行次数是（）

下面代码的输出结果是 for s in "HelloWorld": if s=="W": break print(s,end="")

关于break语句与continue语句的说法中，以下选项中不正确的是

continue语句的作用是：

求100以内的奇数和，请在注释处选择合适的选项( ) s=0 i=1 while i<=100: s=s+i #添加代码 print(s)

求100以内（包括100）的偶数和，请在注释处选择合适的选项： s=0 i=0 while i<=100: s=s+i #添加代码 print(s)

执行下列语句后输出结果是（） i=-2 while i<0: i*=i print(i)

执行下列语句后，循环体共执行（）次 i=-2 while i<0: i*=i print(i)

关于Python的无限循环，以下选项中描述错误的是

下列快捷键中能够中断Python程序运行的是

下面程序的循环执行次数是 k=10000 while k>1: print(k) k=k/2

关于while保留字，以下选项中描述正确的是

下面代码中循环结束后，count的值是（） count = 0 while count<5: count +=2

下列程序运行输出结果为_______。 day=4 x=1 while day>0: x=(x+1)*2 day-=1 print(x)

下面不是while循环的特点的是

下面代码的输出次数是？ k=1000 while k>1: print(k) k=k/2

执行以下代码，结果是什么？ count = 4 while count < 12: print(\"counting\",end=\" \") count = count + 2

求比10小且大于等于0的偶数，下列程序中空格处应填入（） x = 10 while x: x = x-1 if x%2!=0: ________ print (x)

下面程序中语句print(i*j)共执行了____次。 for i in range(5): for j in range(2,5): print(i*j)

下面代码的输出结果是 for num in range(2,10): if num > 1: for i in range(2,num): if (num % i) == 0: break else: print(num,end=",")

以下程序运行时，输出结果是（） s=1 for m in range(1,6): for i in range(2,m): if m%i==0: break else: s*=m+1 #即s=s*(m+1) print(s)

下面程序中语句print(i*j)共执行了_____次。 for i in range(5): for j in range(1,5): print(i*j)

str = 'hello world'，str[-7:8].split()的结果是？

用下面的（）函数，可以将字符串'abcde'用逗号分开，形成新的字符串'a,b,c,d,e'

已知：s='a_ba_bc'，下面（）选项可以实现将s字符串中的“_ ”去掉，变为'ababc'

关于字符串下列说法错误的是（）。

“ab”+“c”*2 结果是（）。

以下关于列表和字符串的描述，错误的是（）。

设str='python'，想把字符串的第一个字母大写，其他字母还是小写，正确的选项是（）。

在一行上输入两个字符串到两个变量a、b中的语句正确的是( )。

执行以下代码，结果为：( ) s='alex' li=list(s) print(li)

已知x是一个序列，则以下选项中，不能访问序列最后一个元素的是（）。

已知a=[1,2,3,4,5]，则a[-3:]的值是（）。

若有序列a=[1,2,3,4]，则a[3]的值为( )

若有序列a=[1,2,3,4,5,6,7,8,9,10]，则数值最小和最大的元素下标分别是( )。

以下代码段的执行结果为( )。 a=[[1,2,3],[4,5],[7]] print(a[1][2])

执行以下代码后，变量number对应哪个列表？ number=list(range(0,9,2))

已知列表x=list(range(1,6))，下列选项中可以取出最后一个元素的操作有_______

已知 aList = [1,2,3,4,5,6,7]，下列说法中错误的是

下列表达式的值是True的有___________。

下面代码的执行结果是（）。 ls=[[1,2,3],[[4,5],6],[7,8]] print(len(ls))

表达式[1, 2, 3]*3的执行结果为（）。

任意长度的Python列表、元组和字符串中最后一个元素的下标为（）。

已知序列对象x = ['11', '2', '3']，则表达式 max(x) 的值为( )。

表达式 min(['11', '2', '3']) 的值为( )。

已知序列x = ['11', '2', '3']，则表达式max(x, key=len) 的值为( )。

执行下列代码后，变量list的值将改变为哪个选项？ list=[1,2] list=list*3

下列表达式的值是False的有（）

已知a=[1,2,3,4,5]，则a[-1:-3:-1]的值是（）。

对于序列s，能够返回序列s中第i到j以k为步长的元素子序列的表达是:( )

以下选项中，不是具体的 Python序列类型的是:( )

设序列s，以下选项中对max（s）的描述正确的是:( )

执行以下代码，结果为：( ) str=“C语言中文网” print(str[0],“==”,str[-6]) print(str[5],“==”,str[-1])

执行以下代码，结果为：( ) list = [None]*5 print(list)

Li=['alex', 'eric', 'arin']，print( len(Li))的值为（）

执行以下代码，结果为：( ) S=‘ABCDEFGH’ S[::-1]

执行下列代码， num=[1,2,3,4] print(len(num)) 运行结果正确的是（）

哪种方法可用于列表转化为元组？

哪种方法可用于元组转化为列表？

已知x=[7, 5, 8, 9, 3]，则x.reverse()后，x的值是（）。

已知x=[1,2,3,4]，则执行x[len(x)-1:]=[5]后，x的值是（）。

已知a=[1,2,3,4,5]，以下选项中，不能删除列表a的最后一个元素5的是（）。

下面代码的执行结果是（）。 ls = ["2020","20.20","Python"] ls.append(2020) ls.append([2020,"2020"]) print(ls)

切片操作list(range(6))[::2]执行结果为（）。

执行下列代码后，变量list2的值将改变为哪个选项？ list1 = [1, 2, 3] list2 = [] for element in list1: list2.append(element) list1 = [4, 5, 6]

执行下列代码后，变量list的值将改变为哪个选项？ list = [1, 2, 3, 4] list[3] = 10

执行下列代码后，变量list2的值将改变为哪个选项？ list1 = [1, 2, 3] list2 = [] for element in list1: list2.insert(0,element) list1 = [4, 5, 6]

执行以下语句，输出结果为：________。 L1=[11,22,33] L2=[22,33,44] for i in L2: if i not in L1: print(i)

执行以下语句，输出结果为：_______。 li=['one','two','three'] li.append('python') print(li)

以下程序运行时，输入1 2 3 4 5，输出结果是（） n=list(input().split()) s=1 for m in n: m=int(m) for i in range(2,m): if m%i==0: break else: s*=m+1 print(s)

已知x=[1, 2, 3]，y=[4, 5]，则x.append(y)后，x的值是（）。

已知x=[1, 2, 3]，y=[4, 5]，则x.extend(y)后，x的值是（）。

以下不能创建一个字典的语句是（）。

以下程序执行的结果是() for x in {'a':'b','c':'d'}: print(x,end=' ')

对于for i in s:......语句，以下说法不正确的是（）。

字典使用（）作为标识符

以下关于字典的描述，错误的是( )

设x是一个字典，返回字典中的“健—值”对的常用方法是( )

>>>dict={1:'one',2:'two',3:'three'} >>>dict[2] 输出的结果是（）

>>>x={'兔子':'胡萝卜','小羊':'青草','老虎':'肉'} >>>print('兔子的食物是:',x['兔子']) 输出的结果是（）

>>>x={'王一':60,'李二':80,'张三':'90'} >>>y=x.get('李二') >>>y 输出的结果是（）

>>>x={'王一':60,'李二':80,'张三':'90'} >>>x1={'aa':40,'bb':50,'张三':60} >>>x.update(x1) >>>x 输出的结果是（）

Python语句print(type({1:1,2:2,3:3,4:4}))

对于字典di={'a':10,'b':20,'c':30,'d':40}，对第4个字典元素的访问形式是_________。

对于字典di={'a':10,'b':20,'c':30,'d':40}，len(di)的值是_________。

对于字典di={'a':10,'b':20,'c':30,'d':40}，sum(list(di.values()))的值是_________。

创建一个集合{0,1,2,3,4,5}，下面__________是正确的。

返回集合中元素个数的函数是______。

对于集合s，以下哪个操作是不存在的？

阅下面的程序： list1 = [1 , 2 , 1 , 3] nums = set(list1) for i in nums: print(i , end = "") 程序执行的结果为（）

导入python中相应模块的关键字是（）

执行下列代码， import random n= random.randint(0,2) list = ['下雨','多云','晴'] print(list[n]) 下列说法错误的是：

关于 import 引用，以下选项中描述错误的是：

可以查看Python的版本的语句是：

以下代码段的执行结果为( )。 def f(n): if n<3: return n else: return f(n-1)+f(n-2) print(f(8))

写出下面代码的执行结果。 def Join(List, sep=None): return (sep or ',').join(List) print(Join(['a', 'b', 'c']))

在函数内部可以通过关键字（）来定义全局变量

以下kk是一个Lambda函数，kk=lambda x,y,z=2:x**3+y%3+z，则计算kk(2,9,3)的得到的结果为_____。

以下代码段的执行结果为( )。 def func(b): b=5 a=[0,1,2,3] func(a[2]) print(a)

关于形参和实参的描述，以下选项中正确的是_____

以下代码段的执行结果为( )。 def f(a,b=3,c=5): return a+b**2+c**3 print(f(b=4,a=2),f(3,8),f(7,2,3))

执行下列代码， a=3 b=4 def fun(): print(a+b) fun() 运行的结果正确的是

执行下列代码， def fun(): print(58) return print(68) fun() 输出结果为：

执行下列代码， def fun(a,b): sum = 2*a+b**2 print(sum) fun(2,5) 运行结果正确的是（）

下列关于自定义函数，说法正确的是_______

关于函数，以下选项中描述错误的是：

执行下列代码，输出_____ def Sum(a, b=3, c=5): return sum([a, b, c]) print(Sum(a=8, c=2))

执行下列代码，输出_____ def Sum(*p): return sum(p) print(Sum(3, 5, 8))

函数的标题由（）组成

以下Python中关于函数的描述中，错误的是（ )。

以下关于Python全局变量和局部变量的描述，错误的是（）

下列选项中不属于函数优点的是（）。

关于函数的说法中正确的是（）。

以下关于函数说法正确的是（）。

自定义函数为func(x1,x2,x3=6)代码如下，主程序调用后，所得结果为： def func(x1,x2,x3=6): if x1<x2: x1,x2=x2,x1 if x3>x1: x=x1;y=x2 x1=x3;x2=x;x3=y elif x3>x2: x2,x3=x3,x2 return x1,x2,x3 '''主程序''' print(func(3,8,7))

以下自定义函数带默认参数，运行之后结果为： def func(a=1,b,c ='abc'): print("a=", end=' ') print("b=", end=' ') print("c=", c) return '''主程序''' func(a=2, b=3)

以下程序运行之后，输出结果正确的是？ def f1(): print(a+3,end=' ') def f2(): a=8 print(a,end=' ') a=6 f1() f2() print(a)

圆周长和面积：键盘输入1个数据，表示半径，计算圆的周长和面积，结果保留2位小数。

求两个数相除的商和余数：键盘输入2个数据，求两个数相除（第一个数除以第二个数）的商和余数。

银行存款：假设银行一年期定期存款利率r为2.5%，每年到期后“本金”+“利息”自动转为下一个一年期定期存款。如果用户存入x元，计算n年后本利之和d（结果保留2位小数）。

球的表面积和体积：从键盘输入球的半径，编程计算球的表面积和体积。（结果保留2位小数）提示：球的表面积公式为4πr**2，球的体积公式为4/3*πr**3。

三角形面积：从键盘输入3个数，判断是否是三角形的3边长，如果是则计算三角形的面积，如果不是输出提示信息。

成绩等级：输入成绩0~100，输出成绩的5个等级。其中，成绩大于等于90为优，小于90但大于等于80为良，小于80但大于等于70为中等，小于70但大于等于60为及格，小于60为不及格。

购物金额：某商场为了促销，采用购物打折的办法。如果金额<2000元，没有任何折扣；如果4000>金额≥2000元，按九五折优惠；如果8000>金额≥4000元，按九折优惠；如果金额≥8000元，按八折优惠。编写程序，输入原购物金额，计算并输出优惠后的金额（保留1位小数）

闰年判断：从键盘任意输入一个公元年份（大于等于1），判断它是否是闰年。要求对输入数据进行合法性判断。已知符合下列条件之一者是闰年：能被4整除，但不能被100整除；或者能被400整除。分析:从键盘输入年份year，如果year不是整数或者小于1，则显示“您输入的不是有效的年份！”；否则，判断year是否满足闰年的条件，如果满足则是闰年，否则不是闰年。

从键盘输入一个正整数，判断它是否为素数，若是素数，输出“是素数”，否则输出“不是素数”。分析：素数即质数，它除了能被1和它本身整除外，不能被其他任何整数整除（1不是素数）。例如，7是素数，除了1和7以外，它不能被2~6之间的任何整数整除。判断素数的方法：把 n 作为被除数，i=2~n-1依次作为除数，判断 n 与 i 相除的结果，若都除不尽，即余数都不为0，则 n 为素数；反之，只要有一次能除尽（余数为0），则说明 n 存在一个1和它本身以外的因子，它就不是素数。

输入正整数n，计算并输出1+2+3+…+n。分析：用累加器

输入正整数n，计算1!+2!+3!+…+n!,输出计算结果。

输入正整数n，计算前n个自然数中能被3或5整除的数之和。注意：0是最小的自然数，前n个自然数是指0~n-1之间的n个自然数。

从键盘任意输入两个公元年份m和n，m<n，输入m~n之间所有闰年年份。已知符合下列条件之一者是闰年：能被4整除，但不能被100整除；或者能被400整除。输入输出样例输入 2020 2050 输出 2020 2024 2028 2032 2036 2040 2044 2048 注意：输出语句使用end参数，end=“\t”

计算百马百担问题：有100匹马，驮100担货，大马驮3担，中马驮2担，两匹小马驮1担，问有大、中、小马各多少？输出要求每行输出一组数据，格式举例如下：大马2匹，中马30匹，小马68匹注意：输出中的，是中文符号。

计算“百钱买百鸡”问题。公鸡每只5元，母鸡每只3元，小鸡3只1元，现要求100元钱买100只鸡，问公鸡、母鸡和小鸡各买几只？输出要求每行输出一组数据，格式举例如下：公鸡0只，母鸡25只，小鸡75只注意：输出中的，是中文符号。

本关任务：编写一个解决鸡兔同笼问题的小程序。相关知识鸡兔同笼大约在 1500 年前，《孙子算经》中记载一个有趣的问题：今有雉兔同笼，上有三十五头，下有九十四足，问雉兔各几何？大概的意思是：有若干只鸡兔同在一个笼子里，从上面数，有 35 个头，从下面数，有 94 只脚，问笼中各有多少只鸡和兔？请编一个程序，用户在同一行内输入两个整数，代表头和脚的数量，编程计算笼中各有多少只鸡和兔（假设鸡和兔都正常，无残疾），如无解则输出`“Data Error! #参考下面的示例代码，从同一行读入两个数 a, b = input().split() # 将输入的以空格分隔的两个数命名为a和b a, b = map(int,input().split(',')) # 将输入的以逗号分隔的两个值，转换为整数后命名为a和b 编程要求根据提示，在右侧编辑区补充代码，计算并输出鸡和兔子的个数。测试说明平台会对你编写的代码进行测试：测试输入：输入为一行，以空格分隔的两个整数 h f，分别代表鸡兔的总头数和总脚数。预期输出：使用输入值进行计算，如有解，则输出：有m只鸡，n只兔如无解则输出数据错误！输入： 35 94 输出：有23只鸡，12只兔注意：输出中的，和！是中文符号。

输入字符串，统计并输出字符串中数字、字母、下划线的个数。输入输出样例输入 1234abcABCDE 输出数字个数为：4，字母的个数：8，下划线的个数：0。提示：判断一个字符是否是数字，可以判断’0’<=字符<=‘9’,或者使用字符串的内置函数：isdigit()判断，格式：字符.isdigit()。判断一个字符是否是字母，可以判断’a’<=字符<=‘b’ or ‘A’<=字符<=‘B’,或者使用字符串的内置函数：isalpha()判断，格式：字符.isalpha()。输出中的，和。都是中文字符。

输入一行字符,统计其中有多少个单词,每两个单词之间以空格隔开。如输入: This is a Python program. . 输出：There are 5 words in the line. 输入输出样例输入 This is a Python program. 输出 There are 5 words in the line. 提示：使用字符串内置函数split()拆分字符串。

输入两个字符串，查找并输出两个字符串中公共的字符。如: 字符串1为:abc123, 字符串2为:mnae3 , 输出:公共字符有:a3 输入输出样例输入 abc123 mnae3 输出 a3 提示：可以使用成员资格检查运算符 in 。

输入字符串，判断并输出是否为回文字符串。回文字符串是正读和反读都一样的字符串，比如字符串"aba"就是回文字符串。输入输出样例输入1 aba 输出是回文字符串输入2 hello 输出不是回文字符串

编写程序，输入列表，将列表中的偶数变成它的平方，奇数变成它的立方，输出新的列表。输入输出样例输入 7,9,8,3,2,1,6,5,4,10 输出 [343, 729, 64, 27, 4, 1, 36, 125, 16, 100]

通过键盘输入一系列整数值，输入 0 则表示输入结束，将这些值（不含 0）建立为一个列表，求列表的元素个数、最大值、最小值、元素之和以及平均值，并按从大到小的顺序将列表所有元素输出在一行上。输入输出样例输入 3 9 5 1 12 33 2 10 0 输出元素个数=8，最大值=33，最小值=1，和=75，平均值=9.375 列表元素从大到小依次为：33 12 10 9 5 3 2 1 注意：输出中的，和：都是中文符号。

输入正整数n，计算并输出斐波那契数列的前n项。该数列的第1项和第2项为1，从第3项开始，每一项均为其前面2项之和，即1，1，2，3，5，8，…… 输入输出样例输入 20 输出 [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

输入一个数，将其转换成中文数字输出。例如，输入“123456789.0”，输出“壹贰叁肆伍陆柒捌玖点零”。输入输出样例输入 123.45 输出壹贰叁点肆伍

查找电话，输入通讯录，输入姓名，在通讯录中查找对应的电话，找到则输出电话，找不到则显示“not found”。通讯录格式示例如下： address_list={ 'mayun':'13309283335', 'zhaolong':'18989227822', 'zhangmin':'13382398921', 'Gorge':'19833824743'} 输入输出样例输入示例1： {'mayun':'13309283335','zhaolong':'18989227822','zhangmin':'13382398921','Gorge':'19833824743'} zhangmin 输出示例1： 13382398921 输入示例2： {'mayun':'13309283335','zhaolong':'18989227822','zhangmin':'13382398921','Gorge':'19833824743'} Jordan 输出示例2： not found

字母出现次数，输入字符串，输出字符串中出现次数最多的字母及其出现次数。输入输出样例输入示例1： strawberry 输出示例1： r 3 输入示例2： blueberry 输出示例3： b 2 e 2 r 2

字典中的成绩，输入的嵌套字典存储了若干同学的成绩，请计算并输出每位同学的姓名、总分、各科平均分。注意：每位同学的成绩个数不一定相同。输入输出样例输入示例： {'张三':{'数学':92,'语文':83,'英语':95,'科学':83},'李四':{'数学':87,'语文':86,'英语':92,'物理':93,'生物':83},'王五':{'数学':95,'语文':89,'英语':90,'化学':87},'赵六':{'数学':82,'语文':80,'英语':85,'历史':97}} 输出示例：张三 353 88.25 李四 441 88.2 王五 361 90.25 赵六 344 86.0

重复的单词，输入一系列空格分隔的单词，删除所有重复的单词并按字母排序后打印这些单词。输入输出样例输入示例1： hello world and practice makes perfect and hello world again 输出示例1：注意：单词之间有空格，但最后一个单词后没有空格 again and hello makes perfect practice world

已知华氏温度转换摄氏温度的计算公式：C=5*(F-32)/9，其中：C表示摄氏温度，F表示华氏温度。定义函数F2C()和主流程完成题目要求。本题要求读入两个华氏温度值f1和f2，打印范围在f1~f2内，每次增加两个华氏温度刻度的速查表。注意：如果f1>f2，则直接打印error。测试程序如下，答题时只需要定义函数，不需要添加测试程序 a,b=map(int,input().split(',')) F2C(a,b) 输入格式输入为一行，为两个不小于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

编写函数，输出所有的水仙花数。如果一个3位数等于其各位数字的立方和，则称这个数为水仙花数。例如，153=1^3+5^3+3^3，因此153就是一个水仙花数。注意：每输出一个水仙花数后再输出一个空格。

编写一个能任意数量参数进行计算机问候的小程序。相关知识:为了完成本关任务，你需要掌握：任意数量参数定义一个函数 say_hi，使之可接收任意数量的姓名为参数，调用函数时，可以传递多个参数。有时候你预先不知道函数需要多少实参，此时可以给函数传递一个用 “*” 开头的序列类型的参数，例如：“*id” ，形参名 id 前面的星号会让 Python 创建一个空元组，将收集到的所有实参值都封装到这个元组里。编程要求:根据提示，在右侧编辑器完成代码，实现一个能任意数量参数进行计算机问候的小程序。 n=input().split(', ') say_hi(*n) 输入格式逗号隔开的若干姓名输出格式分行对每个传入的参数输出“XXX，你好！” 输入举例: 杜甫, 李白, 柳宗元, 李商隐输出：杜甫，你好！李白，你好！柳宗元，你好！李商隐，你好！

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

range(start, stop[, step])

round(x [,n])

sorted(iterable, *, key=None, reverse=False)

A. sum(iterable, /, start=0) 从 start 开始自左向右对 iterable 的项求和并返回总计值。 iterable 的项通常为数字，而 start 值则不允许为字符串。对某些用例来说，存在 sum() 的更好替代。拼接字符串序列的更好更快方式是调用 ''.join(sequence)。要以扩展精度对浮点值求和，请参阅 math.fsum()。要拼接一系列可迭代对象，请考虑使用 itertools.chain()。

B. type(object) 返回对象的类型，用于查看数据的类型

map(function, 可迭代对象【例如列表、range()等序列】) 语法： map(function, 可迭代对象【例如列表、range()等序列】) 功能：把可迭代对象的每个元素代入function计算，返回一个与可迭代对象元素个数相同的 map 对象。a, b = map(…)则是用两个变量接收这些元素。【缺少答案，请补充】

转换 A. int(x[,base]) 把其他类型数据转换成整数。如果x是数值的话，去掉小数点部分【不是四舍五入！】，例：int(3.9) 结果3。若 x 为 str，则可能报错，例：int('3.4') 结果ValueError: invalid literal for int() with base 10: '3.4'

A. float(x) 浮点数，也就是实数

B. str(x) 把其他类型数据转换成字符串

B. dict(x) 把其他类型数据转换成字典。dict()表示空字典。

A. eval(str1) 计算字符串\"XXXXX\"中的有效python表达式，相当于去掉两边的引号，然后在Shell的>>>提示符下运行表达式后的结果.例如 eval('3+4') =7

B. tuple(s) 将序列s转换为元组.在Shell的>>>提示符下输入的 3,4(回车) 自动转换为元组 (3,4)

A. list(s) 将序列s转换为列表

B. set(x) 把其他类型数据转换成集合。无参数set() 函数创建一个空集

内置常量 A+. True True是bool类型用来表示真值的常量。

A+. False 假值

None表示无，它是NoneType的唯一值。对于函数，如果没有return语句，即相当于返回None。

列表list的方法（独有的函数）使用格式：对象.方法名(参数)

A+. x.append（obj）在列表末尾增加一个元素

B. x.reverse（）将列表元素的顺序在原地址反转。会改变原x值，所以如果不想改变x，只是想得到x的倒序的话，可以y=x[::-1]

B. x.sort（key=None，reverse=False）将列表元素在原址排序，key和reverse参数可选。会改变原x值，所以如果不想改变x，只是想排序的话，应该使用内置函数 y=sorted(x)

A. x.count（obj）统计列表中obj出现的次数

B. x.extend（sequence）用sequence扩展列表

A. x.index（obj）返回obj在列表中第1次出现的索引,类似于字符串的find方法【但是找不到时有区别，会报一个异常，而不是返回-1】

B. x.insert（index，obj）在index位置插入对象obj

B. x.pop（index）返回列表中指定索引的元素，同时在列表中删除这个元素。没有指定索引则删除最后一个元素

B. x.remove（obj）删除列表中第1次出现的obj

字符串string的方法（独有的函数）【仅支持A-H选项，选项超出支持范围】

导入模块 import math; math.sin(math.pi/2) # 调用时必须加库名 from math import sin,cos,pi; sin(pi/2) # 调用时不能加库名 from math import *; sin(pi/2) # 调用时不能加库名 import numpy as np; np.arange(5) # 调用时必须加别名，而且不能用原名

1 2