阿尔法python习题整理（全）

最新推荐文章于 2022-12-07 15:18:43 发布

装一袋星辰大海

最新推荐文章于 2022-12-07 15:18:43 发布

阅读量7.5k

点赞数 31

文章标签： python 开发语言

本文链接：https://blog.csdn.net/qq_53846367/article/details/125279924

版权

第二章 Python基本语法元素

温度转换

温度的刻画有两个不同体系：摄氏度（Celsius）和华氏度（Fahrenheit）。‬

编程实现：将用户输入的华氏度转换为摄氏度，或将输入的摄氏度转换为华氏度。‬

转换算法如下：（C表示摄氏度、F表示华氏度）‬

C = ( F - 32 ) / 1.8‬
F = C * 1.8 + 32‬

TempStr = input("请输入带有符号的温度值:")
if TempStr[-1] in ['F','f']:
    C = (eval(TempStr[0:-1])-32)/1.8
    print("{:.2f}C".format(C))
    #print("C{:.2f}".format(C))
elif TempStr[-1] in ['C','c']:
    F = 1.8*eval(TempStr[0:-1])+32
    print("{:.2f}F".format(F))
else:
    print("输入格式错误")

注释所有行

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

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

BMI

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

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

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

# 4.将 bmi 打印输出
print(bmi)

汇率兑换程序

人民币和美元是世界上通用的两种货币之一，按照温度转换程序的设计思路，以1 美元 = 7 人民币的汇率编写一个美元和人民币的双向兑换程序。

要求如下：

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

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

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

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

TempStr=input("请输入带字符的金额")
if TempStr[0:3] in 'RMB':
    #D = int(eval(TempStr[0:-1])/6)
    a = float(TempStr[3:])
    a = a/7
    print("USD%.2f" % a)
elif TempStr[0:3] in 'USD':
    #R = int(eval(TempStr[0:-1])*6)
    r = float(TempStr[3:])
    r = r*7
    print("RMB%.2f" % r)
else:
    print("输入格式错误")

冰墩墩

import turtle

turtle.title('BingDunDun（阿尔法编程）')

turtle.speed(10)  # 速度
#左手
turtle.penup()
turtle.goto(177, 112)
turtle.pencolor("lightgray")
turtle.pensize(3)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(80)
turtle.circle(-45, 200)
turtle.circle(-300, 23)
turtle.end_fill()

# 左手内

turtle.penup()
turtle.goto(182, 95)
turtle.pencolor("black")
turtle.pensize(1)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.setheading(95)
turtle.pendown()
turtle.circle(-37, 160)
turtle.circle(-20, 50)
turtle.circle(-200, 30)
turtle.end_fill()

# 轮廓

# 头顶

turtle.penup()
turtle.goto(-73, 230)
turtle.pencolor("lightgray")
turtle.pensize(3)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(20)
turtle.circle(-250, 35)

# 左耳

turtle.setheading(50)
turtle.circle(-42, 180)

# 左侧

turtle.setheading(-50)
turtle.circle(-190, 30)
turtle.circle(-320, 45)

# 左腿

turtle.circle(120, 30)
turtle.circle(200, 12)
turtle.circle(-18, 85)
turtle.circle(-180, 23)
turtle.circle(-20, 110)
turtle.circle(15, 115)
turtle.circle(100, 12)

# 右腿

turtle.circle(15, 120)
turtle.circle(-15, 110)
turtle.circle(-150, 30)
turtle.circle(-15, 70)
turtle.circle(-150, 10)
turtle.circle(200, 35)
turtle.circle(-150, 20)

# 右手

turtle.setheading(-120)
turtle.circle(50, 30)
turtle.circle(-35, 200)
turtle.circle(-300, 23)

# 右侧

turtle.setheading(86)
turtle.circle(-300, 26)

# 右耳

turtle.setheading(122)
turtle.circle(-53, 160)
turtle.end_fill()

# 右耳内

turtle.penup()
turtle.goto(-130, 180)
turtle.pencolor("black")
turtle.pensize(1)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(120)
turtle.circle(-28, 160)
turtle.setheading(210)
turtle.circle(150, 20)
turtle.end_fill()

# 左耳内

turtle.penup()
turtle.goto(90, 230)
turtle.setheading(40)
turtle.begin_fill()
turtle.pendown()
turtle.circle(-30, 170)
turtle.setheading(125)
turtle.circle(150, 23)
turtle.end_fill()

# 右手内

turtle.penup()
turtle.goto(-180, -55)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.setheading(-120)
turtle.pendown()
turtle.circle(50, 30)
turtle.circle(-27, 200)
turtle.circle(-300, 20)
turtle.setheading(-90)
turtle.circle(300, 14)
turtle.end_fill()

# 左腿内

turtle.penup()
turtle.goto(108, -168)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(-115)
turtle.circle(110, 15)
turtle.circle(200, 10)
turtle.circle(-18, 80)
turtle.circle(-180, 13)
turtle.circle(-20, 90)
turtle.circle(15, 60)
turtle.setheading(42)
turtle.circle(-200, 29)
turtle.end_fill()

# 右腿内

turtle.penup()
turtle.goto(-38, -210)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(-155)
turtle.circle(15, 100)
turtle.circle(-10, 110)
turtle.circle(-100, 30)
turtle.circle(-15, 65)
turtle.circle(-100, 10)
turtle.circle(200, 15)
turtle.setheading(-14)
turtle.circle(-200, 27)
turtle.end_fill()

# 右眼

# 眼圈

turtle.penup()
turtle.goto(-64, 120)
turtle.begin_fill()
turtle.pendown()
turtle.setheading(40)
turtle.circle(-35, 152)
turtle.circle(-100, 50)
turtle.circle(-35, 130)
turtle.circle(-100, 50)
turtle.end_fill()

# 眼珠

turtle.penup()
turtle.goto(-47, 55)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(25, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(-45, 62)
turtle.pencolor("darkslategray")
turtle.fillcolor("darkslategray")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(19, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(-45, 68)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(10, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(-47, 86)
turtle.pencolor("white")
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(5, 360)
turtle.end_fill()

# 左眼

# 眼圈

turtle.penup()
turtle.goto(51, 82)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(120)
turtle.circle(-32, 152)
turtle.circle(-100, 55)
turtle.circle(-25, 120)
turtle.circle(-120, 45)
turtle.end_fill()

# 眼珠

turtle.penup()
turtle.goto(79, 60)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(24, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(79, 64)
turtle.pencolor("darkslategray")
turtle.fillcolor("darkslategray")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(19, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(79, 70)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(10, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(79, 88)
turtle.pencolor("white")
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(5, 360)
turtle.end_fill()

# 鼻子

turtle.penup()
turtle.goto(37, 80)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.circle(-8, 130)
turtle.circle(-22, 100)
turtle.circle(-8, 130)
turtle.end_fill()

# 嘴

turtle.penup()
turtle.goto(-15, 48)
turtle.setheading(-36)
turtle.begin_fill()
turtle.pendown()
turtle.circle(60, 70)
turtle.setheading(-132)
turtle.circle(-45, 100)
turtle.end_fill()

# 彩虹圈

turtle.penup()
turtle.goto(-135, 120)
turtle.pensize(5)
turtle.pencolor("cyan")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-165, 150)
turtle.circle(-130, 78)
turtle.circle(-250, 30)
turtle.circle(-138, 105)
turtle.penup()
turtle.goto(-131, 116)
turtle.pencolor("slateblue")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-160, 144)
turtle.circle(-120, 78)
turtle.circle(-242, 30)
turtle.circle(-135, 105)
turtle.penup()
turtle.goto(-127, 112)
turtle.pencolor("orangered")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-155, 136)
turtle.circle(-116, 86)
turtle.circle(-220, 30)
turtle.circle(-134, 103)
turtle.penup()
turtle.goto(-123, 108)
turtle.pencolor("gold")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-150, 136)
turtle.circle(-104, 86)
turtle.circle(-220, 30)
turtle.circle(-126, 102)
turtle.penup()
turtle.goto(-120, 104)
turtle.pencolor("greenyellow")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-145, 136)
turtle.circle(-90, 83)
turtle.circle(-220, 30)
turtle.circle(-120, 100)
turtle.penup()

# 爱心

turtle.penup()
turtle.goto(220, 115)
turtle.pencolor("brown")
turtle.pensize(1)
turtle.fillcolor("brown")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(36)
turtle.circle(-8, 180)
turtle.circle(-60, 24)
turtle.setheading(110)
turtle.circle(-60, 24)
turtle.circle(-8, 180)
turtle.end_fill()

# 五环

turtle.penup()
turtle.goto(-5, -170)
turtle.pendown()
turtle.pencolor("blue")
turtle.circle(6)
turtle.penup()
turtle.goto(10, -170)
turtle.pendown()
turtle.pencolor("black")
turtle.circle(6)
turtle.penup()
turtle.goto(25, -170)
turtle.pendown()
turtle.pencolor("brown")
turtle.circle(6)
turtle.penup()
turtle.goto(2, -175)
turtle.pendown()
turtle.pencolor("lightgoldenrod")
turtle.circle(6)
turtle.penup()
turtle.goto(16, -175)
turtle.pendown()
turtle.pencolor("green")
turtle.circle(6)
turtle.penup()

turtle.pencolor("black")
turtle.goto(-16, -160)
turtle.write("BEIJING 2022", font=('Arial', 10, 'bold italic'))
turtle.hideturtle()

turtle.done()

求圆面积周长

输入圆的半径r，计算圆的面积(area)和周长(circumference)。

注意: 所有数保留两位小数。π 取值 3.14。方法为：print("%.2f" % a)。

#请使用 input() 输入圆的半径 r

r = float(input("请输入半径："))

#请计算圆的面积和周长，并将计算结果输出
area=3.14*r*r;
circumference=3.14*2*r;
print("面积:%.2f" %area);
print("周长:%.2f" %circumference);

同切圆绘制

import turtle
turtle.pensize(2)
turtle.circle(8)
turtle.circle(32)
turtle.circle(64)
turtle.circle(100)

五角星绘制

from turtle import *

fillcolor("red")
begin_fill()
while True:
    forward(150)
    right(144)
    if distance(0, 0) < 1:
        break
end_fill()
done()

温度转换

温度的刻画有两个不同体系：摄氏度（Celsius）和华氏度（Fahrenheit）。‬

编程实现：将用户输入的华氏度转换为摄氏度，或将输入的摄氏度转换为华氏度。‬

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

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

打印数据类型

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

交换变量值

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

# 请不要修改源代码最上面2行

# 请在下面交换 num1, num2 两个变量的值

num1,num2=num2,num1

计算器

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

输入身高体重并计算BMI

# 请使用 input 获取键盘输入
height=float(input('请输入年龄:'))
# 请使用 input 获取键盘输入
weight=float(input('请输入体重:'))
bmi = weight / (height ** 2)
print(bmi)

Hello World的条件输出

请用程序实现

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

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

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

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

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

# 请使用 input() 输入一个整数 num
num=int(input())
# 请对num进行判断
if num==0:
    print("Hello World")
elif num>0:
    print("He\nll\no \nWo\nrl\nd")
else:
    print("H\ne\nl\nl\no\n \nW\no\nr\nl\nd")

第三章基本图形绘制

绘制玫瑰花

import turtle

turtle.setup(350, 600)

alpha = turtle.Turtle()
alpha.penup()
alpha.left(90)
alpha.fd(200)
alpha.pendown()
alpha.right(90)

alpha.fillcolor("red")
alpha.begin_fill()
alpha.circle(10, 180)
alpha.circle(25, 110)
alpha.left(50)
alpha.circle(60, 45)
alpha.circle(20, 170)
alpha.right(24)
alpha.fd(30)
alpha.left(10)
alpha.circle(30, 110)
alpha.fd(20)
alpha.left(40)
alpha.circle(90, 70)
alpha.circle(30, 150)
alpha.right(30)
alpha.fd(15)
alpha.circle(80, 90)
alpha.left(15)
alpha.fd(45)
alpha.right(165)
alpha.fd(20)
alpha.left(155)
alpha.circle(150, 80)
alpha.left(50)
alpha.circle(150, 90)
alpha.end_fill()

alpha.left(150)
alpha.circle(-90, 70)
alpha.left(20)
alpha.circle(75, 105)
alpha.setheading(60)
alpha.circle(80, 98)
alpha.circle(-90, 40)

alpha.left(180)
alpha.circle(90, 40)
alpha.circle(-80, 98)
alpha.setheading(-83)

alpha.fd(30)
alpha.left(90)
alpha.fd(25)
alpha.left(45)
alpha.fillcolor("green")
alpha.begin_fill()
alpha.circle(-80, 90)
alpha.right(90)
alpha.circle(-80, 90)
alpha.end_fill()

alpha.right(135)
alpha.fd(60)
alpha.left(180)
alpha.fd(85)
alpha.left(90)
alpha.fd(80)

alpha.right(90)
alpha.right(45)
alpha.fillcolor("green")
alpha.begin_fill()
alpha.circle(80, 90)
alpha.left(90)
alpha.circle(80, 90)
alpha.end_fill()

alpha.left(135)
alpha.fd(60)
alpha.left(180)
alpha.fd(60)
alpha.right(90)
alpha.circle(200, 60)

蟒蛇绘制

import turtle
turtle.setup(650,350,200,200)
turtle.penup()
turtle.fd(-250)
turtle.pendown()
turtle.pensize(20)
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.done()

正方型绘制

import turtle

alpha = turtle.Turtle()
alpha.color('red')
alpha.forward(100)
alpha.left(90)
# 完善代码，画一个正方形。
alpha.forward(100)
alpha.left(90)
alpha.forward(100)
alpha.left(90)
alpha.forward(100)
alpha.left(90)

八边形

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

八角形

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

叠边形

import turtle as t
t.pensize(2)
for i in range(9):
    f.td(150)
    t.left(80)

使用循环绘制五角星

import turtle

alpha = turtle.Turtle()

steps = 100

angle1 = (180 * (5 - 2)) / 5
angle2 = 180 - angle1
angle = 2 * angle2

for i in range(5):
    alpha.fd(60)
    alpha.right(angle)

风轮绘制

import turtle as t
t.pensize(3)
for i in range(4):
    t.fd(150)
    t.right(90)
    t.circle(-150,45)
    t.right(90)
    t.fd(150)
    t.right(45)
t.done()
    alpha.right(angle)

第四章基本数据类型

从尾到头

编写程序实现，将数字倒序输出。

输入一个小于 500 的三位整数，将这个整数乘 2 得到一个新的数，将这个新的数从尾到头倒序输出。

# 从键盘输入一个三位数
num = int(input("请输入一个小于500的三位整数"))
# 将其乘 2 后倒序输出
num1 = str(num*2)
i = len(num1)
while(i>0):
    print(num1[i-1],end="")
    i = i-1

抹零

现有小区停车收费规则如下，每小时收 1 元，1 小时内免费，不足一小时按 1 小时算。

# 请输入停车时长
hour = float(input("请输入停车时间:"))

# 请计算需要收取的停车费
if hour<1:
     print("收费0元")
else:
     print("收费{:.0f}元".format(int(hour)))

实现加密器

编程实现：输入一个整数num，将输入的数字进行加密，并将加密后的结果输出。

以下为加密的规则：

加密结果 = (整数 * 10 + 5) / 2 + 3.14159
加密结果仍为一整数

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

# 请对数字 num 进行加密，并将加密结果输出
print(int((num*10+5)/2+3.14159)

判断奇偶数

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

公倍数

# 请使用 input() 输入一个正整数 num
num=int(input())
# 请判断这个正整数是否是 5 和 7 的公倍数
if num%5==0 and num%7==0:
   print("yes")
else:
   print("no")

判断平闰年

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

天天向上的力量第一问

计算千分之一的力量。

要求如下：

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

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

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

解1

dayup=pow(1.001,365)
daydown=pow(0.999,365)
print("向上:{:.2f},向下:{:.2f}".format(dayup,daydown))

解2

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

天天向上的力量第二问

计算千分之五和百分之一的力量。

要求如下：

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

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

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

解1

dayfactor=0.005
dayup=pow(1+dayfactor,365)
daydown=pow(1-dayfactor,365)
print("向上:{:.2f},向下:{:.2f}".format(dayup,daydown))

解2

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

天天向上的力量第三问

工作日的力量。

要求如下：

(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))

天天向上的力量第四问

工作日模式要努力到什么水平，才能与每天努力进步 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))

删除字符

删除预置代码中字符串string中的一部分。

要求如下：

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

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

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

string = 'abcdefghijklmnopqrstuvwxyz'

# 请使用 input() 输入索引 begin 和长度 length
begin = int(input("请输入索引开始值："))
length = int(input("请输入长度："))

# 请将字符串 string 中，从索引 begin 开始，长为 length 的字符串删除，并将剩下的字符串内容输出
remain=string[:begin]+string[begin+length:]
print(remain)

插入字符

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

s = 'abcdefghijklmnopqrstuvwxyz'
sub = input("请输入要添加的字符串")
pos = int(input())
str1 = list(s)
str1.insert(pos,sub)
for i in range(len(str1)):
    print(str1[i],end="")

你中无我

给定两个字符串 s1, s2，删除字符串 s1 中的属于 s2 的字符，并输出结果。

str1 = input("请输入第一个字符串")
str2 = input("请输入第二个字符串")
for i in str1:
    if i not in str2:
        print(i,end="")

拼接最大字符

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

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

单词转换

请用程序实现：输入一段英文文本 text，将文本中的单词分别按照全部小写、全部大写和标题化格式输出。

# 请使用 input() 输入一段文本 text
text = input("输入文本")

# 请将文本中的单词分别按照 全部小写、全部大写 和 标题化 格式输出
print("全部小写：",text.lower())
print("全部大写：",text.upper())
print("标题化：",text.title())

统计词量

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

# 请使用 input() 输入一断文本 text
text = input('')

# 请统计这段文本中的单词数量，并将统计结果输出
num = len(text.split())
print(num)

回文字符串

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

str = input("请输入一个字符串")
#逆序形成新的字符串str1
str1 = str[::-1]
if (str == str1):
   print("yes")
else:
   print("no")

过滤敏感字符

请用程序实现：输入一段英文文本 text，将其中出现的敏感词改为***(三个星号)，并将更改后的内容输出。

注意：敏感字符包括 “fuck”、“shit”、“bitch”，其他的暂不考虑。

# 请使用 input() 输入一段英文文本 text
text = input()

# 请将文本中出现的敏感词改为`***`，并将更改后的内容输出
text = text.replace('fuck','***')
text = text.replace('shit','***')
text = text.replace('bitch','***')
print(text)

时间格式化

获取当前时间，并将获取到的时间按照年-月-日时:分:秒的格式打印输出。

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

文本进度条

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,'-'))

第五章程序控制结构

年龄换算

狗是人类的好朋友，一只狗大约可以生存 15 至 20 年，狗狗在 2 岁时，已经成年。为了对狗的年龄有个直观认识，有一个简单的换算办法能将狗的年龄换算为人类的年龄：

狗狗 1 岁时，相当于人类 15 岁，2 岁时相当于人类 24 岁，此后，狗狗每长 1 岁，都相当于人长 4 岁。

请用程序实现：输入狗狗的年龄，计算并输出对应的人类的年龄。

# 请使用 input() 输入狗狗的年龄
age=int(input())
# 计算相对人的岁数，并将结果输出
if age==1:
    print("15")
elif age==2:
    print("24")
else:
    ages=24+(age-2)*4
    print("%d" %ages)

判断平闰年

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

劣：

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

# 请判断这个年份是否为闰年
if year%400==0:
    print("leap year")
else:
    if year%100==0:
        print("common year")
    else:
        if year%4==0:
            print("leap year")
        else:
            print("common 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")

考试评级

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

劣：

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

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

优：

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

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

大小写转换

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

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

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

判断1：

# 请使用 input() 输入一个英文字母 char
char = input()

# 请实现英文字母的大小写转化
if ord(char)>96:
    char = chr(ord(char)-32)
else:
    char = chr(ord(char)+32)
print(char)

判断2：

# 请使用 input() 输入一个英文字母 char
char=input("输入一个英文字母")
if ord(char)>=ord('A') and ord(char)<=ord('Z'):
    print(chr(ord(char)+32))
else:
    print(chr(ord(char)-32))

# 请实现英文字母的大小写转化

判断位数并打印各位的值

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

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

字典：

# 请使用 input() 输入一个不多于五位的正整数 num
num = input()
wei = {
    1: '一',
    2: '二',
    3: '三',
    4: '四',
    5: '五'
}

# 请计算这个正整数的位数，并将每一位的数字都打印出来。
print(wei[len(num)])
for i in range(len(num)):
    print(num[i],end=" ")
    i += 1

if分支：

num=str(input("输入一个数字"))
lens=len(num)
if len(num)==1:
    print("一")
elif len(num)==2:
    print("二")
elif len(num)==3:
    print("三")
elif len(num) == 4:
    print("四")
elif len(num) == 5:
    print("五")
i=0
while i<len(num):
    print(num[i],end=" ")
    i+=1

判断回文数

输入一个五位数，判断它是否是回文数。如果是，输出yes；如果不是，输出no。

解1

num = input()
a = num[:1]
b = num[1:2]
c = num[2:3]
d = num[3:4]
e = num[4:5]
if a==e and b==d:
    print("yes")
else:
    print("no")

解2

str = input("请输入一个字符串")
#逆序形成新的字符串str1
str1 = str[::-1]
if (str == str1):
   print("yes")
else:
   print("no")

地铁车票

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

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

少判断：

# 请使用 input() 输入乘坐的人数 per_num 和站数 sta_num
per_num = int(input())
sta_num = int(input())

# 请判断输入的人数和站数是否正确，计算购买车票的总金额，并将计算结果输出
if per_num <=0 or sta_num <= 0:
    print("error")
elif sta_num<5:
    print(per_num*3)
elif sta_num<10:
    print(per_num*4)
else:
    print(per_num*5)

多判断：

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

判断星期

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

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

字典：

# 请使用 input() 输入单词的前两个字母 chars
chars = input()
pd = {
    'mo': 'monday',
    'tu': 'tuesday',
    'we': 'wednesday',
    'th': 'thursday',
    'fr': 'friday',
    'sa': 'saturday',
    'su': 'sunday',
}   

# 请判断输入的是星期几，并输出对应的单词
if chars in pd.keys():
    print(pd[chars])
else:
    print("error")

if分支：

# 请使用 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")

身体质量指数BMI

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

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

嵌套if：

height = float(input())
weight = float(input())

# 计算bmi值并将判断结果输出
bmi = weight / height**2
print("BMI数值为:%.2f"%bmi)
if bmi<18.5:
    a = b = '偏瘦'
elif bmi<25:
    a = '正常'
    if bmi<24:
        b = a
    else:
        b = '偏胖'
elif bmi<30:
    a = '偏胖'
    if bmi<28:
        b = a
    else:
        b = '肥胖'
else:
    a = b = '肥胖'
print("BMI指标为:国际'%s', 国内'%s'"%(a,b))

多if：

height = float(input())
weight = float(input())
BMI=weight/pow(height,2)
print(f"BMI数值为：{BMI:.2f}")
A='s'
B='s'
if BMI<18.5:
    A=B='偏瘦'
elif 18.5<=BMI<25:
    A='正常'
elif 25<=BMI<30:
    A='偏胖'
elif BMI>=30:
    A='肥胖'
if 18.5<=BMI<24:
    B='正常'
elif 24<=BMI<28:
    B='偏胖'
elif BMI>=28:
    B='肥胖'
print(f"BMI指标为：国际'{A}',国内'{B}'")

乞丐

丐帮帮主去天桥乞讨，并把每天乞讨的钱都存起来。设帮主存款初始为 0，且不使用这笔钱。

第一天乞讨了 1 块钱；第二天乞讨了 2 块钱；第三天乞讨了 4 块钱；第四天乞讨了 8 块钱；以此类推。

# 请使用 input() 输入一个天数 day
day = int(input("请输入一个天数: "))
 
# 计算帮主这些天的总收入，并将每天的总收入输出
for i in range(1,day+1):
    s = 2 ** i - 1
    print(s)

水仙花数

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

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

for循环：

# 请使用 input() 输入一个三位数 num
num = int(input('请输入一个三位数: '))

# 请找出 100 - num(含) 中的所有水仙花数，并将找出的水仙花数输出
for i in range(100,num+1):
    a = int(i/100)
    b = int(i/10)%10
    c = i%10
    if i == c**3+b**3+a**3:
        print(i)

while循环：

# 请使用 input() 输入一个三位数 num
num = int(input('请输入一个三位数: '))
# 请找出 100 - num(含) 中的所有水仙花数，并将找出的水仙花数输出
s=100
while s<=num:
    ge=s%10
    shi=s//10%10
    bai=s//100
    if pow(ge,3)+pow(shi,3)+pow(bai,3)==s:
        print(s)
    s+=1

篮球弹跳

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

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

# 请使用 input() 输入弹跳的次数 num

num=int(input("请输入弹跳的次数： "))
result=10
for i in range(0,num):
    result=result/2
print(result)

# 请计算弹跳 num 次后的篮球高度，并将结果输出

阶乘

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

# 请使用 input() 输入一个正整数 num
num = int(input('请输入正整数: '))
 
# 请计算这个正整数的阶乘，并将计算结果输出
sum = 1
 
if num == 0:
    print("0的阶乘是1")
elif num < 0:
    print("负数没有阶乘")
else:
    for i in range(1,num + 1):
        sum = sum * i
    print(sum)

猴子摘桃

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

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

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

冰雹猜想

输入一个大于1的正整数num; 如果num为偶数, 就将它变为num / 2; 如果num为奇数, 就将它变为3 * num + 1; 直到num为1时停止。并将每一次运算的结果输出。

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

# 编写程序验证冰雹猜想
while num !=1:
    if num%2==0:
            num = num // 2
            print(num)
    else:
            num = 3*num+1
            print(num)

忽略倍数

输入一个整数num，循环打印1(含)~num(含)中的整数，如果是3的倍数或5的倍数，则忽略。

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

# 请打印 1(含) - num(含) 中的整数，如果是 3 的倍数或 5 的倍数，则忽略
for i in range(1,num+1):
    if i%3!=0 and i%5!=0: 
        print(i)

素数

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

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

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

少语句：

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

增加判定：

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

九九乘法表

str输出：

# 请在此处编写你的程序
for i in range(1,10):
    for j in range(1,i+1):
        print(str(j)+'x'+str(i)+'='+str(i*j),end=' ')
    print()

%输出：

# 请在此处编写你的程序
for i in range(1,10):
    for j in range(1,i+1):
        print('%sx%s=%s'%(i,j,i*j),end = " ")
    print()

随机密码生成

‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬以整数 17 为随机数种子，获取用户输入整数 N 为长度，产生 3 个长度为 N 位的密码，密码的每位是一个数字。每个密码单独一行输出。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

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

# 请在...补充代码
import random

def genpwd(length):
    a = 10 ** (length - 1)
    b = 10 ** length - 1
    return "{}".format(random.randint(a,b))
length = eval(input())
#seed() 方法改变随机数生成器的种子，可以在调用其他随机模块函数之前调用此函数。
random.seed(17)
#设置该种子后 每次随机出现的序列都是相同的
for i in range(3):
    print(genpwd(length))

猜数字

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

要求：

随机生成一个 1 - 100 之间的整数。
7 次猜数字的机会，如果没有猜正确，游戏结束。
输入字母 q，则退出游戏。

# 导入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) + '次猜数字')
    # 实现对输入数字的判断
    guess=input("请输入数字：")
    if guess.isdigit():
        guess=int(guess)
        if guess<num:
            print('您输入的数字太小了，您还有'+str(guess_chances-i)+'次机会，请重新输入！')
        elif guess>num:
            print('您输入的数字太大了，您还有'+str(guess_chances-i)+'次机会，请重新输入！')
        elif guess==num:
            print('恭喜您猜对了！')
            break
        elif guess=='q':
            print("退出游戏")
            break
        else:
            print("输入的内容必须为整数")

圆周率的计算

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

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

解1

#调用random函数，并且使用了perf_counter这个函数，是可以用来计时的一部分
from random import random
from time import perf_counter
#定义变量，当作抛洒点的总数量
DARTS = 1000 * 1000
#撒在圆内部点为0
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))
print("运行时间是:{:.5f}s".format(perf_counter() - start))

解2

import random
m = int(input())
# 统计落在圆内点的数量
n = 0
random.seed(123)
for i in range(m):
    # 随机生成-1到1之间的小数
    x = random.uniform(-1,1)
    y = random.uniform(-1,1)
    # 生成的点到圆心之间的距离
    len = pow(x**2+y**2,0.5)
    # 生成的点在圆内
    if len < 1:
        n += 1
#由于圆面积/正方形面积 = π/4 即π等于4*正方形面积 
pi = 4*(n/m)
print("%.6f"%pi)

求π的近似值

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

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

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

解1

e = float(input())
# 请根据 e 计算 pi 的近似值
x=-1
n=2
result=1
while(1/(2*n-3)>=e):
    result = result+x*(1/(2*n-1))
    x=x*(-1)
    n=n+1
count=4*result
print(count)

解2

e = float(input())

# 请根据 e 计算 pi 的近似值
x = 0
n = 1
while True:      #不断循环去找出条件符合的结果
    x = x + pow(-1,n + 1) * (1/(2 * n - 1))   #格雷戈里公式
    if(e > abs(1/(2 * n - 1))):		
        break    #满足条件跳出循环
    else:
        n += 1
print(x*4)

解3

e = float(input())
#请根据e计算pi 的近似值sum = 0
item= 1time = 1
while item >= e:
    item = (1.6 / (2 *time - 1))
    sum += (1 if time % 2 != 0 else -1)*itemtime += 1
pi = sum *4
print(pi)

第六章函数和代码复用

打招呼函数

用函数给某个人打招呼。请调用函数测验函数代码逻辑是否正确，不要获取键盘输入值。

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

能否组成三角形函数

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

三角形的三条边长必须大于零。
任意两边之和必须大于第三边。

用函数判断三个数字能否构成三角形，并将判断结果返回。

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

"""
编写 is_triangle 函数，此函数有 3 个参数，分别为3个数字，
判断这3个数字所代表的边长能否组成一个三角形
"""
def is_triangle(a, b, c):
    """请实现函数"""
    if(a<=0 or b<=0 or c<=0):
        return -1
    else:
        if a+b>c and a+c>b and b+c>a:
            return 1
        else:
            return 0    
# 调用函数验证三边能否组成三角形    
print(is_triangle(3, 4, 5))

计算n个自然数的立方和

编程实现：定义一个函数，其功能是计算 n 个自然数的立方和，如下图所示。

定义函数 sumOfSeries
有 1 个参数 n 表示自然数的个数
有 1 个返回值，返回自然数的立方和
调用函数，使函数执行后在控制台打印：‘和为：xx’

# 定义立方和的函数
def sumOfSeries(num):
    sum = 0
    for i in range(1,num+1):
        sum+= pow(i,3)
    return sum

# 调用函数
print("和为：",sumOfSeries(5))

简单计算器实现

编程题

请用程序实现

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

参数说明

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

print(addition(3, 4))
print(subtraction(3, 4))
print(multiplication(3, 4))
print(division(12, 4))

转换秒为时间

编程题

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

编程实现：完善函数convert_from_seconds，将一个指定的秒数转换为[天, 时, 分, 秒]的数据格式，并将其返回。请调用函数测验函数代码逻辑是否正确，不要获取键盘输入值。

解1

# 定义一个 convert_from_seconds 函数, 参数 seconds, 返回表示时间的列表
def convert_from_seconds (seconds):
    day = seconds // 86400
    hour = seconds % 86400  // 3600
    minutes = seconds// 60 % 60
    s = seconds % 60
    return [day,hour,minutes,s]

解2

#解2
def convert_from_seconds1 (seconds):
    #day,h,m,s
    int(seconds)
    day=seconds//86400
    h=(seconds-day*86400)//3600
    m=(seconds-day*86400-h*3600)//60
    s=(seconds-day*86400-h*3600-m*60)
    return [day,h,m,s]

print(convert_from_seconds(100000))

最大公约数

编程题

编程实现：按下面的要求，输出两个正整数的最大公约数。

定义函数 common_divisor(num1, num2)，该函数返回两个正整数的最大公约数；函数有两个参数，分别对应两个正整数；有1个返回值，代表求得的最大公约数。
接收两个输入值，调用函数 common_divisor，输出最大公约数。

# 定义并实现函数 common_divisor
def common_divisor(num1, num2):
    if num1 % num2 ==0:
        return num2
    else:
        if num1>num2:
            return common_divisor(num2,num1%num2)
        elif num1<num2:
            return common_divisor(num2,num1)

# 获取输入值，调用函数，输出最大公约数
num1=int(input("请输入第一个数"))
num2=int(input("请输入第二个数"))
result = common_divisor(num1, num2)
print(result)

杨辉三角

编程题

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

                  1
                1   1
              1   2   1
            1   3   3   1
          1   4   6   4   1
        1   5   10  10  5   1
      1   6   15  20  15  6   1
    1   7   21  35  35  21  7   1
  1   8   28  56  70  56  28  8   1
1   9   36  84  126 126 84  36  9   1

由上可以看出:

每行端点与结尾的数为 1
每个数等于它上方两数之和
每行数字左右对称，且由 1 开始逐渐变大
第 n 行的数字有 n 项

# 定义函数 pascal_triangle 接受参数 num，并返回杨辉三角第 num 行
def pascal_triangle(num):
    r=[1]
    for i in range(1,num):
        r.insert(0,0)
        for j in range(i):
            r[j] = r[j]+r[j+1]
    return r

# 调用函数
result = pascal_triangle(3)
print(result)

线性查找

编程题

线性查找指按一定的顺序检查列表中每一个元素，直到找到所要寻找的特定值为止示。

编程实现：定义一个函数，其功能是线性查找列表中的元素，如下图所示。请按下面的要求实现。

定义线性查找函数 linear_searching(list,size,target)，接收三个参数要进行查找的列表(list)、列表长度(size)、目标元素(target)，在 list 中查找 target，如果 target 在 list 中则将 target 的位置（索引+1）返回；否则返回数字 -1。
列表元素已给出，接收输入的目标元素值，调用函数 linear_searching，输出查找结果，如果查到，则输出“该元素在第几个位置”；如果未查到，则输出“该元素不在列表

# 定义函数 linear_searching 接受参数 list, size, target，并将查找结果返回
def linear_searching(list,size,target):
    for i in range(size):
        if list[i]==target:
            return i+1
    return -1
        

# 输入目标元素值，调用函数，输出结果
l=[1,2,3,12,-10]
size = len(l)
target = int(input("输入目标元素"))
index = linear_searching(l,size,target)
if index == -1:
    print("该元素不在列表中")
else:
    print("该元素在第{}个位置".format(index))

七段数码管绘制

编程题

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

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

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

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

import turtle

def drawLine (draw):
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    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)
    
def drawDate (date):
    for i in date:
        drawDigit (eval(i))
        
def main ():
    turtle.setup(800,350)
    turtle.penup()
    turtle.fd(-300)
    turtle.pensize(5)
    drawDate('20200609')
    turtle.hideturtle()
    turtle.done()

main()

斐波那契数列计算

编程题

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

请用程序实现

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

函数定义

def fbi (num):
    pass

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

返回值说明

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

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

# 调用函数
print(fbi(20))

汉诺塔实践

编程题

请用程序实现

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

函数定义

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:
        count += 1
        print("{}: {}->{}".format(count, src, dst))
        
    else:
        hanoi(n-1,src,mid,dst)
        count += 1
        print("{}: {}->{}".format(count, src, dst))
       
        hanoi(n-1, mid, dst, src)
hanoi(3, "A", "C", "B")
print(count)

合法的用户名

编程题

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

请用程序实现

用函数实现对注册用户名的合法性进行检查。请调用函数测验函数代码逻辑是否正确，不要获取键盘输入值。

函数定义

def check_username (username):
    pass

参数说明

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

返回值说明

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

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

科赫雪花小包裹

编程题

科赫曲线，也叫雪花曲线。绘制科赫曲线。

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

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

import turtle


def koch(size, n):
    if n==0:
        turtle.fd(size)
    else:
        for angle in [0,60,-120,60]:
            turtle.left(angle)
            koch(size/3,n-1)



def main(level):
    turtle.setup(600, 600)
    turtle.penup()
    turtle.goto(-200, 100)
    turtle.pendown()
    turtle.pensize(2)
    #level=2
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.hideturtle()


try:
    level = eval(input("请输入科赫曲线的阶: "))
    main(level)
except:
    print("输入错误")

密码的强度

编程题

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

请用程序实现

用函数实现一个校验密码强度的函数，用于提醒用户在注册时，密码是否足够安全。请调用函数测验函数代码逻辑是否正确，不要获取键盘输入值。

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

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

"""
实现密码强度计算函数:
1. 实现函数 passworld_strength 返回 0-10 的数值，表示强度，数值越高，密码强度越强
2. 密码长度在 6 位及以上，强度 +1，
   在 8 位及以上，强度 +2，
   在 12 位及以上，强度 +4
3. 有大写字母，强度 +2
4. 除字母外，还包含数字，强度 +2
5. 有除字母、数字以外字符，强度 +2
"""

def password_strength(pwd):
    intensity=0
    if len(pwd)>=12:
        intensity+=4
    elif 8<=len(pwd)<12:
        intensity+=2
    elif 6<=len(pwd)<8:
        intensity+=1
    pwdlist=list(pwd)
    for i in range(len(pwd)):
        if 'A'<=pwdlist[i]<='Z':
            intensity+=2
            break
    for i in range(len(pwd)):
        if 'A'<=pwdlist[i]<='Z' or 'a'<=pwdlist[i]<='z':
            for j in range(len(pwd)):
                if '0'<=pwdlist[j]<='9':
                    intensity+=2
                    break
        break
    for i in range(len(pwd)):
        if ('null'<=pwdlist[i]<'0') or ('9'<pwdlist[i]<='@') or ('Z'<pwdlist[i]<='`') or ('z'<pwdlist[i]<='~'):
            intensity+=2
            break
    return intensity
pwd1=str(input())
print(password_strength(pwd1))

藏头诗

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

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


def acrostic(poems):
    string= ''
    for poem in poems:
        string+=poem[0]
    return string

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

统计指定字符出现次数函数

编程题

用函数实现，统计字符串中指定字符出现的次数。请调用函数测验函数代码逻辑是否正确，不要获取键盘输入值。

解1

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

解2

描述

Python count() 方法用于统计字符串里某个字符或子字符串出现的次数。可选参数为在字符串搜索的开始与结束位置。

语法

count()方法语法：

str.count(sub, start= 0,end=len(string))

参数

sub – 搜索的子字符串
start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end – 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

返回值

该方法返回子字符串在字符串中出现的次数。

str = "hello_world"
char = 'l'
print(str.count(char))

文件扩展名

编程题

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

请用程序实现

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

函数定义

def file_ext (filename):
    pass

参数说明

filename是一个字符串，表示文件名。

返回值说明

如果 filename 有扩展名，则函数返回该 filename 的扩展名，否则返回文件名错误。请调用函数测验函数代码逻辑是否正确，不要获取键盘输入值。

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

插入排序

编程题

插入排序（英语：Insertion Sort）是一种简单直观的排序算法。

它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

定义一个函数，其功能是进行插入排序，如下图所示。请编写函数完成要求。

# 定义函数 insertion_sort 接受参数 list_sort，并返回插入排序结果。
def insertion_sort(list_sort):
    for i in range(len(list_sort)):
        j = i 
        # 和有序表中的每个一样元素进行比较 从最后一个开始
        while j > 0:
            if list_sort[j] < list_sort[j-1]:
                list_sort[j],list_sort[j-1] = list_sort[j-1],list_sort[j]
                j -= 1
            else:
                break
    return list_sort
list_sort = [9,8,8,7,6,5,4,3,2,1]
print(insertion_sort(list_sort))

选择排序

编程题

选择排序（Selection sort）是一种简单直观的排序算法。

它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，

然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

# 定义函数 selection_sort 接受参数 list_sort，并返回选择排序结果。
def selection_sort(list_sort):
    for i in range(len(list_sort)):
        for j in range(i,len(list_sort)):
            if list_sort[i] > list_sort[j]:
                    list_sort[i], list_sort[j] = list_sort[j], list_sort[i]
    return list_sort             
list_sort = [9, 8, 7, 6, 5, 4, 3, 2, 1]
print(selection_sort(list_sort))

冒泡排序

编程题

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

# 定义函数 bubble_sort 接受参数 list_sort，并返回冒泡排序结果
def bubble_sort(list_sort):
    n = len(list_sort)
    for i in range(n):
        for j in range(0,n-i-1):
            if list_sort[j] > list_sort[j+1]:
                    list_sort[j], list_sort[j+1] = list_sort[j+1], list_sort[j]
    return list_sort
sort = [2,4,2,8,4,6,1]
print(bubble_sort(sort))

二分查找

编程题

二分搜索是一种在有序数组中查找某一特定元素的搜索算法。

搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；

如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。

这种搜索算法每一次比较都使搜索范围缩小一半。

定义一个函数，其功能是进行二分查找，如下图所示。请编写函数完成要求。

# 定义函数 binary_search 接受参数 list_sort, size, targer，并将查找结果返回
def binary_search(list_sort, size, targer):
    middle = size//2
    if targer == list_sort[middle]:
        return middle
    elif targer>=list_sort[middle]:
        for i in range(middle,size):
            if targer == list_sort[i]:
                return i
            return -1
    else:
         for i in range(0,middle):
            if targer == list_sort[i]:
                return i
            return -1
              
list_sort =[1,2,3,5,6,7,8]
print(binary_search(list_sort,7,6))

第七章组合数据类型

集合运算

程序中已经存在 manager 集合存储公司所有的经理名字，technician 集合存储所有的技术员的名字。

请编写代码按照下面的要求，生成新的集合。

将既是经理又是技术员的职员保存到集合 set1 中，并输出
将是经理但不是技术员的职员保存到集合 set2 中，并输出
将是技术员但不是经理的职员保存到集合 set3 中，并输出
将身兼一职的职员保存到集合 set4 中，并输出
判断张飞是否是经理，如果是经理，输出「yes」；不是输出「no」
求经理和技术员有几人，并将结果输出

# 将既是经理又是技术员的职员保存到集合 set1 中，并输出
set1 = manager & technician
print(set1)
# 将是经理但不是技术员的职员保存到集合 set2 中，并输出
set2 = manager - technician
print(set2)
# 将是技术员但不是经理的职员保存到集合 set3 中，并输出
set3 = technician - manager
print(set3)
# 将身兼一职的职员保存到集合 set4 中，并输出
set4 = manager ^ technician
print(set4)
# 判断 张飞 是否是经理
set5 = {"张飞"}
if "张飞" in manager:
    print("「yes」")
else:
    print("「no」")
print(set5)
# 求出经理和技术员有几人，并将结果输出
print(len(manager | technician))
# |去除了两个集合之中重复的元素 只保留1个

集合的关系

请通过集合操作符判断集合 set1和set2的子集关系，具体要求如下：

若set1＜set2，则输出set1是set2的子集；
若set1>set2，则输出set1包含set2；
若set1=set2一样，则输出set1和set2互为子集。
否则输出 set1和set2无关

解1

# 创建两个集合
set1 = {2, 3, 4, 5, 6}
set2 = {2, 4, 6}

# 判断两集合关系
if set1 < set2:
    print("set1是set2的子集")
elif set1 > set2:
    print("set1包含set2")
elif set1 == set2:
    print("set1和set2互为子集")
else:
    print("ser1和set2无关")

解2

#issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False。
set1 = {2, 3, 4, 5, 6}
set2 = {2, 4, 6}
if (set1.issubset(set2) and set2.issuperset(set1)) or set1 == set2 == null:
    print('set2是set1的真超集，set1是set2的真子集')
elif set2.issubset(set1) and set1.issuperset(set2):
    print('set1是set2的真超集，set2是set1的真子集')
elif set1 == set2:
    print('set1和set2互为子集')
else:
    print('set1和set2没有关系')

集合综合练习

已知某学校的某次考试成绩分班级保存在集合 score1, score2, score3, score4, score5 中，5个集合都已存在，可直接使用。

请用集合解决以下问题：

突然发现 score1 的数据格式为列表，请将 score1 转换为集合，并将集合 score1 输出
使用 add() 方法将数据 10 添加到集合 score2 中，并将集合 score2 输出
使用 update() 方法将数据 {11, 12, 13} 添加到集合 score3 中，并将集合 score3 输出
使用 remove() 方法将数据 83 从集合 score4 中删除，并将集合 score4 输出
使用 clear() 方法将集合 score5 中的数据清空，并将集合 score5 输出

# 将 score1 转换为集合
score1 = set(score1) 
print(score1)
# 将 10 添加到 score2 中
score2.add(10)
print(score2)
# 将 {11, 12, 13} 添加到 score3 中
score3.update({11,12,13})
print(score3)
# 将 83 从 score4 中删除
score4.remove(83)
print(score4)
# 将 score5 清空
score5.clear()
print(score5)

添加元素方法

add 元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作

update 添加元素，且参数可以是列表，元组，字典等

移除元素方法

**remove **元素 x 从集合 s 中移除，如果元素不存在，则会发生错误

discard 如果元素不存在，不会发生错误

pop 随机删除集合中的一个元素 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

元组元素抓7

请用程序实现：找出元组 tuple_pre 中元素是 7 的倍数或个位为 7 的数，并将计算结果输出。

注意：元组 tuple_pre 已存在，可以直接使用 tuple_pre。

解1

tuple_pre = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30)

# 请计算元组 tuple_pre 中元素是7的倍数及个位为7的数，并将计算结果输出
for i in range(len(tuple_pre)):
    if tuple_pre[i] % 7 == 0 or tuple_pre[i] % 10 == 7:
        print(tuple_pre[i])

解2

tuple_pre = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30)
# 请计算元组 tuple_pre 中元素是7的倍数及个位为7的数，并将计算结果输出
for i in tuple_pre:
    if i % 7 == 0 or i % 10 == 7:
        print(i)

元组解包

“*” 的使用。在对一个元组进行解包时，变量的数量必须和元组中的元素数量一致，也可以在变量前边添加一个 * 号，这样变量将会获取元组中所有剩余的元素。

my_tuple = 10, 20, 30, 40

# 在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致
# 也可以在变量前边添加一个*，这样变量将会获取元组中所有剩余的元素
a, b, *c = my_tuple
print('1. a =', a, 'b =', b, 'c =', c)

a, *b, c = my_tuple
print('2. a =', a, 'b =', b, 'c =', c)

*a, b, c = my_tuple
print('3. a =', a, 'b =', b, 'c =', c)

a, b, *c = [1, 2, 3, 4, 5, 6, 7]
print('4. a =', a, 'b =', b, 'c =', c)

a, b, *c = 'hello world'
print('5. a =', a, 'b =', b, 'c =', c)

# 不能同时出现两个或以上的*变量
# *a , *b , c = my_tuple

升序降序

编写程序，将列表中的前10个元素升序排列，后10个元素降序排列，并输出结果。

解1

# 打印输出 list_pre
print(list_pre)
# 请对上面列表中的元素进行排序
list_pre[:10] = sorted(list_pre[:10])
list_pre[10:] = sorted(list_pre[10:],reverse=True)
print(list_pre)

解2

# 打印输出 list_pre
print(list_pre)
# 请对上面列表中的元素进行排序
list1 = list_pre[0:10]
list1.sort()
list2 = list_pre[-10:]
list2.sort(reverse=True)
print(list1+list2)

截取部分元素

将列表list_pre中的部分元素截取到列表list_new中。

在两行中分别输入两个非负整数，表示需要截取的索引段，且第一个数小于第二个数。

list_pre = [23, 7, 54, 53, 36, 42, 2, 24, 76, 70, 18, 35, 44, 1, 9, 6, 8, 75, 49]

# 请使用 input() 输入两个正整数 begin, end
begin = int(input('请输入第一个索引: '))
end = int(input('请输入第二个索引: '))

# 将列表 list_pre 中下标从 begin(含) 到 end(含) 的元素截取到列表 list_new 中，并将 list_new 输出
list_new = list_pre[begin:end+1]
print(list_new)

判断元素是否在列表中存在

请用程序实现：判断指定元素是否存在于列表 list_test 中。

注意：要求分别用 for 循环与 in 关键字完成练习，列表 list_test 已存在，可以直接使用 list_test。

# 打印输出 list_test
print(list_test)
 
# 使用for循环判断元素 4 是否存在于 list_test 列表中
 
print("查看 4 是否在列表中 ( 使用循环 ) : ") 
  
for i in list_test: 
    if(i == 4) : 
        print ("存在") 
        
# 使用in关键字判断元素 4 是否存在于 list_test 列表中
 
print("查看 4 是否在列表中 ( 使用 in 关键字 ) : ") 
 
if 4 in list_test: 
    print ("存在")

头尾对调

请用程序实现：将列表 list_ht 中的头尾两个元素对调，并将对调的结果输出。

# 打印输出 list_ht
print(list_ht)

# 将列表 list_ht 中的头尾两个元素对调，并将对调的结果输出
list_ht[0],list_ht[-1] = list_ht[-1],list_ht[0]
print(list_ht)

翻转列表

请用程序实现，将列表 list_reverse 翻转，并将翻转后的列表输出。

# 打印输出 list_reverse
print(list_reverse)

# 将列表翻转
list_reverse.reverse()
print(list_reverse)

指定元素对调

请用程序实现，将列表list_swap 中所指定的元素对调到列表的尾部，并输出对调后的列表，如下图所示。

# 打印输出 list_swap
print(list_swap)

# 将列表 list_swap 中的第1、2个元素对调到列表的尾部
for i in range(2):
    temp = list_swap[0]
    for i in range(6):
        list_swap[i] = list_swap[i + 1]
    list_swap[6] = temp
print(list_swap)

约瑟夫生者死者小游戏

编程题

一条船上有 num 个人(num为偶数)，超载了，需要一半的人下船。于是人们排成一排，排队的位置即为他们的编号。他们从头开始从 1 开始报数，数到某个数字的人下船，并且下一个人又从 1 开始报数，如此循环，直到船上只有原来一半人为止。

请用程序实现：输入表示船上总人数的偶数 num 和需要下船的特殊数字 special_num，输出下船人的编号。

num = int(eval(input("请输入船上的总人数:")))
special_num = int(eval(input("请输入需要下船的特殊数字:")))
people = []
for i in range(1,num+1):
    people.append(i)
longth= int(num/2)
repo = 1
while(len(people)>longth):
    if repo != special_num:
        pp = people.pop(0)
        people.append(pp)
    else:
        pp = people.pop(0)
        print(pp)
        repo = 0
    repo = repo + 1

计算列表元素之和

已存在定义好的列表list_sum，请计算列表list_sum中的所有元素之和，并将计算结果输出。

# 请计算列表 list_sum 中的所有元素之和，并将计算结果输出
sum = 0
for i in list_sum:
    sum = sum+i
print(sum)

计算总分和平均分

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

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

# 小明的期末考试成绩分数如下：

scores = [95, 69, 98, 74, 64, 72, 53, 92, 83]

# 请计算小明的总分、平均分，并保存至变量 total_score, avg_score 中

total_score=0
for i in scores:
    total_score += i
avg_score = total_score/9
print(total_score)
print(avg_score)

添加用户

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

模拟用户登录

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

如果输入的用户名存在，且密码正确，则输出success
如果输入的用户名存在，但密码不正确，则输出password error
如果输入的用户名不存在，则输出not found

users = {
    "alpha": "alpha123",
    "beta": "betaisverygood",
    "gamma": "1919191923",
    "zhangsan": "123456",
    "lisi": "123456",
    "admin": "ADMIN",
    "root": "Root123"
}
 
username = input()
password = input()
 
if username not in users:
    print("not found")
elif users[username] != password:
    print("password error")
else:
    print("success")

第八章文件和数据格式化

读取文件并显示不以 # 开头的所有行

读取当前目录下的 data.txt 文件，显示除了以 # 开头的行以外的所有行

# 读取 data.txt 并将其中非井号（#）开头的行打印到控制台标准输出中
#创建一个空的列表
new = []
#文件以只读方式打开
text = open('data.txt','r')
#从文件读出所有行赋给text列表
contents = text.readlines()
#遍历contents列表
for i in contents:
    #若列表内容开始不为#
    if i.startswith('#') == False:
        #将列表内容添加到new列表中去
        new.append(i)
#关闭文件 释放文件使用授权
text.close()
#将序列中的元素以指定的字符(换行符)连接生成一个新的字符串输出
print('\n'.join(new))

读取文件中的数字并排序输出

已知文本文件 data.txt 中存放了若干数字，每个数字之间以空格分隔。

请编程读取文件中所有的数字，并以从大到小的方式输出到控制台，输出方式为每个数字之间用空格分隔。

"""
编程读取 data.txt 文件
并以从大到小的方式输出到控制台
"""
#以只读方式打开文件
f = open("data.txt", "r", encoding='utf8')
#读入文件内容返回字符串存储在s之中
s = f.read()
#将s进行字符串分割
l = s.split(' ')
#生成器表达式 int函数取整数 每一个x均来自于l字符串
l = [int(x) for x in l]
#排序从小到大
l.sort()
#字符串的反转
l.reverse()
print(' '.join([str(x) for x in l]))

生成器表达式实例

 s=input('请输入4个数,用英文逗号分隔:')
 l=s.split(',')
 l=[int(x) for x in l]
 print('最大值:',max(l),'最小值:',min(l))

统计文件中关键字出现的次数

综合项目

读取当前目录下的 data.txt 文件，请编程统计关键字中国出现的次数，并输出到控制台。

data.txt 内容

['中国\n', '美国\n', '中国人民\n', '日本\n', '中国人']

输出

"""
读取 data.txt 中的内容
统计关键字中国出现的次数，输出至控制台
"""
text = open('data.txt')
s = text.readlines()
k = 0
text.close()

#count()函数：统计在字符串/列表/元组中某个字符出现的次数，可以设置起始位置或结束位置
for i in s:
    k +=i.count("中国")
print(k)

读取文件进行大小写转换

已知文本文件 data.txt 中存放了若干字母，每个字母之间以空格分隔。

请编程读取文件中所有的字母，把其中的大写字母变成小写字母，小写字母变成大写字母，将转化后的字母写到一个新文件result.txt中。

data.txt 内容

a b c D E f z

result.txt 内容

A B C d e F Z

"""
读取 data.txt 中空格分隔的字母列表，
并将字母进行大小写转化，然后输出至 result.txt
"""
a = open("data.txt")
c = a.readlines()
a.close()
g = " ".join(c)  # 将列表转化为字符串
g = g.swapcase() # 将字符串大小写进行转化
print(g)
f = open("result.txt","w")  # 写入文件
f.write(g)
f.close()

对文件内容加密

综合项目

已知文本文件 data.txt 中存放有若干英文字符，每个字符之间以空格分隔，请将该文件中每个英文字母加密后写到一个新文件secret.txt中。

加密规则是：将A变成B，B变成C，…,Y变成Z, Z变成A, a变成b，b变成c，…. y变成z, z变成a,其他字符不变。

data.txt 内容

A B 1 a Y Z

secret.txt

B C 1 b Z A

"""
读取 data.txt 中空格分隔的字符列表，
并将字符按加密规则进行加密，输出至 secret.txt
"""
f = open("data.txt","r")
content = f.read()
newStr = ""
for i in content:
    temp = ord(i)
    if temp in range(65,91):
        #字母是z 返回a 
        if temp == 90:
            char1 = chr(temp-25)
            newStr += char1
        else:
            char2 = chr(temp + 1)
            newStr += char2 
    elif temp in range(97,123):
        if temp ==122:
            char3 = chr(temp-25)
            newStr += char3
        else:
            char4 = chr(temp + 1)
            newStr += char4
    else:
         newStr = newStr + i
f.close()
f2 = open("secret.txt",'w+')
f2.write(newStr)
f2.seek(0)
for line in f2:
    print(line)
f2.close()

文件拷贝

综合项目

已知文本文件 data.txt 中存放了若干内容。

请编程在当前目录下产生一个相同文件的副本data_cp.txt，实现文件的拷贝功能。

"""
编程实现文件拷贝功能
"""
strNew = ''
text = open('data.txt')
content = text.readlines()
for i in content:
    strNew = strNew + i
text.close()
text2 = open('data_cp.txt','w+')
text2.write(strNew)
text2.close()

统计文件行数

已知文本文件 data.txt 中每行包含一段英文。

请编程读取文件中的全部内容，统计行数，并按要求输出至控制台。

"""
请编程读取文件中的全部内容,
统计行数，并按要求输出至控制台。
"""
s = open('data.txt')
context = s.readlines()
k = 0
for i in context:
    k = k+1 
s.close()
print(k)

统计文件中以P开头的总行数

已知文本文件 data.txt 中每行包含一段英文。

请编程读取文件中的全部内容，统计文件中以大写字母P开头的总行数，并按要求输出至控制台。

"""
请编程读取文件中的全部内容,
统计以大写P开头的总行数，并按要求输出至控制台。
"""
s = open('data.txt')
context = s.readlines()
k = 0
for i in context:
    if i.startswith('P'):
          k = k+1 
s.close()
print(k)