1 基础语法

1-1 基础语法

第1关：Hello Python!

代码

#coding=utf-8

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

第2关：我想看世界

代码

#coding=utf-8

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

第3关：学好Python

任务描述

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

输入输出

测试输入：风清扬 预期输出：

风清扬同学，学好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

代码

import math
pi = math.pi   #pi = 3.14159

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

第5关：货币转换

任务描述

本关任务：编写一个人民币和美元两种货币间币值转换程序。其中，人民币和美元间汇率固定为：1美元 = 6.4人民币。 程序可以接受人民币或美元输入，转换为美元或人民币输出。人民币采用RMB表示，美元采用USD表示，符号和数值之间没有空格。 注意： (1)结果小数点后保留两位。 (2) 获得输入请使用input("") 。

输入输出

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

代码

#********请输入您的代码********#
#************begin************#
money = input("")
if ("USD" in money) :
    print("RMB{:.2f}".format(eval(money[3:]) * 6.4))
else :
    print("USD{:.2f}".format(eval(money[3:]) / 6.4))
#************end************#

1-2 基础语法

第1关：行与缩进

编程要求

根据提示，改正右侧编辑器中代码的缩进错误，使其能够正确运行，并输出结果。

测试说明

改正后可得到以下输出：

wrong1
这里有一个错误缩进
wrong2
wrong3
hello world

代码

#有错误的函数1
def wrong1():
    print("wrong1")
    print("这里有一个错误缩进")

#有错误的函数2
def wrong2():
    print("wrong2")
    if False:
        print("这个不应该输出")
        print("这个也不应该输出")

#有错误的函数3
def wrong3():
    print("wrong3")
    print("hello world")


#这里是调用三个函数的代码
#不要修改
if __name__ == '__main__':
    wrong1()
    wrong2()
    wrong3()

第2关：标识符与保留字

编程要求

根据提示，改正右侧编辑器的代码，并输出 Python3 的所有保留字。

测试说明

改正程序后会得到以下输出：

string
1024
1.024
False
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']`
end

代码

import keyword

if __name__ == '__main__':
    #错误1
    str1 = "string"
    print(str1)

    #错误2
    _1024 = 1024
    print(_1024)

    #错误3
    float_1024 = 1.024
    print(float_1024)

    #错误3
    _False = False
    print(_False)


    #在此处输出保留关键字
    print(keyword.kwlist)
    print("end")

第3关：注释

编程要求

根据提示，对右侧编辑器中，部分代码添加注释或者取消注释，使其输出结果与测试说明中的结果一致。

测试说明

处理后的代码应该输出：

1
3
5
hello world
3
4

代码

if __name__ == '__main__':
    #以下是要修改的代码
    print(1)
    #print(2)
    print(3)
    #print(4)
    print(5)
    #print(6)

    print("hello world")
    """
    print("这个不应该输出")
    """
    """
    print(1)
    print(2)
    """
    print(3)
    print(4)

第4关：输入输出

编程要求

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

测试说明

平台会对你编写的代码进行测试：

测试输入：

100
200

预期输出：

100 + 200 = 300
100 - 200 = -100
100 * 200 = 20000
100 / 200 = 0.500000

测试输入：

5
2

预期输出：

5 + 2 = 7
5 - 2 = 3
5 * 2 = 10
5 / 2 = 2.500000

代码

if __name__ == "__main__":
    a = int(input())
    b = int(input())
# ********** Begin ********** #
    print("{} + {} = {}".format(a, b, a + b))
    print("{} - {} = {}".format(a, b, a - b))
    print("{} * {} = {}".format(a, b, a * b))
    print("{} / {} = {:f}".format(a, b, a / b))
# ********** End ********** #

2 基本运算

2-1 基本运算

第1关：变量和常量

编程要求 根据提示，在右侧编辑器补充代码，按要求输出打印以下内容：

2018年10月1日，国庆节当天全国共接待旅客1.13亿人次。

其中format()函数是用来处理一个字符串的特定位置上的值，例如：

a = 100
b = "人民币"
print("我捡到了{}块{}".format(a，b))

上面的代码输出为：

我捡到了100块人民币

改变a和b的值：

a = 200
b = "假币"
print("我捡到了{}块{}".format(a,b))

则输出为：

我捡到了200块假币

可以看出{}起到占用位置的作用，有几个{}对应几个变量，字符串后面加一个点“.”再加format()表明这个字符串要使用format()函数进行操作，format()函数括号里则是对应要填充的变量，要注意的是这里面的个数要与前面要处理的字符串中的{}个数对应，且按照顺序来填充。

测试说明 本关的测试文件是src/step2/variableConstant.py，测试过程如下：

平台自动编译并运行variableConstant.py，并获取相应的输出。

平台将程序输出与预期输出对比。如果一致则测试通过，否则测试失败。

代码

#coding=utf-8
# 请在此处添加代码完成输出打印
#********* Begin *********#
year = 2018
month = 10
day = 1
holiday = "国庆"
peoples = 1.13
print("{}年{}月{}日，{}节当天全国共接待游客{}亿人次。".format(year,month,day,holiday,peoples))
#********* End *********#

第2关：基本数据类型

编程要求 根据提示，在右侧编辑器补充代码，给变量a,b,c,d按要求赋值，然后使用print()函数和format()函数进行输出。

测试说明 本关的测试文件是src/step1/dataType.py，测试过程如下： 平台自动编译并运行dataType.py，并获取相应的输出。 平台将程序输出与预期输出对比。如果一致则测试通过，否则测试失败。 测试按以下形式输出：

1 1.2 True 这里是字符串

代码

#coding = utf-8
# 请在此处添加代码按要求输出打印
#********* Begin *********#
a = 1
b = 1.2
c = True
d = "这里是字符串"
print(a)
print(b)
print(c)
print(d)
#********* End *********#

第3关：注释

编程要求 根据提示，在右侧编辑器补充代码，将数学公式转换为代码。

测试说明 本关的测试文件是src/step2/operator.py，测试过程如下： 平台自动编译并运行operator.py，并获取相应的输出。 平台将程序输出与预期输出对比。如果一致则测试通过，否则测试失败。 第一题 求 a 和 b 的平均值 第二题 求 a 除以 b 的余数 第三题 求 a 和 b 的平方和 第四题 求 a 和 b 的立方差 第五题 求 1.8b+32 的值 第六题 求的1 + 1 / (1 + 1 / (1 + 1 / a))值

代码

#coding=utf-8
a = int(input()) # 输入 a
b = int(input()) # 输入 b
# 请在此处添加代码，根据要求在"c ="后填写相应代码
#********* Begin *********#
#第一题
c = (a + b) / 2
print(c)
#第二题
c = a % b
print(c)
#第三题
c = a ** 2 + b ** 2
print(c)
#第四题
c = a ** 3 - b ** 3
print(c)
#第五题
c = 1.8 * b + 32
print(c)
#第六题
c = 1 + 1 / (1 + 1 / (1 + 1 / a))
print(c)
#********* End *********#

2-2 基本运算

第1关：Python算术运算符及表达式基本运算

任务描述 本关任务：编写程序计算以下运算结果。 1、输入出生日期，求从你出生日开始到今天已经过去多少天了（出生日算第一天，不包括今天） 2、输入一个算术表达式，判断其运算结果是否是整数 3、输入一个字符，判断该字符是否是英文字母

代码

import datetime
import re
#输入部分
#第一题生日变量,输入格式为yyyymmdd，测试：19991010
birthday=input()
#第二题表达式，输入测试例子：10*25/(3**4)
exp=input()
#第三题输入的字符串，输入测试例子 "asdf"
c_in=input()

#计算部分
#第一题计算部分
#以下可以自行添加代码段，如不需要可忽略，最终计算d并输出
#获取当前日期类型值（由于答案的时间为20191017，故不使用today）
d_now = datetime.date(2019,10,17)
#求生日的日期类型值
d_bir= datetime.date(int(birthday[0:4]),int(birthday[4:6]),int(birthday[6:]))
#求天数差
d= d_now - d_bir
print("从出生到现在一共{}天".format(d.days))

#第二题计算部分
#求输入表达式的值
exp = eval(exp)
#以下可以自行添加代码段，如不需要可忽略
#求取整后是否与原数相同，相同为True，不同为False
result= int(exp) == exp
print(result)

#第三题计算部分
#根据c_in字符串取首字符
c_in = c_in[0]
#以下可以添加代码段，如不需要可忽略
#判断是否是数字，是为True，否为False
result = (ord("a") <= ord(c_in) <= ord("z")) or (ord("A") <= ord(c_in) <= ord("Z"))
print(result)

第2关：Python算术运算符及表达式基本运算2

任务描述 1、输入一个华氏温度，输出对应的摄氏温度 2、进制转换，输入8位二进制数，分别将其转换为八进制、十进制、十六进制输出

代码

#第一题测试用例输入华氏度
f=input()
#第二题测试用例输入二进制数
bin_value=input()

#第一题计算部分
#以下可以自行添加代码段，如不需要可忽略
#转换测试用例值的类型
f=float(f)
#计算摄氏度
c=(f - 32) * (5 / 9)
#第一题输出，注意题目要求格式
print("华氏度:{:.2f},摄氏度:{:.2f}".format(f, c))

#第二题计算部分
#以下可以自行添加代码段，如不需要可忽略
#已从测试用例读入bin_value值,分别计算十进制：int_value，八进制：oct_value和十六进制:hex_value
int_value=int(bin_value,2)
oct_value=oct(int_value)
hex_value=hex(int_value)
#按题目要求输出
print("八进制:" + oct_value)
#按题目要求输出
print("十六进制:" + hex_value)
#按题目要求输出
print("十进制:" + str(int_value))

3 基础结构

3-1 基础结构

第1关：列表及操作

任务描述 本关任务：学习列表的定义和表示，了解列表的相关操作。

代码

#coding = utf-8
#********* Begin *********#
#第一步 请在列表fruits中找出不属于水果一类元素，赋值给变量 a
fruit = ["苹果","梨子","菠萝","黄瓜","香蕉"]
a = fruit[3]
#第二步 将变量 a 的值添加到列表vegetable 的末尾
vegetable = ["土豆","萝卜","茄子","白菜"]
vegetable.append(a)
#第三步 删去列表fruit中不属于水果的元素
fruit.pop(3)
#第四步 将列表fruit和列表vegetable作为元素按顺序加入到列表food中
food = []
food.append(fruit)
food.append(vegetable)
#补充print语句，先打印输出列表food，再打印输出列表food中第1个列表的第3个元素
print(food)
print(food[0][2])
#********* End *********#

第2关：元组及操作

任务描述 本关任务：熟悉元组的相关知识，了解元组的使用。

代码

#coding = utf-8
#********* Begin *********#
#第一题  列表和元组相互转换，修改元组中的数据
#第一步  将元组 fruit 转换为一个名为 fruit 的列表并打印输出
fruit = ("苹果","梨子","菠萝","黄瓜","香蕉")
fruit = list(fruit)
print(fruit)
#第二步  在上一步得到的列表 fruit 通过索引位置将"黄瓜"去掉并打印输出
fruit.pop(3)
print(fruit)
#第三步  将上一步的到的列表 fruit 转换为元组并打印输出
fruit = tuple(fruit)
print(fruit)


#第二题  通过元组的嵌套修改元组中的数据
#第一步  创建元组 food 将列表 fruit 和 vegetable 放入其中并打印输出元组food
fruit = ["苹果","梨子","菠萝","黄瓜","香蕉"]
vegetable = ["土豆","萝卜","茄子","白菜"]
food = (fruit, vegetable)
print(food)
#第二步  打印输出上一步得到的元组 food 的第一个元素（列表fruit）
print(food[0])
#第三步  通过索引位置去掉元组 food 的第一个元素（列表fruit）的"黄瓜"
food[0].pop(3)
print(food[0])          #打印输出元组 food 的第一个元素
#第四步  打印输出元组 food
print(food)
#********* End *********#

第3关：集合及操作

任务描述 本关任务：熟悉集合的相关知识，了解集合的使用。

代码

# -*- coding: utf-8 -*-
#********* Begin *********#
#第一步 请将列表fruit转换为一个集合
fruit = ["苹果","梨子","菠萝","黄瓜","香蕉"]
fruit = set(fruit)
#第二步 将集合fruit中的“黄瓜”去掉
fruit.remove("黄瓜")
#第三步 使用"in"判断"黄瓜"是否在fruit中，将判断结果打印输出
print("黄瓜"in fruit)
#第四步 创建空集合food，输出集合food的长度
food = set()
print(len(food))
#第五步 将fruit和vegetable通过集合运算“并集”合并到food并输出此时food的长度
vegetable = {"土豆","萝卜","茄子","白菜"}
food = fruit | vegetable
print(len(food))
#********* End *********#

第4关：字典及操作

任务描述 本关任务：熟悉字典的相关知识，了解字典的使用。

代码

# -*- coding: utf-8 -*-
#********* Begin *********#
#第一步 创建一个空字典 menu
menu = { }
#第二步 将列表fruit中水果与prices中的价格对应给menu赋值并输出
fruit = ["苹果","梨子","菠萝","黄瓜","香蕉"]
prices = [2,3,10,2,1]
menu = dict(zip(fruit, prices))
print(menu)
#第三步 将20块钱的"哈密瓜"添加到字典menu中并输出
menu['哈密瓜'] = 20
print(menu)
#第四步 将"黄瓜"从menu中去掉并输出
del menu['黄瓜']
print(menu)
#第五步 将菠萝的价格修改为9.9，打印输出menu
menu['菠萝'] = 9.9
print(menu)
#********* End *********#

3-2 基础结构

第1关：列表实训说明

任务描述 此实训用于说明实训过程，只需要大家阅读程序，理解后点击评测即可通过.

代码

#要求一、创建列表
#(1)
ls1=[]                #创建空列表ls1
for i in range(4):    #循环4次
    item=input( )    #读入一个测试数据并保存在item中
    ls1.append(item)    #将读入的数据加入到ls1中
#(2)
n=int(input())        #读入下一个测试数据并转成整型n
ls2=list(range(n))    #使用range(n)生成整数序列并转换成列表ls2

#(3)
str1=input()        #读入下一个测试数据
ls3=list(str1)        #将读入的str1转换为字符列表ls3

#要求二、打印列表

#（1）直接打印列表1
print(ls1)

#(2)使用循环程序将列表2中所有元素打印出来
for item in ls2:        #使用in循环遍历ls2
    print(item,end=' ')    #将所有元素打印在一行并用空格隔开
print()                    #打印换行

#(3)逆序打印列表3
print(ls3[ :  : -1])    #切片选择，start为空，end为空，step=-1，表示逆序打印所有元素

#(4)循环逆序打印所有列表1中元素
i=len(ls1)-1        #获取ls1的最大下标
while i>=0:            #终止下标为0
    print(ls1[i])    #逆序打印一个元素
    i=i-1            #下标减1
#********* End *********#

第2关：调位置

任务描述 本关任务：程序将测试数据已经读入列表中(end为结束标志,不是列表元素） 请编写程序将列表中第一个元素与最后一个元素（end之前）互换，并逆序打印所有列表元素。

测试说明 例如： 测试数据为：

abc def 123 456 789 end

输出应为：

abc 456 123 def 789

代码

#此段程序为循环读入测试数据到列表ls中，阅读但不要修改
#创建列表ls
ls=[ ]
#读入第一个测试数据
item=input()
#判断是否结尾
while item!="end":
    #加入到ls中
    ls.append(item)
    #再读一个数据
    item=input()

####begin，请在此编程实现功能##
temp = ls[0]
ls [0] = ls[len(ls) - 1]
ls[len(ls) - 1] = temp
ls.reverse()
for x in ls: print(x)
####end#########

第3关：追加列表元素

任务描述 本关任务：编写一段程序可以向列表追加指定元素。 程序开头代码已经将测试数据读入到列表ls中，请编写程序将以下元素追加入ls中 （1）追加['tom','jack','山东','北京']到列表结尾 （2）追加50到100之间的所有7的倍数到列表结尾 （3）直接打印列表ls作为输出。

测试说明 例如： 测试数据为：['a','b','c'] 测试结果为：['a','b','c','tom','jack','山东','北京', 56, 63, 70, 77, 84, 91, 98]

代码

#此段程序为循环读入测试数据到列表ls中，阅读但不要修改
#创建列表ls
ls=[ ]
#读入第一个测试数据
item=input()
#判断是否结尾
while item!="end":
    #加入到ls中
    ls.append(item)
    #再读一个数据
    item=input()

####   begin，请在此编程实现功能   ##
ls.extend(['tom','jack','山东','北京'])
for num in range(50, 100):
    if num % 7 == 0:
        ls.append(num)

print (ls,end=' ')
####  end    #########

第4关：去除重复数字

任务描述 本关任务：编写一个小程序，读取测试数据到列表ls[ ]。 测试数据中会有重复数字，请将重复的数据去除，去除掉重复数据的数字应保留原有顺序。

测试说明 例如： 测试数据：[12, 33, 12, 44, 76, 54, 33, 55, 76, 88, 90, 76] 输出数据：[12, 33, 44, 76, 54, 55, 88, 90]

代码

#此段程序为循环读入测试数据到列表ls中，阅读但不要修改
#创建列表ls
ls=[ ]
#读入第一个测试数据
item=input()
#判断是否结尾
while item!="end":
    #加入到ls中
    ls.append(item)
    #再读一个数据
    item=input()

####   begin，请在此编程实现功能   ##
ls_new = [ ]
for x in ls:
    if x not in ls_new:
        ls_new.append(x)

print (ls_new,end=' ')
####  end    #########

3-3 基础结构

第1关：列表转元组

编程要求 在右侧编辑器中Begin-End之间补充代码，将读入的测试数据列表List转换为元组并输出。

测试说明 测试输入：

1
3
5
12
5
8

预期输出：

('1', '3', '5', '12', '5', '8')

代码

#此部分为读入测试数据到list1中
list1 = []
while True:
    try:
        item= input()
        list1.append(item)
    except:
        break

######### Begin ##########
#将读入的list1转换为tup并整体打印
tup = tuple(list1)
print(tup)
##########  End  #########

第2关：字符串按单词转元组

测试说明 测试输入：

i am a student

预期输出：

('i', 'am', 'a', 'student')

代码

#此部分为读入测试字符串到变量s中
s = input()

##########  Begin  #########
#将读入的s按单词转换为tup并整体打印
li = [ ]
li = s.split(' ')
tup = tuple(li)
print(tup)
##########  End  #########

第3关：在元组中找最大值

测试说明 测试输入：

1
3
4
5
4
3
1

预期输出：

(1, 3, 4, 5, 4, 3, 1)
5 3    #最大值5和对应下标3

代码

#此部分为读入测试数据到list1中
list1 = []
while True:
    try:
        n= int(input())
        list1.append(n)
    except:
        break

##########  Begin  #########
#（1）定义元组，将list1中元素按顺序保存在元组中，输出整个元组
tup = tuple(list1)
print(tup)
#（2）查找元组中最大值，输出最大值和对应下标
maxn = max(tup)
print("{} {}".format(maxn, tup.index(maxn)))
##########  End  #########

第4关：盘点订单

编程要求 在右侧编辑器中补充代码，具体要求如下： 测试数据内是该盘点期限内的所有订单列表数据，程序开始会将其读入列表list1中； 由于记录员的失误，有可能会在list1中存在相同的订单编号，要求程序将相同的编号删除并按原始顺序记录将所有不同订单编号列表转成元组并输出。 输出该盘点周期内完成最多的订单的是哪一天。

测试说明 平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试，程序运行过程如下： 程序开始会将其读入到list1中，list1:[1801020001,1801020002,1801030001,1801020002,1801030002,1801030003,1801040001]。 第一步：大家编写的程序需要在list1中去掉重复元素[180102002]并按顺序转换为元组输出：(1801020001,1801020002,1801030001,1801030002,1801030003,1801040001)； 第二步：大家需要按规则查找元组中每个元素，根据日期和订单数量进行比较，得出单日最大订单数量是180103，订单为3个，输出这个数字即可：180103。 测试输入：

1801020001
1801020002
1801030001
1801020002
1801030002
1801030003
1801040001

代码

#此部分为读入订单测试数据到list1中
list1 = []
while True:
    try:
        order= input()
        list1.append(order)
    except:
        break

##########  Begin  #########
#（1）定义元组，将list1中元素按顺序去掉重复值并保存在元组中，输出整个元组
list2 = [ ]
for item in list1:
    if item not in list2:
        list2.append(item)
tup = tuple(list2)
print(tup)
#（2）查找最大当日订单数，并输出年月日：格式如下：180101
max_order = int(list2[0][6:10])
max_order_date = list2[0][0:6]
for item in list2:
    temp = int(item[6:10])
    if int(item[6:10]) > max_order:
        max_order = temp
        max_order_date = item[0:6]
print(max_order_date)
##########  End  #########

4 逻辑控制

4-1 逻辑控制（if）

第1关：单按钮灯光开关控制

测试说明 平台会对你编写的代码进行测试，若是与预期输出相同，则算通关。 light=input()语句从测试集中读入light的状态，测试集为：“开"或"关” 如果读入light值为"开"，则应将light值设置为"关" 相反读入light值为"关"，则应将light值设置为"开" 测试输入：关； 预期输出： 开

测试输入：开； 预期输出： 关

代码

#从测试集读入light值，此部分代码不用修改
light=input()

######begin 从此处向下，开始你的编码，根据light的值进行输出###
if light == "开":
    print("关")
if light == "关":
    print("开")
#####end###

第2关：求解一元二次方程组

代码

import math  # 引入math模块
a = float(input())  # 读入测试变量a
b = float(input())  # 读入测试变量b
c = float(input())  # 读入测试变量c

# **********begin*******以下编写代码实现
if a == 0:
    print('x=', - (c / b))
else:
    dealt = b ** 2 - 4 * a * c
    if dealt == 0:
        print('x1=x2=', -b / 2 * a)
    elif dealt > 0:
        print('x1=', ((-b + math.sqrt(dealt)) / 2 * a), 'x2=', ((-b - math.sqrt(dealt)) / 2 * a))
    elif dealt < 0:
        print('x1=', complex(-b / 2 * a, math.sqrt(-dealt) / 2 * a), 'x2=', complex(-b / 2 * a, -(math.sqrt(-dealt) / 2 * a)))
# **********end***********

第3关：输入分数，输出等级

测试说明 测试输入：90； 预期输出： 等级A

测试输入：75； 预期输出： 等级C

代码

#读入测试变量score
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***********

测试说明 测试输入：90； 预期输出： 等级A

测试输入：75； 预期输出： 等级C

代码

#读入测试变量score
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***********

4-2 逻辑控制（for）

学习-Python循环结构之for…else…之寻找水仙花数

任务描述

本关任务：给定一个整数 n，判断 n 以内的正数是否含有水仙花数。水仙花数是指一个 3 位的整数，它的每个位上的数字的 3 次幂之和等于它本身。

代码

# 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
########## Begin ##########
# 使用for-else判断 n 以内的正数是否含有水仙花数
num = int(input())
for n in range(100, num):
    a = int(n / 100)
    b = int((n - a * 100) / 10)
    c = int((n - a * 100 - b * 10))
    if n == (a ** 3 + b ** 3 + c ** 3):
        print("有水仙花数")
        break
else:
    print("没有水仙花数")
########## End ##########

4-3 逻辑控制（while）

第1关：输入整数n，计算n!

测试说明

平台会对你编写的代码进行测试，若是与预期输出相同，则算通关。 1 测试输入：5 预期输出：120 2 测试输入：22 预期输出：1124000727777607680000

代码

n = int(input())  # 从测试集读入n的值

# ******************begin*********开始你的代码，根据n的值输出n!
sum = 1
i = 1
while i <= n:
    sum *= i
    i += 1
print(sum)
# ************end***************

第2关：循环输入，直到正确为止

任务描述 本关任务：循环输入，直到正确为止。（熟悉实训平台循环程序的编码方式）。 请阅读本任务测试说明，对照说明修改代码，理解实训平台在循环结构中的评测过程！

测试说明 平台会对你编写的代码进行测试，若是与预期输出相同，则算通关。 代码：

m=int(input())
n=int(input())
whlie n!=m:
    print(n)
    n=int(input())
print(n)

测试输入数据：

10
5
6
9
10

代码说明：

m=int(input())        #从测试集数据中读入第一个数10
n=int(input())        #从测试数据中读入第二个数5
whlie n!=10:        #判断n当前值为5!=10进入循环
    print(n)        #打印这个数5
    n=int(input())    #从测试数据中读入第三个数6，
                    #后接着返回while循环打印6，
                    #第二次循环后再次读入第四个测试数据9，
                    #进入循环打印9，再次读入第五个数据10，
                    #不满足n!=10的循环条件后退出
print(n)            #循环结束后打印最后一个n：10

根据上述代码说明，预测输出应为

5        #第一次循环打印n:5
6        #第二次循环打印n:6
9        #第三次循环打印n:9
10        #循环结束后打印n:10

其他测试集： 输入：

20
7
9
10
20

预测输出：

7
9
10
20

代码

m=int(input())        #从测试集数据读取第一个数据
n=int(input())        #从测试集数据读取第二个数据
while n!=m:
    print(n)
    n=int(input())            #每次执行时从测试集依次读取一个数据,修改方法：
                  #请将上一行中【】删除并加入代码：n=int(input())
print(n)

第3关：猜数字游戏

任务描述

本关任务：编写一个猜数字的游戏： 程序首先从测试集中读取1个数作为要猜测的数据， 接着从测试集读取下一个数据作为第一次猜测的数字，判断两个数的大小关系并给出提示， 然后循环读取测试集中下一个猜测的数据并判断，只到猜对为止。 注意：测试集数据说明及测试使用方法 本题目共有4组测试数据，第一组开放，后三组隐藏。 注意代码编写要求： 1、不要输出任何欢迎界面和结束界面！ 2、请使用以下语句从测试集中读取要猜测数字、测试猜测数值和输出猜测提示！ 例如： 使用以下语句从测试集读取要猜测的数字： num=int(input()) 使用以下语句从测试集读取用户输入的数字： guess=int(input()) 使用以下语句提示猜大了 print('猜大了') 使用以下语句提示猜小了 print('猜小了') 使用以下语句提示猜对了 print('猜对了')

相关知识

游戏的基本流程： 1、从测试集读取要猜测的数字：num=int(input()) 2、从测试集读取一个猜测数字：guess=int(input()) 4、循环判断是否猜准，如果猜不准则给出提示并再次读取测试集数字

while num!=guess
    if guess>num:
        输出:猜大了
    else:
        输出:猜小了
    guess=再获取一个数
输出：猜对了

测试说明 平台会对你编写的代码进行测试，若是与预期输出相同，则算通关。

测试输入：5，6，3，5； 5是要猜测数字，6，3，5是依次输入的猜测数字 预期输出：

猜大了
猜小了
猜对了

还有3组猜测数据被隐藏。

4-4 逻辑控制（try）

学习-Python异常处理之try…except…

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，按照提示在 Begin-End 之间编写程序代码。相关信息如下：

  • 使用 input 获取列表；
  • 列表内的元素不一定全部都是数字，也有可能是其它类型的数据，如果是其它类型的数据，则不对该元素进行求和计算或者令该元素等于 0；
  • 打印计算后的结果。

测试说明 平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。 可在右侧 “测试结果”区查看具体的测试集详情。 测试输入：

["a","b",[1,2,3],2,3,5]

预期输出：

10

代码

# 请在下面的 Begin-End 之间按照注释中给出的提示编写正确的代码
########## Begin ##########
# 计算列表内所有数字的和
inp = input()
li = eval(inp)
num = 0
for i in range(0, len(li)):
    try:
        num += li[i]
    except TypeError as f:
        continue
print(num)
########## End ##########

5 函数

5-1 函数

第1关：完成以下选择题

1、以下关于函数优点的描述中，正确的是

  • 函数可以表现程序的复杂度

  • 函数可以减少代码重复

  • 函数可以使程序更加模块化

  • 函数便于阅读

2、python中定义函数的关键字为

  • defun

  • define

  • def

  • function

3、以下关于函数的描述中，正确的是

  • 函数可以同时返回多个结果

  • 定义函数时，某些参数可以赋予默认值

  • 函数必须要有返回值

  • 可以定义函数接收可变数量的参数

4、以下代码的输出结果是（）

t=10.5
def above_zero(t):
    return t>0
above_zero(t)

  • False

  • True

  • 10.5

  • 没有输出

5、以下关于return语句描述正确的是

  • 函数中最多只有一个return语句

  • 函数中可以没有return语句

  • return只能返回一个值

  • return 0 返回一个None类型

6、以下关于全局变量和局部变量的描述中，正确的是

  • 当函数退出时，局部变量依然存在，下次调用函数可以继续使用

  • 全局变量一般指定义在函数外的变量

  • 局部变量在函数内部创建和使用，函数退出后变量被释放

  • 使用global关键字声明后，变量可以作为全局变量被函数使用

7、关于以下代码描述错误的是

def fact(n):
    s=1
    for i in range(1,n+1):
    s*=i
    return s

  • fact(n)函数功能是求n的阶乘

  • range( )函数是python的内置函数

  • 代码中的 n 是可选参数

  • s是局部变量

8、以下代码的输出结果为

def func(a,b):
    a*=b
    return a
s=func(5,2)
print(s)

  • 5

  • 10

  • 15

  • 20

9、list类型变量需要定义在函数外部，在函数内部可直接被使用。 以下代码输出结果是

ls=['car','truck']
def func(a):
    ls.append(a)
    return
func('bus')
print(ls)

  • ['car', 'truck', 'bus']

  • ['car', 'truck']

  • []

  • ['bus'] ['car', 'truck', 'bus']

10、对一个非列表、字典的变量，对与全局变量同名的局部变量进行修改，不会影响全局变量。如果使用外部全局变量则应使用global关键字 以下程序运行结果为

a=10
def func(x):
    global a
    a+=x
    return a
b=func(10)
print (a,b)

  • 20 20

  • 10 10

  • 10 20

  • 错误

第2关：两数相加

代码

def add(x,y):
    z=x+y
    return z

第3关：打印斜三角字符

测试说明

平台会对你编写的代码进行测试：

测试输入：'*',5；

预期输出：

*****
****
***
**
*

测试输入：5，4；

预期输出：

5555
555
55
5

代码

def printc(ch, n):
    for i in range(1, n + 1):
        print(ch * (1 - i + n))

第4关：求满足条件的元素和函数

测试说明

平台会对你编写的代码进行测试：

测试输入：4，91，51，2，32；

平均值为 44.0，大于平均值的元素有 91，51，求和为 142。

预期输出：142

测试输入：5，1，151，12，22，100；

平均值为 57.2，大于平均值的元素有 151 ，100，求和为251。

预期输出：251

代码

def sumover(ls):
    sumls = 0
    for i in range(0, len(ls)):
        sumls += ls[i]
    average = sumls / len(ls)
    sum_bigger_than_average = 0
    for j in range(0, len(ls)):
        if ls[j] > average:
            sum_bigger_than_average += ls[j]
    return sum_bigger_than_average

第5关：编写函数统计字符数

任务描述

本关任务：编写一个函数，函数参数接收一个字符串，返回字符串中字符及出现次数的一个字典。

函数名为word_dic(s)；

例如：

字符串：i am a student!；

返回字典结果：

{'i': 1, ' ': 4, 'a': 2, 'm': 1, 's': 1, 't': 2, 'u': 1, 'd': 1, 'e': 1, 'n': 1, '!': 1}

代码

def word_dic(s):
    di = {}
    for i in range(0, len(s)):
        ch = s[i]
        if ch not in di:
            di[ch] = 1
        else:
            di[ch] += 1
    return di

5-2 函数

第1关：函数的参数-搭建函数房子的砖

测试说明

测试输入：

1 2 3 4 5

预期输出：

15

测试输入：

1 3 5 7 9 11

预期输出：

36

测试输入：

2 4 6 8 10 12 14 16

预期输出：

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 *********#
def plus(num):
   sumnum = 0
   for i in range(len(numbers)):
      sumnum += num[i]
   return sumnum
#********** End **********#
d = plus(numbers)
print(d)

第2关：函数的返回值 - 可有可无的return

测试说明

总有人比自己更优秀、更帅、更春风得意。接受这个现实，但你还是要做自己心中的王。

代码

#coding=utf-8

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

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

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

第3关：函数的使用范围：Python作用域

测试说明

路程中会遇到很多很多麻烦困难，我们需要承受，更要去解决，俞敏洪说过一句话：坚持下去，不是我们有足够的坚强，而是我们已经无法选择。

代码

#coding=utf-8

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

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

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

6 对象

6-1 对象

第1关：TOM猫原型 类

任务描述

尝试设计编写一个TOM猫的类：cat类，并且在实例化后能够完成以下功能：

1、打球可以消耗体力5

2、干活可以获得金钱20

3、吃饭可以获得体力到100

分析

要求

（1）按类的写法完成类名及定义cat类

（2）类中包含以下类数据属性：

status    状态，字符串型,初始值为空
ph        体力，整型，初始值为100
money    金钱，整型，初始值为0

（3）包含以下方法：

play(self):    打球：消耗体力5
eat(self):    吃东西：恢复体力到100
work(self):    干活，增加金钱20
show(self):    显示当前状态，有多少钱，体力如何

根据上述描述补全右侧代码。并通过测试。

测试说明

测试数据：

work
work
work
eat
eat
eat
play
play
play
show

测试结果：

money=60,ph=85

代码

###############  begin： 完成cat类##################
class cat:
    status = ""
    money = 0
    ph = 100

    def work(self):
        self.money += 20

    def eat(self):
        self.ph = 100

    def play(self):
        self.ph -= 5

    def show(self):  # 展示方法show
        print('money=', self.money, 'ph=', self.ph)
###############  end   ##############################

7 矩阵

7-1 矩阵（numpy）

第1关：ndarray对象

编程要求

根据提示，在右侧编辑器 Begin-End 中填充代码，根据测试用例的输入，实例化出对应的 ndarray 对象并打印。具体要求如下：

  • 使用 input 获取字典，字典示例如下：
    {'shape':[1, 2], 'data':[[1, 2]]}
    表示 ndarray 对象的形状为 1 行 2 列，第 1 行第 1 列的值为 1 ，第 1 行第 2 列的值为 2 。
  • 将字典中的 data 值转换为 ndarray 对象并打印。

测试说明

测试输入：

{'shape':[1, 2], 'data':[[1, 2]]}

预期输出：

[[1 2]]

代码

# 请在下面的 Begin-End 之间按照注释中给出的提示编写正确的代码
########## Begin ##########
# 第1步：导入 numpy 模块
import numpy as np
# 第2步：使用 input 获取列表，并将列表转换为 ndarray 对象
type_in = input()
in_list = eval(type_in)
a = np.array(in_list["data"])
a.reshape(in_list["shape"])
print(a)
########## End ##########

第2关：形状操作

测试说明

测试输入：

[[1, 2, 3], [4, 5, 6]]

预期输出：

[1, 2, 3, 4, 5, 6]

代码

import numpy as np

# 请在下面的 Begin-End 之间按照注释中给出的提示编写正确的代码
########## Begin ##########
# 完成 ndarray 对象的变形
type_in = input()
in_list = eval(type_in)
a = np.array(in_list)
b = a.reshape(np.size(a))
print(b)
########## End ##########

第3关：矩阵运算

测试说明 测试输入：

[[0.2, 0.7, 0.1], [0.1, 0.3, 0.6]]
[[2, 7], [1, 3], [1, 4]]

预期输出：

4.0

代码

import numpy as np

# 请在下面的 Begin-End 之间按照注释中给出的提示编写正确的代码
########## Begin ##########
# 使用 input 获取两个列表，将列表分别转换为 ndarray 对象
li = []
for i in range(0, 2):
    type_in = input()
    in_list = eval(type_in)
    li.append(in_list)
a = np.array(li[0])
b = np.array(li[1])

# 计算两个 ndarray 的点积
c = np.dot(a, b)

# 打印计算后得到的 ndarray 中的最大值
print(c.max())

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

第4关：随机数生成

测试说明

注意：评测程序内部已经设置好了随机种子，为了顺利评测，请使用np.random.choice()函数来实现打乱顺序。

测试输入：

[1, 2, 3, 4, 5, 6]

预期输出：

[4, 3, 5, 1, 2, 6]

代码

import numpy as np

np.random.seed(233)     # 请勿修改随机种子
# 请在下面的 Begin-End 之间按照注释中给出的提示编写正确的代码
########## Begin ##########
# 使用 input 获取列表，并打乱列表的顺序
type_in = input()
in_list = eval(type_in)
print(list(np.random.choice(in_list, size = len(in_list), replace=False)))
########## End ##########

第5关：索引与切片

编程要求

在图像处理中，我们通常会将我们感兴趣的区域提取出来再进行处理，而这个感兴趣区域成为 ROI (Region Of Interest)。本关的任务是根据提示，在右侧编辑器 Begin-End 处补充代码，根据测试用例的输入将 ROI 提取并打印出来(ROI 是一个矩阵)。

测试说明

测试输入：

{'image':[[1, 2, 255, 255, 0], [255, 255, 0, 0, 3]], 'x':0, 'y':1, 'w':3, 'h':2}

预期输出：

[[  2 255 255]
 [255   0   0]]

代码

import numpy as np

# 请在下面的 Begin-End 之间按照注释中给出的提示编写正确的代码
########## Begin ##########
# 使用 input 获取一个字典，完成 ROI 提取
dict1 = eval(input())
data = np.array(dict1["image"])
print(data[dict1["x"]:dict1["x"]+dict1["h"], dict1["y"]:dict1["y"]+dict1["w"]])
########## End ##########

第6关：数组堆叠

测试说明

测试输入：

{'feature1':[[1, 2, 3, 4], [4, 3, 2, 1], [2, 3, 4, 5]], 'feature2':[[1], [2], [3]]}

预期输出：

[2.33333333 2.66666667 3.         3.33333333 2.        ]

代码

import numpy as np

# 请在下面的 Begin-End 之间按照注释中给出的提示编写正确的代码
########## Begin ##########
# 对两个数组进行横向堆叠，并求出每一行的均值
type_in = input()
in_dict = eval(type_in)
a = np.array(in_dict["feature1"])
b = np.array(in_dict["feature2"])
c = np.hstack((a, b))
d = []
for i in range(c.shape[1]):
    sumall = 0
    for j in range(len(c[:, i])):
        sumall += c[:, i][j]
    d.append(sumall / len(c[:, i]))
    sumall = 0
e = np.array(d)
print(e)
########## End ##########

第7关：比较、掩码和布尔逻辑

测试说明

测试输入：

[[ 3 ,15, 9 ,11 , 7],[ 2, 0 , 8, 19 ,16],[ 6 , 6, 16 , 9, 5],[ 7 , 5 , 2 , 6 ,13]]
10

预期输出：

[15 11 19 16 16 13]

代码

import numpy as np

# 请在下面的 Begin-End 之间按照注释中给出的提示编写正确的代码
########## Begin ##########
# 根据输入的数据筛选出大于指定数值的值
type_in = input()
in_list = eval(type_in)
a = np.array(in_list)
num = int(input())
b = []
c = a.flat
for n in c:
    if n > num:
        b.append(n)
print(np.array(b))

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

第8关：索引方式

测试说明

测试输入：

["d","a","A","p","b","I","C","K"]

预期输出：

['A' 'I' 'C' 'K']

代码

import numpy as np

# 请在下面的 Begin-End 之间按照注释中给出的提示编写正确的代码
########## Begin ##########
# 过滤出 input 函数获取的列表中的所有的大写字母，并以列表的形式返回过滤掉的大写字母
type_in = input()
in_list = eval(type_in)
a = np.array(in_list).flat
b = []
for ch in a:
    if ord("A") <= ord(ch) <= ord("Z"):
        b.append(ch)
print(np.array(b))
########## End ##########

第9关：NumPy广播机制

测试说明

测试输入：

[[9, 3, 1], [7, 0, 6], [4, 6, 3]]
[1, 5, 9]
[[9], [6], [7]]

预期输出：

[[19 17 19]
 [14 11 21]
 [12 18 19]]

代码

import numpy as np

# 请在下面的 Begin-End 之间按照注释中给出的提示编写正确的代码
########## Begin ##########
# 将三个输入数据转换为 ndarray 对象，然后计算他们的和
li = []
for i in range(3):
    type_in = input()
    in_list = eval(type_in)
    li.append(in_list)
a = np.array(li[0])
b = np.array(li[1])
c = np.array(li[2])
print(a + b + c)
########## End ##########