Python__VPL作业

Python

Python__VPL作业

标签（空格分隔）： Python

输入PM2.5的值，判断是否存在空气污染

题目：输入PM2.5的值，判断是否存在空气污染，如果输入值大于等于75，提醒“存在空气污染”,否则告知用户“可以进行户外运动”
Test Case:------------------------

Case = PM2.5的判断
input = 75
output = /.*空气污染*/
Case = PM2.5的判断
input = 90
output = /.*空气污染*/
Case = PM2.5的判断
input = 74
output = /.*户外运动*/

参考程序：----------------------------

# -*- coding: utf-8 -*-
pm = float(input("请输入PM2.5值:"))
if pm>=75:
    print("存在空气污染")
else:
    print("可进行户外运动")

判断是不是闰年

题目：请输入一个年份，如果是闰年，程序输出Yes,否则输出No
Test Case:------------------------

Case= 闰年判断测试
input = 2000
output = /.*Yes*/i
Case= 闰年判断测试
input = 2001
output = /.*No*/i
Case= 闰年判断测试
input = 1700
output = /.*No*/i
Case= 闰年判断测试
input = 2004
output = /.*Yes*/i

参考程序：----------------------------

# -*- coding: utf-8 -*-
y=int(input("请输入一个年份："))
if(y%4==0 and y%100!=0 or y%400==0):
   print("Yes")
else:
   print("No")

判断3条边能否组成三角形及三角形类别

题目：输入3条边的长度（限整数），判断这3条边能否组成三角形。如果能组成三角形，判断这个三角形是不是等边、等腰、直角三角形
Test Case:------------------------

Case = 三角形测试用例
input = 2
3
4
output = /.*能*/
Case = 三角形测试用例
input = 1
2
3
output = /.*不能*/
Case = 三角形测试用例
input = 3
4
5
output = /.*直角*/
Case = 三角形测试用例
input = 6
6
6
output = /.*等边*/
Case = 三角形测试用例
input = 6
8
8
output = /.*等腰*/

参考程序：----------------------------

# -*- coding: utf-8 -*-
a=int(input("a="))
b=int(input("b="))
c=int(input("c="))
if(a+b>c and b+c>a and c+a>b):
    print("%d,%d,%d能组成三角形"%(a,b,c))
    if(a==b and b==c ):
        print("能组成等边三角形")
    elif(a==b or b==c or a==c):
        print("能组成等腰三角形")
    else:
        print("非等腰、等边三角形")
    if(a*a + b*b == c*c or b*b + c*c == a*a or c*c + a*a ==b*b):
        print("该三角形是直角三角形")
    else:
        print("该三角形是非直角三角形")
else:
    print("%d,%d,%d不能组成三角形"%(a,b,c))

求数列前n项和(循环的应用)

输入一个正整数n，求数列 1 + 1/3 + 1/5 + 1/7 + 1/9 + 1/11 + .....的前n项和

Case= 数列前n项和测试
input = 1
output = /.*[1].[0]{0,}*/
Case= 数列前n项和测试
input = 2
output = /.*[1].[3]{0,}*/
Case= 数列前n项和测试
input = 5
output = /.*[1].[7][0-9]{0,}*/

# -*- coding: utf-8 -*-
n = int(input("n="))
sum = 0.0
i = 1
while i<=n:
    sum += 1.0 / (2*i - 1)
    i = i+1
print("sum=",sum)

输出质数(循环的应用)

输入一个正整数n，输出n以内的所有质数

Case= 质数输出测试
input = 20
output = /.*[2].*[3].*[13].*[19].*/
Case= 质数输出测试
input = 50
output = /.*[2].*[17].*[23].*[43].*[47].*/
Case= 质数输出测试
input = 100
output = /.*[7].*[19].*[41].*[79].*[97].*/
Case= 质数输出测试
input = 10
output = /.*[^(4,6,8,9)].*/

# -*- coding: utf-8 -*-
n = int(input("请输入一个正整数:"))
for m in range(2,n,1):
    IsZhiShu = True
    for i in range(2,m//2+1,1):
        if m%i==0:
            IsZhiShu = False
            break
    if IsZhiShu:
        print("%d\t"%m,end='')

输出字典

输入正整数n，生成包含 （i， i*i）的dict，该dict的keys为 1 到 n所有整数（包含1、在内），然后，输出该字典。
例如，如果输入9,程序的输出应该如下：
n=9
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

Case= 输入n，输出字典
input = 4
output = {1: 1, 2: 4, 3: 9, 4: 16}
Case= 输入n，输出字典
input = 11
output = {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100, 11: 121}

n=int(input("n="))
d=dict()
for i in range(1,n+1):
    d[i]=i*i
print( d )

输出正整数的约数的并集

输入2个大于20的正整数m和n，求出m和n的约数的并集，并输出。
例如，如果输入21和36,程序的运行结果应该如下：
m=21
n=36
{1, 2, 3, 4, 6, 7, 9, 12, 18, 21, 36}

Case= 输入2个正整数，输出它们约数的并集
input = 25
28
output = /.*1,.*2,.*4,.*5,.*7,.*14,.*25,.*28.*/
Case= 输入2个正整数，输出它们约数的并集
input = 21
24
output = /.*1.*21.*24.*/
Case= 输入2个正整数，输出它们约数的并集
input = 24
27
output = /.*3.*/
Case= 输入2个正整数，输出它们约数的并集
input = 23
26
output = /.*2.*/

m=int(input("m="))
n=int(input("n="))
ys_m=set()
ys_n=set()
for i in range(1,m+1):
    if m%i == 0:
        ys_m.add(i)
for i in range(1,n+1):
    if n%i == 0:
        ys_n.add(i)
uset = ys_m | ys_n
print(uset)

输入一个年份，输出其12个月的天数构成的一个tuple

输入一个年份，输出其12个月的天数构成的tuple。

例如：
当你输入一个闰年，比如2000时，程序的运行结果如下图：T1.png
而如果输入的不是闰年，比如2019时，程序的运行结果如下图：T2.png

Case=  输入一个年份，输出其12个月的天数构成的一个tuple
input = 2000
output = (31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
Case=  输入一个年份，输出其12个月的天数构成的一个tuple
input = 2001
output = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
Case=  输入一个年份，输出其12个月的天数构成的一个tuple
input = 1700
output = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
Case=  输入一个年份，输出其12个月的天数构成的一个tuple
input = 2004
output = (31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)

y = int(input("输入一个年份:"))
ls1 = [31,28,31,30,31,30,31,31,30,31,30,31]
if y%400 == 0 or y%4 == 0 and y%100 !=0:
    ls1[1] = 29
t1 = tuple(ls1)
print(t1)

输入扇形的半径r，输出扇形面积构成的list

输入扇形的半径r,输出1个list，这个list的各个元素的值为：从0°开始，到360°结束，圆心角每增加10°，所对应的扇形面积构成的list。π值取3.14，要包含360°在内
例如：
如果输入为10，程序运行结果如下图：T3.png

Case= 输入扇形的半径r，输出扇形面积构成的list 
input = 10
output = /.*\[0.0, .*, 305.*\].*/
Case= 输入扇形的半径r，输出扇形面积构成的list 
input = 10
output = /.*\[0.0, .*, 314.*\].*/
Case= 输入扇形的半径r，输出扇形面积构成的list 
input = 5
output = /.*\[0.0, 2.*, 6.*15.*, .*74.*, 76.*\].*/
Case= 输入扇形的半径r，输出扇形面积构成的list 
input = 5
output = /.*\[0.0, 2.*, 6.*15.*, .*74.*, 76.*, 78.*\].*/

r = int(input("r="))
ls1 = [ ]
for n in range(0,361,10):
    ls1.append((n / 360.0) * 3.14 * r * r)
print(ls1)

输入n，输出字典

输入正整数n，生成包含 （i， i*i）的dict，该dict的keys为 1 到 n所有整数（包含1、在内），然后，输出该字典。
例如，如果输入9,程序的输出应该如下图：ex1.png

Case= 输入n，输出字典
input = 4
output = {1: 1, 2: 4, 3: 9, 4: 16}
Case= 输入n，输出字典
input = 11
output = {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100, 11: 121}

"""
输入正整数n，生成包含 （i， i*i）的dict，该dict的keys为 1 到 n所有整数（包含1、n在内），
然后，输出该字典。
"""
n = int(input("n="))
d1 = {  } 
for i in range(1,n+1):
    d1[i] = i*i
print(d1)

成绩输入合法性检查
输入百分制的成绩，判断输入合法性，若输入合法，则给出对应等级：[90,100]为A等，[80 - 90) 为B等，[70 - 80) 为C等，[60 - 70) 为D等，[0,60)为E等。
使用 try - except 、assert语句进行成绩输入合法性检查，要求输入的成绩必须是 0--100分的数字，如果输入不是数字，提示“输入不是数字”，如果数字超出范围，提示“分数超出范围”

Case= 成绩输入合法性检查
input = 100
output = /.*[Aa].*/
Case= 成绩输入合法性检查
input = 89
output = /.*[Bb].*/
Case= 成绩输入合法性检查
input = 78
output = /.*[Cc].*/
Case= 成绩输入合法性检查
input = 68
output = /.*[Dd].*/
Case= 成绩输入合法性检查
input = 54
output = /.*[Ee].*/
Case= 成绩输入合法性检查
input = 4ab
output = /.*不是.*数字.*/
Case= 成绩输入合法性检查
input = 112
output = /.*超出.*范围.*/
Case= 成绩输入合法性检查
input = -1
output = /.*超出.*/

try:
    g_fen_shu=int(input("请输入百分制成绩:"))
    assert 0<=g_fen_shu<=100
    if g_fen_shu<60:
        print("E")
    elif g_fen_shu<70:
        print("D")
    elif g_fen_shu<80:
        print("C")
    elif g_fen_shu<90:
        print("B")
    elif g_fen_shu<=100:
        print("A")
except ValueError:
    print("输入不是数字")
except AssertionError:
    print("分数超出范围")

用函数方式输出质数

定义一个函数，该函数可以判断传入的值（形参值）是不是质数，然后调用该函数输出m--n之间(包括m、n在内)的所有质数。
1、m、n由用户输入。m>=2,n>=2，若不满足要求，程序提示：“m和n的值必须大于等于2”
2、允许m>n，但是程序要考虑这种情况如何处理。
3、要求程序能对不合法的输入（m或者n不是整数）进行异常的捕获和处理，提示：“输入不是整数”
4、输入语句：
m = int(input("m:"))
n = int(input("n:"))

def is_prime(n):
    prime = True
    for i in range(2,n//2):
        if n % i ==0:
            return False
    return True
try:
    m = int(input("m:"))
    n = int(input("n:"))
    if m>=2 and n>=2:
        step = 1
        end = n+1
        if m>n:
            step = -1
            end = n-1
        for i in range(m,end,step):
            if is_prime(i):
                print(i,end = " ")
    else:
        print("m和n的值必须大于等于2")
except:
    print("输入不是整数!")

闭包应用：手机消费贷款手续费计算

某手机商为了促进销售，提供如下的消费贷款方案：
贷款额度 0 -- 5000元，零利率，但是要收取手续费，手续费收取的金额与贷款期限相关,方案如下
1--3个月：手续费1%，贷款期限每延长一个月，手续费增加千分之五。编写一个程序，输入贷款期限、金额，计算输出手续费。

要求用闭包实现

def DaiKuan(qx):
    fl = 10
    if(qx>4):
        fl = fl + (qx-3)*5
    def ShouXuFei(Jine):
        return Jine*fl/1000
    return ShouXuFei
n = eval(input("请输入贷款期限（个月数）："))
sxf = DaiKuan(n)
je = eval(input("请输入贷款金额："))
print("手续费：%.2f元"%sxf(je))

Case= 闭包应用：手机消费贷款手续费计算
input = 3
100
output = /.*1.00.*/
Case= 闭包应用：手机消费贷款手续费计算
input = 3
100
output = /.*1.*/
Case= 闭包应用：手机消费贷款手续费计算
input = 12
1500
output = /.*82.50.*/
Case= 闭包应用：手机消费贷款手续费计算
input = 12
1500
output = /.*82.*/

高阶函数应用：计算输出多个人全年个人所得税应纳税金额列表

我国个人所得税起征点是5000元，全年应纳税所得额 = 全年收入 - 60000,
个人所得税的税率如下表所示：

输入多个人全年收入列表，使用map( )函数计算输出应纳税金额列表。
参考下图：

图略

实现1：

def grsds(je): #个人上的税
    ynssde = je - 60000 #应纳税所得额
    jt = [(960000,45),(660000,35),(420000,30),(300000,25),(144000,20),(36000,10),(0,3)]
    nse = 0 #纳税额
    for jtz,sl in jt: #阶梯值,税率
        if ynssde>jtz:
            jdynssd = ynssde - jtz #该阶段内的应纳税所得额
            nse = nse + jdynssd * sl/100 #各阶段纳税额累加
            ynssde = jtz #还未计算纳税额的应纳税所得额
    return nse
drsr = list(eval(input("请输入多个人的全年收入列表："))) #多人收入
#print(drsr)
print("以上各人对应的全年个人所得税纳税额为：",list(map(grsds,drsr)))

实现2:

def sds(nsr):
    nsjt    = [960000,660000,420000,300000,144000,36000,0]
    sl      = [45,35,30,25,20,10,3]
    ynssde = nsr - 60000
    nse = 0
    i = 0
    while(ynssde>0):
        jtynssde = 0
        if ynssde > nsjt[i]:
            jtynssde = ynssde - nsjt[i]  #4万 = 100万 - 96万
            ynssde = nsjt[i]    #96万 还未计算所得税
        nse = nse + jtynssde * sl[i]/100
        i += 1
    return nse
srlb = list(eval(input("请输入多个人的全年收入列表:")))
sdslb = list(map(sds,srlb))
print("对应的所得税额是:",sdslb)

Case= 高阶函数应用：计算输出多个人全年个人所得税应纳税金额列表
input = 36000,200000,1000000
output = /.*\[0, 11480.*, 243080.*\].*/
Case= 高阶函数应用：计算输出多个人全年个人所得税应纳税金额列表
input = [36000,200000,1000000]
output = /.*\[0, 11480.*, 243080.*\].*/
Case= 高阶函数应用：计算输出多个人全年个人所得税应纳税金额列表
input = [37000,78000,145000,700000,1000000,2000000]
output = /.*\[0, 540.*, 5980.*, 139080.*, 243080.*, 691080.*\].*/
Case= 高阶函数应用：计算输出多个人全年个人所得税应纳税金额列表
input = 37000,78000,145000,700000,1000000,2000000
output = /.*\[0, 540.*, 5980.*, 139080.*, 243080.*, 691080.*\].*/