文章目录
- 1 Python基本语法元素
- 1.1 第一个程序
- 1.2 打印元旦祝福语
- 1.3 打印欢迎购物
- 1.4 求圆面积周长
- 1.5 同切圆绘制
- 1.6 五角星绘制
- 1.7 温度转换
- 1.8 使用变量
- 1.9 计算BMI
- 1.10 存储MP3信息
- 1.11 打印数据类型
- 1.12 交换变量值
- 1.13 输入身高体重并计算BMI
- 1.14 货币转换
- 1.15 HelloWorld的条件输出
- 1.16 回响
- 1.17 注释所有行
- 1.18 打印实心菱形
- 1.19 存储购物小票
- 1.20 计算平均分
- 1.21 计算器
- 2 Python基本图形绘制
- 3 基本数据类型
- 3.1 判断奇偶数
- 3.2 公倍数
- 3.3 判断平闰年
- 3.4 天天向上的力量第一问
- 3.5 天天向上的力量第二问
- 3.6 天天向上的力量第三问
- 3.7 天天向上的力量第四问
- 3.8 拼接最大字符
- 3.9 删除字符
- 3.10 插入字符
- 3.11 回文字符串
- 3.12 统计词量
- 3.13 你中无我
- 3.14 时间格式化
- 3.15 文本进度条
- 4 程序的控制结构
- 4.1 大小写转换
- 4.2 判断位数并打印各位的值
- 4.3 地铁车票
- 4.4 考试评级
- 4.5 判断星期
- 4.6 身体质量指数BMI
- 4.7 阶乘
- 4.8 水仙花数
- 4.9 猴子摘桃
- 4.10 素数
- 4.11 随机密码生成
- 4.12 圆周率的计算
- 4.13 求pi的近似值
- 4.14 篮球弹跳
- 4.15 猜数字
- 5 函数和代码复用
- 5.1 打招呼函数
- 5.2 能否组成三角形
- 5.3 转换秒为时间
- 5.4 最大公约数
- 5.5 简单计算器实现
- 5.6 杨辉三角
- 5.7 七段数码管绘制
- 5.8 斐波那契数列计算
- 5.9 汉诺塔实践
- 5.11 合法的用户名
- 5.12 密码的强度
- 5.13 藏头诗
- 5.14 统计字符出现次数
- 5.15 文件扩展名
- 6 组合数据类型
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恤的单价(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%,那么工作日应该多努力才能追上A君呢?
请用程序实现
计算要使 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