Python头歌合集（题集附解）_头歌python程序设计答案

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6

在这里插入图片描述

目录

一、Python初识-基本语法 

第1关Hello Python!

 第2关我想看世界

 第3关学好Python

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

 第5关货币转换

 二、turtle简单绘图

第1关英寸与厘米转换

 第2关绘制等边三角形

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

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

 第5关绘制圆圈

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

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

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

 第3关将整数换算为天、时、分、秒

 第4关回文数判断

 第5关字符串的拼接名字的组成

第6关字符替换 

第7关字符串查找与替换 

四、Python 入门之函数结构 

第1关函数的参数 - 求输入的整数之和

第2关函数的返回值 - 求两个正整数的最大公约数 

第3关函数的使用范围与Python 作用域-求两个正整数的最小公倍数 

五、函数和代码复用1 

第1关圆面积计算函数

第2关素数判断

 第3关求和函数

 第4关最大公约数

 第5关最小公倍数

 六、Python 入门之经典函数实例

第1关lambda 函数 - 匿名函数的使用-比较两数大小

 第2关递归函数 - 汉诺塔的魅力

 七、分支和循环结构

第1关英寸与厘米互换

 第2关百分制转换为等级制成绩

 第3关三角形图案打印

 第4关输出九九乘法表

 第5关水仙花数判断

 八、函数和代码复用2

第1关温度转化函数

 第2关在函数中修改全局变量

 第3关一元二次方程求解函数v1

 第4关一元二次方程求解函数v2

 第5关使用递归

 九、列表

第1关列表元素的增删改客人名单的变化

 第2关列表元素的排序给客人排序

 第3关数值列表用数字说话

 第4关列表切片你的菜单和我的菜单

 第5关列表与循环 - 验证是否为三位数

 十、元组与字典

第1关元组的使用这份菜单能修改吗

 第2关字典的使用这份菜单可以修改

 第3关字典的遍历菜名和价格的展示

 第4关嵌套 - 菜单的信息量好大

 第5关统计投票结果

 十一、Python 计算思维训练——文件操作与异常处理

第1关从文件中读取数据信息时代已经到来

 第2关将信息写入文件会读会写方为正道

一、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("") 。

输入输出

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

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

开始你的任务吧祝你成功

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

#********请输入您的代码********#
#************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("") 。

输入输出

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

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

测试输入3C76                   预期输出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三边颜色为红色。

相关知识

模块导入

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

  1. import turtle

创建turtle对象

  1. Bob = turtle.Turtle()

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

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

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

函数别名缩写功能
forwarddfd(d)向前移动距离d代表距离
backward(d)bk(d)或back(d)向后移动距离d代表距离
right(degree)rt(degree)向右转动多少度
left(degree)It(degree)向左转动多少度
goto(x,y)将画笔移动到坐标为xy的位置
stamp()绘制当前图形
speed(speed)画笔绘制的速度范围[010]整数
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三边颜色为蓝色填充颜色为黄色。

相关知识

模块导入

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

  1. import turtle
  2. from turtle import *

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

创建turtle对象

  1. Bob = turtle.Turtle()

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

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

  • 下表给出了turtle的部分运动函数
函数别名缩写功能
forwarddfd(d)向前移动距离d代表距离
backward(d)bk(d)或back(d)向后移动距离d代表距离
right(degree)rt(degree)向右转动多少度
left(degree)It(degree)向左转动多少度
goto(x,y)将画笔移动到坐标为xy的位置
stamp()绘制当前图形
speed(speed)画笔绘制的速度范围[010]整数
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颜色为红色填充颜色为白色。

相关知识

- 模块导入

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

  1. import turtle
  2. from turtle import *

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

- 创建turtle对象

  1. Bob = turtle.Turtle()

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

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

  • 下表给出了turtle的部分运动函数
函数别名缩写功能
forwarddfd(d)向前移动距离d代表距离
backward(d)bk(d)或back(d)向后移动距离d代表距离
right(degree)rt(degree)向右转动多少度
left(degree)It(degree)向左转动多少度
goto(x,y)将画笔移动到坐标为xy的位置
stamp()绘制当前图形
speed(speed)画笔绘制的速度范围[010]整数
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=intinput()
    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=intinput()
    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所示请问应该如何操作
 
 

 图 1
 
 
本关目标就是通过对汉诺塔问题的探讨让学习者了解并掌握递归函数的相关知识。
 
 
相关知识
 
 
在编程语言中如果一种计算过程的其中每一步都会用到前一步或前几步的结果这个计算过程就可以称为递归的。而用递归计算过程定义的函数则被称为递归函数。递归函数的应用很广泛例如连加、连乘及阶乘等问题都可以利用递归思想来解决。而汉诺塔问题也是递归函数的经典应用。
 
 
汉诺塔问题的解决思路是如果我们要思考每一步怎么移可能会非常复杂但是可以将问题简化。我们可以先假设除a柱最下面的盘子之外已经成功地将a柱上面的63个盘子移到了b柱这时我们只要再将最下面的盘子由a柱移动到c柱即可。如下图2所示
 
 

 图 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柱上的圆盘个数abc三个柱子的顺序代表要将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则输出‘请输入有效的单位’。结果保留两位小数。本函数不需返回值
 
 
测试说明
 
 
平台会对你编写的代码进行测试
 
 
测试输入3cm 预期输出1.18英寸
 
 
测试输入3厘米 预期输出1.18英寸
 
 
测试输入5in 预期输出12.70厘米
 
 
测试输入5英寸 预期输出12.70厘米
 
 
测试输入5tt 预期输出请输入有效的单位
 
 

 
开始你的任务吧祝你成功
 

 

"""
英制单位英寸和公制单位厘米互换
"""
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: 等级ABCDE
'''
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 开始。例如range5等价于range0 5
  • stop: 计数到 stop 结束但不包括 stop。例如range0 5 是[0, 1, 2, 3, 4]没有5
  • step步长默认为1。例如range0 5 等价于 range(0, 5, 1)

 
编程要求
 
 
要求利用for循环输出九九乘法表通过双层for循环进行控制然后按照相应的格式输出九九乘法表。
 
 
  • 注意换行的处理。

 
测试说明
 
 
我会对你编写的代码进行测试
 
 
样例输出
 
 
 开始你的任务吧祝你成功
 
 
 

 

# -*- 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列表排序函数的语法关键词
     
  •  
    reversesort函数的可选参数如果设置其值为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列表中添加另外一个菜单字典menu2menu2菜单中的菜名和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())


 


                

        
阿里云国内75折 回扣 微信号：monov8   


阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8  飞机：@monov6 



                                                

                    标签:                    python                

                            

        

        

            返回列表
            
上一篇：10 个杀手级的 Python 自动化脚本

            
下一篇：【超硬核】- python 3分钟实现暴力破解wifi密码EXE应用

        

    



	
“Python头歌合集（题集附解）_头歌python程序设计答案” 的相关文章

	


Python中sorted（）用法_python中sorted1年前 (2023-02-02)
1.Python简介&&开发环境配置&&工具准备_python开发环境与工具1年前 (2023-02-02)
Python基础(四)：函数部分小结1年前 (2023-02-02)
TicTacToe: 基于时序差分TD(0)算法的agent实现以及完整python实现框架1年前 (2023-02-02)
Python数学建模问题总结(3)数据可视化Cookbook指南·下1年前 (2023-02-02)
Python学习笔记-PyQt6消息窗1年前 (2023-02-02)
爆款专栏《Python 黑科技》目录导航丨进度：12/501年前 (2023-02-02)
Python matplotlib库绘制3D图1年前 (2023-02-02)
python pdf install1年前 (2023-02-02)
实战四十八：基于python设置的分词系统（完整代码+数据、毕业设计）1年前 (2023-02-02)
	




                            

        

    



	

    

        

        
阿里云国际版