1. AI技术聚合首页
  2. Python

Python头歌合集（题集附解）

青葱年少 • • Python • 阅读 384

在这里插入图片描述

目录

目录

一、Python初识-基本语法 

        Python 是一种面向对象的解释型计算机程序设计语言，以其简洁性、易读性、可扩展性、丰富和强大的功能库，语言表达能力极强，很多非常复杂的功能，只需简单几行代码即可实现，成为最受欢迎的程序设计语言之一。

        本实训的主要目标是，让学习者通过 Python 交互式编程以及脚本编程，实现一个简单的打印字符串功能，感受和体验 Python 编程，并对 Python 建立一个初步的认识。

第1关：Hello Python! 

任务描述

利用 Python 提供的print()内置函数，打印输出Hello Python!，初步体验和感受 Python 编程的魅力。

输入

无

输出

Hello Python!

开始你的任务吧，祝你成功！

#coding=utf-8

#请在此处添加代码完成输出“Hello Python”,注意要区分大小写！
###### Begin ######
print("Hello Python!")


###### End ######

 第2关：我想看世界

任务描述

本关任务：字符串拼接。接收用户输入的两个字符串，将它们组合后输出。

相关知识

为了完成本关任务，你需要掌握： 1.如何使用input()函数，获得用户输入的字符串; 2.输出函数print()如何按照期望的格式输出字符信息。

输入与输出

输入1： 请输入一个人的名字：张三 请输入一个国家的名字：美国

输出1： 世界那么大，张三想去美国看看。

输入2： 请输入一个人的名字：三毛 请输入一个国家的名字：巴西

输出2： 世界那么大，三毛想去巴西看看。

开始你的任务吧，祝你成功！

#coding=utf-8

#请在此处补充代码，按要求完成输出
###### Begin ######
name=input('请输入一个人的名字：')
country=input('请输入一个国家的名字：')
print('世界那么大，'+name+'想去'+country+'看看。')


###### End ######

 第3关：学好Python

任务描述

本关任务：简单的人名对话。

相关知识

为了完成本关任务，你需要掌握： 1.如何格式化输入输出; 2.如何截取字符串。

输入输出

测试输入：风清扬

预期输出：

风清扬同学，学好Python，前途无量！

风大侠，学好Python，大展拳脚！

清扬哥哥，学好Python，人见人爱！

开始你的任务吧，祝你成功！

#coding=utf-8

#请在此处补充代码，按要求完成输出
###### Begin ######
name=input("输入姓名：")
print("{}同学，学好Python，前途无量！".format(name))     #请将命令行补充完整
print("{}大侠，学好Python，大展拳脚！".format(name[0]))                                              #请将命令行补充完整
print("{}哥哥，学好Python，人见人爱！".format(name[1:]))                                              #请将命令行补充完整

###### End ######

 第4关：根据圆的半径计算周长和面积

任务描述

本关任务：编写一个能计算圆的周长和面积的程序。 结果保留小数点后两位。

输入输出

测试输入：3            预期输出： 周长: 18.85 面积: 28.27

测试输入：6.2         预期输出： 周长: 38.96 面积: 120.76

相关知识

可以用eval(input())将所获得的input()输入值由字符串转为数值。

开始你的任务吧，祝你成功！

"""
输入半径计算圆的周长和面积


"""
import math
pi = math.pi   #pi = 3.14159

#*******请输入您的代码********#
#***********begin************#
r = eval(input())
c = 2*pi*r
s = pi*r**2
print('周长:'+' {:.2f}'.format(c))
print('面积:'+' {:.2f}'.format(s))
#***********end************#

 第5关：货币转换

任务描述

本关任务：编写一个人民币和美元两种货币间币值转换程序。其中，人民币和美元间汇率固定为：1美元 = 6.4人民币。

程序可以接受人民币或美元输入，转换为美元或人民币输出。人民币采用RMB表示，美元采用USD表示，符号和数值之间没有空格。 注意： (1) 结果小数点后保留两位。

(2) 获得输入请使用input("") 。

输入输出

测试输入1：USD12； 预期输出1：RMB76.8

测试输入2：RMB76.8； 预期输出2：USD12

开始你的任务吧，祝你成功！

"""
人民币和美元两种货币间币值转换
"""

#********请输入您的代码********#
#************begin************#
a=input("")
if a[0] in ["R"]:
    c=eval(a[3:])/6.4
    print("USD{:.2f}".format(c))
elif a[0] in ["U"]:
    b=eval(a[3:])*6.4
    print("RMB{:.2f}".format(b))
else:
    print("输入格式错误")

#************end************#

 二、turtle简单绘图

第1关：英寸与厘米转换

任务描述

本关任务： 屏幕尺寸是指液晶显示器屏幕对角线的长度，单位为英寸。编写一个英寸和厘米两种长度单位间的转换程序。其中，转换关系为：1厘米= 0.393700787402英寸， 1英寸= 2.54厘米。

程序可以接受英寸或厘米输入，转换为厘米或英寸输出。英寸采用IN表示，厘米采用CM表示，符号和数值之间没有空格。 注意： (1) 结果小数点后保留两位。

(2) 获得输入请使用input("") 。

输入输出

测试输入1：IN12；                 预期输出1：CM30.48

测试输入2：CM76；                 预期输出2：IN29.92

测试输入3：C76；                   预期输出3：输入不符合要求！

开始你的任务吧，祝你成功！

"""
cm与inch转换
"""

#********请输入您的代码********#
#************begin************
a=input("")
if a[0:2] in ["IN"]:
    C=eval(a[2:])*2.54
    print("CM{:.2f}".format(C))
elif a[0:2] in ["CM"]:
    I=eval(a[2:])*0.393700787402
    print("IN{:.2f}".format(I))
else:
    print("输入不符合要求！")

#************end************#

 第2关：绘制等边三角形

任务描述

仿照教材例5-3画五角星程序，编写程序导入turtle库，并画出如图所示的等边三角形。要求边长为200，三边颜色为红色。

Python头歌合集（题集附解）

相关知识

模块导入

在使用模块中的函数之前，需要先将模块用import命令导入，有两种形式：

  1. import turtle

创建turtle对象

  1. Bob = turtle.Turtle()

表示在系统中创建了一个Turtle类型的对象，将其命名为Bob.

turtle的部分运动和画笔控制函数

下表给出了turtle的部分运动函数

函数别名（缩写）功能
forward（d）fd(d)向前移动距离d代表距离
backward(d)bk(d)或back(d)向后移动距离d代表距离
right(degree)rt(degree)向右转动多少度
left(degree)It(degree)向左转动多少度
goto(x,y)将画笔移动到坐标为（x，y）的位置
stamp()绘制当前图形
speed(speed)画笔绘制的速度范围[0，10]整数
setheading(degree)seth(degree)海龟朝向，degree代表角度
circle(radius,extent)绘制一个圆形，其中，radius为半径，extent为度数，例如，若extent为180，则画一个半圆；如果画一个圆形，可不必写第2个参数

下表给出了turtle的部分画笔控制函数

函数别名（缩写）功能
pendown()down()或pd()画笔落下，移动时绘制图形
penup()up()或pu()画笔拾起，移动时不绘制图形
reset()恢复所有设置
pensize(width)width()画笔的宽度
pencolor(colorstring)画笔的颜色
fillcolor(colorstring)绘制图形的填充颜色

编程要求

本关的编程任务是补全文件的代码内容，实现如下功能：

  • step1:用import命令导入turtle模块；
  • step2:创建turtle对象；
  • step3:用pencolor函数设置画笔的颜色；
  • step4:使用turtle的运动函数绘制图形。 本关涉及的代码文件 的代码框架如下：
  1. # coding = utf-8
  2. # 请在下面添加代码绘制任务中的等边三角形
  3. ###### Begin ######
  6. ####### End #######

开始你的任务吧，祝你成功！

#********* Begin *********#
import turtle
turtle.pencolor("red")
turtle.pendown()
turtle.seth(0)
turtle.fd(200)
turtle.seth(120)
turtle.fd(200)
turtle.seth(240)
turtle.fd(200)
turtle.seth(0)


#********* End *********#
#保存屏幕图片
ts = turtle.getscreen()
ts.getcanvas().postscript(file="Python/src1/py1-2/yourimg/sj.ps")

 第3关：绘制两个叠加的等边三角形

任务描述

仿照教材例5-3画五角星程序，编写程序导入turtle库，并画出如图所示的等边三角形。外面三角形边长为200，三边颜色为红色；里面的三角形边长为100，三边颜色为蓝色，填充颜色为黄色。

Python头歌合集（题集附解）

相关知识

模块导入

在使用模块中的函数之前，需要先将模块用import命令导入，有两种形式：

  1. import turtle
  2. from turtle import *

其中，*是通配符，表示所有函数

创建turtle对象

  1. Bob = turtle.Turtle()

表示在系统中创建了一个Turtle类型的对象，将其命名为Bob.

turtle的部分运动和画笔控制函数

  • 下表给出了turtle的部分运动函数
函数别名（缩写）功能
forward（d）fd(d)向前移动距离d代表距离
backward(d)bk(d)或back(d)向后移动距离d代表距离
right(degree)rt(degree)向右转动多少度
left(degree)It(degree)向左转动多少度
goto(x,y)将画笔移动到坐标为（x，y）的位置
stamp()绘制当前图形
speed(speed)画笔绘制的速度范围[0，10]整数
setheading(degree)seth(degree)海龟朝向，degree代表角度
circle(radius,extent)绘制一个圆形，其中，radius为半径，extent为

度数，例如，若extent为180，则画一个半圆；如果画一个圆形，可不必写第2个参数 |

  • 下表给出了turtle的部分画笔控制函数
函数别名（缩写）功能
pendown()down()或pd()画笔落下，移动时绘制图形
penup()up()或pu()画笔拾起，移动时不绘制图形
reset()恢复所有设置
pensize(width)width()画笔的宽度
pencolor(colorstring)画笔的颜色
fillcolor(colorstring)绘制图形的填充颜色
  • 绘制填充图像前后需要添加的函数：
  1. turtle.begin_fill()#准备开始填充图形；
  4. turtle.end_fill()#填充完成；

编程要求

本关的编程任务是补全文件的代码内容，绘制出任务描述中两个叠加等边三角形。 本关涉及的代码文件 的代码框架如下：

  1. # coding = utf-8
  2. # 请在下面添加代码绘制任务中的两个叠加等边三角形
  3. ###### Begin ######
  6. ####### End #######

开始你的任务吧，祝你成功！

#********* Begin *********#
import turtle
turtle.pencolor("red")
turtle.pendown()
turtle.seth(0)
turtle.fd(200)
turtle.seth(120)
turtle.fd(200)
turtle.seth(240)
turtle.fd(200)
turtle.seth(0)
turtle.penup()
turtle.fd(100)
turtle.pendown()
turtle.color("blue","yellow")
turtle.begin_fill()
turtle.seth(60)
turtle.fd(100)
turtle.seth(180)
turtle.fd(100)
turtle.seth(-60)
turtle.fd(100)
turtle.end_fill()

#********* End *********#
#保存屏幕图片
ts = turtle.getscreen()
ts.getcanvas().postscript(file="Python/src1/py1-3/yourimg/sj.ps")

 第4关：绘制三个叠加的等边三角形

任务描述

仿照教材例5-3画五角星程序，编写程序导入turtle库，并画出如图所示的等边三角形。最外面三角形边长为200，三边颜色为红色，次外面的三角形边长为100，三边颜色为蓝色，填充颜色为黄色；最里面的三角形三边长度为50，颜色为红色，填充颜色为白色。

Python头歌合集（题集附解）

相关知识

– 模块导入

在使用模块中的函数之前，需要先将模块用import命令导入，有两种形式：

  1. import turtle
  2. from turtle import *

其中，*是通配符，表示所有函数

– 创建turtle对象

  1. Bob = turtle.Turtle()

表示在系统中创建了一个Turtle类型的对象，将其命名为Bob.

– turtle的部分运动和画笔控制函数

  • 下表给出了turtle的部分运动函数
函数别名（缩写）功能
forward（d）fd(d)向前移动距离d代表距离
backward(d)bk(d)或back(d)向后移动距离d代表距离
right(degree)rt(degree)向右转动多少度
left(degree)It(degree)向左转动多少度
goto(x,y)将画笔移动到坐标为（x，y）的位置
stamp()绘制当前图形
speed(speed)画笔绘制的速度范围[0，10]整数
setheading(degree)seth(degree)海龟朝向，degree代表角度
circle(radius,extent)绘制一个圆形，其中，radius为半径，extent为

度数，例如，若extent为180，则画一个半圆；如果画一个圆形，可不必写第2个参数 |

  • 下表给出了turtle的部分画笔控制函数
函数别名（缩写）功能
pendown()down()或pd()画笔落下，移动时绘制图形
penup()up()或pu()画笔拾起，移动时不绘制图形
reset()恢复所有设置
pensize(width)width()画笔的宽度
pencolor(colorstring)画笔的颜色
fillcolor(colorstring)绘制图形的填充颜色
  • 绘制填充图像前后需要添加的函数：
  1. turtle.begin_fill()#准备开始填充图形；
  4. turtle.end_fill()#填充完成；

编程要求

本关的编程任务是补全文件的代码内容，绘制出任务描述中两个叠加等边三角形。 本关涉及的代码文件 的代码框架如下：

  1. # coding = utf-8
  2. # 请在下面添加代码绘制任务中的两个叠加等边三角形
  3. ###### Begin ######
  6. ####### End #######

开始你的任务吧，祝你成功！

#********* Begin *********#
import turtle
turtle.pencolor("red")
turtle.fd(200)
turtle.seth(120)     
turtle.fd(200)
turtle.seth(240)     
turtle.fd(200)
turtle.seth(0)     
turtle.fd(100)
turtle.begin_fill()
turtle.color("blue","yellow")
turtle.seth(60)     
turtle.fd(100)
turtle.seth(180)    
turtle.fd(100)
turtle.seth(-60)
turtle.fd(100)
turtle.seth(60)
turtle.end_fill()
turtle.fd(50)
turtle.seth(120)
turtle.begin_fill()
turtle.color("red","white")
turtle.fd(50)
turtle.seth(-120)
turtle.fd(50)
turtle.seth(0)
turtle.fd(50)
turtle.end_fill()

#********* End *********#
#保存屏幕图片
ts = turtle.getscreen()
ts.getcanvas().postscript(file="Python/src1/py1-4/yourimg/sj.ps")

 第5关：绘制圆圈

任务描述

本关任务：

利用海龟turtle来画几个叠加圈。

绘制要求:

  • 每个圆半径为40像素
  • 上面三圆颜色自左向右依次为蓝、黑、红，下面两圆颜色自左向右依次为黄、绿，绘制顺序依次为蓝、黑、红、绿、黄
  • 每一个圆绘制时均从该圆上的最低点开始绘制，每次绘制一个完整的圆，直到结束
  • 画笔绘制起点为画布原点，画笔宽度为3

输入

无

输出

5 O

开始你的任务吧，祝你成功！

#********* Begin *********#
import turtle
turtle.speed(0)
turtle.pensize(3)
turtle.up()
turtle.goto(0, 0)
turtle.down()
turtle.color('blue')
turtle.circle(40)
turtle.up()
turtle.goto(80, 0)
turtle.down()
turtle.color('black')
turtle.circle(40)
turtle.up()
turtle.goto(160, 0)
turtle.down()
turtle.color('red')
turtle.circle(40)
turtle.up()
turtle.goto(120, -40)
turtle.down()
turtle.color('green')
turtle.circle(40)
turtle.up()
turtle.goto(40, -40)
turtle.down()
turtle.color('yellow')
turtle.circle(40)

#********* End *********#
#保存屏幕图片
ts = turtle.getscreen()
ts.getcanvas().postscript(file="Python/src1/py1-5/yourimg/sj.ps")

 三、数字与字符串类型及其操作

第1关：银行存款本金和计算

任务描述

编写一个能计算银行存款复利的小程序。假设目前银行年利率是1.5%，输入你的存款数，计算5年后的本金和。 本金和=本金∗（1+年利率）^n n是年数。

输入

存款金额。

输出

5年存款的本金和。

测试输入：50000

预期输出：53864.20

开始你的任务吧，祝你成功！

# coding = utf-8
# 请在下面添加代码
###### Begin ######
a=eval(input())
for i in range(5):
    s=a*(1+0.015)**5
print("{:.2f}".format(s))


####### End #######

第2关：将整数换算为月份数和天数

任务描述

在指定的编写程序，输入一个整数，把这个整数换算为月份数和天数，每月以30天计算。

相关知识

– 要用到的函数

  • input函数 input函数为一个输入函数，是Python的内置函数中最常用的函数之一，其基本功能是获取键盘输入的数据源。input函数的基本语法举例如下：

    1. a=int（input()）
    2. print(a)

    将input函数获取的数据用int函数转换为整数。

    • print函数 print函数是Python的内置函数中最常用的函数之一，其基本功能是打印输出一个对象。print函数的基本语法举例如下： （1）例1 
      1. print（'Hello World'）
    （2）例2
    1. y=5
    2. x=6
    3. print( "y = %d ,x = %d" % (y,x) )
    具体执行结果会在终端打印输出下述字符串： 其中， print中的“y = ”和“x = ”为两个字符串，直接输出; %d 是用来设置x和y的输出格式为整数； %（x,y）中的x和y是要输出的变量，输出的为x和y的值。
    • format函数 format的功能是使任意数据转换成字符串。format函数的基本语法举例如下: 
      1. a=8
      2. b=7.333
      3. print("{:d} , {:.2f}".format(a,b))
       具体执行结果会在终端打印输出下述字符串：  其中， {:d} 表示将a输出为整数，d表示整数； {:.2f} 表示将b输出浮点数，保留两位小数，f表示浮点数； format(a,b) 是将a与b的值转换成字符串。
– 数字类型的内置运算符与内置函数
  • 数字类型的内置运算符与内置函数如下表所示：
运算与函数名结果
x + y计算 x 与 y的和
x – y计算 x 与 y的差
x * y计算 x 与 y的积
x / y计算 x 与 y的商
x // y计算 x 与 y的整数商，即不大于计算 x / y的整数
x % y计算 x 除以 y的余数
– xx 的负值
+ xx 本身
abs(x)返回x的绝对值
int(x)将x 转换成整数
float(x)将x 转换成浮点数
complex(re, im)生成一个复数，实部为re, 虚部为 im. im 默认为0
divmod(x, y)返回一个二元组(x // y, x % y)，即整数对
pow(x, y)返回 xy
x ** y计算 xy
round(x,n)返回x四舍五入，保留n位小数的值
max(x1,x2,..,xn)返回x1,x2,..,xn中最大值
min(x1,x2,..,xn)返回x1,x2,..,xn中最小值
编程要求
本关的编程任务是补全文件的代码内容，输入一个整数，把这个整数换算为月份数和天数，每月以30天计算。 注意：在输出时用format函数将数字转换成字符串输出。
本关涉及的代码文件 的代码框架如下：
  1. # coding = utf-8
  2. data=int(input())
  3. # 请在下面添加代码
  4. ###### Begin ######
  7. ####### End #######
以下是平台对&的样例测试集： 测试输入： 100 预期输出： Months=3 Days=10
测试说明
本关的测试文件是 src/p5-1-4.py，测试过程如下： 1.读者将src/p5-1-4.py中的代码补充完毕，然后点击测评，平台自动编译并运行，并以标准输入方式提供测评输入； 2.平台获取程序的输出，然后将其与预期输出对比，如果一致则测试通过；否则测试失败。
开始你的任务吧，祝你成功！
# coding = utf-8
data=int(input())
# 请在下面添加代码
###### Begin ######
c=data//30
x=data%30
print("Months={:.0f} Days={:.0f}".format(c,x))


####### End #######
 第3关：将整数换算为天、时、分、秒
任务描述
编写程序，输入一个任意位数大于0的整数，作为秒数，将此整数换算为天、时、分、秒，并按“天：时：分：秒”的形式显示结果。
相关知识
– 要用到的函数
  •  
    input函数 input函数为一个输入函数，是Python的内置函数中最常用的函数之一，其基本功能是获取键盘输入的数据源。input函数的基本语法举例如下：
    1. a=int（input()）
    2. print(a)
    将input函数获取的数据用int函数转换为整数。
     
  •  
    print函数 print函数是Python的内置函数中最常用的函数之一，其基本功能是打印输出一个对象。print函数的基本语法举例如下： （1）例1
    1. print（'Hello World'）
    （2）例2
    1. y=5
    2. x=6
    3. print( "y = %d ,x = %d" % (y,x) )
    其中， print中的“y = ”和“x = ”为两个字符串，直接输出; %d 是用来设置x和y的输出格式为整数； %（x,y）中的x和y是要输出的变量，输出的为x和y的值。
     
  •  
    format函数 format的功能是使任意数据转换成字符串。format函数的基本语法举例如下:
     
    1. a=8
    2. b=7.333
    3. print("{:d} , {:.2f}".format(a,b))
    其中， {:d} 表示将a输出为整数，d表示整数； {:.2f} 表示将b输出浮点数，保留两位小数，f表示浮点数； format(a,b) 是将a与b的值转换成字符串。
     
– 数字类型的内置运算符与内置函数
  • 数字类型的内置运算符与内置函数如下表所示：
运算与函数名结果
x + y计算 x 与 y的和
x – y计算 x 与 y的差
x * y计算 x 与 y的积
x / y计算 x 与 y的商
x // y计算 x 与 y的整数商，即不大于计算 x / y的整数
x % y计算 x 除以 y的余数
– xx 的负值
+ xx 本身
abs(x)返回x的绝对值
int(x)将x 转换成整数
float(x)将x 转换成浮点数
complex(re, im)生成一个复数，实部为re, 虚部为 im. im 默认为0
divmod(x, y)返回一个二元组(x // y, x % y)，即整数对
pow(x, y)返回 xy
x ** y计算 xy
round(x,n)返回x四舍五入，保留n位小数的值
max(x1,x2,..,xn)返回x1,x2,..,xn中最大值
min(x1,x2,..,xn)返回x1,x2,..,xn中最小值
编程要求
本关的编程任务是补全文件的代码内容，输入一个任意位数大于0的整数，作为秒数，将此整数换算为天、时、分、秒，并按“天：时：分：秒”的形式显示结果。 注意：在输出时用format函数将数字转换成字符串后输出。
本关涉及的代码文件 的代码框架如下：
  1. # coding = utf-8
  2. # 请在下面添加代码
  3. ###### Begin ######
  6. ####### End #######
以下是平台对&的样例测试集： 测试输入： 100 预期输出： 100秒是0天0时1分40秒
测试说明
本关的测试文件是src/p5-1-3.py，测试过程如下： 1.读者将src/p5-1-3.py中的代码补充完毕，然后点击测评，平台自动编译并运行，并以标准输入方式提供测评输入； 2.平台获取程序的输出，然后将其与预期输出对比，如果一致则测试通过；否则测试失败。
开始你的任务吧，祝你成功！
# coding = utf-8

# 请在下面添加代码
###### Begin ######
n=int(input())
a=n//86400
b=(n%86400)//14400
c=((n%86400)%14400)//60
d=n%86400%14400%60
print("{:.0f}秒是{:.0f}天{:.0f}时{:.0f}分{:.0f}秒".format(n,a,b,c,d))


####### End #######
 第4关：回文数判断
任务描述
从键盘输入一个5位数，编程判断这个数字是不是回文数。 可以用str.isdigit()来判断字符串str是否是数字类型的字符串，是的话返回True，否则返回False。
输入
一个5位数。
输出
是回文数，输出“True”，否则输出“False”。 如果不是5位数字，则输出“输入有误！”
测试输入：12821 预期输出：True
测试输入：15821 预期输出：False
开始你的任务吧，祝你成功！
# coding = utf-8
# 请在下面添加代码
###### Begin ######
list1=input()
list2=list1[::-1]
if len(list1)==5 and len(list2)==5:
    if list1==list2:
        print("True")
    else:
        print("False")
else:
    print("输入有误！")

####### End #######
 第5关：字符串的拼接：名字的组成
任务描述
本关任务是将两个不同的字符串，拼接形成一个字符串，并将新字符串输出来。字符串或串（String）是由数字、字母、下划线组成的一串字符。在 Python 中，字符串用单引号或者双引号括起来。在很多情况下，我们需要将两个字符串拼接起来，形成一个字符串。
 例如，一个人的姓名，通常是由“姓氏”+“名字”组成的。在很多程序中，为了方便后续处理，通常将姓氏和名字分别存在两个变量中。然后在显示时，要将姓氏和名字拼接起来，按全名显示。
  1. first_name = 'Zhang'
  2. last_name = 'san'
输出如下：
  1. full_name = 'Zhang san'
相关知识
Python 中使用+来合并两个字符串，这种合并字符串的方法叫做拼接。其基本语法如下：
  1. result_string = source_string1 + source_string2
其中：
  •  
    source_string1：待合并的第一个字符串；
     
  •  
    source_string2：待合并的第二个字符串；
     
  •  
    result_string：合并后的字符串。
     
注意：如果需要，在两个字符串之间可以增加相应的空格，具体见下面的例子。例如，将姓氏和名字拼接成全名：
  1. # coding=utf-8
  3. # 将姓氏和名字分别保存在两个变量中
  4. first_name = 'Zhang'
  5. last_name = 'san'
  7. # 将姓氏和名字拼接，将结果存储在full_name变量中
  8. full_name = first_name + " " + last_name
  9. print(full_name)
输出结果：
  1. Zhang san
如果您想了解更多有关字符串的知识，请参考：【美】 Eric Matthes 著《Python 编程——从入门到实践》第二章。
编程要求
本关的编程任务是补全src/Step1/full_name.py文件中 Begin-End 区间的代码，实现如下功能：
  •  
    将存放姓氏的字符串变量和存放名字的字符串变量拼接起来，中间用一个空格隔开，并将结果存储在full_name变量中；
     
  •  
    打印输出full_name变量。
     
测试说明
本关的测试文件是src/step1/full_name.py，测试过程如下：
  1.  
    学习者将src/Step1/full_name.py中的代码补充完毕，然后点击评测。平台自动编译并运行full_name.py，并以标准输入方式提供测评输入；
     
  2.  
    平台获取程序的输出，然后将其与预期输出对比。如果一致，则测试通过，否则测试失败。
     
以下是平台对src/step1/full_name.py的样例测试集：
测试输入：
  1. Hu
  2. dong
预期输出：
  1. Hu dong
开始你的任务吧，祝你成功！
# coding=utf-8

# 存放姓氏和名字的变量
first_name = input()
last_name = input()

# 请在下面添加字符串拼接的代码，完成相应功能
########## Begin ##########
print(first_name+" "+last_name)


########## End ##########
第6关：字符替换 
任务描述
有段英文，其中有单独字母“P”被误写为“p”，请编写程序进行纠正。
输入
用户输入一个字符串。
输出
输出字符串，其中原本包含的英文字母“p”全部被替换为“P”。
以下是平台样例测试集：
测试输入：python 预期输出：Python
开始你的任务吧，祝你成功！
# coding=utf-8

# 获取待处理的源字符串
source_string = input()

# 请在下面添加字符串转换的代码
########## Begin ##########
a=source_string.replace("p","P")
print(a)



########## End ##########


第7关：字符串查找与替换 
任务描述
本关的任务是，给定一个字符串，要利用 Python 提供的字符串处理方法，从该字符串中，查找特定的词汇，并将其替换为另外一个更合适的词。例如，给定一个字符串Where there are a will, there are a way，我们发现这句话中存在语法错误，其中are应该为is，需要通过字符串替换将其转换为Where there is a will, there is a way。
在大家日常工作使用 Word 编写文档的过程中，经常会遇到一个问题，发现前面写的文档中某个词用错了，需要换为另外一个词来表达。Word 提供了全文查找与替换的功能，可以帮助用户很方便的处理这一问题。那么，这一功能最基础和核心的就是字符替换，如果我们要自己基于 Python 来实现，该怎么做呢？
相关知识
本关的小目标：学习并掌握 Python 中常用的字符串方法，包括字符串查找、字符串切分、字符串替换等。
字符串查找
Python 提供了内置的字符串查找方法find()，利用该方法可以在一个较长的字符串中查找子字符串。如果该字符串中，有一个或者多个子字符串，则该方法返回第一个子串所在位置的最左端索引，若没有找到符合条件的子串，则返回-1。find()方法的基本使用语法如下：
  1. source_string.find(sub_string)
其中：
  •  
    source_string：源字符串；
     
  •  
    sub_string：待查的目标子字符串；
     
  •  
    find：字符串查找方法的语法关键字。
     
例如，在一个字符串中，查找两个单词的位置：
  1. # coding=utf-8
  3. # 创建一个字符串
  4. source_string = 'The past is gone and static'
  6. # 查看"past"在source_string字符串中的位置
  7. print(source_string.find('past'))
  9. # 查看"love"在source_string字符串中的位置
  10. print(source_string.find('love'))
输出结果：
  1. 4
  2. -1
字符串替换
Python 提供了replace()方法，用以替换给定字符串中的子串。其基本使用语法如下：
  1. source_string.replace(old_string, new_string)
其中：
  •  
    source_string：待处理的源字符串；
     
  •  
    old_string：被替换的旧字符串；
     
  •  
    new_string：替换的新字符串；
     
  •  
    replace：字符串替换方法的语法关键词。
     
例如，在如下字符串中，用small子串替换big子串：
  1. # coding = utf-8
  3. # 创建一个字符串circle
  4. source_string = 'The world is big'
  6. # 利用replace()方法用子串"small"代替子串"big"
  7. print(source_string.replace('big','small'))
输出结果：
  1. The world is small
字符串分割
Python 提供了split()方法实现字符串分割。该方法根据提供的分隔符，将一个字符串分割为字符列表，如果不提供分隔符，则程序会默认把空格（制表、换行等）作为分隔符。其基本使用语法如下：
  1. source_string.split(separator)
其中：
  •  
    source_string：待处理的源字符串；
     
  •  
    separator：分隔符；
     
  •  
    split：字符串分割方法的关键词。
     
例如，用+、/还有空格作为分隔符，分割字符串：
  1. # coding = utf-8
  3. # 待处理字符串source_string
  4. source_string = '1+2+3+4+5'
  6. # 利用split()方法，按照`+`和`/`对source_string字符串进行分割
  7. print(source_string.split('+'))
  8. print(source_string.split('/'))
输出结果：
  1. ['1', '2', '3', '4', '5']
  2. ['1+2+3+4+5']
编程要求
本关的编程任务是，补全src/Step3/method2.py文件中 Begin-End 区间的代码，实现如下功能：
  •  
    step1 ：查找输入字符串source_string中，是否存在day这个子字符串，并打印输出查找结果；
     
  •  
    step2 ：对输入字符串source_string执行字符替换操作，将其中所有的 day替换为time，并打印输出替换后的字符串；
     
  •  
    step3 ：对 step2 进行替换操作后的新字符串，按照空格进行分割，并打印输出分割后的字符列表。
     
测试说明
本关的测试文件是src/Step3/method2.py，测试过程如下：
  1.  
    学习者将src/Step3/method2.py中的代码补充完毕，然后点击评测。平台自动编译并运行method2.py，并以标准输入方式提供测评输入；
     
  2.  
    平台获取程序的输出，然后将其与预期输出对比。如果一致，则测试通过，否则测试失败。
     
以下是平台对src/Step3/method2.py的样例测试集：
测试输入：
  1. All day is no day when it is past.
预期输出：
  1. 4
  2. All time is no time when it is past.
  3. ['All', 'time', 'is', 'no', 'time', 'when', 'it', 'is', 'past.']
开始你的任务吧，祝你成功！
# coding = utf-8
source_string = input()

# 请在下面添加代码
########## Begin ##########
print(source_string.find("day"))
a=source_string.replace("day","time")
print(a)
b=a.split(" ")
print(b)




########## End ##########



四、Python 入门之函数结构 
第1关：函数的参数 – 求输入的整数之和
任务描述
当我们需要在程序中多次执行同一类型的任务时，不需要反复编写代码段来完成任务，而是可以利用函数工具来大大方便我们的编程工作。函数是可重复使用的、用来实现相关联功能的代码段。
本实训的目标是让学习者了解并掌握函数结构的相关知识，本关的小目标则是让学习者先了解并掌握函数参数的有关知识。
相关知识
我们在使用函数前，得先定义一个满足自己使用要求的函数。定义函数的基本结构是：
  1. def functionname( parameters ):
  2. "函数_文档字符串"
  3. function_suite
  4. return [expression]
  • 定义函数以def关键词开头，后面跟着函数名、圆括号()、括号中的参数、冒号；
  • 接着，在缩进块中编写函数体，函数的第一行语句一般是写文档字符串，用于存放函数说明，也可以选择不写；
  • Return[expression]表示结束函数，并返回值。而不带表达式的return相当于返回空值。
本关的重点就是研究函数的参数parameters。定义函数的时候，参数的名字和位置定下来了，函数的接口定义也就完成了。我们在调用函数时，只用知道该传递什么样的参数，函数内部的运行情况已经被封装，使用者不必了解。
Python 的函数参数主要包含以下几种：
  • 必选参数；
  • 默认参数；
  • 可变参数；
  • 关键字参数。
必选参数
必选参数也叫位置参数，是函数中最常用的参数。必选参数就是在调用函数的时候必须指定参数值。例如：
  1. # 定义加法函数plus，参数a,b就是必选参数
  2. def plus(a,b):
  3. c=a+b
  4. return(c)
  6. # 调用函数plus时，必须给参数a,b传递值
  7. d=plus(1,2)
  9. # 输出结果d
  10. print(d)
输出结果：
  1. 3
如果调用plus函数时，传入的参数不符合要求，则会出现错误。例如：
  1. >>d = plus()
  3. TypeError: plus() missing 2 required positional arguments: 'a' and 'b'
  5. >>d = plus(1)
  6. TypeError: plus() missing 1 required positional argument: 'b'
默认参数
默认参数是指给函数参数提供默认值，如果在调用函数的时候没有给该参数传递值，则该参数使用默认值。例如：
  1. # 定义加法函数plus，参数a是必选参数，参数b是默认值2的参数
  2. def plus(a,b=2):
  3. c=a+b
  4. return(c)
  6. # 调用函数plus时，必须给参数a传递值，若不给b传递值，则b默认为2
  7. d=plus(1)
  10. # 输出结果d
  11. print(d)
从上面的例子可以看出，在函数调用过程中可以不用给默认参数传递参数值。但在使用默认参数时，有两点需要注意：
  • 默认参数要放在所有必选参数的后面；
  • 默认参数必须指向不变对象。
可变参数
在有些情况下，我们在定义函数的时候，还不能确定函数应该包含多少个参数，这时我们可以使用可变参数，可变参数就是传入的参数数量是可变的。例如：
  1. # 定义plus函数，完成的功能是返回输入的整数之和。
  2. # 参数numbers是可变参数，表示输入的参数个数可以为任意值
  3. def plus(*numbers):
  4. add = 0
  5. for i in numbers:
  6. add += i
  7. return(add)
  9. # 调用3次plus函数，每次的参数个数都不相同
  10. d1 = plus(1,2,3)
  11. d2 = plus(1,2,3,4)
  12. d3 = plus(1,3,5,7,9)
  14. # 向函数中可以传递任意参数，包括0个参数
  15. d4 = plus()
  17. # 输出结果
  18. print(d1)
  19. print(d2)
  20. print(d3)
  21. print(d4)
输出结果：
  1. 6
  2. 10
  3. 25
  4. 0
在上面的例子中，numbers就是一个可变参数，可变参数前面加一个标识符*。在函数内部，可变参数numbers接收到的值是一个tuple。我们在调用参数是可变参数的函数时，可以给该函数传递任意个数的参数，包括0个参数。
关键字参数
可变参数允许我们在调用函数时传入任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许我们传入任意个含参数名的参数，这些关键字参数在函数调用时自动组装为一个dict。也就是说，关键字参数将长度任意的键-值对，作为参数传递给函数。例如：
  1. # 定义一个包含关键字参数的函数，返回值为参数值
  2. def plus(**kw):
  3. return kw
  5. # 调用plus函数，参数值为空
  6. d1 = plus()
  8. # 调用plus函数，参数值为x=1
  9. d2 = plus(x=1)
  11. # 调用plus函数，参数值为x=1,y=2
  12. d3 = plus(x=1, y=2)
  14. # 输出d1,d2,d3
  15. print(d1)
  16. print(d2)
  17. print(d3)
输出结果：
  1. {}
  2. {'x': 1}
  3. {'x': 1, 'y': 2}
在上面的例子中，kw就是一个关键字参数，关键字参数前面加**表示。关键字参数可以扩展函数功能，使传递参数过程更为简便。例如：
  1. # 定义一个plus函数，有3个参数，返回值是3个参数之和
  2. def plus(x,y,z):
  3. return x+y+z
  5. # 有一个dict列表，当中3个键的值分别为1,2,3
  6. dict = {'x':1, 'y':2, 'z':3}
  8. # 将dict列表中的3个值传入plus函数中，得到返回值d
  9. d = plus(dict['x'],dict['y'],dict['z'])
  11. # 输出d
  12. print(d)
输出结果：
  1. 6
但在上述例子中，将字典中的值向plus函数中传递参数的方法过于累赘，可以采取关键字参数的方法。例如：
  1. # 定义一个plus函数，有3个参数，返回值是3个参数之和
  2. def plus(x,y,z):
  3. return x+y+z
  5. # 有一个dict列表，当中3个键的值分别为1,2,3
  6. dict = {'x':1, 'y':2, 'z':3}
  8. # 用关键字参数的方法将dict列表中的3个值传入plus函数中，得到返回值d
  9. d = plus(**dict)
  11. # 输出d
  12. print(d)
输出结果：
  1. 6
使用关键字参数**dict的方法，可以大大提高参数传递的效率。
参数组合
我们在函数定义过程中，可以同时用到必选参数、默认参数、可变参数、关键字参数中的一种或几种。但是需要特别注意的是，这四种参数在使用的过程中是有顺序的，顺序依次应该是必选参数、默认参数、可变参数和关键字参数。例如：
  1. # 定义一个包含必选参数、默认参数、可变参数和关键字参数的函数plus
  2. def plus(x, y, z=0, *args, **kw):
  3. print('x=',x)
  4. print('y=',y)
  5. print('z=',z)
  6. print('args=',args)
  7. print('kw=',kw)
  9. # 调用函数plus，输入两个参数1,2
  10. plus(1,2)
输出结果：
  1. x= 1
  2. y= 2
  3. z= 0
  4. args= ()
  5. kw= {}
上面这个例子中，向plus函数中传入了两个必选参数1和2。必选参数必须得提供值，但是默认参数、可变参数和关键字参数可以不用提供值，我们还可以给默认参数、可变参数和关键字参数传递值。例如：
  1. # 定义一个包含必选参数、默认参数、可变参数和关键字参数的函数plus
  2. def plus(x, y, z=0, *args, **kw):
  3. print('x=',x)
  4. print('y=',y)
  5. print('z=',z)
  6. print('args=',args)
  7. print('kw=',kw)
  9. # 调用函数plus，输入参数x=1,y=2,z=3,args=(4,5,6),kw={}
  10. plus(1,2,3,4,5,6)
  12. print('\n')
  14. # 调用函数plus，输入参数x=1,y=2,z=3,args=(4,5,6),kw={'k':7, 'm':8}
  15. plus(1,2,3,4,5,6,k=7,m=8)
输出结果：
  1. x= 1
  2. y= 2
  3. z= 3
  4. args= (4, 5, 6)
  5. kw= {}
  8. x= 1
  9. y= 2
  10. z= 3
  11. args= (4, 5, 6)
  12. kw= {'k': 7, 'm': 8}
小结
  • 不同类型的参数是有顺序的，依次是必选参数、默认参数、可变参数和关键字参数；
  • 默认参数一定要用不可变对象，用可变对象容易产生逻辑错误；
  • *args表示的是可变参数，*args接收的是一个元组；
  • **kw表示的是关键字参数，**kw接收的是一个字典。
编程要求
本关的编程任务是补全src/Step1/plus.py文件的代码，实现相应的功能。具体要求如下：
  • 定义并调用一个函数，功能是对输入的列表中的数值元素进行累加，列表中元素的个数没有确定；
  • 将累加结果存储到变量d中；
  • 输出累加结果d。
本关涉及的src/Step1/plus.py代码文件的代码框架如下：
  1. # coding=uft-8
  3. # 创建一个空列表numbers
  4. numbers = []
  6. # str用来存储输入的数字字符串，lst1是将输入的字符串用空格分割，存储为列表
  7. str = input()
  8. lst1 = str.split(' ')
  10. # 将输入的数字字符串转换为整型并赋值给numbers列表
  11. for i in range(len(lst1)):
  12. numbers.append(int(lst1.pop()))
  14. # 请在此添加代码，实现编程要求
  15. ########## Begin ##########
  19. ########## End ##########
  20. print(d)
测试说明
本关的测试文件是src/Step1/plus.py，测试过程如下：
  1. 平台自动编译生成plus.exe；
  2. 平台运行plus.exe，并以标准输入方式提供测试输入；
  3. 平台获取plus.exe输出，并将其输出与预期输出对比。如果一致则测试通过，否则测试失败。
以下是平台对src/Step1/plus.py的样例测试集：
测试输入：
  1. 1 2 3 4 5
预期输出：
  1. 15
测试输入：
  1. 1 3 5 7 9 11
预期输出：
  1. 36
测试输入：
  1. 2 4 6 8 10 12 14 16
预期输出：
  1. 72
开始你的任务吧，祝你成功！
如果你觉得这一关的内容对你有帮助，请你在下面点赞。
# coding=utf-8

# 创建一个空列表numbers
numbers = []

# str用来存储输入的数字字符串，lst1是将输入的字符串用空格分割，存储为列表
str = input()
lst1 = str.split(' ')

# 将输入的数字字符串转换为整型并赋值给numbers列表
for i in range(len(lst1)):
   numbers.append(int(lst1.pop()))

# 请在此添加代码，对输入的列表中的数值元素进行累加求和
########## Begin ##########
d=0
for i in numbers:
    d+=i




########## End ##########

print(d)









第2关：函数的返回值 – 求两个正整数的最大公约数 
任务描述
函数在进行运算处理后，返回的值被称为返回值。函数返回的值是通过return语句执行。返回值能够让我们直接得到函数处理的结果，而不必关心函数内部复杂繁重的运算过程，大大提高了编程效率。本关的主要目标是让学习者了解并掌握函数返回值的相关知识。
相关知识
return语句将值返回到调用函数的出口，函数中一定要有return返回值才是完整的函数。如果我们没有在函数中定义函数返回值，那么程序会自动让函数返回一个结果，该结果是None对象，而None对象表示没有任何值。
将值作为返回值
函数的返回值只有一个，但有时我们会发现有的函数好像有多个返回值，其实这里的“多个”并不是指多个返回值。比如函数返回一列表，里面包含很多个元素值。这就类似于，只能从超市带走一个箱子，但是允许我们把一些东西都装到箱子里面看做一个东西带走。例如：
  1. def f():
  2. return 1,'abc','1234'
  4. print(f())
输出结果：
  1. (1, 'abc', '1234')
调用f()函数，程序输出为一个元组，所以函数返回值表面上是3个值，其实是返回一个元组，元组里面有三个不同元素（元组语法上不需要一定带上圆括号）。
将函数作为返回值
我们除了可以将各种类型的值作为返回值外，也可以将函数作为返回值。例如，我们要定义一个函数来求列表中数值元素的和，一般情况下我们是这样定义的：
  1. def plus(*args):
  2. s = 0
  3. for n in args:
  4. s = s + n
  5. return s
但是，如果我们不需要立刻求和，而是在后面的程序中，根据需求再计算，这种情况怎么办呢？这时我们定义的函数可以不返回求和的结果，而是返回计算求和的函数。所以我们还可以用如下方法定义函数：
  1. def lazy_plus(*args):
  2. def plus():
  3. s = 0
  4. for n in args:
  5. s = s + n
  6. return s
  7. return plus
当我们调用lazy_plus()时，返回的并不是求和结果，而是计算求和的函数：
  1. # 定义求和函数，返回的并不是求和结果，而是计算求和的函数
  2. def lazy_plus(*args):
  3. def plus():
  4. s = 0
  5. for n in args:
  6. s = s + n
  7. return s
  8. return plus
  10. # 调用lazy_plus()时，返回的并不是求和结果，而是求和函数
  11. f = lazy_plus(1,2,3,4,5)
  12. print(f)
输出结果：
  1. <function lazy_plus.<locals>.plus at 0x000001DAC97F9950>
调用函数f时，才真正计算求和的结果：
  1. # 定义求和函数，返回的并不是求和结果，而是计算求和的函数
  2. def lazy_plus(*args):
  3. def plus():
  4. s = 0
  5. for n in args:
  6. s = s + n
  7. return s
  8. return plus
  10. # 调用函数f时，得到真正求和的结果
  11. f = lazy_plus(1,2,3,4,5)
  12. print(f())
输出结果：
  1. 15
在上述例子中，我们在函数lazy_plus中又定义了函数plus，而且内部函数plus是可以引用外部函数lazy_plus的参数和局部变量的。当函数lazy_plus返回函数plus时，相关参数和变量也将会保存在返回的函数中，这种方式也称为“闭包”（Closure）。
小结
我们除了可以将函数计算的值作为返回值外，也可以将函数作为返回值。
如果您想了解更多函数结构的相关知识，请参考：【美】 Eric Matthes 著《 Python 编程——从入门到实践》第八章。
编程要求
本关的编程任务是补全src/step2/return.py文件的代码，实现相应的功能。具体要求如下：
  • 定义一个函数gcd，功能是求两个正整数的最大公约数；
  • 调用函数gcd，得到输入的两个正整数的最大公约数，并输出这个最大公约数。
本关涉及的代码文件src/step2/return.py的代码框架如下：
  1. # coding=utf-8
  3. # 输入两个正整数a,b
  4. a = int(input())
  5. b = int(input())
  7. # 请在此添加代码，求两个正整数的最大公约数
  8. ########## Begin ##########
  13. ########## End ##########
  15. # 调用函数，并输出最大公约数
  16. print(gcd(a,b))
测试说明
本关的测试文件是src/step2/return.py，测试过程如下：
  1. 平台自动编译生成return.exe；
  2. 平台运行return.exe，并以标准输入方式提供测试输入；
  3. 平台获取return.exe输出，并将其输出与预期输出对比。如果一致则测试通过，否则测试失败。
以下是平台对src/step2/return.py的样例测试集：
测试输入：
  1. 1
  2. 8
预期输出：
  1. 1
测试输入：
  1. 9
  2. 3
预期输出：
  1. 3
测试输入：
  1. 9
  2. 21
预期输出：
  1. 3
测试输入：
  1. 126
  2. 36
预期输出：
  1. 18

 开始你的任务吧，祝你成功！ 
 
如果你觉得这一关的内容对你有帮助，请你在下面点赞。
# coding=utf-8

# 输入两个正整数a,b
a = int(input())
b = int(input())

# 请在此添加代码，求两个正整数的最大公约数
########## Begin ##########
def gcd(a,b):
    if a<b:
        a,b=b,a
    while a%b!=0:
        a,b=b,(a%b)
    return(b)

########## End ##########

# 调用函数，并输出最大公约数
print(gcd(a,b))



第3关：函数的使用范围与Python 作用域-求两个正整数的最小公倍数 
任务描述
函数是有使用范围的，在一个模块中，我们可以定义很多函数和变量。但我们希望有的函数和变量别人可以使用，有的函数和变量仅仅可以在模块内部使用，这就是 Python 作用域的相关问题。本关的目标就是让学习者了解并掌握函数的使用范围，即 Python 作用域的相关知识。
相关知识
在 Python 中，正常的函数和变量名是公开的（public），是可以被直接引用的。比如abs()、abc、dir()等。
  •  
    类似__xxx__这种格式的变量是特殊变量，允许被直接引用，但是会被用作特殊用途。比如__author__、__name__就是属于特殊变量。hello模块定义的文档注释也可以用特殊变量__doc__访问，我们自己编程定义的变量一般不会用这种变量名。
     
  •  
    类似_xxx和__xxx这种格式的函数和变量就是非公开的（private），不应该被直接引用。
     
  •  
    补充：_xxx的函数和变量是protected，我们直接从外部访问不会产生异常。__xxx的函数和变量是private，我们直接从外部访问会报异常，我们要注意前缀符号的区别。
     
我们要注意用词的区别，我们说的private函数和变量是“不应该”被直接引用，而不是“不能”被直接引用。这是因为在 Python 中并没有一种方法可以真正完全限制访问private函数或变量。但是我们为了养成良好的编程习惯，是不应该引用private函数或变量的。private函数的作用是隐藏函数的内部逻辑，让函数有更好的封装性。例如：
  1. def _private_1(name):
  2. return 'Hello, %s' % name
  4. def _private_2(name):
  5. return 'Hi, %s' % name
  7. def greeting(name):
  8. if len(name) > 3:
  9. return _private_1(name)
  10. else:
  11. return _private_2(name)
我们在上述程序块里公开了greeting()函数，greeting()函数需要使用_private_1()和_private_2()函数。学习者并不需要知道greeting()函数中的内部实现细节，所以我们可以将内部逻辑用private函数隐藏起来，这是一种十分常用的代码封装的方法。
小结
为了让程序的封装性更好，我们一般都限定函数的使用范围。一般我们把外部需要使用的函数定义为public函数，而把只在内部使用而外部不需要引用的函数定义成private函数。
编程要求
本关的编程任务是补全src/step3/scope.py文件的代码，实现相应的功能。具体要求如下：
  • 编写程序，功能是求两个正整数的最小公倍数；
  • 要求实现方法：先定义一个private函数 _gcd()求两个正整数的最大公约数，再定义public函数lcm()调用 _gcd()函数求两个正整数的最小公倍数；
  • 调用函数lcm()，并将输入的两个正整数的最小公倍数输出。
本关涉及的代码文件src/step3/scope.py的代码框架如下：
  1. # coding=utf-8
  3. # 输入两个正整数a,b
  4. a = int(input())
  5. b = int(input())
  7. # 请在此添加代码，求两个正整数的最小公倍数
  8. ########## Begin ##########
  13. ########## End ##########
  15. # 调用函数，并输出a,b的最小公倍数
  16. print(lcm(a,b))
测试说明
本关的测试文件是src/step3/scope.py，测试过程如下：
  1. 平台自动编译生成scope.exe；
  2. 平台运行scope.exe，并以标准输入方式提供测试输入；
  3. 平台获取scope.exe输出，并将其输出与预期输出对比。如果一致则测试通过，否则测试失败。
以下是平台对src/step3/scope.py的样例测试集：
测试输入：
  1. 5
  2. 6
预期输出：
  1. 30
测试输入：
  1. 8
  2. 10
预期输出：
  1. 40
测试输入：
  1. 16
  2. 24
预期输出：
  1. 48
测试输入：
  1. 132
  2. 214
预期输出：
  1. 14124
开始你的任务吧，祝你成功！
# coding=utf-8

# 输入两个正整数a,b
a = int(input())
b = int(input())

# 请在此添加代码，求两个正整数的最小公倍数
########## Begin ##########
c=a*b
def lcm(a,b):
    if a<b:
        a,b=b,a
    while a%b!=0:
        a,b=b,(a%b)
    return(c//b)



########## End ##########

# 调用函数，并输出a,b的最小公倍数
print(lcm(a,b))


五、函数和代码复用1 
第1关：圆面积计算函数
任务描述
  • 定义一个函数，要求实现圆的面积的计算；
  • 根据输入的不同整数值的半径，调用函数计算，并输出圆的面积，结果保留两位小数。
输入
圆半径
输出
圆的面积，结果保留两位小数。
测试集
测试输入：
  1. 4
预期输出：
  1. 50.27
测试输入：
  1. 5
预期输出：
  1. 78.54
开始你的任务吧，祝你顺利过关！
# coding=utf-8

from math import pi as PI

n = int(input())

# 请在此添加代码，实现圆的面积计算，并输出面积结果
########## Begin ##########
s=PI*n*n
print("{:.2f}".format(s))




########## End ##########



第2关：素数判断
任务描述
  • 定义一个函数，功能是判断一个数是否为素数；
  • 调用函数，对输入的整数进行判断。如果是素数则输出为True，否则输出为False。 
    输入
     一个整数 
    输出
     该整数为素数则输出为True，否则输出为False 
    测试集
     
测试输入：
  1. 1
预期输出：
  1. False
测试输入：
  1. 3
预期输出：
  1. True
测试输入：
  1. 9
预期输出：
  1. False
开始你的任务吧，祝你成功！
# coding=utf-8

# 输入一个整数n
n =  int(input())

# 请在此添加代码，对输入的整数进行判断，如果是素数则输出True，否则输出False
########## Begin ##########
if n< 2:
    print(False)
else:
    for i in range(2, n):
        if n% i == 0:
            print(False)
            break  
    else:
        print(True)



########## End ##########


 第3关：求和函数
任务描述
  • 定义并调用一个函数，功能是对输入的列表中的数值元素进行累加，列表中元素的个数没有确定；
  • 将累加结果存储到变量d中；
  • 输出累加结果d。
输入
用空格分隔的数字字符串
输出
对输入的数字串进行累加求和
测试说明
测试输入：
  1. 1 2 3 4 5
预期输出：
  1. 15
测试输入：
  1. 1 3 5 7 9 11
预期输出：
  1. 36
开始你的任务吧，祝你成功！
# coding=utf-8

# 创建一个空列表numbers
numbers = []

# str用来存储输入的数字字符串，lst1是将输入的字符串用空格分割，存储为列表
str = input()
lst1 = str.split(' ')

# 将输入的数字字符串转换为整型并赋值给numbers列表
for i in range(len(lst1)):
   numbers.append(int(lst1.pop()))

# 请在此添加代码，对输入的列表中的数值元素进行累加求和
# 可以通过"for i in numbers:"来遍历numbers列表中的每一个元素
########## Begin ##########
print(sum(numbers))




########## End ##########









 第4关：最大公约数
任务描述
  • 定义一个函数gcd，功能是求两个正整数的最大公约数；
  • 调用函数gcd，得到输入的两个正整数的最大公约数，并输出这个最大公约数。
输入
两个整数
输出
两数的最大公约数
测试说明
测试输入：
  1. 1
  2. 8
预期输出：
  1. 1
测试输入：
  1. 9
  2. 3
预期输出：
  1. 3
开始你的任务吧，祝你成功！
# coding=utf-8

# 输入两个正整数a,b
a = int(input())
b = int(input())

# 请在此添加代码，求两个正整数的最大公约数
########## Begin ##########
def gcd(a,b):
    c=a*b
    if a<b:
        a,b=b,a
    while a%b!=0:
        a,b=b,(a%b)
    return(b)



########## End ##########

# 调用函数，并输出最大公约数
print(gcd(a,b))



 第5关：最小公倍数
任务描述
  • 编写程序，功能是求两个正整数的最小公倍数；
  • 要求实现方法：先定义一个private函数 _gcd()求两个正整数的最大公约数，再定义public函数lcm()调用 _gcd()函数求两个正整数的最小公倍数；
  • 调用函数lcm()，并将输入的两个正整数的最小公倍数输出。
输入
两个整数
输出
两数的最小公倍数
测试说明
测试输入：
  1. 5
  2. 6
预期输出：
  1. 30
测试输入：
  1. 8
  2. 10
预期输出：
  1. 40
开始你的任务吧，祝你成功！
# coding=utf-8

# 输入两个正整数a,b
a = int(input())
b = int(input())

# 请在此添加代码，求两个正整数的最小公倍数
########## Begin ##########
def lcm(a,b):
    c=a*b
    if a<b:
        a,b=b,a
    while a%b!=0:
        a,b=b,(a%b)
    return(c//b)



########## End ##########

# 调用函数，并输出a,b的最小公倍数
print(lcm(a,b))


 六、Python 入门之经典函数实例
第1关：lambda 函数 – 匿名函数的使用-比较两数大小
任务描述
在 Python 编程中我们除了可以用def语句来定义函数之外，还可以使用lambda来定义。我们用def语句来定义函数时需要指定函数名字，而使用lambda来定义函数时则不需要。lambda函数是 Python 中一个非常独特的函数类型。本关目标就是让学习者了解并掌握lambda函数的相关知识。
相关知识
lambda函数又称匿名函数，匿名函数顾名思义就是没有名字的函数。可能我们现在还无法接受，函数没有名字怎么能行？但实际上是可以的。当我们在编程过程中只是临时使用某些函数，而且这些函数的逻辑功能也很简单时，就没有必要非给这些函数取个名字不可。
这就类似于电影里面都会有很多群众演员，他们每个人所占的戏份很少，只是起临时演出的作用，所以一般没有必要给临时演员起一个电影名字，统一称为群演就行。
匿名函数不需要return来返回值，lambda函数表达式本身的计算结果就是返回值。例如，我们可以用lambda函数定义一个加法，计算两个整数相加：
  1. f = lambda x,y:x+y
  2. print(f(1,2))
运算结果：
  1. 3
x和y是函数的两个参数，:后面的表达式x+y表明函数的功能就是计算两个数的和。在这里我们并没有给函数取名字，而是直接将匿名函数赋给变量f。然后给f传入参数(1,2)，就相当于给匿名函数传入参数，得到返回结果3。
尽管 Python 算不上是一门纯函数式编程语言，但它本身提供了很多函数式编程的特性。像map、reduce、filter、sorted这些函数都支持函数作为参数，lambda函数也可以应用在函数式编程中。例如，现在有一个整数列表，要求按照列表中元素的绝对值从小到大排列。我们可以先采取普通def函数解决这个问题：
  1. # 给出一个包含正数和负数的列表
  2. list1 = [2,3,-5,0,-4,-8,-1]
  4. # 定义一个函数，返回输入值的绝对值
  5. def f(x):
  6. return abs(x)
  8. # 利用sorted函数对列表中的元素根据绝对值的大小升序排序
  9. list2=sorted(list1, key=f)
  11. # 输出新列表
  12. print(list2)
我们也可以采取lambda函数更加简便地实现这个目标：
  1. # 给出一个包含正数和负数的列表
  2. list1 = [2,3,-5,0,-4,-8,-1]
  4. # 利用sorted函数对列表中的元素根据绝对值的大小升序排序
  5. list2=sorted(list1, key=lambda x: abs(x))
  7. # 输出新列表
  8. print(list2)
由这个例子可以看出，lambda函数会使部分函数式编程更加简便与快捷。lambda函数能起到速写函数的作用，允许在使用的代码内嵌入一个函数的定义。在仅需要嵌入一小段可执行代码的情况下，就可以带来更简洁的代码结构。
编程要求
本关的编程任务是补全src/step2/lambda.py文件的代码，实现相应的功能。具体要求如下：
  • 使用lambda来创建匿名函数，然后判断输入的两个数值的大小，并分别输出较大的值和较小的值。
本关涉及的代码文件src/step2/lambda.py的代码框架如下：
  1. # coding=utf-8
  3. # 请在此添加代码，使用lambda来创建匿名函数，能够判断输入的两个数值的大小，
  4. ########## Begin ##########
  9. ########## End ##########
  11. # 输入两个正整数
  12. a = int(input())
  13. b = int(input())
  15. # 输出较大的值和较小的值
  16. print('较大的值是：%d' % MAXIMUM(a,b))
  17. print('较小的值是：%d' % MINIMUM(a,b))
测试说明
本关的测试文件是src/step2/lambda.py，测试过程如下：
  1. 平台自动编译生成lambda.exe；
  2. 平台运行lambda.exe，并以标准输入方式提供测试输入；
  3. 平台获取lambda.exe输出，并将其输出与预期输出对比。如果一致则测试通过，否则测试失败。
以下是平台对src/step2/lambda.py的样例测试集：
测试输入：
  1. 5
  2. 12
预期输出：
  1. 较大的值是：12
  2. 较小的值是：5
测试输入：
  1. 7
  2. 3
预期输出：
  1. 较大的值是：7
  2. 较小的值是：3
测试输入：
  1. 120
  2. 89
预期输出：
  1. 较大的值是：120
  2. 较小的值是：89
测试输入：
  1. 13
  2. 110
预期输出：
  1. 较大的值是：110
  2. 较小的值是：13
开始你的任务吧，祝你成功！
# coding=utf-8

# 请在此添加代码，使用lambda来创建匿名函数，能够判断输入的两个数值的大小
########## Begin ##########
MAXIMUM=lambda a,b:a if a>b else b
MINIMUM=lambda a,b:a if a<b else b




########## End ##########

# 输入两个正整数
a = int(input())
b = int(input())

# 输出较大的值和较小的值
print('较大的值是：%d' % MAXIMUM(a,b))
print('较小的值是：%d' % MINIMUM(a,b))



 第2关：递归函数 – 汉诺塔的魅力
任务描述
在 Python 函数内部，我们可以去调用其他函数。所以如果一个函数在内部调用自身，这个函数我们就称为递归函数。本关我们将以汉诺塔的例子来感受递归函数的方法与应用。
汉诺塔问题源于印度一个古老传说。相传大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上并规定，任何时候，在小圆盘上都不能放大圆盘，且在三根柱子之间一次只能移动一个圆盘。如下图1所示，请问应该如何操作？
Python头歌合集（题集附解）
 图 1
本关目标就是通过对汉诺塔问题的探讨，让学习者了解并掌握递归函数的相关知识。
相关知识
在编程语言中，如果一种计算过程的其中每一步都会用到前一步或前几步的结果，这个计算过程就可以称为递归的。而用递归计算过程定义的函数，则被称为递归函数。递归函数的应用很广泛，例如连加、连乘及阶乘等问题都可以利用递归思想来解决。而汉诺塔问题也是递归函数的经典应用。
汉诺塔问题的解决思路是：如果我们要思考每一步怎么移可能会非常复杂，但是可以将问题简化。我们可以先假设除a柱最下面的盘子之外，已经成功地将a柱上面的63个盘子移到了b柱，这时我们只要再将最下面的盘子由a柱移动到c柱即可。如下图2所示：
Python头歌合集（题集附解）
 图 2
        当我们将最大的盘子由a柱移到c柱后，b柱上便是余下的63个盘子，a柱为空。因此现在的目标就变成了将这63个盘子由b柱移到c柱。这个问题和原来的问题完全一样，只是由a柱换为了b柱，规模由64变为了63。因此可以采用相同的方法，先将上面的62个盘子由b柱移到a柱，再将最下面的盘子移到c柱。
以此类推，再以b柱为辅助，将a柱上面的62个圆盘最上面的61个圆盘移动到b柱，并将最后一块圆盘移到c柱。我们已经发现规律，我们每次都是以a或b中一根柱子为辅助，然后先将除了最下面的圆盘之外的其他圆盘移动到辅助柱子上，再将最底下的圆盘移到c柱子上，不断重复此过程。
        这个反复移动圆盘的过程就是递归。例如我们每次想解决n个圆盘的移动问题，就要先解决（n-1)个盘子进行同样操作的问题。我们先假设a柱上只有3个圆盘，利用 Python 进行编程实现圆盘的移动，代码如下：
  1. def move(n, a, b, c):
  2. if(n == 1):
  3. print(a,"->",c)
  4. return
  5. move(n-1, a, c, b)
  6. move(1, a, b, c)
  7. move(n-1, b, a, c)
  9. move(3, "a", "b", "c")
函数运行结果：
  1. a -> c
  2. a -> b
  3. c -> b
  4. a -> c
  5. b -> a
  6. b -> c
  7. a -> c
程序分析：
        首先我们定义了一个函数move(n,a,b,c)，参数n代表a柱上的圆盘个数，a，b，c三个柱子的顺序代表要将a柱上的圆盘最终移动到c柱上，然后b柱作为中间柱。
我们在递归函数中肯定会有终止递归的条件。第2到4行的代码就是表示，当a柱上的圆盘个数为1时，就中止递归并返回。因为此时a柱上面只有一个圆盘，肯定就是直接把圆盘从a柱移动到c柱了。
第5行的代码move(n-1, a, c, b)表示，先得把a柱上的n-1个圆盘从a柱移动到b柱，这时c柱是中间辅助柱。第6行的代码move(1, a, b, c)表示，当条件n=1的时候，把a柱上剩下的1个最大圆盘从a柱移动到c柱。
第7行的代码move(n-1, b, a, c)表示，现在n-1个圆盘已经转移到b柱上了，还是递归调用move函数，将n-1个圆盘从b柱移动到c柱，这时a柱是中间辅助柱。
最后我们调用move函数将3个圆盘从a柱移动到到c柱。当移动64个圆盘时，只需要将调用函数move(n,a,b,c)中的n变为64即可。这个计算量是十分巨大的，也只能交给计算机去解决。
小结
        我们通过汉诺塔的例子感受了递归函数的基本思路，并尝试解决了一个具体问题。递归函数的优点是定义清晰、思路简洁，能够极大简化编程过程。理论上，所有的递归函数都可以用循环的方法代替，但循环方法的编程过程要比递归函数复杂很多。
编程要求
本关的编程任务是补全src/step1/recursive.py文件的代码，实现相应的功能。具体要求如下：
  • 定义一个函数fact(n)，实现的功能是对输入的正整数n进行n!运算；
  • 调用函数fact(n)，对输入的正整数n进行阶乘运算，并输出计算结果。
本关涉及的代码文件src/step1/recursive.py的代码框架如下：
  1. # coding=utf-8
  3. # 输入正整数n
  4. n = int(input())
  6. # 请在此添加代码，对输入的正整数n进行阶乘运算，并输出计算结果。
  7. ########## Begin ##########
  12. ########## End ##########
测试说明
本关的测试文件是src/step1/recursive.py，测试过程如下：
  1. 平台自动编译生成recursive.exe；
  2. 平台运行recursive.exe，并以标准输入方式提供测试输入；
  3. 平台获取recursive.exe输出，并将其输出与预期输出对比。如果一致则测试通过，否则测试失败。
以下是平台对src/step1/recursive.py的样例测试集：
测试输入：
  1. 5
预期输出： 120
测试输入：
  1. 6
预期输出：
  1. 720
测试输入：
  1. 7
预期输出：
  1. 5040
测试输入：
  1. 8
预期输出：
  1. 40320
开始你的任务吧，祝你成功！
# coding=utf-8

# 输入正整数n
n = int(input())

# 请在此添加代码，对输入的正整数n进行阶乘运算，并输出计算结果。
########## Begin ##########
def fact(n):
    if n ==0:
        return 1
    else:
        return n*fact(n-1)
print(fact(n))



########## End ##########


 七、分支和循环结构
第1关：英寸与厘米互换
任务描述
本关任务：编写一个能实现单位英寸与公制单位厘米的程序。
相关知识
为了完成本关任务，你需要掌握：1.if条件语句。
编程要求
根据提示，在右侧编辑器补充代码，实现单位英寸与公制单位厘米互换。 （1英寸 = 2.54厘米） 注：函数有两个参数，一个value值（代表长度），一个单位（in（英寸）或cm（厘米）），如单位是cm则直接输出单位为英寸的长度，如单位是in则直接输出单位为厘米的长度，如果单位不是cm或in，则输出‘请输入有效的单位’。结果保留两位小数。（本函数不需返回值）
测试说明
平台会对你编写的代码进行测试：
测试输入：3，cm； 预期输出：1.18英寸
测试输入：3，厘米； 预期输出：1.18英寸
测试输入：5，in； 预期输出：12.70厘米
测试输入：5，英寸； 预期输出：12.70厘米
测试输入：5，tt； 预期输出：请输入有效的单位
开始你的任务吧，祝你成功！
"""
英制单位英寸和公制单位厘米互换
"""
value = input()
value = int(value)
unit = input()
#        请在此处添加代码       #
# *************begin************#

if unit in ["in"] or unit in ["英寸"]:
    a=value*2.54
    print("{:.2f}厘米".format(a))
elif unit in ["cm","厘米"]:
    b=value/2.54
    print("{:.2f}英寸".format(b))
else:
    print("请输入有效的单位")



# **************end*************#

 第2关：百分制转换为等级制成绩
任务描述
本关任务：编写一个能将百分制成绩转换为等级制成绩的程序。
相关知识
为了完成本关任务，你需要掌握： 1.if条件语句。
编程要求
根据提示，在右侧编辑器补充代码，将百分制成绩转换为等级制成绩。 (90<=score<=100:A); (80<=socre<90:B); (70<=socre<80:C); (60<=socre<70:D); (score<60:E)
测试说明
平台会对你编写的代码进行测试：
测试输入：90.5； 预期输出：A
测试输入：82； 预期输出：B
开始你的任务吧，祝你成功！
'''
百分制成绩转换为等级制成绩
:param score:百分制分数
:return: 等级（A，B，C，D，E）
'''
score = float(input())
#        请在此处添加代码       #
# *************begin************#
if 90<=score<=100:
    print("A")
elif 80<=score<90:
    print("B")
elif 70<=score<80:
    print("C")
elif 60<=score<70:
    print("D")
elif score<60:
    print("E")
# **************end*************#
    

 第3关：三角形图案打印
任务描述
本关任务：编写一个能打印三角形图案的程序。
相关知识
为了完成本关任务，你需要掌握：1.for循环嵌套语句。
编程要求
根据提示，在右侧编辑器补充代码，根据输入编写一个能打印指家数三角形图案的程序。
测试说明
平台会对你编写的代码进行测试：
测试输入：4； 预期输出：
  1. *
  2. **
  3. ***
  4. ****
  5. *
  6. **
  7. ***
  8. ****
  9. *
  10. ***
  11. *****
  12. *******
说明：程序会根据函数参数pow打印三个三角形，每个三角形pow行。
测试输入：8； 预期输出：
  1. *
  2. **
  3. ***
  4. ****
  5. *****
  6. ******
  7. *******
  8. ********
  9. *
  10. **
  11. ***
  12. ****
  13. *****
  14. ******
  15. *******
  16. ********
  17. *
  18. ***
  19. *****
  20. *******
  21. *********
  22. ***********
  23. *************
  24. ***************
开始你的任务吧，祝你成功！
row = int(input())
'''
    根据row值，打印三个三角形
    :row:三角形行数
    :return: 无返回值
    '''
#        请在此处添加代码       #
# *************begin************#
for i in range(1,row+1):
    x="*"*i
    print("{:<}".format(x))
for i in range(1,row+1):
    y="*"*i
    print("{0:>{1}}".format(y,row))
for i in range(row):
    for _ in range(row - i - 1):
        print(' ', end='')
    for _ in range(2 * i + 1):
        print('*', end='')
    print()


# **************end*************#

 第4关：输出九九乘法表
任务描述
本关任务：利用小程序输出九九乘法表。
为了完成本关任务，你需要掌握：Python的循环结构。
for 循环
for循环在Python中是一个通用的迭代器，可以遍历任何有序的序列对象内的元素。for语句可用于字符串、列表、元组、文件等可迭代对象。for循环格式如下：
  1. for <循环变量> in <遍历结构>:
  2. <语句块1>
  3. else:
  4. <语句块2>
在for循环，内置函数range()产生序列，可以来控制循环结构。
range(start, stop, [step])
  • start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）
  • stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
  • step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
编程要求
要求利用for循环输出九九乘法表，通过双层for循环进行控制，然后按照相应的格式输出九九乘法表。
  • 注意换行的处理。
测试说明
我会对你编写的代码进行测试：
样例输出：
Python头歌合集（题集附解） 开始你的任务吧，祝你成功！
# -*- coding:utf-8 -*-
for i in range(1,10):
    for j in range(1,i+1):

        #********* Begin *********#
    
        if i!=j:
          print(i,'*',j,'=',i*j,end=' ')
        if i==j:
          print(i,'*',j,'=',i*j,end='')
  

      # 在此处补全代码
        #********* End *********#
    if i != 9:
        print()
 第5关：水仙花数判断
任务描述
本关任务：输入一个整数，判断其是否是水仙花数。 对每个输入，输出一行。如果是水仙花数，就输出True；如果不是，就输出False。
相关知识
水仙花数指一个三位数，满足如下条件： 假设该三位数记作abc，则abc=a3+b3+c3
编程要求
本关只有一个文件main.py，完善该文件以完成任务。
#***Begin your code here***#
n=input()
def shui(n):
    if len(n)!=3:
        return False
    else:
        a=eval(n[0])
        b=eval(n[1])
        c=eval(n[2])
        if int(n)==a*a*a+b*b*b+c*c*c:
            return True
        else:
            return False
print(shui(n))

#***End your code here***#水仙花数是指一个三位数，它的每个数位上的数字的立方和等于该数本身（如：1**3+5**3+3**3=153），要求编程输出所有三位的水仙花数。
 八、函数和代码复用2
第1关：温度转化函数
任务描述
函数是组织好的、可重复使用的、用来实现单一或相关联功能的代码段。函数能提高代码的重复利用率，一般来讲稍微复杂些的程序中必然包含函数。
本关的任务是让读者初识 Python 函数，定义一个函数来实现华氏-摄氏温度的转换。
相关知识
函数的定义
函数可以由程序员自行定义，一般是程序员自己想要实现的功能模块，以下为定义规则：
  •  
    函数定义以def关键字开头，后接函数名称和圆括号 ( ) ，括号后接冒号: ；
     
  •  
    圆括号中为参数，参数个数不限；
     
  •  
    函数第一行可以使用文档字符串来对函数进行说明；
     
  •  
    函数结束时以return [表达式]将值返回给调用方。
     
函数定义语法如下:
  1. def functionname(参数):
  2. "文档字符串"
  3. function_suite
  4. return [表达式]
函数定义样例代码如下:
  1. def theprint(str):
  2. "打印传入的字符串"
  3. print (str)
  4. return
该代码定义了一个名为theprint(str)的函数，实现了打印输出传入的字符串的功能。
编程要求
本关的编程任务是补全 src/step1/step1.py 文件中的代码，要求对于输入的数完成从摄氏度到华氏度的转化。
从摄氏度到华氏度的转化公式为： F(C)=59​C+32
本关涉及的 src/step1/step1.py 文件的代码框架如下:
  1. # coding:utf-8
  3. deg = float(input())
  5. def F(C):
  6. #请在此添加代码，将摄氏度 deg 转换为华氏度
  7. #********** Begin *********#
  9. #********** End *********#
  11. print ("%.2f" %(F(deg)))
测试说明
本关直接要求填入代码，然后运行程序并根据程序输出的结果判断填入的代码是否正确。
本关的测试样例如下。
测试输入 1： 10 预期输出 1： 50.00
测试输入 2： 20 预期输出 2： 68.00
开始你的任务吧，祝你成功！
# coding:utf-8 

deg = float(input())

def F(C):
    return((9/5)*C+32)
#**********  End  *********#

print ("%.2f" %(F(deg)))

 第2关：在函数中修改全局变量
任务描述
在 Python 中全局变量是指存在于模块内、在所有函数外面并且在class外面的变量。全局变量的值不能被随意调用与更改，如需调用，必须通过特殊方式声明后才能调用。
本关任务是让学习者掌握 Python 中全局变量的调用与更改。
相关知识
全局变量的调用
在 Python 中通过关键字global来调用全局变量，例如:
  1. var = 100
  2. def change():
  3. global var
  4. var = var + 10
  5. return var
编程要求
本关的编程任务是补全 src/step2/step2.py 文件中的代码，给定全局变量counter，初始值设为 0 ，补全函数access，使得其每被调用一次，counter的值就增加 1 。 本关涉及的 src/step2/step2.py 文件的代码框架如下:
  1. # coding:utf-8 
  3. counter = 0
  5. def access():
  6. #请在此添加代码，实现 counter 的调用，每次调用 counter 的值加 1
  7. #********** Begin *********#
  9. #********** End **********#
  11. for i in range(5):
  12. access()
  14. print (counter)
测试说明
本关直接要求读者填入代码，然后运行程序并根据程序输出的结果判断填入的代码是否正确，所以本关没有测试文件。
以下是平台对 src/step2/step2.py 文件的样例测试集: 测试输入： 0 预期输出： 5
开始你的任务吧，祝你成功！
# coding:utf-8 

counter = 0

def access():
#请在此添加代码，实现counter的调用，每次调用counter的值加1
#********** Begin *********#
  global counter
  counter+=1

#********** End **********#
  
for i in range(5):
  access()
  
print (counter)

 第3关：一元二次方程求解函数v1
任务描述
在函数中，参数是一个非常重要的组成部分。通过传入参数我们可以灵活地变换函数内参数变量值，从而达到代码的重复使用。
本关的任务是让学习者掌握如何在 Python 函数中使用参数，并读入数据作为参数传入函数作为一元二次方程的系数，然后求解并返回该方程的解。
相关知识
声明带参数的函数
在 Python 中定义带参数的函数的语法如下所示:
  1. def function_name(var1,var2,..):
  2. #function body
在函数定义时，在函数名后的括号中放置需要的参数var1、var2等。这些参数可以在函数体中被使用。当调用该函数时，需要传入相应的参数，完成相应的计算。
示例代码如下：
  1. def add_function(value1, value2)
  2. return (value1 + value2)
  4. >>> add_function(2,3)
  5. >>> 5
上述样例代码定义了一个基本的求和函数add_function，该函数带有两个参数value1和value2，在函数体中进行求和操作。调用求和函数传入参数 2 和 3 ，则计算返回结果 5 。
数学函数sqrt()
在 Python 内置的数学函数中，sqrt(X)函数计算并返回数值X的平方根。sqrt(X)函数不能直接访问，它存在于 math 模块中。 如果需要在我们自己的代码中使用该函数，必须先导入 math 模块。导入 math 模块的语法如下:
  1. from math import sqrt
该语法会将 math 模块中的sqrt函数导入到代码中，然后在后续代码中就可以直接使用sqrt()进行调用。
编程要求
本关的编程任务是补全 src/step3/step3.py 文件中的代码，要求对于输入的a,b,c三个数，编写函数roots(a,b,c),求方程 ax2+bx+c=0 的解，返回由方程根构成的列表，若方程有无数解，返回['inf']。
本关涉及的 src/step3/step3.py 文件的代码框架如下：
  1. # coding:utf-8 
  2. from math import sqrt
  4. a = float(input());
  5. b = float(input());
  6. c = float(input())
  8. def roots(a,b,c):
  9. #请在此添加代码，求方程 ax^2+bx+c = 0的解,返回由方程根构成的列表,若方程有无数解，返回['inf']
  10. #********** Begin *********#
  12. #********** End **********#
  13. print (roots(a,b,c))
测试说明
本关直接要求学习者填入代码，然后运行程序并根据程序输出的结果判断填入的代码是否正确。
本关测试样例如下。
测试输入 1： 1.0 -2.0 1.0 预期输出 1： [1.0]
测试输入 2： 1.0 2.0 1.0 预期输出 2： [-1.0]
开始你的任务吧，祝你成功！
# coding:utf-8 
from math import sqrt

a = float(input()); b = float(input()); c = float(input())

def roots(a,b,c):
#请在此添加代码，求方程 ax^2+bx+c = 0的解,返回由方程根构成的列表,若方程有无数解，返回['inf']
#********** Begin *********#
    if a!=0:
        if b*b-4*a*c<0:
            return("inf")
        elif b*b-4*a*c==0:
            s=-b/(2*a)
            list1=[]
            list1.append(s)
            return(list1)
        else:
            root=math.sqrt(b*b-4*a*c)
            x1=(-b-root)/(2*a)
            x2=(-b-root)/(2*a)
            list2=[]
            list2.append(x1)
            list2.append(x2)
            return(list2)
    if a==0:
        list3=[]
        x3=(-c)/b
        list3.append(x3)
        return(list3)



#********** End **********#
print (roots(a,b,c))

 第4关：一元二次方程求解函数v2
任务描述
在编写函数时，我们很可能会希望这个函数能够返回多个值，这样能够大大方便我们的编程。本关的任务是通过实现一个一元二次方程求解并返回多个根的案例让读者掌握在 Python 函数中如何返回多个值。
相关知识
函数返回多个值
在函数中，我们一般使用return关键字来返回值，但是return关键字严格来说只能返回一个值，那如果我们要返回多个值我们应该怎么做呢？
此时我们可以使用元组 ( tuple ) ，将要返回的值放到一个元组内来间接达到返回多个值。 例如:
  1. def function(x,y):
  2. a = x + y
  3. b = x % y
  4. return (a,b) 
该函数读入两个参数，分别对两个数进行求和与求余操作，并将和与余数通过元组方式返回。
编程要求
本关的编程任务是补全 src/step4/step4.py 文件中的代码。根据第三关方程求根的例子，我们现在假设一元二次方程 ax2+bx+c=0 的二次项系数 a 不等于 0，此时方程必有两个根。再次编写函数roots(a,b,c)返回该方程的两个根。
本关涉及的 src/step4/step4.py 文件的代码框架如下:
  1. # coding:utf-8
  2. from math import sqrt
  4. a=float(input()); b=float(input()); c=float(input())
  6. def roots(a, b, c):
  7. #请在此添加代码，在a不等于0的情况下编写函数求解方程的两个根并将根返回
  8. #********** Begin *********#
  10. #********** End **********#
  12. if a != 0:
  13. print (roots(a,b,c))
测试说明
本关直接要求读者填入代码，然后运行程序并根据程序输出的结果判断填入的代码是否正确。
本关测试样例如下: 测试输入： 1.0 -2.0 1.0 预期输出： (1.0,1.0)
开始你的任务吧，祝你成功！
# coding:utf-8
from math import sqrt

a=float(input()); b=float(input()); c=float(input())

def roots(a, b, c):
#请在此添加代码，在a不等于0的情况下编写函数求解方程的两个根并将根返回
#********** Begin *********#
  if b*b-4*a*c<0:
    return("inf")
  elif b*b-4*a*c>=0:
    root=sqrt(b*b-4*a*c)
    x1=(-b-root)/(2*a)
    x2=(-b-root)/(2*a)
    list2=[]
    list2.append(x1)
    list2.append(x2)
    r=tuple(list2)
    return(r)
#********** End **********#

if a != 0:
  print (roots(a,b,c))

 第5关：使用递归
任务描述
递归（Recursion）是一种非常重要的程序设计思想。它可以极其方便的简化程序设计流程，以非常简洁的方式完成复杂的逻辑设计。
本关的任务是让学习者掌握使用递归的方式设计函数。
相关知识
递归
我们都知道在一个函数内部还可以调用其它函数，但是如果在一个函数的内部调用函数自身，那么这个函数就是递归函数。例如：
我们计算阶乘n! = 1 * 2 * 3 * ... * n，用函数 fact(n)表示，可以看出： fact(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = fact(n-1) * n 所以，fact(n)可以表示为 n * fact(n-1)，只有n=1时需要特殊处理。 于是，fact(n)用递归的方式写出来就是：
  1. def fact(n):
  2. if n ==1:
  3. return 1
  4. return n * fact(n -1)
这就是一个递归函数。 注意，在使用递归策略时，必须要有一个明确的递归结束条件，称为递归出口。 递归的优点：
  •  
    递归使代码看起来更加整洁、优雅；
     
  •  
    可以用递归将复杂任务分解成更简单的子问题；
     
  •  
    使用递归比使用一些嵌套迭代更容易。
     
递归的缺点:
  •  
    递归的逻辑很难调试、跟进；
     
  •  
    递归调用的代价高昂（效率低），因为占用了大量的内存和时间。
     
编程要求
本关的编程任务是补全 src/step8/step8.py 文件中的代码，以递归的方式设计函数abs_sum(L) ，返回列表L（假设其中全是整数）中所有整数绝对值之和，并且约定abs_sum([])的值为0。
本关涉及的 src/step8/step8.py 文件的代码框架如下:
  1. # coding:utf-8
  3. n = input()
  4. Lst = [1,-2, 6, 11, -5]
  6. def abs_sum(L):
  7. #请在此添加代码，以递归的方式设计函数abs_sum(L)返回列表L（假设其中全是整数）中所有整数绝对值之和
  8. #********** Begin *********#
  10. #********** End *********#
  11. print abs_sum(Lst)
测试说明
本关要求学习者直接填入代码，然后运行程序并根据程序输出的结果判断填入的代码是否正确。
以下是平台对 src/step8/step8.py 文件的样例测试集： 测试输入： 3 预期输出： 25
开始你的任务吧，祝你成功！
# coding:utf-8


Lst = input()
Lst = Lst.split(',')

def abs_sum(L):
#请在此添加代码，以递归的方式设计函数abs_sum(L)返回列表L（假设其中全是整数）中所有整数绝对值之和
#********** Begin *********#
    a,b=0,0
    for i in L:
        if int(i)>=0:
            a+=int(i)
        else:
            b-=int(i)
    return a+b
#**********  End  *********#

print(abs_sum(Lst))

 九、列表
第1关：列表元素的增删改：客人名单的变化
任务描述
本关任务：对一个给定的列表进行增、删、改等操作，并输出变化后的最终列表。
列表是由按一定顺序排列的元素组成，其中的元素根据需要可能会发生变化。其中，列表元素的添加、删除或修改等是最常见的操作。下面以一则请客的故事来说明列表元素操作的应用场景。
有个人邀请几个朋友吃饭，初步拟定了一个客人名单列表guests=['Zhang san','Li si','Wang wu','Zhao liu']。后面因为一些临时情况，这个客人名单不断变化：
  •  
    Zhao liu说要带他的朋友Hu qi一起来。
     
  •  
    Zhang san因临时有事不能来了。
     
  •  
    Wang wu说由他的弟弟Wang shi代他赴宴。
     
最终的客人名单列表如下：
['Li si','Wang shi','Zhao liu','Hu qi']
相关知识
Python为列表类型提供了一系列内置操作，包括append()、insert()、pop()、remove()等函数，能够很方便的处理上述列表元素变化的情况。
我们以上述客人名单列表为例介绍这几种列表操作方法。
添加列表元素
Python提供了append()和insert()等函数，实现向一个列表增加新元素的功能。
(1). 在列表尾部添加元素 在Python中，可以使用append()方法向一个列表的尾部追加一个元素，其基本语法如下：
source_list.append(obj)
其中，
  •  
    source_list：为待修改的列表
     
  •  
    obj：为待插入的元素
     
例如，要向guests列表尾部增加客人Hu qi，相应的语句为：
  1. # 初始化guests列表
  2. guests=['Zhang san','Li si','Wang wu','Zhao liu']
  4. # 向guests列表尾部追加一个名为Hu qi的客人
  5. guests.append('Hu qi')
  7. # 输出新的guests列表
  8. print(guests)
输出结果为： ['Zhang san','Li si','Wang wu','Zhao liu','Hu qi']
(2). 在列表指定位置添加元素
Python也提供了insert()方法，可以在列表任意指定位置插入元素，其基本语法为：
source_list.insert(index,obj)
其中，
  •  
    source_list：为待修改的列表
     
  •  
    index：为待插入的位置索引
     
  •  
    obj：为待插入的元素
     
注意：在Python中，列表起始元素的位置索引为0
例如，要向guests列表中Zhang san的后面增加客人Hu qi，则相应的语句为：
  1. # 创建并初始化guests列表
  2. guests=['Zhang san','Li si','Wang wu','Zhao liu']
  4. # 向guests列表Zhang san后面增加一个名为Hu qi的客人
  5. guests.insert(1,'Hu qi')
  7. # 输出新的guests列表
  8. print(guests)
输出结果为： ['Zhang san','Hu qi','Li si','Wang wu','Zhao liu']
修改列表元素
Python中修改列表元素的方法为，直接将列表中要修改的元素索引指出，然后为其指定新值。其基本语法如下：
source_list[index] = obj
其中，
  •  
    source_list：为待修改的列表
     
  •  
    index：为待修改元素的位置索引
     
  •  
    obj：为待元素的新值
     
例如，将请客名单guests列表中的Wang wu改为Wang shi。 ，则相应的语句为：
  1. # 初始化guests列表
  2. guests=['Zhang san','Li si','Wang wu','Zhao liu']
  4. # 将列表中的`Wang wu`改为`Wang shi`
  5. guests[2] = 'Wang shi'
  7. # 输出新的guests列表
  8. print(guests)
输出结果为： ['Zhang san','Li si','Wang shi','Zhao liu']
删除列表元素
Python提供了多种不同的方法来实现对列表中元素的删除操作，包括根据元素索引位置或者元素值删除元素的方法。
(1). 删除指定位置的元素
del方法
在Python中，调用del函数能够删除指定索引位置的元素，其基本语法如下：
del source_list[index]
其中，
  •  
    source_list：为待修改的列表
     
  •  
    index：为待删除元素的位置索引
     
例如，将请客名单guests列表中的Zhang san删除。则相应的语句为：
  1. # 初始化guests列表
  2. guests=['Zhang san','Li si','Wang wu','Zhao liu']
  4. # 将列表中的`Zhang san`删除
  5. del guests[0]
  7. # 输出新的guests列表
  8. print(guests)
输出结果为： ['Li si','Wang wu','Zhao liu']
pop方法
Python还提供了pop()方法来删除元素，该方法将从源列表删除对应元素，同时返回被删除的元素。其基本语法如下：
deleted_obj = source_list.pop(index)
其中，
  •  
    deleted_obj：为保存被删除元素的变量，可根据需要自由命名
     
  •  
    source_list：为待修改的列表
     
  •  
    index：为待删除元素的位置索引
     
注意:index参数为可选项，不填则默认删除列表末尾的元素
例如，将请客名单guests列表中的Zhang san删除。 ，则相应的语句为：
  1. # 初始化guests列表
  2. guests=['Zhang san','Li si','Wang wu','Zhao liu']
  4. # 将列表中的`Zhang san`删除
  5. deleted_obj = guests.pop(0)
  7. # 输出被删除的元素以及删除后的guests列表
  8. print(deleted_obj)
  9. print(guests)
输出结果为： Zhang san ['Li si','Wang wu','Zhao liu']
(2). 删除指定值对应的元素
有些时候我们并不知道要删除元素的位置索引，怎么办呢？别着急，Python还提供了remove()方法，可以直接通过元素值来删除对应的元素。其基本语法如下：
source_list.remove(obj)
其中，
  •  
    source_list为待修改的列表
     
  •  
    obj为待删除元素的值
     
  1. 注意：如果列表中有多个值为obj的元素，remove仅删除位置索引最靠前的那个元素
例如，将请客名单guests列表中的Zhang san删除。 ，则相应的语句为：
  1. # 初始化guests列表，列表中有多个名为Zhang san的客人
  2. guests=['Zhang san','Li si','Wang wu','Zhao liu','Zhang san']
  4. # 将列表中的`Zhang san`删除
  5. guests.remove('Zhang san')
  7. # 输出新的guests列表
  8. print(guests)
输出结果为：
  1. `['Li si','Wang wu','Zhao liu','Zhang san']`
如果您想了解更多有关列表操作知识，请参考:【美】Eric Matthes著《Python编程——从入门到实践》第三章。
编程要求
本关的编程任务是补全src/Step1/guests.py文件的代码，实现相应的功能。具体要求如下：
  •  
    step1：将guests列表末尾的元素删除，并将这个被删除的元素值保存到deleted_guest变量
     
  •  
    step2：将deleted_guest插入到step1删除后的guests列表索引位置为2的地方；
     
  •  
    step3：将step2处理后的guests列表索引位置为1的元素删除
     
  •  
    打印输出step1的deleted_guest变量。
     
  •  
    打印输出step3改变后的guests列表；
     
本关涉及的代码文件src/Step1/guests.py的代码框架如下：
  1. # coding=utf-8
  3. # 创建并初始化Guests列表
  4. guests = []
  6. while True:
  7. try:
  8. guest = input()
  9. guests.append(guest)
  10. except:
  11. break
  14. # 请在此添加代码，对guests列表进行插入、删除等操作
  15. ###### Begin ######
  18. ####### End #######
测试说明
本关的测试文件是src/Step1/guests.py，测试过程如下：
  1.  
    平台自动编译并运行guests.py，并以标准输入方式提供测试输入；
     
  2.  
    平台获取程序输出，并将其输出与预期输出对比。如果一致则测试通过，否则测试失败。
     
以下是平台对src/Step1/guests.py的样例测试集：
测试输入：
  1. zhang san
  2. li si
  3. wang wu
  4. tan qi
  5. hu ba
预期输出：
  1. hu ba
  2. ['zhang san', 'hu ba', 'wang wu', 'tan qi']
开始你的任务吧，祝你成功！
# coding=utf-8

# 创建并初始化Guests列表
guests = []
while True:
    try:
        guest = input()
        guests.append(guest)
    except:
        break

    
# 请在此添加代码，对guests列表进行插入、删除等操作
###### Begin ######
deleted_guest=guests.pop(-1)
guests.insert(2,deleted_guest)
guests.pop(1)
print(deleted_guest)
print(guests)
#######  End #######

 第2关：列表元素的排序：给客人排序
任务描述
本关任务：学会列表排序相关操作的使用方法，实现对列表元素的排序。
一般情况下我们创建的列表中的元素可能都是无序的，但有些时候我们需要对列表元素进行排序。
例如，对参加会议的专家名单，我们需要根据专家姓名按照首字母从小到大或者从大到小的顺序进行排序。
例如我们想将如下的客人guests列表中的五个名字元素['zhang san','li si','wang wu','sun qi','qian ba']分别按照首字母从小到大的顺序和从大到小的顺序分别排序。排序后的输出分别为：
['li si','qian ba','sun qi','wang wu','zhang san']
['zhang san','wang wu','sun qi','qian ba','li si']
相关知识
Python针对列表数据结构内置提供了sort()方法，实现对列表元素的排序功能。其基本语法如下：
source_list.sort(reverse=True)
其中，
  •  
    source_list：待排序的列表
     
  •  
    sort：列表排序函数的语法关键词
     
  •  
    reverse：sort函数的可选参数，如果设置其值为True，则进行反向从大到小排序，如果设置为False或者不填写该参数，则默认进行正向从小到大排序。
     
例如，给定一个客人列表guests，我们对其按照字母排序如下：
  1. guests = ['zhang san','li si','wang wu','sun qi','qian ba']
  2. guests.sort()
  3. print(guests)
  5. guests.sort(reverse=True)
  6. print(guests)
程序输出结果：
['li si','qian ba','sun qi','wang wu','zhang san']
['zhang san','wang wu','sun qi','qian ba','li si']
  1. 注意，sort函数会直接作用于待排序的列表并修改其排序
如果您想了解更多有关列表操作知识，请参考:【美】Eric Matthes著《Python编程——从入门到实践》第三章。
编程要求
本关的编程任务是补全src/step2/sortTest.py 文件中的函数部分，要求实现对输入列表source_list中的元素按照首字母从小到大的顺序进行排序，并且输出排序后的列表。
本关涉及的代码文件src/step2/sortTest.py 的代码框架如下：
  1. #coding=utf-8
  3. # 创建并初始化`source_list`列表
  4. source_list = []
  5. while True:
  6. try:
  7. list_element = input()
  8. source_list.append(list_element)
  9. except:
  10. break
  12. # 请在此添加代码，对guests列表进行排序等操作并打印输出排序后的列表
  13. #********** Begin *********#
  16. #********** End **********#
评测说明
本关的测试文件是src/Step2/sortTest.py,测试过程如下：
  1.  
    平台自动编译并运行sortTest.py，并以标准输入方式提供测试输入；
     
  2.  
    平台获取程序输出，并将其输出与预期输出对比。如果一致则测试通过，否则测试失败。
     
以下是平台对src/Step2/sortTest.py的样例测试集：
测试输入：
  1. zhang san
  2. li si
  3. wang wu
  4. tan qi
  5. hu ba
预期输出： ['hu ba', 'li si', 'tan qi', 'wang wu', 'zhang san']
开始你的任务吧，祝你成功！
#coding=utf-8

# 创建并初始化`source_list`列表
source_list = []
while True:
    try:
        list_element = input()
        source_list.append(list_element)
    except:
        break
    
# 请在此添加代码，对source_list列表进行排序等操作并打印输出排序后的列表
#********** Begin *********#
source_list.sort()
print(source_list)

#********** End **********#


 第3关：数值列表：用数字说话
任务描述
本关任务：利用合适方法快速创建数字列表，并能够对列表中的元素数值进行简单的统计运算。
在数据可视化的背景下，数字列表在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
     
  1. 注意，range()函数的三个参数都只能为整数。如果range函数中仅一个参数，则该参数表示upper_limit;如果仅两个参数，则分别表示lower_limit和upper_limit。
例如，要生成1~6之间步长为2的系列整数：
  1. for i in range(1,6,2):
  2. print(i)
输出结果：
  1. 1
  2. 3
  3. 5
基于range()函数创建数字列表
我们可以通过range()函数，利用Python列表提供的append()插入功能创建一个列表。
例如，我们要创建一个包含10个（0~9）整数的平方的列表：
  1. # 声明一个列表变量
  2. numbers = []
  4. # 利用append()函数和range()函数向列表插入目标元素
  5. for i in range(10):
  6. number = i**2
  7. numbers.append(number)
  9. 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的数字列表：
  1. data_list = list(range(1,6))
  2. print(data_list)
输出结果： [1,2,3,4,5]
对数字列表进行简单的统计运算
Python中有一些专门处理数字列表简单的统计运算的函数，利用这些函数可以轻松找到数字列表的最小值、最大值和总和等一系列统计运算。其基本语法如下：
  1. min_value = min(data_list)
  2. max_value = max(data_list)
  3. sum_value = sum(data_list)
其中，
  •  
    min：数字列表求最小值的语法关键字
     
  •  
    max：数字列表求最大值的语法关键字
     
  •  
    sum：数字列表求和的语法关键字
     
具体使用示例如下：
  1. numbers = [2,4,11,1,21,32,5,8]
  2. print('The min number is',min(numbers))
  3. print('The max number is',max(numbers))
  4. print('The sum is',sum(numbers))
输出结果：
  1. The min number is 1
  2. The max number is 32
  3. The sum is 84
如果您想了解更多有关列表操作知识，请参考:【美】Eric Matthes著《Python编程——从入门到实践》第三章。
编程要求
编程任务是补全src/Step3/numbers_square.py文件的代码内容，实现如下功能：
  •  
    step1：根据给定的下限数lower, 上限数upper以及步长step,利用range函数生成一个列表；
     
  •  
    step2：计算该列表的长度并输出；
     
  •  
    step3：求该列表中的最大元素与最小元素之差并输出；
     
本关的代码文件src/Step3/numbers_square.py的代码框架如下：
  1. #coding=utf-8
  3. # 创建并读入range函数的相应参数
  4. lower = int(input())
  5. upper = int(input())
  6. step = int(input())
  8. # 请在此添加代码，实现编程要求
  9. ###### Begin ######
  12. ####### End #######
评测说明
本关的测试文件是src/Step3/numbers_square.py，测试过程如下：
  1.  
    平台自动编译并运行numbers_square.py，并以标准输入方式提供测试输入；
     
  2.  
    平台获取程序输出，并将其输出与预期输出对比。如果一致则测试通过，否则测试失败。
     
以下是平台对src/Step3/numbers_square.py的样例测试集：
测试输入：
  1. 25
  2. 90
  3. 4
预期输出：
  1. 17
  2. 64
开始你的任务吧，祝你成功！
#coding=utf-8

# 创建并读入range函数的相应参数
lower = int(input())
upper = int(input())
step = int(input())

# 请在此添加代码，实现编程要求
###### Begin ######
list1=[]
for i in range(lower,upper,step):
    list1.append(i)
print(len(list1))
list1.sort()
a=list1[-1]-list1[0]
print(a)

####### End #######

 第4关：列表切片：你的菜单和我的菜单
任务描述
我们在前三关中学习了如何处理单个列表元素和所有列表元素，在这一关中我们还将学习如何处理部分列表元素——Python中称为切片。
例如，当我们去餐馆吃饭点菜时，你的菜单和我的菜单有些时候是一模一样，也有些时候是部分菜名一样。那么如何根据我已经点好的菜单生成你的菜单呢？
本关通过菜名列表的部分复制，让读者了解并掌握列表切片的基础知识。
相关知识
Python切片是对一个列表取其部分元素获得一个子序列的常见操作，切片操作的返回结果类型与被切片的对象一致。要创建一个已有列表的切片，通过指定切片的第一个列表元素和最后一个列表元素的索引号即可。其基本语法如下：
list_slice = source_list[start:end:step]
其中，
  •  
    source_list：被切片的源列表
     
  •  
    list_slice：切片后生成的子序列列表
     
  •  
    start：切片起始索引位置，省略则从头开始
     
  •  
    end：切片结束索引位置，省略则切至列表末尾
     
  •  
    step：切片步长，可选参数，表示每N个元素取一个，默认为1
     
  1. 注意：切片和range()函数一样，Python会自动到达所指定切片结束索引位置的前面一个元素停止。
例如，下面是我已经点好的菜名列表，现在朋友点的菜单中包含我的前三个菜名，输出朋友的菜单：
  1. my_menu = ['fish','pork','pizza','carrot']
  2. print(my_menu[1:4:2])
  3. print(my_menu[:3])
  4. print(my_menu[2:])
输出结果： ['pork','carrot'] ['fish','pork','pizza'] ['pizza','carrot']
负数索引返回离列表末尾相应间隔的元素。列表末尾元素的索引是从-1开始的。
例如，朋友的菜单是包含我的菜单最后3个菜名：
  1. my_menu=['fish','pork','pizza','carrot']
  2. print(my_menu[-3:])
输出结果： ['pork','pizza','carrot']
如果您想了解更多有关列表操作知识，请参考:【美】Eric Matthes著《Python编程——从入门到实践》第四章。
编程要求
本关的编程任务是补全src/Step4/foods.py文件的代码内容，实现如下功能:
  •  
    利用切片方法从my_menu列表中每3个元素取1个，组成子序列并打印输出；
     
  •  
    利用切片方法获取my_menu列表的最后三个元素组成子序列并打印输出。
     
本关涉及的代码文件src/Step4/foods.py的代码框架如下：
  1. # coding=utf-8
  3. # 创建并初始化my_munu列表
  4. my_menu = []
  5. while True:
  6. try:
  7. food = input()
  8. my_menu.append(food)
  9. except:
  10. break
  12. # 请在此添加代码，对my_menu列表进行切片操作
  13. ###### Begin ######
  16. ####### End #######
评测说明
本关的测试文件是src/Step4/foods.py，测试过程如下：
  1.  
    平台自动编译并运行foods.py，并以标准输入方式提供测试输入；
     
  2.  
    平台获取程序输出，并将其输出与预期输出对比。如果一致则测试通过，否则测试失败。
     
以下是平台对src/Step4/foods.py的样例测试集：
测试输入：
  1. pizza
  2. chicken
  3. carrot
  4. apple
  5. banana
预期输出：
  1. ['pizza','apple']
  2. ['carrot','apple','banana']
开始你的任务吧，祝你成功！
# coding=utf-8

# 创建并初始化my_menu列表
my_menu = []
while True:
    try:
        food = input()
        my_menu.append(food)
    except:
        break

# 请在此添加代码，对my_menu列表进行切片操作
###### Begin ######
list_slice = my_menu[::3]
print(list_slice)
pppp=my_menu[-3:-1]
pppp.append(my_menu[-1])
print(pppp)


#######  End #######


 第5关：列表与循环 – 验证是否为三位数
任务描述
本关任务要求结合 Python 列表以及循环结构编写代码，验证一个给定的整数是否为三位数。
相关知识
Python 序列
序列是 Python 中最基本的数据结构。相比于单一变量只能存储一个对象（数字或者字符串），序列可以用于存储多个对象。Python 有 6 种内置的序列类型，但最常见的是列表(list)和元组(tuple)。
列表list
list是一种有序的集合，可以随时添加和删除其中的元素。列表的数据项不需要具有相同的类型。创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可，如下所示：
  1. list1 = ['physics', 'chemistry', 1997, 2000]
  2. list2 = [1, 2, 3, 4, 5 ]
在list中用索引来访问list中每一个位置的元素。注意索引是从 0 开始的，当索引超出了范围时，Python 会报一个IndexError错误。所以，要确保索引不要越界，记得最后一个元素的索引是len(list) - 1。
例如，要获取上面示例代码中的list1中的第 2 个元素，则可以通过下面的代码来获得：
  1. >>> list1[1] #索引是从 0 开始的，所以第二个元素对应的索引是 1 而不是 2。
  2. chemistry
列表list包含以下方法:
方法功能
list.append(obj)在列表末尾添加新的对象
list.count(obj)统计某个元素在列表中出现的次数
list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)将对象插入列表
list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)移除列表中某个值的第一个匹配项
list.reverse()反向列表中元素
元组tuple
 Python 的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可，如下所示：
  1. tup1 = ('physics', 'chemistry', 1997, 2000)
  2. tup2 = (1, 2, 3, 4, 5 )
  3. tup3 = (1,)
元组中只包含一个元素时，需要在元素后面添加逗号，以免被误解成数学计算意义上的括号。
元组中的元素不可变，所以它没有append()，insert()这样的方法。另外，元组中的元素值也是不允许删除的，但我们可以使用del语句来删除整个元组。比如，del tup1。
其他获取元素的方法和list是一样的，你可以正常地使用tup1[0]，tup1[-1]，但不能赋值成另外的元素。元组这种不可变的特性能够使得代码更安全。
编程要求
请编写代码验证输入的列表N_list中的整数是否为三位数，并求这些三位数的百位数值，并用列表存储，最终直接输出列表。
测试说明
本实训的测试样例如下：
测试输入：100,200,300,400,500 预期输出：[1, 2, 3, 4, 5]
开始你的任务吧，祝你成功！
#请验证输入的列表N_list中的整数是否为三位数，并返回三位数整数的百位数值

N_list = [int(i) for i in input().split(',')]

#   请在此添加实现代码   #
# ********** Begin *********#
a=[]
for i in N_list:
    i=str(i)
    if len(i)==3 and i[0]!=0:
        i=int(i)
        c=i//100
        a.append(c)
print(a)





# ********** End **********#

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

# 创建并初始化menu_list列表
menu_list = []
while True:
    try:
        food = input()
        menu_list.append(food)
        if food=="":
            break
    except:
        break

# 请在此添加代码，对menu_list进行元组转换以及元组计算等操作，并打印输出元组及元组最大的元素
###### Begin ######
print(tuple(menu_list))
print(max(tuple(menu_list)))


#######  End #######



 第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对象用作字典中的值。
访问字典中的值
要获取与键相关联的值，可依次指定字典名和放在方括号内的键，如下所示：
  1. # 创建并初始化menu字典
  2. menu = {'fish':40, 'pork':30, 'potato':15, 'noodles':10}
  4. # 获取并返回menu字典中键'fish'键对应的值
  5. print(menu['fish'])
输出结果： 40
添加键-值对
字典是一种动态数据结构，可随时在字典中添加键—值对。要添加键—值对时，可依次指定字典名、键和键对应的值。
下面在字典menu中添加两道菜的菜名和价格：
  1. # 创建并初始化menu字典
  2. menu = {'fish':40, 'pork':30, 'potato':15, 'noodles':10}
  4. # 向menu字典中添加菜名和价格
  5. menu['juice'] = 12
  6. menu['egg'] = 5
  8. #输出新的menu
  9. print(menu)
输出结果： {'fish': 40,'pork': 30,'potato': 15,'noodles': 10, 'juice': 12,'egg': 5}
新的menu字典包含6个键-值对，新增加的两个键-值对（菜名和对应价格）添加在了原有键-值对的后面，注意字典中键-值对的排列顺序和添加顺序没有必然联系，Python不关心字典中键-值对的排列顺序，而只关心键与值得对应关系。
同理，字典和列表一样，可以先创建一个空字典，然后可以不断向里面添加新的键-值对。
修改字典中的值
字典和列表一样，里面的值都是可以修改的。要修改字典中的值，可直接指定字典中的键所对应的新值。例如，将menu中的fish价格改为50。
  1. # 创建并初始化menu字典
  2. menu = {'fish':40, 'pork':30, 'potato':15, 'noodles':10}
  4. # 修改menu字典中菜fish的价格
  5. menu['fish'] = 50
  7. # 打印输出新的menu
  8. print(menu)
输出结果： {'fish': 50, 'pork': 30, 'potato': 15, 'noodles': 10}
删除键-值对
我们可以通过del方法删除字典中不需要的键-值对，使用del方法时，要指定字典名和要删除的键。
例如，在menu菜单中删除键noodles和它的值。
  1. # 创建并初始化menu字典
  2. menu = {'fish':40, 'pork':30, 'potato':15, 'noodles':10}
  4. # 删除noodles键值对
  5. del menu['noodles']
  7. # 打印输出新的menu
  8. print(menu)
输出结果： {'fish': 40, 'pork': 30, 'potato': 15}
如果您想了解更多有关列表使用知识，请参考:【美】Eric Matthes著《Python编程——从入门到实践》第六章。
编程要求
本关的编程任务是补全src/Step2/menu.py文件的代码，实现相应的功能。具体要求如下:
  •  
    向menu_dict字典中添加一道菜名lamb，它的价格是50；
     
  •  
    获取menu_dict字典中的fish的价格并打印出来；
     
  •  
    将menu_dict字典中的fish的价格改为100；
     
  •  
    删除menu_dict字典中noodles这道菜；
     
  •  
    输出新的menu_dict菜单。
     
本关涉及的代码文件src/Step2/menu.py的代码框架如下：
  1. # coding=utf-8
  3. # 创建并初始化munu_dict字典
  4. menu_dict = {}
  5. while True:
  6. try:
  7. food = input()
  8. price = int(input())
  9. menu_dict[food]= price
  10. except:
  11. break
  13. #请在此添加代码，实现对menu_dict的添加、查找、修改等操作，并打印输出相应的值
  14. ###### Begin ######
  17. ####### End #######
测试说明
本关的测试文件是src/Step2/menu.py，测试过程如下：
  1.  
    平台自动编译并运行menu.py，并以标准输入方式提供测试输入；
     
  2.  
    平台获取程序输出，并将其输出与预期输出对比。如果一致则测试通过，否则测试失败。
     
以下是平台对src/Step2/menu.py的样例测试集：
测试输入：
  1. pizza
  2. 40
  3. noodles
  4. 30
  5. carrot
  6. 20
  7. turkey
  8. 34
  9. fish
  10. 37
预期输出：
  1. 37
  2. {'pizza': 40, 'carrot': 20, 'turkey': 34, 'fish': 100, 'lamb': 50}
开始你的任务吧，祝你成功！
# coding=utf-8

# 创建并初始化menu_dict字典
menu_dict = {}
while True:
    try:
        food = input()
        price = int(input())
        menu_dict[food]= price
    except:
        break

#请在此添加代码，实现对menu_dict的添加、查找、修改等操作，并打印输出相应的值
###### Begin ######
menu_dict["lamb"]=50

print(menu_dict.get('fish'))
menu_dict["fish"]=100
del menu_dict['noodles']
print(menu_dict)


#######  End #######

 第3关：字典的遍历：菜名和价格的展示
任务描述
Python字典中包含大量数据，字典和列表一样，支持遍历操作。Python有多种遍历字典的方式，可以遍历字典的所有键-值对，键或值。
例如：餐馆的菜单包含了菜名和价格等信息，餐馆需要将菜名和价格都展示给顾客，但也有些时候只需要将菜名都展示给厨师，还有些时候只需要将价格展示给收银员。这三种情况就用到了字典不同的遍历方式。
本关的目标是让读者掌握字典遍历的相关知识和用法，需要基于这些知识实现对菜单不同的查找和展示处理。
相关知识
遍历字典中的键-值对
Python为字典类型提供了items()方法，items()方法会将字典里的所有的键与值一起返回，
例如，餐馆有一个菜单包含了菜名和价格信息。菜名和价格顾客都需要知道，可以通过遍历输出menu字典的键和值来实现。
  1. #coding = utf-8
  3. # 创建并初始化menu菜单字典
  4. menu={'fish':'40','pork':'30','potato':'20','lamb':'50'}
  6. # 利用items()方法遍历输出键和值
  7. for key,value in menu.items():
  8. print('\nkey:'+key)
  9. print('value:'+value)
输出结果：
  1. key:fish
  2. value:40
  4. key:pork
  5. value:30
  7. key:potato
  8. value:20
  10. key:lamb
  11. value:50
输出结果表示，items()方法每次都将对应的键和值指定到key和value变量中，然后用for循环输出。
遍历字典中的键
对于餐馆中的厨师来说，他们并不想要知道菜的价格，只需要知道菜名然后将其做出来就行。所以对于厨师来说，我们需要遍历menu字典中的所有菜名。
Python为字典类型内置了keys()方法，该方法会将字典里的键遍历出来，例如：
  1. # 创建并初始化menu菜单字典
  2. menu={'fish':'40','pork':'30','potato':'20','lamb':'50'}
  4. # 利用keys()方法遍历输出键
  5. for key in menu.keys():
  6. print('food_name:'+key)
输出结果： food_name:fish food_name:pork food_name:potato food_name:lamb
输出结果表示，keys()方法每次都是将menu菜单中的键输出，显示菜名。
遍历字典中的值
对于餐馆中的收银员来说，他们可能并不想知道菜单的菜名，只需要知道菜的价格然后收账即可。所以对于收银员来说，我们需要遍历menu字典中的所有菜的价格。
Python为字典类型内置了values()方法，该方法会将字典里的值遍历出来，例如：
  1. # 创建并初始化menu菜单字典
  2. menu={'fish':'40','pork':'30','potato':'20','lamb':'50'}
  4. # 利用values()方法遍历输出值
  5. for value in menu.values():
  6. print('food_price:'+value)
输出结果： food_price:40 food_price:30 food_price:20 food_price:50
输出结果表示，values()方法每次都是将menu菜单中的值输出，显示菜的价格。
如果您想了解更多有关字典使用知识，请参考:【美】Eric Matthes著《Python编程——从入门到实践》第六章。
编程要求
本关的编程任务是补全src/Step3/key-values.py文件的代码，实现相应的功能。具体要求如下：
  •  
    将menu_dict菜单的键遍历输出；
     
  •  
    将menu_dict菜单的值遍历输出；
     
本关涉及的代码文件src/Step3/key_values.py的代码框架如下：
  1. # coding=utf-8
  3. # 创建并初始化munu_dict字典
  4. menu_dict = {}
  5. while True:
  6. try:
  7. food = input()
  8. price = int(input())
  9. menu_dict[food]= price
  10. except:
  11. break
  13. #请在此添加代码，实现对menu_dict的遍历操作并打印输出键与值
  14. ###### Begin ######
  17. ####### End #######
测试说明
本关的测试文件是src/Step3/key_values.py，测试过程如下：
  1.  
    平台自动编译并运行key_values.py，并以标准输入方式提供测试输入；
     
  2.  
    平台获取程序输出，并将其输出与预期输出对比。如果一致则测试通过，否则测试失败。
     
以下是平台对src/Step3/key_values.py的样例测试集：
测试输入：
  1. Spring Rolls
  2. 40
  3. pork
  4. 30
  5. Fried Wonton
  6. 15
预期输出：
  1. Spring Rolls
  2. pork
  3. Fried Wonton
  4. 40
  5. 30
  6. 15
开始你的任务吧，祝你成功！
# coding=utf-8

# 创建并初始化menu_dict字典
menu_dict = {}
while True:
    try:
        food = input()
        price = int(input())
        menu_dict[food]= price
    except:
        break

#请在此添加代码，实现对menu_dict的遍历操作并打印输出键与值
###### Begin ######
for i in menu_dict.keys():
    print(i)
for w in menu_dict.values():
    print(w)


#######  End #######




 第4关：嵌套 – 菜单的信息量好大
任务描述
Python的列表和字典可以存储任意类型的元素，所以我们可以将字典存储在列表中，也可以将列表存储在字典中，这种操作称为嵌套。
例如，餐馆中的菜单不仅仅包含菜名和价格，可能还会包含很多其他信息，这时候我们可能就需要采取嵌套的存储方式。
本关任务是让学习者利用嵌套方式存储菜单，让读者掌握Python嵌套的基本操作。
相关知识
列表中存储字典
餐馆中已经有了3份菜单，每份菜单都会有菜名和价格，我们要将这些信息存储在一起，可以采取如下方法。
将3份菜单用字典的方式存储菜名和价格，然后将这3份菜单字典存储在一个列表中，例如：
  1. # 创建3个菜单字典，包含菜名和价格
  2. menu1 = {'fish':40, 'pork':30, 'potato':20,'noodles':15}
  3. menu2 = {'chicken':30, 'corn':55, 'lamb':65,'onion':12}
  4. menu3 = {'bacon':36, 'beaf':48, 'crab':72,'eggs':7}
  6. # 将3个菜单字典存储到列表menu_total中
  7. menu_total = [menu1,menu2,menu3]
  9. # 输出列表
  10. 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}]
字典中存储列表
我们也可以在字典中存储列表，比如我们对于一份菜单，菜名作为键，而值我们想是这道菜的配料，那么我们就可以将这些配料作为列表存储，然后作为值存储在字典中。例如：
  1. # 初始化menu菜单，里面包含配料列表
  2. menu = {'fish':['vinegar','soy','salt'], 'pork':['sugar','wine']}
  4. # 输出pork这道菜的配料
  5. print('The burding of pork is:',menu['pork'])
输出结果：
The burding of pork is: ['sugar', 'wine']
字典中存储字典
我们也可以在字典中存储字典，例如我们有一份总菜单，包含2个子菜单，每个子菜单都包含菜名和价格。例如：
  1. # 创建一个字典menu_sum，里面包含两个子菜单字典menu1和menu2
  2. menu_sum = { 
  3. 'menu1':{'fish':40, 'pork':30, 'potato':20,'noodles':15},
  4. 'menu2':{'chicken':30, 'corn':55, 'lamb':65,'onion':12}
  5. }
  7. # 输出menu1和menu2中的菜名和价格
  8. print(menu_sum['menu1'])
  9. print(menu_sum['menu2'])
输出结果：
{'fish': 40, 'pork': 30, 'potato': 20, 'noodles': 15} {'chicken': 30, 'corn': 55, 'lamb': 65, 'onion': 12}
如果您想了解更多有关字典使用知识，请参考:【美】Eric Matthes著《Python编程——从入门到实践》第六章。
编程要求
本关的编程任务是补全src/Step4/menu_nest.py文件的代码，实现相应的功能。具体要求如下：
  •  
    menu_total列表中初始时只包含menu1字典，menu1字典中包含两道菜和两道菜的价格；
     
  •  
    编程要求是向menu_total列表中添加另外一个菜单字典menu2，menu2菜单中的菜名和menu1菜单一样，菜的价格是menu1菜的价格的2倍；
     
  •  
    输出新的menu_total列表。
     
本关涉及的代码文件src/Step4/menu_nest.py的代码框架如下：
  1. # coding=utf-8
  3. # 初始化menu1字典，输入两道菜的价格
  4. menu1 = {}
  5. menu1['fish']=input()
  6. menu1['pork']=input()
  8. # menu_total列表现在只包含menu1字典
  9. menu_total = [menu1]
  11. # 请在此添加代码，实现编程要求
  12. ###### Begin ######
  15. ###### End ######
  17. # 输出menu_total列表
  18. print(menu_total)
测试说明
本关的测试文件是src/Step4/menu_nest.py，测试过程如下：
  1.  
    平台自动编译运行menu_nest.py，并以标准输入方式提供测试输入；
     
  2.  
    平台获取程序输出，并将其输出与预期输出对比。如果一致则测试通过，否则测试失败。
     
以下是平台对src/Step4/menu_nest.py的样例测试集：
测试输入： 40 30 预期输出： [{'fish': 40, 'pork': 30}, {'fish': 80, 'pork': 60}]
开始你的任务吧，祝你成功！
#coding=utf-8

#初始化menu1字典，输入两道菜的价格
menu1 = {}
a=menu1['fish']=int(input())
b=menu1['pork']=int(input())

#menu_total列表现在只包含menu1字典
menu_total = [menu1]

# 请在此添加代码，实现编程要求
#********** Begin *********#
menu2 = {}
menu2['fish']=a*2
menu2['pork']=b*2
menu_total = [menu1,menu2]



#********** End **********#

#输出menu_total列表
print(menu_total)






 第5关：统计投票结果
任务描述
本关任务：编程统计投票结果。
相关知识
为了完成本关任务，你需要掌握：
  1. 如何将字符串转换为列表
  2. 字典的定义
  3. 如何遍历列表
  4. 字典元素的添加、修改
  5. 字典元素的遍历
1.将字符串转换为列表
用 str.split()函数：用参数指定的字符作为分隔符，将字符串拆分为列表 比如，s = 'ab,cd,e' list1 = s.split(',') 结果: list1列表为 ['ab','cd','e']
2.字典的定义
用{} 或 dict() 函数
3. 如何遍历列表
用for 循环，比如 for s in list1: print(s) 输出： ab cd e
4.字典元素的添加、修改
dicta[key] = value 将键为key的键值修改为value，当键为key的元素不在字典中时，则添加一个元素（key:value）
5.字典的遍历
与列表一样，用for循环 for i in dicta: print(i,':',dicta[i]) #输出每个键值对
编程要求
根据提示，在右侧编辑器补充代码 。
测试说明
平台会对你编写的代码进行测试：
测试输入：王海 刘美含 李丽滢 王海 韩强 刘美含 康洋 王海； 预期输出： ['王海', '刘美含', '李丽滢', '王海', '韩强', '刘美含', '康洋', '王海'] 王海:3 刘美含:2 李丽滢:1 韩强:1 康洋:1
提示： 统计结果用字典表示：姓名：票数 统计过程中，将列表中的每个姓名添加到字典中。
开始你的任务吧，祝你成功！
###### 统计投票结果，请在下面标注序号的位置添加程序 #####
#输入一行姓名，用空格分隔
nameStr = input()
 
#(1)将字符串转换为列表nameList，每个姓名为一个元素
n=nameStr.split()
print(n)
#(2)创建一个空字典 count
count={}
for i in n:
    count[i]=count.get(i,0)+1
 
#(3)统计列表中每个姓名出现的次数，用字典表示（name:num）
ppp={}
word=count.keys()
for w in word:
    ppp[w]=ppp.get(w,0)+1
 
#输出统计结果，每行输出一个： 姓名：票数
for item in count:
    print('%s:%d'%(item,count[item]))
    
###### 程序结束#####
 十一、Python 计算思维训练——文件操作与异常处理
第1关：从文件中读取数据：信息时代已经到来
任务描述
我们现在生活在信息爆炸的时代，计算机中文本文件可存储的数据量多得难以置信，我们可以把各种信息都存储在文本文件中。每当我们需要利用程序去修改或分析存储在文本文件中的信息时，就必须先正确地读取文件。
要用 Python 程序去修改或分析文本文件中的信息，首先需要将文本文件中的信息读取到内存中。我们既可以将文本文件中的内容一次性读取，也可以按每次一行的方法逐行读取。
本关的目标就是让学习者了解并掌握利用 Python 工具从文件中读取数据的相关知识。
相关知识
读取整个文件
一般我们读取的文件和编写的 Python 文件位于同一目录下，例如在当前目录下我们已经创建了要处理的文件 test.txt ，里面包含的内容为：
  1. Hello,world!
  2. Hello,Python!
  3. Hello,my brothers.
我们运行在同一目录下的 Python 文件 test.py ，代码如下：
  1. with open('test.txt') as file_object:
  2. contents = file_object.read()
  3. print(contents)
程序运行结果：
  1. Hello,world!
  2. Hello,Python!
  3. Hello,my brothers.
test.py 文件中的第一行代码中有函数open()，用于打开文件，这是我们处理文件的第一步。函数open()中的参数'test.txt'就是要打开的文件。函数open()返回的是打开文件的对象，第一行代码就是把文本文件 test.txt 打开，并将其对象保存在file_object变量中。
关键字with的功能是在不再需要访问文件后自动将文件关闭。所以我们在这里只是open()打开了文件，但是没有加入close()代码关闭文件，因为 Python 会在处理文件之后自动将文件关闭。
test.py 文件中的第二行代码是使用read()方法读取文本文件 test.txt 的全部内容，并将内容保存在字符串变量contents中，然后通过print()将结果都输出。
如果我们要处理的文本文件和 Python 程序文件不在同一目录下，那么我们就要在open()函数中传入文本文件的绝对路径。
逐行读取
我们也可以将文本文件中的数据进行逐行读取，我们要处理的文本文件还是上面的 test.txt ，这时我们可以逐行将 test.txt 的内容输出，代码如下：
  1. with open('test.txt') as file_object:
  2. for line in file_object:
  3. print(line)
输出结果：
  1. Hello,world!
  3. Hello,Python!
  5. Hello,my brothers.
我们会发现输出结果中每一行内容后面都多了一个空行，这时因为在文件中每一行的末尾都会有一个换行符，而每条print()语句也会加上一个换行符，所以每行末尾都有两个换行符，所以输出之后就会多一个空行。
我们可以采取rstrip()方法消除空行，代码如下：
  1. with open('test.txt') as file_object:
  2. for line in file_object:
  3. print(line.rstrip())
这时输出的结果中就没有多余的空行了：
  1. Hello,world!
  2. Hello,Python!
  3. Hello,my brothers.
创建一个包含文件各行内容的列表
在上文中，函数open()返回的对象只在with代码块内可用，但是我们想在with代码块之外的位置使用，这就需要在with代码块内创建一个包含文本文件 test.txt 各行内容的列表。例如：
  1. with open('test.txt') as file_object:
  2. lines = file_object.readlines()
上述代码中readlines()方法就是从文本文件 test.txt 中依次读取每一行，并保存在lines列表中。
如果您想了解更多有关读取文本文件信息的相关知识，请参考: 【美】Eric Matthes 著《 Python 编程——从入门到实践》第十章 。
编程要求
本关的编程任务是补全 src/Step1/test1.py 文件的代码，实现相应的功能。具体要求如下：
  •  
    补充代码，功能是输出文本文件 test.txt 的前n行信息，文本文件 test.txt 和测试代码在同一目录下,n由输入指定；
     
  •  
    要求：输出的前n行信息中间不能有空行。
     
本关涉及的代码文件 src/Step1/test1.py 的代码框架如下：
  1. #coding=utf-8
  3. #输入n
  4. n = int(input())
  6. with open('src/Step1/test.txt') as file_object:
  7. lines = file_object.readlines()
  8. # 请在此添加代码，实现编程要求
  9. #********** Begin *********#
  14. #********** End **********#
测试说明
本关的测试文件是 src/Step1/test1.py ，测试过程如下：
  1.  
    平台自动编译生成 test1.exe ；
     
  2.  
    平台运行 test1.exe ，并以标准输入方式提供测试输入；
     
  3.  
    平台获取 test1.exe 输出，并将其输出与预期输出对比。如果一致则测试通过，否则测试失败。
     
以下是平台对 src/Step1/test1.py 的样例测试集：
测试输入： 1 预期输出： Hello,world!
测试输入： 2 预期输出： Hello,world! Hello,Python!
测试输入： 3 预期输出： Hello,world! Hello,Python! Hello,my brothers.
开始你的任务吧，祝你成功！
#coding=utf-8

#输入n
n = int(input())



# 请在此添加代码，实现编程要求
#********** Begin *********#
with open('src/Step1/test.txt') as file_object:
    lines=file_object.readlines()
    i=0
    for line in lines:
        print(line.rstrip())
        i+=1
        if i == n:
            break



#********** End **********#





 第2关：将信息写入文件：会读会写方为正道
任务描述
在上一关中，我们学习了 Python 中读取文本文件中的数据信息等相关知识，与之对应的就是将信息写入文本文件中。我们既可以利用 Python 工具将信息写入空的文本文件，也可以将信息添加到已经存在的文本文件中去。
本关目标是让学习者了解并掌握在 Python 中将信息写入到文本文件中的相关知识。
相关知识
写入空文件
要将信息写入文本文件中，我们依然用open()方法，只不过除了将文本文件名当作参数传入函数open()中去之外，还需要再传入写参数w，例如下面这个 Python 的程序 test2.py ：
  1. with open('test2.txt','w') as example:
  2. example.write('Hello world!')
程序运行结果就是在 test2.py 文件所在目录生成了一个名为 test2.txt 的文本文件，文本文件中的内容为：
Hello world!
在这个例子中，调用函数open()，传入两个参数，一个是我们要创建的文件名test2.txt，还有一个就是参数w，代表的是写入命令。
我们也可以往 test2.txt 中传入多行信息，例如：
  1. with open('test2.txt','w') as example:
  2. example.write('Hello world!\n')
  3. example.write('Hello python!\n')
该段程序中第二行write()函数中还加入了换行符\n，这样就可以将加入的消息分行了。
程序运行之后生成的 test2.txt 的内容为：
  1. Hello world!
  2. Hello python!
附加到文件尾
我们要注意的是，使用w命令打开一个待写入的文本文件时，如果该文本文件原来已经存在了，Python 将会在写入内容前将文本文件中原来的内容全部清空。所以我们如果要在已经存在的文本文件中添加信息内容，而不是将原来的信息内容都清除，就要采取附加模式打开文件。
我们用附加模式打开文件时，Python 会将我们写入的数据直接加入到文本文件原有信息的末尾，如果指定的文本文件不存在，才会新建一个文本文件。
例如现在已经存在了文本文件 test2.txt ，里面的内容为：
  1. Hello world!
  2. Hello python!
我们现在想在文本文件 test2.txt 中再加入两句话：
Hello my brothers! Hello my sisters!
实现代码如下：
  1. with open('test2.txt','a') as example:
  2. example.write('Hello my brothers!\n')
  3. example.write('Hello my sisters!\n')
我们在函数open()中传入了参数a,告诉 Python 程序我们是将信息加入到文本文件的末尾，而不是覆盖文件。
程序运行之后，文本文件 test2.txt 中的内容变为：
  1. Hello world!
  2. Hello python!
  3. Hello my brothers!
  4. Hello my sisters!
如果您想了解更多有关文本文件信息写入的相关知识，请参考: 【美】Eric Matthes 著《 Python 编程——从入门到实践》第十章 。
编程要求
本关的编程任务是补全 src/Step2/test2.py 文件的代码，实现相应的功能。具体要求如下：
  •  
    补充代码，功能是将通过input()输入的信息传入文本文件 test2.txt 中，文本文件 test2.txt 和测试代码在同一目录下；
     
  •  
    要求：将输入信息覆盖原文本文件 test2.txt 中的内容。
     
本关涉及的代码文件 src/Step2/test2.py 的代码框架如下：
  1. #coding=utf-8
  3. #输入字符串
  4. s = input()
  6. # 请在此添加代码，将字符串 s 输入到 test2.txt 中
  7. #********** Begin *********#
  12. #********** End **********#
  14. #输出test2.txt中的内容
  15. with open('src/Step2/test2.txt') as file_object:
  16. lines = file_object.readlines()
  17. for line in lines:
  18. print(line.rstrip())
测试说明
本关的测试文件是 src/Step2/test2.py ，测试过程如下：
  1.  
    平台自动编译生成 test2.exe ；
     
  2.  
    平台运行 test2.exe ，并以标准输入方式提供测试输入；
     
  3.  
    平台获取 test2.exe 输出，并将其输出与预期输出对比。如果一致则测试通过，否则测试失败。
     
以下是平台对 src/Step2/test2.py 的样例测试集：
测试输入： Hello,world! 测试输出： Hello,world!
测试输入： Hello,,Python! 测试输出： Hello,,Python!
测试输入： Hello,my brothers. 测试输出： Hello,my brothers.
开始你的任务吧，祝你成功！
#coding=utf-8

#输入字符串
s = input()

# 请在此添加代码，将字符串s输入到test2.txt中
#********** Begin *********#
with open('test2.txt','w') as example:
    example.write(s)




#********** End **********#

#输出test2.txt中的内容
with open('test2.txt') as file_object:
    lines = file_object.readlines()
for line in lines:
    print(line.rstrip())



    
        
            
            
        
        
    
    

                    

            
文章出处登录后可见！

            
            
已经登录？立即刷新

            


      
            
      
                      
  •                       
    •                   
  •                       
    •                   
  •                       
    •                   
  •                       
    •                   
  •                       
    •               
    
    
        
      共计人评分，平均分    
    
      到目前为止还没有投票！成为第一位评论此文章。    
    
  
          
                                                                                


                        

                        

                            
 赞 (0)


                                                    


                        

                            

                                                                    

                                                                                
                                            青葱年少的头像青葱年少普通用户                                        
                                    

                                                                

                                    

                                                                                     0                                                                                                                    

                                    
                                    

                                        
                                    

                                

                            

                        

                    

                                            

                    

                
                

                     上一篇
                    2023年3月4日 下午9:36
                

            

                            

                
                

                    下一篇 
                    2023年3月4日 下午9:38
                

            

            

                    



                                            

                            
相关推荐