Python语言练习

1 Python基本语法元素

1.1 第一个程序

Python程序由指令组成，运行程序时，计算机依据预设好的指令执行程序。
print是最简单，但很常用的指令，它用于将一些信息输出至屏幕上。
下面演示Python中的print指令：

print("Hello World!")
print("Hello Python")

1.2 打印元旦祝福语

请用程序实现
打印一条元旦祝福语，具体内容如下所示：

注意: 第一行和最后一行各有 30 个 * 号。

# 请将指定内容打印输出
print("******************************")
print("祝大家2020年元旦快乐，万事如意")
print("******************************")

1.3 打印欢迎购物

请用程序实现
将下列内容，按照格式，利用print()函数在控制台打印输出。

# 请将指定内容打印输出
print("==========欢迎购物==========")
print("  请选择：")
print("  1.衣服")
print("  2.生鲜")
print("  3.日用品")
print("===========================")
print("请输入商品编码：")

1.4 求圆面积周长

请用程序实现
输入圆的半径r，计算圆的面积(area)和周长(circumference)。
注意: 所有数保留两位小数。π取值3.14。方法为：print("%.2f" % a)。

# 请使用 input() 输入圆的半径 r
r = float(input("请输入半径："))
area=3.14*r*r
circumference=2*3.14*r
# 请计算圆的面积和周长，并将计算结果输出
print("面积：{:.2f}".format(area))
print("周长：{:.2f}".format(circumference))

1.5 同切圆绘制

请用程序实现
使用turtle库，绘制半径分别为 10，40，80，160 的同切圆。

import turtle
turtle.pensize(2)
turtle.circle(10)
turtle.circle(40)
turtle.circle(80)
turtle.circle(160)

1.6 五角星绘制

请用程序实现
使用turtle库，绘制一个五角星。

from turtle import *
color('red','red')
begin_fill()
for i in range(5):
    fd(200)
    rt(144)
end_fill()
done()

1.7 温度转换

温度的刻画有两个不同体系：摄氏度（Celsius）和华氏度（Fahrenheit）。‬
编写一个程序，将用户输入的华氏度转换为摄氏度，或将输入的摄氏度转换为华氏度。‬
转换算法如下：（C表示摄氏度、F表示华氏度）‬
C = ( F - 32 ) / 1.8‬
F = C * 1.8 + 32‬
要求如下：‬
(1) 输入输出的摄氏度可采用大小写字母C结尾，温度可以是整数或小数，如：12.34C指摄氏度12.34度；‬
(2) 输入输出的华氏度可采用大小写字母F结尾，温度可以是整数或小数，如：87.65F指华氏度87.65度；‬
(3) 输出保留小数点后两位，输入格式错误时，输出提示：输入格式错误；‬
(4) 使用input()获得输入时，不要增加提示字符串。

TempStr = input("请输入带有符号的温度值:")

if TempStr[-1] in ['F', 'f']:
    C = (eval(TempStr[0:-1]) - 32) / 1.8
    print("转换后的温度是{:.2f}C".format(C))
elif TempStr[-1] in ["C", "c"]:
    F = 1.8 * eval(TempStr[0:-1]) + 32
    print("转换后的温度是{:.2f}F".format(F))
else:
    print("输入格式错误")

1.8 使用变量

变量用来「保存」一些中间结果，这可以让复杂的计算变得简单，清晰。变量「保存」的数据实际存储在内存中。
变量有一个「名字」，要把数据「保存」到变量中，使用等于 = 符号，这过程称为「赋值」，下面一行代码将 12 保存到变量 cola_price 中:
cola_price = 12
接下来，你就可以使用 cola_price 变量进行计算。
注意：等于符号=，表示赋值，将右边的值赋给左边的变量，它并不像数学的等式一样，表示左边等于右边。
用100元去买可乐，最多能买多少瓶，及还剩多少钱。我们用程序来算一算，假设每瓶可乐 12 元。

cola_price = 12

# 计算 100 元能买多少瓶，并保存至变量 num 中
num = 100/cola_price
num=int(num)
# 计算应找零多少，并保存到 remaining 中
remaining = 100-num*cola_price

# 输出瓶数
print("能买{:.0f}瓶".format(num))

# 输出还剩多少钱
print("找零{:.0f}元".format(remaining))

1.9 计算BMI

标准体重是反映和衡量一个人健康状况的重要标志之一。过胖和过瘦都不利于健康，也不会给人以健美感。不同体型的大量统计材料表明，反映正常体重较理想和简单的指标，可用身高体重的关系来表示。
BMI指数,是用体重(千克)除以身高(米)的平方得出的数字，是国际上常用的衡量人体胖瘦程度以及是否健康的一个标准。下图是有关BMI的分级表。

BMI指数
来计算一下 BMI 指数吧。

# 1.创建表示身高的变量 height 并赋值 1.8
height=1.8

# 2.创建表示体重的变量 weight 并赋值 81
weight=81

# 3.创建表示BMI值的变量 bmi 并计算
bmi=weight/(height*height)

# 4.将 bmi 打印输出
print("{:.1f}".format(bmi))

1.10 存储MP3信息

请用程序实现
使用变量(括号内的单词)存储以下MP3信息(冒号后的信息)：

品牌（brand）：爱国者 F928
重量（weight）：12.4
电池类型（types）：内置锂电池
价格（price）：499

请编写代码，完成练习。

# 请将MP3信息保存到变量中
brand="爱国者 F928"
weight=12.4
types="内置锂电池"
price=499

1.11 打印数据类型

右侧编辑器中的代码功能是输出当前 num3 的数据类型，输出结果为：

<class ‘float’>

请使用 int() 函数将 num3 转换为 int 类型，使其输出结果为：

<class ‘int’>

num1 = 30
num2 = 7
num3 = num1/num2
# 在下面将 num3 转换成 int 类型，并使得最终输出是 <class 'int'>
num3=int(num3)
print(type(num3))

1.12 交换变量值

现在有两个变量num1=10和num2=20，如何能做到交换两个变量的值？

请用程序实现
将两个变量的值进行交换。

请在右侧编辑器中编写代码，完成练习。

num1 = int(input())
num2 = int(input())

# 请不要修改源代码最上面2行
# 请在下面交换 num1, num2 两个变量的值
t=num1
num1=num2
num2=t

1.13 输入身高体重并计算BMI

当前计算BMI的程序中 height, weight 都是固定值，请将程序更改为从键盘获取输入，再计算 BMI。

先输入身高(单位：米)，然后输入体重(单位：公斤)，然后再计算并输出 BMI 值。

在 Python 中，可以通过 input() 指令获取键盘输入的内容，直至遇到回车，下面的代码获取输入，并保存到变量 name 中：

name = input()
print(name)
提示用户输入时，可以添加一段提示文字，像这样：

age = input(‘请输入年龄：’)
print(name, ‘的年龄是:’, age)
好，现在试试修改这个程序吧。

# 请使用 input 获取键盘输入
height = input("")
height=float(height)
# 请使用 input 获取键盘输入
weight = input("")
weight=float(weight)
bmi = weight / height**2

print(bmi)

1.14 货币转换

人民币和美元是世界上通用的两种货币之一，人民币和美元间汇率固定为：1美元 = 7.00人民币。

请用程序实现
将用户输入的美元转换为人民币，或将输入的人民币转换为美元。

要求如下：

(1) 输入输出的人民币采用大写的 RMB 开头，金额可以是整数或小数，如：RMB123 指人民币123元；

(2) 输入输出的美元采用大写的 USD 开头，金额可以是整数或小数，如：USD20 指美元 20 元；

(3) 输出保留小数点后两位，方法为：print("%.2f" % a)。输入格式错误时，输出提示：输入格式错误；

(4) 使用 input() 获得输入时，不要增加提示字符串。

Money = input("")
if Money[:3] in ['RMB']:
    a=(eval(Money[3:])/7.00)
    print("USD{:.2f}".format(a))
elif Money[:3] in ['USD']:
    b=(eval(Money[3:])*7.00)
    print("RMB{:.2f}".format(b))
else:
    print("输入格式错误")

1.15 HelloWorld的条件输出

请用程序实现
获得用户输入的一个整数 num ，参考该整数值，打印输出"Hello World"。

要求如下：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(1) 如果输入值是 0，直接输出"Hello World"‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(2) 如果输入值大于 0，以两个字符一行方式输出"Hello World"（空格也是字符）‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(3) 如果输入值小于 0，以垂直方式输出"Hello World"。

# 请使用 input() 输入一个整数 num
num = int(input())
s = 'Hello World'
m = len(s)
# 请对num进行判断
if num == 0:
    print(s)
elif num > 0:
    for i in range(m):
        if i % 2 == 0:
            print(s[i], end='') 
        else:
            print(s[i])
else:
    for i in range(m):
        print(s[i])

1.16 回响

请用程序实现，从控制台读入一行内容，再把这行内容输出到控制台上，即输入什么就输出什么，称为回响。

# 请实现回响功能，输入什么即输出什么
n=input("")
print("{}".format(n))

1.17 注释所有行

请用程序实现
使用注释，使得下面所有的代码不在控制台显示。

print(‘我是第一行’)
print(‘我是第二行’)
print(‘我是第三行’)
print(‘我是第四行’)
print(‘我是第五行’)

'''print('我是第一行')
print('我是第二行')
print('我是第三行')
print('我是第四行')
print('我是第五行')'''

1.18 打印实心菱形

请用程序实现
输入一个字符char，用此字符排列成菱形，并将排列的结果输出。

# 请使用 input() 输入一个字符 char
char=input("")

# 请用此字符排列成菱形，并将排列的结果输出
for i in range(1, 5, 2):
    print((char * i).center(5))
for i in reversed(range(1, 6, 2)):
    print((char * i).center(5))

1.19 存储购物小票

请用程序实现
商店打印出了用户购物的结算小票，给出的信息如下：

Ｔ恤的单价(T_shirt_price): 245元
球鞋的单价(sneaker_price): 430元
网球拍的单价(racket_price): 320元
该用户总共购买了:
T恤(T_shirt): 2件
球鞋(sneaker): 1双
网球拍(racket): 2个

请把上述所有数字存储在对应的变量中（注意，变量名大小写需完全一致）。

# 请将所有数据保存到对应的变量中
T_shirt_price=245
sneaker_price=430
racket_price=320
T_shirt=2
sneaker=1
racket=2

1.20 计算平均分

已知王浩同学的Java成绩为 100 分，Python成绩为 88 分，SQL成绩为 99 分。

请用程序实现
计算 Java 课和 SQL 课的分数之差(Java成绩减去SQL成绩)，输出格式：“Java 和 Sql 的成绩差为：***”。
计算这 3 门课的平均分，输出格式：“三门课程的平均分为：***”。

请在右侧编辑器中编写代码，完成练习。

java = 100
python = 88
sql = 99
n=java-python
# 打印出 Java 和 Sql 的成绩差。
print('Java 和 Sql 的成绩差为：{:.0f}'.format(n))
avg=(java+python+sql)/3
# 打印出三门课程的平均分。
print('三门课程的平均分为：{:.2f}'.format(avg))

1.21 计算器

请用程序实现
输入两个数 num1, num2，分别计算他们的和(summation)、差(difference)、积(product)、商(quotient)，并将计算结果输出。

提示: 计算和时使用num1 + num2，计算差时使用num1 - num2，计算积时使用 num1 * num2，计算商时使用num1 / num2。

注意: 输出时所有数据均保留两位小数。

# 请使用 input() 输入两个数 num1, num2
num1=input("")
num2=input("")
num1=float(num1)
num2=float(num2)
# 请分别计算 num1,num2 的和(summation)、差(difference)、积(product)、商(quotient)，并将计算结果输出
summation=num1+num2
difference=num1 - num2
product=num1*num2
quotient=num1/num2
print("和为：{:.2f}".format(summation))
print("差为：{:.2f}".format(difference))
print("积为：{:.2f}".format(product))
print("商为：{:.2f}".format(quotient))

2 Python基本图形绘制

2.1 蟒蛇绘制

使用turtle库，绘制一个蟒蛇形状的图形。‬

import turtle
turtle.setup(650,350,200,200)
turtle.penup()
turtle.fd(-250)
turtle.pendown()
turtle.pensize(25)
turtle.pencolor("purple")
turtle.seth(-40)
for i in range(4):
    turtle.circle(40,80)
    turtle.circle(-40,80)
turtle.circle(40,80/2)
turtle.fd(40)
turtle.circle(16,180)
turtle.fd(40* 2/3)
turtle.down()

2.2 正方形绘制

使用turtle库，绘制一个正方形。‬

import turtle
turtle.setup(600,600)
turtle.fd(200)
turtle.seth(90)
turtle.fd(200)
turtle.seth(180)
turtle.fd(200)
turtle.seth(-90)
turtle.fd(200)
turtle.down()

2.3 八边形

使用turtle库，绘制一个八边形。‬‬

注意: 这不是自动评阅题目，仅用于练习，没有评阅。请补充"编程模板"中横线内容。

import turtle as t
t.pensize(2)
for i in range(8):
    t.fd(60)
    t.left(45)

2.4 八角形

使用turtle库，绘制一个八角图形。‬

注意: 这不是自动评阅题目，仅用于练习，没有评阅。请补充"编程模板"中横线内容。

import turtle as t
t.pensize(2)
for i in range(8):
    t.fd(150)
    t.left(135)

2.5 叠边形绘制

使用turtle库，绘制一个叠边形，其中，叠边形内角为100度。‬

import turtle
turtle.setup(600,600)
for i in range(9):
    turtle.fd(200)
    turtle.left(80)

2.6 风轮绘制

使用turtle库，绘制一个风轮效果，其中，每个风轮内角为45度，风轮边长150像素。‬

注意: 这不是自动评阅题目，仅用于练习，没有评阅。

提示: turtle.goto(x,y)函数，能够将turtle画笔移动到坐标(x,y)

import turtle
turtle.setup(600,600)
#第四象限
turtle.seth(-45)
turtle.fd(150)
turtle.seth(45)
turtle.circle(150,45)
turtle.seth(-180)
turtle.fd(150)
#第一象限
turtle.seth(45)
turtle.fd(150)
turtle.seth(135)
turtle.circle(150,45)
turtle.seth(-90)
turtle.fd(150)
#第二象限
turtle.seth(135)
turtle.fd(150)
turtle.seth(-135)
turtle.circle(150,45)
turtle.seth(0)
turtle.fd(150)
#第三象限
turtle.seth(-135)
turtle.fd(150)
turtle.seth(-45)
turtle.circle(150,45)
turtle.seth(90)
turtle.fd(150)

2.7 自由绘图

恭喜你，你已经学会了 Python Turtle 的基本绘图方法了。

现在，你可以发挥你的想象力，自由创作，绘制一些有趣的图形并与你的同学、朋友分享吧！

你可以在自己的电脑上利用编辑器（PyCharm 或 IDLE 等）编写代码，运行并查看结果（而不必通过在线平台进行）。

另外 Python Turtle 还有更多的功能，这些功能都在 turtle 这个模块中，你可以通过下面的文档详细阅读了解 turtle 模块的所有功能，以帮助你更好地进行自由创作。

Python turtle 海龟绘图官方文档

一些有趣的绘图示例
这里还提供给你一些有趣的示例，你可以在自己电脑中，通过编辑器打开文件并复制粘贴运行看看效果。

你还可以通过在 cmd 中运行 python3 -m turtledemo 命令

彩虹糖

from turtle import *
from random import random
import contextlib

def draw_circle(r):
    a, b, c = random(), random(), random()
    #pencolor(a, b, c)
    fillcolor(a, b, c)
    begin_fill()
    circle(r)
    end_fill()

def pen_skip(step):
    penup()
    forward(step)
    pendown()

speed(5)
setup(width=800,height=600)
screensize(600,400, "gray")
long = 600
high = 450
left(180)
pen_skip(250)
left(90)
pen_skip(200)
left(90)
high_start = 50
high_step = 50
long_start = 50
long_step = 50
for i in range(high_start,high,high_step):
    for j in range(long_start,long,long_step):
        if (i//high_step)%2 ==1:
            if j == long-long_step:
                draw_circle(long_step//2)
                continue
            draw_circle(long_step // 2)
            pen_skip(long_step)
        else:
            if j == long-long_step:
                draw_circle(-long_step // 2)
                continue
            draw_circle(-long_step // 2)
            pen_skip(long_step)
    if (i//50)%2 == 1:
        left(90)
        pen_skip(high_step)
        left(90)
    else:
        right(90)
        pen_skip(high_step)
        right(90)
exitonclick()

阴阳图

from turtle import *

def yin(radius, color1, color2):
    width(3)
    color("black", color1)
    begin_fill()
    circle(radius/2., 180)
    circle(radius, 180)
    left(180)
    circle(-radius/2., 180)
    end_fill()
    left(90)
    up()
    forward(radius*0.35)
    right(90)
    down()
    color(color1, color2)
    begin_fill()
    circle(radius*0.15)
    end_fill()
    left(90)
    up()
    backward(radius*0.35)
    down()
    left(90)

def main():
    reset()
    yin(200, "black", "white")
    yin(200, "white", "black")
    ht()
    return "Done!"

if __name__ == '__main__':
    main()
    mainloop()

花纹设计

from turtle import Turtle, mainloop
from time import clock

# wrapper for any additional drawing routines
# that need to know about each other
class Designer(Turtle):

    def design(self, homePos, scale):
        self.up()
        for i in range(5):
            self.forward(64.65 * scale)
            self.down()
            self.wheel(self.position(), scale)
            self.up()
            self.backward(64.65 * scale)
            self.right(72)
        self.up()
        self.goto(homePos)
        self.right(36)
        self.forward(24.5 * scale)
        self.right(198)
        self.down()
        self.centerpiece(46 * scale, 143.4, scale)
        self.getscreen().tracer(True)

    def wheel(self, initpos, scale):
        self.right(54)
        for i in range(4):
            self.pentpiece(initpos, scale)
        self.down()
        self.left(36)
        for i in range(5):
            self.tripiece(initpos, scale)
        self.left(36)
        for i in range(5):
            self.down()
            self.right(72)
            self.forward(28 * scale)
            self.up()
            self.backward(28 * scale)
        self.left(54)
        self.getscreen().update()

    def tripiece(self, initpos, scale):
        oldh = self.heading()
        self.down()
        self.backward(2.5 * scale)
        self.tripolyr(31.5 * scale, scale)
        self.up()
        self.goto(initpos)
        self.setheading(oldh)
        self.down()
        self.backward(2.5 * scale)
        self.tripolyl(31.5 * scale, scale)
        self.up()
        self.goto(initpos)
        self.setheading(oldh)
        self.left(72)
        self.getscreen().update()

    def pentpiece(self, initpos, scale):
        oldh = self.heading()
        self.up()
        self.forward(29 * scale)
        self.down()
        for i in range(5):
            self.forward(18 * scale)
            self.right(72)
        self.pentr(18 * scale, 75, scale)
        self.up()
        self.goto(initpos)
        self.setheading(oldh)
        self.forward(29 * scale)
        self.down()
        for i in range(5):
            self.forward(18 * scale)
            self.right(72)
        self.pentl(18 * scale, 75, scale)
        self.up()
        self.goto(initpos)
        self.setheading(oldh)
        self.left(72)
        self.getscreen().update()

    def pentl(self, side, ang, scale):
        if side < (2 * scale): return
        self.forward(side)
        self.left(ang)
        self.pentl(side - (.38 * scale), ang, scale)

    def pentr(self, side, ang, scale):
        if side < (2 * scale): return
        self.forward(side)
        self.right(ang)
        self.pentr(side - (.38 * scale), ang, scale)

    def tripolyr(self, side, scale):
        if side < (4 * scale): return
        self.forward(side)
        self.right(111)
        self.forward(side / 1.78)
        self.right(111)
        self.forward(side / 1.3)
        self.right(146)
        self.tripolyr(side * .75, scale)

    def tripolyl(self, side, scale):
        if side < (4 * scale): return
        self.forward(side)
        self.left(111)
        self.forward(side / 1.78)
        self.left(111)
        self.forward(side / 1.3)
        self.left(146)
        self.tripolyl(side * .75, scale)

    def centerpiece(self, s, a, scale):
        self.forward(s); self.left(a)
        if s < (7.5 * scale):
            return
        self.centerpiece(s - (1.2 * scale), a, scale)

def main():
    t = Designer()
    t.speed(0)
    t.hideturtle()
    t.getscreen().delay(0)
    t.getscreen().tracer(0)
    at = clock()
    t.design(t.position(), 2)
    et = clock()
    return "runtime: %.2f sec." % (et-at)

if __name__ == '__main__':
    msg = main()
    print(msg)
    mainloop()

时钟

from turtle import *
from datetime import datetime

def jump(distanz, winkel=0):
    penup()
    right(winkel)
    forward(distanz)
    left(winkel)
    pendown()

def hand(laenge, spitze):
    fd(laenge*1.15)
    rt(90)
    fd(spitze/2.0)
    lt(120)
    fd(spitze)
    lt(120)
    fd(spitze)
    lt(120)
    fd(spitze/2.0)

def make_hand_shape(name, laenge, spitze):
    reset()
    jump(-laenge*0.15)
    begin_poly()
    hand(laenge, spitze)
    end_poly()
    hand_form = get_poly()
    register_shape(name, hand_form)

def clockface(radius):
    reset()
    pensize(7)
    for i in range(60):
        jump(radius)
        if i % 5 == 0:
            fd(25)
            jump(-radius-25)
        else:
            dot(3)
            jump(-radius)
        rt(6)

def setup():
    global second_hand, minute_hand, hour_hand, writer
    mode("logo")
    make_hand_shape("second_hand", 125, 25)
    make_hand_shape("minute_hand",  130, 25)
    make_hand_shape("hour_hand", 90, 25)
    clockface(160)
    second_hand = Turtle()
    second_hand.shape("second_hand")
    second_hand.color("gray20", "gray80")
    minute_hand = Turtle()
    minute_hand.shape("minute_hand")
    minute_hand.color("blue1", "red1")
    hour_hand = Turtle()
    hour_hand.shape("hour_hand")
    hour_hand.color("blue3", "red3")
    for hand in second_hand, minute_hand, hour_hand:
        hand.resizemode("user")
        hand.shapesize(1, 1, 3)
        hand.speed(0)
    ht()
    writer = Turtle()
    #writer.mode("logo")
    writer.ht()
    writer.pu()
    writer.bk(85)

def wochentag(t):
    wochentag = ["Monday", "Tuesday", "Wednesday",
        "Thursday", "Friday", "Saturday", "Sunday"]
    return wochentag[t.weekday()]

def datum(z):
    monat = ["Jan.", "Feb.", "Mar.", "Apr.", "May", "June",
             "July", "Aug.", "Sep.", "Oct.", "Nov.", "Dec."]
    j = z.year
    m = monat[z.month - 1]
    t = z.day
    return "%s %d %d" % (m, t, j)

def tick():
    t = datetime.today()
    sekunde = t.second + t.microsecond*0.000001
    minute = t.minute + sekunde/60.0
    stunde = t.hour + minute/60.0
    try:
        tracer(False)  # Terminator can occur here
        writer.clear()
        writer.home()
        writer.forward(65)
        writer.write(wochentag(t),
                     align="center", font=("Courier", 14, "bold"))
        writer.back(150)
        writer.write(datum(t),
                     align="center", font=("Courier", 14, "bold"))
        writer.forward(85)
        tracer(True)
        second_hand.setheading(6*sekunde)  # or here
        minute_hand.setheading(6*minute)
        hour_hand.setheading(30*stunde)
        tracer(True)
        ontimer(tick, 100)
    except Terminator:
        pass  # turtledemo user pressed STOP

def main():
    tracer(False)
    setup()
    tracer(True)
    tick()
    return "EVENTLOOP"

if __name__ == "__main__":
    mode("logo")
    msg = main()
    print(msg)
    mainloop()

wikipedia

from turtle import Screen, Turtle, mainloop
from time import clock, sleep

def mn_eck(p, ne,sz):
    turtlelist = [p]
    #create ne-1 additional turtles
    for i in range(1,ne):
        q = p.clone()
        q.rt(360.0/ne)
        turtlelist.append(q)
        p = q
    for i in range(ne):
        c = abs(ne/2.0-i)/(ne*.7)
        # let those ne turtles make a step
        # in parallel:
        for t in turtlelist:
            t.rt(360./ne)
            t.pencolor(1-c,0,c)
            t.fd(sz)

def main():
    s = Screen()
    s.bgcolor("black")
    p=Turtle()
    p.speed(0)
    p.hideturtle()
    p.pencolor("red")
    p.pensize(3)

    s.tracer(36,0)

    at = clock()
    mn_eck(p, 36, 19)
    et = clock()
    z1 = et-at

    sleep(1)

    at = clock()
    while any([t.undobufferentries() for t in s.turtles()]):
        for t in s.turtles():
            t.undo()
    et = clock()
    return "runtime: %.3f sec" % (z1+et-at)


if __name__ == '__main__':
    msg = main()
    print(msg)
    mainloop()

3 基本数据类型

3.1 判断奇偶数

请用程序实现: 输入一个整数，判断它是奇数还是偶数。如果是奇数，输出odd；如果是偶数，输出even。

# 请使用 input() 输入一个整数 num
num=int(input(""))
# 请判断这个数是奇数还是偶数
n=num%2
if(n==0):
    print("even")
else:
    print("odd")

3.2 公倍数

请用程序实现
输入一个正整数，判断它是否是5和7的公倍数。如果是，输出yes；如果不是，输出no。

# 请使用 input() 输入一个正整数 num
num=int(input(""))

# 请判断这个正整数是否是 5 和 7 的公倍数
a=num%5
b=num%7
if a==0 and b==0:
    print("yes")
else:
    print("no")

3.3 判断平闰年

如果一个年份可以被 4 整除且不能被 100 整除，或者可以被 400 整除，那么这个年份就是闰年。

请用程序实现
输入一个年份year，判断它是「平年」还是「闰年」。如果是平年，输出common year；如果是闰年，输出leap year。

# 请使用 input() 输入一个年份 year
year=int(input(""))

# 请判断这个年份是否为闰年
if ((year%4==0)and(year%100!=0))or(year%400==0):
    print("leap year")
else:
    print("common year")

3.4 天天向上的力量第一问

请用程序实现
计算千分之一的力量。

要求如下：

(1) 计算一年 365 天，每天进步千分之一，累计进步到多少，并将计算结果输出。

(2) 计算一年 365 天，每天退步千分之一，累计剩下多少，并将计算结果输出。

(3) 输出时，在一行内输出进步的结果和退步的结果。

dayup=1.0
daydown=1.0
dayfactor=0.01
for i in range(365):
    dayup=dayup*(1+dayfactor)
for i in range(365):
    daydown=daydown*(1-dayfactor)
print("向上：{:.2f}".format(dayup),end="")
print(",向下：{:.2f}".format(daydown))

3.5 天天向上的力量第二问

请用程序实现
计算千分之五和百分之一的力量。

要求如下：

(1) 计算一年 365 天，每天进步千分之五或百分之一，累计进步到多少，并将计算结果输出。

(2) 计算一年 365 天，每天退步千分之五或百分之一，累计剩下多少，并将计算结果输出。

(3) 输出时，在一行内输出进步的结果和退步的结果。

dayup1=1.0
dayup2=1.0
daydown1=1.0
daydown2=1.0
dayfactor1=0.005
dayfactor2=0.01
for i in range(365):
    dayup1=dayup1*(1+dayfactor1)
for i in range(365):
    dayup2=dayup2*(1+dayfactor2)
for i in range(365):
    daydown1=daydown1*(1-dayfactor1)
for i in range(365):
    daydown2=daydown2*(1-dayfactor2)
print("向上：{:.2f}".format(dayup1),end="")
print("{:.2f}".format(dayup2),end="")
print(",向下：{:.2f}".format(daydown1),end="")
print("{:.2f}".format(daydown2))

3.6 天天向上的力量第三问

请用程序实现
工作日的力量。

要求如下：

(1) 一年 365 天，一周 5 个工作日，每天进步 1%；

(2) 一年 365 天，一周 2 个休息日，每天退步 1%；

(3) 计算按照工作日和休息日的进步或退步情况，经过一年 365 天后，累计剩下多少，并将计算结果输出。

(4) 输出时，在一行内输出计算的结果。

dayup=1.0
dayfactor=0.01
for i in range(365):
    if i%7 in [6,0]:
        dayup=dayup*(1-dayfactor)
    else:
        dayup=dayup*(1+dayfactor)
print("{:.2f}".format(dayup))

3.7 天天向上的力量第四问

工作日模式要努力到什么水平，才能与每天努力进步 1% 一样？‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

A君: 一年 365 天，每天进步 1%，不停歇，365天之后，达到37.78 ‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬

B君: 一年 365 天，每周工作 5 天休息 2 天，休息日每天退步 1%，那么工作日应该多努力才能追上Ａ君呢？

请用程序实现
计算要使 B君 和 A君 一年后的进步程度一样，那么 B君 每天需要进步的值，并将计算结果输出。

要求如下：‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(1) ‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬一年 365 天，以第 0 天的能力值为基数，记为 1.0；‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(2) ‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬当好好学习时，能力值相比前一天提高 1%；当没有学习时，由于遗忘等原因能力值相比前一天下降 1%；

(3) 输出保留小数点后三位，冒号后有一个空格。如：工作日的努力参数是: 0.019。

def dayUp(df):
    dayup=1
    for i in range(365):
        if i%7 in [6,0]:
            dayup=dayup*(1-0.01)
        else:
            dayup=dayup*(1+df)
    return dayup
dayfactor=0.01
while dayUp(dayfactor)<37.78:
    dayfactor += 0.001
print("工作日的努力参数:{:.3f}".format(dayfactor))

3.8 拼接最大字符

请用程序实现
输入两个长度相等的字符串，将两字符串中相同索引中较大的字符组成一个新的字符串并输出，使用 ASCII 码来比较字符大小。

注：如 ASCII 码相等，任选 1 个

输入格式
在两行中分别输入两个字符串，长度相等

输出格式
在一行中输出结果字符串

# 请使用 input() 输入两个字符串 string1, string2
string1=input("")
string2=input("")
# 请分别比较两个字符串中的每一个字符，将大的字符拼接成一个新的字符串，并输出
for i in range(len(string1)):
    if(ord(string1[i])<=ord(string2[i])):
        print(chr(ord(string2[i])),end="")
    else:   
        print(chr(ord(string1[i])),end="")

3.9 删除字符

请用程序实现
删除预置代码中字符串string中的一部分。

要求如下：

(1) 分两行输入两个整数，第一个整数表示字符串 string 的索引 begin，第二个整数表示需要删除的长度 length。

(2) 将字符串 string 中，从索引 begin 开始，长为 length 的子字符串删除。

(3) 输出字符串 string 删除后剩下的部分。

str = 'abcdefghijklmnopqrstuvwxyz'
# 请使用 input() 输入索引 begin 和长度 length
begin=int(input(""))
length=int(input(""))
# 请将字符串 string 中，从索引 begin 开始，长为 length 的字符串删除，并将剩下的字符串内容输出
for i in range(len(str)):
    if(i<begin or i>length+begin-1):
        sub_str=str[i]
        print(sub_str,end="")
    

3.10 插入字符

请用程序实现
已知字符串 s ，请将另一个字符串 sub 添加到字符串 s 的指定索引位置中，并将添加后的 s 输出。

s = 'abcdefghijklmnopqrstuvwxyz'
sub=input("")
pos=int(input(""))
str_s=list(s)
str_s.insert(pos, sub)
a_b = ''.join(str_s)
print(a_b)

3.11 回文字符串

如果一个字符串从左往右读与从右往左读是相同的字符串，那么这个字符串就是回文字符串。如 “level”、"noon"都是回文字符串。

请用程序实现
输入一个字符串，判断它是否为回文字符串。如果是回文字符串，输出yes；如果不是回文字符串，输出no。

str=input("please input a string:")#输入一个字符串
length=len(str)#求字符串长度
left=0#定义左右‘指针’
right=length-1
while left<=right:#判断
    if str[left]==str[right]:
        left+=1
        right-=1
    else:
        break;
if left>right:
    print("yes")
else :
    print("no")

3.12 统计词量

请用程序实现
输入一段仅由英文字母、空格组成的文本，并通过split()方法统计这段文本中的单词数量，并将统计结果输出

text = input()
text1 = text.strip() #去掉头尾空格
index = 0
count = 0
while index < len(text1):
    while text1[index] != " ": #有空格时结束当前循环
        index += 1
        if index == len(text1): #下标与字符串长度相等结束当前循环
            break
    count += 1 #计算单词的个数
    if index == len(text1): #下标与字符串长度相等结束当前循环
        break
    while text1[index] == " ": #单词之间多个空格时，下标加1
        index += 1
print(count)

3.13 你中无我

请用程序实现
给定两个字符串 s1, s2，删除字符串 s1 中的属于 s2 的字符，并输出结果。

s1=input("")
s2=input("")
for i in range(len(s1)):
    str=s1[i].strip(s2)
    print(str,end="")

3.14 时间格式化

请根据视频内容的讲解，获取当前时间，并将获取到的时间按照年-月-日 时:分:秒的格式打印输出。

import time
t=time.gmtime()
print(time.strftime("%Y-%m-%d %H:%M:%S",t))

3.15 文本进度条

采用字符串方式打印可以动态变化的文本进度条‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬，进度条需要能在一行中逐渐变化.

要求如下：‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(1) 采用 sleep() 模拟一个持续的进度,获得文本进度条的变化时间；‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(2) 通过 print() 函数实现单行动态刷新，在 print() 函数中更换参数 end 的默认值为’’，每次使用 print() 函数输出时不能换行；‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(3) 要能回退：打印后光标到之前的位置\r。

请在 Windows 的命令行(cmd 或 PowerShell)或其他操作系统的命令行下执行 Python 程序，获得进度条效果。

import time
scale=50
print("执行开始".center(scale//2,"-"))
start=time.perf_counter()
for i in range(scale+1):
    a='*'*i
    b='.'*(scale-i)
    c=(i/scale)*100
    dur=time.perf_counter()-start
    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c,a,b,dur),end='')
    time.sleep(0.1)
print("\n"+"执行速度".center(scale//2,'-'))

4 程序的控制结构

4.1 大小写转换

a、b、c、d这样的52个字母（包括大写）在计算机中存储时也要使用二进制数来表示。

标准ASCII码使用7位二进制数（剩下的1位二进制为0）来表示所有的大写和小写字母，如下图所示，可以看出字母对应大小写的差值为32。

来进行大小写转换吧。

注意：python 中，使用 ord() 函数将 字符 转换成其对应的 ASCII 码；使用 chr() 函数将 ASCII 码转换成其对应的 字符。

如：ord(‘A’) 得到结果 65，chr(65) 得到结果 ‘A’。

请用程序实现
输入一个英文字母char，判断它是「大写字母」还是「小写字母」。如果是大写字母，将其转换为「对应的小写字母」；如果是小写字母，将其转换为「对应的大写字母」；并将转换后的结果输出。

# 请使用 input() 输入一个英文字母 char
char=input('')
# 请实现英文字母的大小写转化
if ord(char)>=65 and ord(char)<=65+26-1:
    print(chr(ord(char)+(97-65)))
else:
    print(chr(ord(char)-(97-65)))

4.2 判断位数并打印各位的值

请用程序实现
输入一个不多于五位的正整数num，求出它是几位数，将结果输出，并将每一位的数字都打印出来。

注意: 位数和每位的数字分两行打印。

# 请使用 input() 输入一个不多于五位的正整数 num
num=int(input(""))
# 请计算这个正整数的位数，并将每一位的数字都打印出来。
a=len(str(num))
if a==1 :
    print("一")
    for i in range(a):
        print(str(num)[i],end=" ")
elif a==2 :
    print("二")
    for i in range(2):
        print(str(num)[i],end=" ")
elif a==3 :
    print("三")
    for i in range(3):
        print(str(num)[i],end=" ")
elif a==4 :
    print("四")
    for i in range(4):
        print(str(num)[i],end=" ")
else :
    print("五")
    for i in range(5):
        print(str(num)[i],end=" ")

4.3 地铁车票

购买地铁车票的规定如下：

乘 1~4 站，3 元/位；
乘 5~9 站，4 元/位；
乘 9 站以上，5 元/位。

请用程序实现
输入乘坐人数(per_num)和乘坐站数(sta_num)，计算购买地铁车票需要的总金额，并将计算结果输出。

注意: 如果「乘坐人数」和「乘坐站数」为0或负数，输出error。

# 请使用 input() 输入乘坐的人数 per_num 和站数 sta_num
per_num =int(input(""))
sta_num =int(input(""))
# 请判断输入的人数和站数是否正确，计算购买车票的总金额，并将计算结果输出
if sta_num>=1 and sta_num<=4 and per_num>0:
    money=per_num*3
    print(money)
elif sta_num>=5 and sta_num<=9 and per_num>0:
    money=per_num*4
    print(money)
elif sta_num>=9 and per_num>0:
    money=per_num*5
    print(money)
else:
    print("error")

4.4 考试评级

请用程序实现
输入一个表示考试成绩score的整数，判断该成绩属于哪个级别，并将判断结果输出。

以下为成绩级别划分：

# 请使用 input() 输入考试成绩 score
score = int(input('请输入考试成绩: '))

# 请判断成绩属于哪个级别
if score>=90 and score<=100:
    print("A")
elif score>=80 and score<=89:
    print("B")
elif score>=70 and score<=79:
    print("C")
elif score>=60 and score<=69:
    print("D")
else:
    print("E")

4.5 判断星期

每个星期对应的英语单词都不同，星期一到星期天的单词分别为：monday、tuesday、wednesday、thursday、friday、saturday、sunday。

请用程序实现
输入单词的前两个字符，判断输入的单词是星期几，并输出对应的单词；如果输入的字符不匹配，则输出error。

# 请使用 input() 输入单词的前两个字母 chars
chars = input()

# 请判断输入的是星期几，并输出对应的单词
if chars=='mo':
    print("monday")
elif chars=='tu':
    print("tuesday")
elif chars=='we':
    print("wednesday")
elif chars=='th':
    print("thursday")
elif chars=='fr':
    print("friday")
elif chars=='sa':
    print("saturday")
elif chars=='su':
    print("sunday")
else:
    print("error")

4.6 身体质量指数BMI

BMI ：Body Mass Index 国际上常用的衡量人体肥胖和健康程度重要标准，主要用于统计分析‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬。BMI 的计算公式为 BMI = 体重(kg) / (身高(m) * 身高(m))。

请用程序实现
获取用户输入的体重和身高值，计算并给出国际和国内的 BMI 分类。

‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬要求如下：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(1) 混合计算并给出国际和国内的 BMI 分类；‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(2) 使用input()获得测试用例输入时，不要增加提示字符串。

height = float(input())
weight = float(input())
bmi=weight/pow(height,2)
# 计算bmi值并将判断结果输出
print("BMI数值为：{:.2f}".format(bmi))
if bmi<18.5:
    who,nat="偏瘦","偏瘦"
elif 18.5<=bmi<24:
    who,nat="正常","正常"
elif 24<=bmi<25:
    who,nat="正常","偏胖"
elif 25<=bmi<28:
    who,nat="偏胖","偏胖"
elif 28<=bmi<30:
    who,nat="偏胖","肥胖"
else:
    who,nat="肥胖","肥胖"
print("BMI指标为:国际'{:}', 国内'{:}'".format(who,nat))

4.7 阶乘

请用程序实现
输入一个正整数num，计算这个正整数的阶乘，并将计算结果输出。

# 请使用 input() 输入一个正整数 num
num=int(input(""))
# 请计算这个正整数的阶乘，并将计算结果输出
for i in range(num-1):
    num*=(i+1)
print(num)

4.8 水仙花数

"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如 153 = 1³ + 5³ + 3³，所以 153 是一个水仙花数。

请用程序实现
输入一个三位数，找出100~num(含)中的所有水仙花数，并将找出的水仙花数从小到大输出，每行输出1个数。

# 请使用 input() 输入一个三位数 num
i = int(input('请输入一个三位数: '))
# 请找出 100 - num(含) 中的所有水仙花数，并将找出的水仙花数输出
for num in range(100, i):
    gewei = num % 10
    shiwei = num // 10 % 10
    baiwei = num//100
    if gewei**3 + shiwei**3 + baiwei**3 == num:
        print(num)

4.9 猴子摘桃

一只猴子摘桃子, 第一天摘了两个桃, 以后每天摘的是前一天的两倍还多一个.

请用程序实现
输入一个天数day，计算第day天它摘的个数，并将结果输出。

# 请使用 input() 输入一个天数 day
day = int(input('请输入一个天数: '))
num=2
# 请计算第 day 天猴子摘的桃子个数，并将结果输出
for i in range(day-1):
    num=num*2+1
print(num)

4.10 素数

「质数」又称素数，有无限个。素数定义为在大于 1 的自然数中，除了 1 和它本身以外不再有其他因数的数称为素数。

例如17就是素数，因为它不能被2 - 16的任一整数整除。

请用程序实现: 输入一个大于 1 的整数num，输出1~num(含)中的所有的素数（每行输出1个素数，从小到大排列）。

# 请使用 input() 输入一个整数 num
num = int(input('请输入一个整数: '))
# 输出 1 - num(含) 中的所有的素数
for i in range(2,num+1):
    for n in range(2,i):
        if i%n == 0:
            break
    else:
        print(i)

4.11 随机密码生成

补充编程模板中代码，完成如下功能：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬
以整数 17 为随机数种子，获取用户输入整数 N 为长度，产生 3 个长度为 N 位的密码，密码的每位是一个数字。每个密码单独一行输出。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

注意: 产生密码采用random.randint()函数。

# 请在...补充代码
import random
def genpwd(length):
    s=random.randint(pow(10,length-1),pow(10,length))
    return s
length = eval(input())
random.seed(17)
for i in range(3):
    print(genpwd(length))

4.12 圆周率的计算

求解圆周率可以采用蒙特卡罗方法，在一个正方形中撒点，根据在 1/4 圆内点的数量占总撒点数的比例计算圆周率值。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

请用程序实现
请以 123 作为随机数种子，获得用户输入的撒点数量，编写程序输出圆周率的值，保留小数点后 6 位。

from random import random
from time import perf_counter
darts=1000*1000
hits=0.0
start=perf_counter()
for i in range(1,darts+1):
    x,y=random(),random()
    dist=pow(x**2+y**2,0.5)
    if dist<=1.0:
        hits=hits+1
pi=4*(hits/darts)
print("圆周率值是：{}".format(pi))

4.13 求pi的近似值

输入精度 e，使用格雷戈里公式求 π 的近似值，精确到最后一项的绝对值小于 e.

格雷戈里公式如下：

π/4​ = 1 − 1/3 + 1/5 - 1/7 + 1/9 + ··· + 1/(2 * n - 1)

注意: n从 1 开始.

输入格式:
输入在一行中给出精度 e

输出格式:
对于给定的输入，在一行中输出π的近似值。

p=float(input())
n,s,t,pai=1,1,1,0.0
if p==1.0:
    pai=p
else:
    while True:
        t=1/(2*n-1)
        pai+=s*t
        if t<p:
            break
        n+=1
        s=-s
pai*=4
print(pai)

4.14 篮球弹跳

篮球从一定高度向下掉落，每一次弹起的高度，都是前一次高度的一半。一次掉落和一次弹起极为一次弹跳。假设篮球初始高度为10米。

请用程序实现
输入篮球弹跳的次数num，计算num次后篮球所在的高度，并将计算结果输出。

# 请使用 input() 输入弹跳的次数 num
num = int(input('请输入弹跳的次数: '))
height=10
# 请计算弹跳 num 次后的篮球高度，并将结果输出
for i in range(num):
    height=height/2
print(height)

4.15 猜数字

.random() 方法返回随机生成的一个实数，它在 [0,1) 范围内。这个实数是大于等于 0，小于 1 的，也就是说不会随机生成 1。

我们如何使用它呢？看下面的代码:

import random
#生成一个[0,1)的随机数
randomNum = random.random()
那么我们想生成一个在 [0,100) 范围内的随机数呢？当然也是可以的，我们只需要将 random.random() 生成的随机数扩大 100 倍就行了:

import random
#生成一个[0,100)的随机数
randomNum = random.random() * 100
注意： .random() 是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。

同样，random 模块还有很多的方法，如：random.randint(1, 10) 将返回 1 - 10 之间的整数。

使用 python 实现猜数字游戏，即系统随机生成一个整数，通过 input() 函数，输入整数，根据系统给出的提示猜数字。

要求：

随机生成一个 1 - 100 之间的整数。
7 次猜数字的机会，如果没有猜正确，游戏结束。
输入字母 q，则退出游戏。
注意: 这不是自动评阅题目，仅用于练习，没有评阅。

运行你的程序，执行效果如下所示：

您只有7次猜数字的机会哦！
这是第1次猜数字
请输入数字：1
您输入的数字太小了，您还有6次机会，请重新输入！
这是第2次猜数字
请输入数字：n
输入的内容必须为整数，请重新输入！
这是第3次猜数字
请输入数字：q
退出游戏！
进一步改进程序
7 次可能太少，改成 10 次的话，如何调整程序？
0 - 100 的数太小了，如果要改为 0 - 1000 怎么调整代码？

# 导入random模块
import random

# 生成随机数，并赋值给num变量
num = random.randint(1, 100)

# 定义 guess_chances 变量，初始化猜的次数
guess_chances = 7
print('您只有7次猜数字的机会哦！')

# 循环输入的次数
for i in range(1, guess_chances + 1):
    print('这是第' + str(i) + '次猜数字')

    # 实现对输入数字的判断

5 函数和代码复用

5.1 打招呼函数

请用程序实现
用函数给某个人打招呼。

函数定义
def say_hello (name):
pass

参数说明
name是一个字符串，表示名字。

返回值说明
该函数没有返回值，调用该函数会输出一段话：你好，xxx，认识你很高兴！

"""
练习：打招呼函数
要求：
1. 定义函数 say_hello
2. 有 1 个参数 name 表示要给谁打招呼
3. 实现函数功能，即在控制台打印：`你好，<name>，认识你很高兴！`（注：name 是函数的参数）
"""
def say_hello (name):
    return name
name=input('')
print("你好，{}，认识你很高兴！".format(say_hello(name)))

5.2 能否组成三角形

判断三条线段能否构成一个三角形，需要满足两条规则：

三角形的三条边长必须大于零。
任意两边之和必须大于第三边。
请用程序实现
用函数判断三个数字能否构成三角形，并将判断结果返回。

函数定义
def is_triangle (a, b, c):
pass

参数说明
a, b, c均为整数。

返回值说明
三角形三边长必须大于零，不满足则返回数字-1，表示数据不合法；
任意两边之和必须大于第三边：
不满足则返回数字0，表示不能组成三角形；
满足则返回数字1，表示能组成三角形。

def is_triangle (a,b,c):
    if a>0 and b>0 and c>0:
        if (a+b)>c and (a+c)>b and (b+c)>a:
            return 1
        else:
            return 0
    else:
        return -1

5.3 转换秒为时间

1 天有 86400 秒，那么 100000 秒相当于多长时间呢？

请用程序实现
用函数实现，将一个指定的秒数转换为[天, 时, 分, 秒]的数据格式，并将其返回。

函数定义
def convert_from_seconds (seconds):
pass

参数说明
seconds是一个整数，表示待转换的秒数。

返回值说明
函数返回一个列表，列表内存储的值分别为[天, 时, 分, 秒]，且0 ≤ 秒 ≤ 59，0 ≤ 分 ≤ 59，0 ≤ 时 ≤ 23，天 ≥ 0。

# 定义一个 convert_from_seconds 函数, 参数 seconds, 返回表示时间的列表
def convert_from_seconds(seconds):
    tian,shi,fen,miao=0,0,0,0
    if seconds<86400:
        if seconds<3600:
            if seconds<60:
                miao=seconds
            else:
                miao=seconds%60
                fen=seconds//60
        else:
            shi=seconds//3600
            fen=(seconds-3600*shi)//60
            miao=(seconds-3600*shi-60*fen)
    else:
        tian=seconds//86400
        shi=(seconds-tian*86400)//3600
        fen=(seconds-tian*86400-shi*3600)//60
        miao=(seconds-tian*86400-shi*3600-fen*60)
    return [tian,shi,fen,miao]
print(convert_from_seconds(100000))

5.4 最大公约数

请用程序实现
用函数计算两个整数的最大公约数，并将计算结果返回。

函数定义
def common_divisor (num1, num2):
pass

参数说明
num1, num2均为正整数。

返回值说明
返回值为整数，且为num1和num2的最大公约数。

# 定义并实现函数 common_divisor
def common_divisor(a,b):
    max=a if a>b else b
    min=b if a>b else a
    if max%min==0:
        return min
    else:
        return common_divisor(min, max-min*(max//min))
# 调用函数
result = common_divisor(24, 16)
print(result)

5.5 简单计算器实现

请用程序实现
用函数实现 加、减、乘、除 的运算。

函数定义
#加法函数
def addition (num1, num2):
pass

#减法函数
def subtraction (num1, num2):
pass

#乘法函数
def multiplication (num1, num2):
pass

#除法函数
def division (num1, num2):
pass

参数说明
num1,num2均为整数，表示需要进行计算的两个数字。

返回值说明
四个函数的返回值，均为执行对应操作后计算出来的值。

这里使用加法函数做演示：

# 定义加法函数 addition
def addition (num1, num2):
    return num1 + num2
# 定义减法函数 subtraction
def subtraction (num1, num2):
    return num1 - num2
# 定义乘法函数 multiplication
def multiplication (num1, num2):
    return num1 *  num2
# 定义除法函数 division
def division (num1, num2):
    return num1 / num2

5.6 杨辉三角

杨辉三角，又称贾宪三角形、帕斯卡三角形，是二项式系数在三角形中的一种几何排列。以下是杨辉三角的前十行：

由上可以看出:

每行端点与结尾的数为 1
每个数等于它上方两数之和
每行数字左右对称，且由 1 开始逐渐变大
第 n 行的数字有 n 项
请用程序实现
用函数实现，返回一个指定行数的杨辉三角数列。

函数定义
def pascal_triangle (num):
pass

参数说明
num是一个整数，表示需要输出的行数。

返回值说明
函数返回一个列表，列表内存储的值为杨辉三角某一行的数据。

# 定义函数 pascal_triangle 接受参数 num，并返回杨辉三角第 num 行
def pascal_triangle(num):
    if num==0:
        return 
    if num==1:
        return[1]
    if num==2:
        return [1,1]
    num -= 2
    rList = [[1],[1,1]]
    while num>0:
        newList = [1]
        for i in range(len(rList[-1])-1):
            newList.append(rList[-1][i]+rList[-1][i+1])
        newList.append(1)
        num -= 1
        rList.append(newList)
    return newList
print(pascal_triangle(3))

5.7 七段数码管绘制

七段数码管是一种展示数字的有效方式。

请用程序绘制当前系统时间对应的七段数码管，效果如下：

要求如下：‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(1) 使用 time 库获得系统当前时间，格式如下：20190411‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(2) 绘制对应的七段数码管‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(3) 数码管风格不限‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

import turtle,time
def drawGap():
    turtle.penup()
    turtle.fd(5)
def drawLine(draw):
    drawGap()
    turtle.pendown()if draw else turtle.penup() 
    turtle.pendown()
    turtle.fd(40)
    drawGap()
    turtle.right(90)
def drawDigit(digit):
    drawLine(True) if digit in [2,3,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1,3,4,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,3,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,6,8] else drawLine(False)
    turtle.left(90)
    drawLine(True) if digit in [0,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,3,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1,2,3,4,7,8,9] else drawLine(False)
    turtle.left(180)
    turtle.penup()
    turtle.fd(20)
def drawDate(date):
    turtle.pencolor("red")
    for i in date:
        if i=='-':
            turtle.write('年',font=("Arial",18,"normal"))
            turtle.pencolor("green")
            turtle.fd(40)
        elif i=='=':
            turtle.write('月',font=("Arial",18,"normal"))
            turtle.pencolor("blue")
            turtle.fd(40)
        elif i=='+':
            turtle.write('日',font=("Arial",18,"normal"))
        else:
            drawDigit(eval(i))
def main():
    turtle.setup(800,350,200,200)
    turtle.penup()
    turtle.fd(-300)
    turtle.pensize(5)
    drawDate(time.strftime('%Y-%m=%d+',time.gmtime()))
    turtle.hideturtle()
    turtle.done()
main()
        

5.8 斐波那契数列计算

形如1，1，2，3，5，8…的数列，被称之为斐波那契数列。这个数列的特点是从第三个数字开始，每个数字都等于前两个数字之和。

请用程序实现
用函数实现，计算斐波那契数列某项的值，并将计算结果返回。

函数定义
def fbi (num):
pass

参数说明
num是一个整数，表示斐波那契数列的项数。

返回值说明
函数返回一个整数，该整数为斐波那契数列第 num 项的值。

# 定义一个 fbi 函数，参数 num，返回斐波那契数列第 num 项的值。
def fbi(n):
    assert n >= 0
    if n <= 1:
        return n
    return fbi(n-1) + fbi(n-2)
print(fbi(2))

5.9 汉诺塔实践

请用程序实现
用函数实现汉诺塔的移动步骤拆解。

函数定义
def hanoi (n, src, dst, mid):
pass

参数说明
n是整数，表示圆柱 A 上面的圆盘个数。
src是大写字母A，表示最左边的圆柱。
dst是大写字母C，表示最右边的圆柱。
mid是大写字母B，表示中间的圆柱。

返回值说明
此函数没有返回值，调用函数后函数输出圆盘移动的步骤。

# 请在...补充一行或多行代码
count = 0

def hanoi (n, src, dst, mid):
    global count
    if n == 1:
        print("{}: {}->{}".format(1, src, dst))
        count += 1
    else:
        ...

hanoi(3, "A", "C", "B")
print(count)

5.10 科赫雪花小包裹
科赫曲线，也叫雪花曲线。绘制科赫曲线。


请补充编程模板中代码，完成功能：获得用户输入的整数level，作为阶，绘制level阶科赫曲线。

# 请在...补充一行或多行代码

import turtle
def koch(size, n):
    ...

def main(level):
    turtle.setup(600,600)
    turtle.penup()
    turtle.goto(-200, 100)
    turtle.pendown()
    turtle.pensize(2)
    ...
    
try:
    level = eval(input("请输入科赫曲线的阶: "))
    main(level)
except:
    print("输入错误")

5.11 合法的用户名

有一些网站注册用户时，会对用户名长度进行限制，比如用户名的长度必须在6(含)~18(含)位之间。

请用程序实现
用函数实现对用户名的合法性进行检查。

函数定义
def check_username (username):
pass

参数说明
username是一个任意长度的字符串，表示待检查的用户名。

返回值说明
如果用户名长度在6(含)~18(含)，则用户名有效，返回True；否则返回False。

"""
实现 check_username 函数，检查 username 是否有效
username 长度在 6-18 位之间，返回 True，否则返回 False
"""
def check_username(username):
    if len(username)>=6 and len(username)<=18:
        return True
    else:
        return False
str=input("")
print(check_username(str))

5.12 密码的强度

密码是账户的重要安全保障，涉及到安全问题，太简单的密码容易被猜到或破解。

请用程序实现
用函数实现一个校验密码强度的函数，用于提醒用户在注册时，密码是否足够安全。

以下为密码强度校验规则：

密码长度在 6 位及以上，强度 +1，在 8 位及以上，强度 +2，12 位及以上，强度 +4
有大写字母，强度 +2
除字母外，还包含数字，强度 +2
有除字母、数字以外字符强度 +2

函数定义
def passworld_strength (pwd):
pass

参数说明
pwd是一个字符串，表示需要检查的密码。

返回值说明
函数返回一个整数，表示密码强度。

"""
实现密码强度计算函数:
1. 实现函数 passworld_strength 返回 0-10 的数值，表示强度，数值越高，密码强度越强
2. 密码长度在 6 位及以上，强度 +1，
   在 8 位及以上，强度 +2，
   在 12 位及以上，强度 +4
3. 有大写字母，强度 +2
4. 除字母外，还包含数字，强度 +2
5. 有除字母、数字以外字符，强度 +2
"""
def password_strength(pwd):
    n=0
    if len(pwd)>=6 and len(pwd)<8:
        n=n+1
    elif len(pwd)>=8 and len(pwd)<12:
        n=n+2
    elif len(pwd)>=12:
        n=n+4
    pwdlist=list(pwd)
    for i in range(len(pwd)):
        if pwdlist[i]>='A' and pwdlist[i]<='Z':
            n=n+2
            break
    for i in range(len(pwd)):
        if pwdlist[i]>='0' and pwdlist[i]<='9':
            n=n+2
            break
    for i in range(len(pwd)):
        if ('null'<=pwdlist[i]<'0') or ('9'<pwdlist[i]<='@') or ('Z'<pwdlist[i]<='`') or ('z'<pwdlist[i]<='~'):
            n=n+2
            break
    return n
pwd=input()
print(password_strength(pwd))

5.13 藏头诗

古人经常使用藏头诗，隐晦的表达自己的想说的话，既有诗意，又能传递信息，比如下面这两首诗：

芦花丛中一扁舟，
俊杰俄从此地游。
义士若能知此理，
反躬难逃可无忧。

我画蓝江水，
爱晚亭上枫。
秋月溶溶照，
香烟袅袅绕。
请用程序实现
用函数实现，将藏头诗中隐含的意思找出来。

函数定义
def acrostic (poem):
pass

参数说明
poem是一个列表，其保存了一首诗。

返回值说明
函数返回一个字符串，字符串为藏头诗中隐含的意思。

poem1 = [
    "芦花丛中一扁舟",
    "俊杰俄从此地游",
    "义士若能知此理",
    "反躬难逃可无忧"
]

poem2 = [
    "我画蓝江水",
    "爱晚亭上枫",
    "秋月溶溶照",
    "香烟袅袅绕"
]


def acrostic(poem):
    newstr=[]
    for i in range(len(poem)):
        str1=poem[i]
        rstr=list(str1)
        newstr.append(rstr[0])
    newstr1=''.join(newstr)
    return newstr1


print(acrostic(poem1))
print(acrostic(poem2))

5.14 统计字符出现次数

请用程序实现
用函数实现，统计字符串中指定字符出现的次数。

注意: 禁止使用count()函数。

函数定义
def sum_char (string, char):
pass

参数说明
string是一个字符串，char是一个字符

返回值说明
函数返回一个整数，表示字符 char 在 string 中出现的次数。

"""
统计字符串 string 中出现字符 char 的次数，并返回；
char 是长度为 1 的字符串。
"""
def sum_char(string, char):
    number=0
    for i in string:
        if i == char:
            number=number+1
    return number
sum_char('hello,world','o')

5.15 文件扩展名

文件扩展名是操作系统用来标记文件类型的一种机制。通常来说，一个扩展名是跟在主文件名后面的，由一个分隔符(.)分隔。

请用程序实现
用函数实现，将文件的扩展名获取出来。

函数定义
def file_ext (filename):
pass

参数说明
filename是一个字符串，表示文件名。

返回值说明
如果 filename 有扩展名，则函数返回该 filename 的扩展名，否则返回文件名错误。

"""
获取文件扩展名
说明：实现 file_ext 函数，该函数接受一个表示文件名的字符串参数 filename，返回它的扩展名
"""
def file_ext(filename):
    str1=list(filename)
    for i in range(len(filename)):
        if str1[i]!=".":
            continue
        if str1[i]==".":
            str2=str1[i+1:]
            str3=''.join(str2)
            return str3
            break
        else:
            return "error"  
filename1=input()
print(file_ext(filename1))

6 组合数据类型

6.1 创建水果列表

学校附近新开了一家水果超市，超市老板请你帮忙把水果放到货架上。

这里有一个表示货架的列表fruits，请将以下水果放到列表中：

“苹果”
“草莓”
“香蕉”
“梨”
“百香果”
提示: 定义一个列表，将指定数据存储到列表中即可。

fruits = ["苹果","草莓","香蕉","梨","百香果"]
print(fruits)

6.2 删除水果

由于季节原因，水果超市中有些水果将不再提供。

请将以下水果从fruits列表中删除：

“草莓”
“百香果”
注意: list.remove(obj)方法可以将列表中的指定数据删除。

fruits = ['苹果', '草莓', '香蕉', '梨', '百香果']
fruits.remove('草莓')
fruits.remove('百香果')
print(fruits)

6.3 添加水果

超市新进了一批水果，请你将以下水果添加到列表fruits 中：

“西瓜”
“葡萄”
注意: list.append(obj)方法可以将指定数据添加到列表的末尾。

fruits = ['苹果', '香蕉', '梨']
fruits.append('西瓜')
fruits.append('葡萄')
print(fruits)

6.4 计算总分和平均分

小明刚结束期末考试，他将自己各科的分数保存到了列表scores中，现在，请帮他进行一些计算：

计算总分，并将计算结果保存到变量total_score中
计算平均分，并将计算结果保存到变量avg_score中

# 小明的期末考试成绩分数如下：
scores = [95, 69, 98, 74, 64, 72, 53, 92, 83]

# 请计算小明的总分、平均分，并保存至变量 total_score, avg_score 中
total_score = 0
avg_score = 0
for i in scores:
    total_score = total_score + i
    avg_score = total_score/(len(scores))
print(total_score)
print(avg_score)

6.5 添加用户

这里有一个保存用户账户信息的「字典」，字典的 key 是用户名，value 是明文密码，形式如下：

users = {
“user1”: “password1”,
“user2”: “123456”
}
请编写程序，向用户字典中添加如下账户：

提示: dict[key] = value可以向字典中添加新的键/值对，也可以修改已有的键/值对。

users = {
    "alpha": "alpha123",
    "beta": "betaisverygood",
    "gamma": "1919191923"
}
users["zhangsan"] = "zs123456"
users["lisi"] = "123456"
users["lisi"] = "si123456"
print(users)

6.6 模拟用户登录

这里有一个保存用户账户信息的字典，请用程序模拟系统的登录验证过程。

请用程序实现
用键盘模拟用户输入，判断输入的用户名或密码是否正确，并输出登录信息。

如果输入的用户名存在，且密码正确，则输出success
如果输入的用户名存在，但密码不正确，则输出password error
如果输入的用户名不存在，则输出not found
输入格式
分两行输入，第一行为用户名，第二行为密码。

users = {
    "alpha": "alpha123",
    "beta": "betaisverygood",
    "gamma": "1919191923",
    "zhangsan": "123456",
    "lisi": "123456",
    "admin": "ADMIN",
    "root": "Root123"
}

username = input()
password = input()

# 请在下面编写代码，判断输入的用户名或密码是否正确
key_list=list(users.keys())
value_list=list(users.values())
for i in range(len(key_list)):
    if username == key_list[i]:
        if password == value_list[i]:
            print("success")
        else:
            print("password error")
    if username not in key_list:
        print("not found")

END