python期末考试必考40个基础编程题

        该40个基础编程涉及领域广泛，适合各专业，金融，数学，算法，数据结构，可视化等多个领域，涵盖了pyth基础语法，列表操作，字符串操作，数据类型转换，循环结构，判断结构，函数定义，变量声明，class类编程等基础知识。

        运行代码无需环境配置，只要安装python成功，复制代码即可

1.计算固定资产折旧

amount = 200000
rate = 0.05
accuDep = 178833.3
dep = round(amount*(1 - rate) / 120,2)
for i in range(12):
    if amount - accuDep - dep - amount * rate > 0:
            dep = dep
    else:
            dep = round(amount - accuDep - amount * rate,2)
    print('第',i+1,'个月折旧额为',dep)
    accuDep += dep

2.BMI指数计算

user_weight = float(input("请输入您的体重（单位：kg）："))
user_height = float(input("请输入您的身高（单位：m）："))
user_BMI = user_weight / (user_height) ** 2
print("您的BMI值为：" + str(user_BMI))

if user_BMI <= 18.5:
    print("此BMI值属于偏瘦范围。")
elif 18.5 < user_BMI <= 25:
    print("此BMI值属于正常范围。")
elif 25 < user_BMI <= 30:
    print("此BMI值属于偏胖范围。")
else:
    print("此BMI值属于肥胖范围。")

3.回文数数据判断

palindrome_num = int(input('请输入一个三位数: ')) 
single = palindrome_num % 10
ten = int(palindrome_num /10) % 10
hundred = int(palindrome_num / 100)
reverse_order = single * 100 + ten * 10 + hundred
if palindrome_num == reverse_order:
    print(str(palindrome_num) + '是回文数') 
else:
    print(str(palindrome_num) + '不是回文数')

4.编写程序实现以下功能：对于数值x，如果x在区间(1,2]上，则输出x+2.5；如果x在区间[-1,1]上，则输出4.35x；如果x在区间[-2,-1)上，则输出x；如果x为其他值，则输出“无效值”。

x=eval(input('请输入一个数值：'))
if x>1 and x<=2:
    print(x+2.5)
elif x>=-1 and x<=1:
    print(4.35*x)
elif x>=-2 and x<-1:
    print(x)
else:
    print('无效值')

5.编写程序实现以下功能：判断ax^2+bx+c=0（这里用^表示乘方）是否是一元二次方程，如果是的话再判断是否有两个实根、一个实根或没有实根，并将判断结果输出。

a=eval(input('请输入a的值：'))
b=eval(input('请输入b的值：'))
c=eval(input('请输入c的值：'))
t=b*b-4*a*c
if a==0:
    print('不是一元二次方程')
elif t>0:
    print('有两个实根')
elif t==0:
    print('有一个实根')
else:
    print('无实根')

 6.使用for循环编写程序实现以下功能：计算1!+2!+…+n!。

n=eval(input('请输入一个大于0的整数：'))
sum=0
rlt=1
for i in range(1,n+1):
    rlt*=i
    sum+=rlt
print('结果为：%d'%sum)

6.使用while循环编写程序实现以下功能：把一张100元人民币换成10元、5元、1元面额，将所有可能的换法及换法总数输出。

n,i=0,0
while i<=100//10:
    j=0
    while j<=(100-i*10)//5:
        print('10元%d张，5元%d张，1元%d张'%(i,j,100-i*10-j*5))
        n+=1
        j+=1
    i+=1
print('总共有%d种换法'%n)

7.使用while循环编写程序实现以下功能：输入一个整数，判断其是否是素数，并输出判断结果。

n=eval(input('请输入一个大于1的整数：'))
m=int(n**0.5)
i=2
while i<=m:
    if n%i==0:
        break
    i+=1
if i<=m:
    print('不是素数')
else:
    print('是素数')

8.编写程序实现以下功能：输入若干整数（输入0结束），每个整数输入完毕后，马上输出该整数是否为素数。要求判断一个整数是否为素数的功能用一个函数实现。

def IsPrime(n):
    m=int(n**0.5)
    i=2
    while i<=m:
        if n%i==0:
            print('%d不是素数'%n)
            break
        i+=1
    else:
        print('%d是素数'%n)

while True:
    n=eval(input('请输入一个整数（输入0结束程序）：'))
    if n==0:
        break
    elif n<2:
        print('输入的整数必须大于1，请重新输入！')
        continue
    else:
        IsPrime(n)

9.编写程序实现以下功能：输入若干个整数（输入0结束），将不能被3整除的整数相加，并将求和结果输出。要求判断一个整数n是否能被另一个整数m整除的功能用一个函数实现。

def IsMultiple(n,m):
    if n%m==0:
        return True
    return False
sum=0
while True:
    n=eval(input('请输入一个整数（输入0结束程序）：'))
    if n==0:
        break
    if IsMultiple(n,3)==False:
        sum+=n
print('所有不能被3整除的整数之和为：%d'%sum)

10.请定义一个Circle类，具体要求为：（1）每个Circle类对象可以存储圆心和半径信息；（2）具有设置圆心和半径的方法SetCenter和SetRadius；（3）具有输出圆信息的方法PrintInfo；（4）具有计算圆面积的方法GetArea。

class Circle:
    x,y,r=0,0,1
    def SetCenter(self,x,y):
        self.x=x
        self.y=y
    def SetRadius(self,r):
        self.r=r
    def PrintInfo(self):
        print('圆心：(%f,%f)，半径：%f'%(self.x,self.y,self.r))
    def GetArea(self):
        return 3.14*self.r*self.r
if __name__=='__main__':
    c=Circle()
    c.SetCenter(3.2,5.5)
    c.SetRadius(1.5)
    c.PrintInfo()
    print('面积为：%f'%c.GetArea())

11.请定义一个Time类，具体要求为：（1）每个Time类对象可以存储一个时间（包括时、分、秒）；（2）具有设置当前时间的方法SetTime；（3）具有每次增加1秒的方法AddOneSec；（4）具有输出当前时间的方法PrintTime。

class Time:
    h,m,s=0,0,0
    def SetTime(self,h,m,s):
        self.h=h
        self.m=m
        self.s=s
    def AddOneSec(self):
        self.s+=1
        if self.s==60:
            self.m+=1
            self.s=0
        if self.m==60:
            self.h+=1
            self.m=0
        if self.h==24:
            self.h=0
    def PrintTime(self):
        print('当前时间：%02d:%02d:%02d'%(self.h,self.m,self.s))
if __name__=='__main__':
    t=Time()
    t.SetTime(23,58,59)
    for i in range(100):
        t.PrintTime()
        t.AddOneSec()

12.请定义一个Cylinder类，具体要求为：（1）每个Cylinder类对象可以存储一个圆柱体（包括半径和高）；（2）具有用于初始化半径和高的构造方法；（3）具有输出圆柱体信息的方法PrintInfo；（4）具有计算圆柱体体积的方法GetVolume。

class Cylinder:
    r,h=1,1
    def __init__(self,r,h):
        self.r=r
        self.h=h
    def GetVolume(self):
        return 3.14*self.r*self.r*self.h
    def PrintInfo(self):
        print('半径：%f，高：%f'%(self.r,self.h))
if __name__=='__main__':
    c=Cylinder(3.1,2.5)
    c.PrintInfo()
    print('圆柱体体积为：%f'%c.GetVolume())

13.编写程序实现以下功能：根据指定值从一个列表中查找所有匹配元素的位置，要求使用列表中的index方法进行查找。

def findall(ls,x):
    beg=0
    total=ls.count(x)
    rlt=[]
    for i in range(total):
        pos=ls[beg:].index(x)
        rlt.append(pos+beg)
        beg=pos+beg+1
    return rlt
if __name__=='__main__':
    r=findall([1,3,3,5,2,3,6,3,7,9,3],3)
    print('匹配的元素下标为：',r)

14.编写程序实现以下功能：在字符串s1中检索指定字符串s2，获取所有匹配字符串的起始字符位置，要求使用字符串的find方法进行检索。

def findsubstr(str,sub):
    beg=0
    rlt=[]
    while True:
        pos=str.find(sub,beg)
        if pos==-1:
            break
        rlt.append(pos)
        beg=pos+1
    return rlt
if __name__=='__main__':
    r=findsubstr('cat dog cat dog cat cat dog','cat')
    print('匹配字符串的起始字符下标为：',r)

15.编写程序实现以下功能：利用正则表达式对象的search方法，查找一个字符串中的所有HTML标记（即由一对尖括号<>括起来的内容）。

import re
def findhtmlmarks(str):
    pattern=re.compile(r'<[^<]*>')
    beg=0
    ls=[]
    while True:
        rlt=pattern.search(str,beg)
        if rlt==None:
            break
        ls.append(rlt)
        beg=rlt.end()
    return ls
ls=findhtmlmarks('<body><h1>南开大学</h1></body>')
print(ls)

16.编写程序实现以下功能：在字符串s1中检索指定字符串s2，获取所有匹配字符串的起始字符位置，要求使用字符串的index方法进行检索。

def findsubstr(str,sub):
    beg=0
    rlt=[]
    while True:
        try:
            pos=str.index(sub,beg)
            rlt.append(pos)
            beg=pos+1
        except ValueError:
            break
    return rlt
if __name__=='__main__':
    r=findsubstr('cat dog cat dog cat cat dog','cat')
    print('匹配字符串的起始字符下标为：',r)

17.编写函数，判断一个数字是否为素数，是则返回字符串YES，否则返回字符串NO。

import math
def IsPrime(v):
    n = int(v)+1
    for i in range(2,n):
        if v%i==0:
            return 'No'
    else:
        return 'Yes'
v=5
print(IsPrime(v))

18.编写程序，运行后用户输入4位整数作为年份，判断其是否为闰年。如果年份能被400整除，则为闰年；如果年份能被4整除但不能被100整除也为闰年。

x = input('Please input an integer of 4 digits meaning the year:')
x = eval(x)
if x%400==0 or (x%4==0 and not x%100==0):
    print('Yes')
else:
    print('No')

19.编写程序，实现分段函数计算，如下表所示。

x = input('Please input x:')
x = eval(x)
if x<0 or x>=20:
    print(0)
elif 0<=x<5:
    print(x)
elif 5<=x<10:
    print(3*x-5)
elif 10<=x<20:
    print(x-2)

20.编写一个python程序，输入两个数，比较它们的大小并输出其中较大者。

x = int(input("Please enter first integer: "))
y = int(input("Please enter second integer: "))
if (x == y):
    print("两数相同！")
elif (x > y):
    print("较大数为：",x)
else:    
    print("较大数为：",y)

21.写一个算法（流程图和python程序）：输入三个数，输出其最大者。

a,b,c=3,4,5
if a <= b:
    if c < b:
        print ("b是最大的数")
    else:
        print ("c是最大的数")
else:
    if c < a:
        print ("a是最大的数")
    else:
        print ("c是最大的数")

22.使用Python编程，求1～100间所有偶数的和

sum=0
for x in range(1,101):
   if x % 2==0:
       print(x)
       sum=sum+x
print("累加和是:",sum)

23.用Python编程，假设一年期定期利率为3.25%，计算一下需要过多少年，一万元的一年定期存款连本带息能翻番？

cunkuan = 10000  #本金10000元
years=0
while cunkuan<20000:
       years+=1
       cunkuan=cunkuan*(1+0.0325)
print(str(years)+"年以后，存款会翻番")

24.从键盘接收一百分制成绩（0~100），要求输出其对应的成绩等级A~E。其中，90分以上为'A'，80~89分为'B'，~79分为'C'，60~69分为'D'，60分以下为'E'。

score=int(input('请输入成绩（0～100）：'))
if score > 100:
    grade = "输入错误！"
elif score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
elif score >= 70:
    grade = 'C'
elif score >= 60:
    grade = 'D'
elif score >= 0:
    grade = 'E'
else:
    grade = "输入错误！"
print(grade)

25.猜数游戏。预设一个0~9之间的整数，让用户猜一猜并输入所猜的数，如果大于预设的数，显示“太大”；小于预设的数，显示“太小”，如此循环，直至猜中该数，显示“恭喜！你猜中了！”。

import random
num=random.randint(0,9)
while True:
    guess=int(input('请输入你猜的数（0～9）：'))
    if guess == num:
        print("恭喜！你猜中了！")
        break
    elif guess > num:
        print("太大")
    else:
        print("太小")

26.输入一个数，判断这个数是否为素数，并输出判断结果。

import math
n=int(input("请输入一个数:"))
x=int(math.sqrt(n))
i,w=2,0
for i in range (2,x+1):
     if n%i==0:
         w=1
if w==1:
    print(n,"不是素数。")
else:
    print(n,"是素数。")

27.输入一个时间（小时:分钟:秒），输出该时间经过5分30秒后的时间。

hour,minute,second=input('请输入一个时间（h:m:s）:').split(':')
hour=int(hour)
minute=int(minute)
second=int(second)
second+=30
if second >= 60:
    second = second-60
    minute += 1
minute+=5
if minute >= 60:
    minute = minute-60
    hour += 1
if hour == 24:
    hour = 0
print('%d:%d:%d'%(hour,minute,second))

28.一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如，6的因子为1、2、3，而6=1+2+3，因此6是完数。编程，找出1000之内的所有完数，并输出该完数及对应的因子。（枚举法）

m=1000
for a in range(2,m+1):
    s=a
    L1=[]
    for i in range(1,a):
        if a%i==0:
            s-=i
            L1.append(i)
    if s==0:
        print("完数：%d，因子包括："%a,end="")
        for j in range(1,len(L1)):
            print("%d"%L1[j],end=",")
        print("\n")

29.解决猴子吃桃问题。
猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个。第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想吃时，只剩下一个桃子了。求第一天共摘多少个桃子。（迭代法）

day=9
x=1
while day>0:
    x=(x+1)*2
    day-=1
print("total=",x)

30.从键盘接收若干个整数（直接输入回车表示结束），用冒泡法或选择法进行排序（从小到大），并将排序结果在屏幕上输出。两个程序算法的时间复杂度均为O(n2)。

#选择排序：
def bubble1(List):
    num=len(List)
    for i in range(0,num-1):
        for j in range(i+1,num):
            if List[i]>List[j]:
                List[i],List[j]=List[j],List[i]
    return List

L1=[]
num_str=input('请输入一个需排序的整数：')
while len(num_str) != 0:
    L1.append(int(num_str))
    num_str=input('请输入一个需排序的整数：')
print('选择排序后结果:', bubble1(L1))
#冒泡排序：
def bubble2(List):
    for i in range(0,len(List)-1):
        for j in range(len(List)-1,i,-1):
            if List[j-1]>List[j]:
                List[j-1],List[j]=List[j],List[j-1]
    return List
L1=[]
num_str=input('请输入一个需排序的整数：')
while len(num_str) != 0:
    L1.append(int(num_str))
    num_str=input('请输入一个需排序的整数：')
print('冒泡排序后结果:', bubble2(L1))

31.从键盘接收一个正整数n，输出对应斐波那契（Fibonacci）数列的前n项（计算数列中某项的值请用递归函数实现）。另外，请指出所用算法的复杂度。
有能力的同学还可进一步改进算法的效率。

def fib(n):
    if n==0 or n==1:
        return n
    else:
        return fib(n-1) + fib(n-2)

n=int(input('n='))
for i in range(n+1):
    print(fib(i),end=" ")

#  算法时间复杂度为O(n*2n).

#  可改进为：

def fib(n,List):
    a,b=0,1
    List.append(a)
    while b<=n:
        List.append(b)
        a,b = b,a+b
n=int(input('n='))
L1=[]
fib(n,L1)
print(L1)
# 算法的时间复杂性为O(n)

32.编程，输入一行字符，分别统计出其中英文字母、空格、数字和其他字符的个数。

方法一

letters,space,digit,other=0,0,0,0
s=input("请输入一行字符：")
for i in range(len(s)):
    if (s[i]>='a' and s[i]<='z') or (s[i]>='A' and s[i]<='Z'):
        letters+=1
    elif s[i]==' ':
        space+=1
    elif s[i]>='0' and s[i]<='9':
        digit+=1
    else:
        other+=1
print("字母数：%d\n空格数：%d\n数字数：%d\n其他字符数：%d\n"%(letters,space,digit,other))

方法二

p=input('请输入一行字符:')
a,b,c,d=0,0,0,0
for i in p:
    if((i<='Z' and i>='A') or (i<='z' and i>='a')):
        a+=1
    elif (i==' '):
        b+=1
    elif(i>='0' and i<='9'):
        c+=1
    else:
        d+=1
print ('英文字母的个数为：'+str(a))
print ('空格的个数为：'+str(b))
print ('数字的个数为：'+str(c))
print ('其他字符的个数为：'+str(d))

方法三

letter,space,digit,other=0,0,0,0
s = input('input a string:')
for c in s:
    if c.isalpha():
        letter +=1
    elif c.isspace():
        space +=1
    elif c.isdigit():
        digit +=1
    else:
        other +=1
print("字母数：%d\n空格数：%d\n数字数：%d\n其他字符数：%d\n"%(letter,space,digit,other))

33用函数或函数的递归实现求n!的算法。（主程序已给出）。同时估计程序的复杂度。程序复杂度为O(n)。

def fact1(n):
    value=1
    for count in range(1,n+1):
        value*=count
    return value
print(fact1(10))

34.分别编写求两个整数的最大公约数的函数hcf和求最小公倍数的函数lcd。主函数已给出，其从键盘接收两个整数，调用这两个函数后输出结果。
（提示：求最大公约数可用辗转相除法。即将大数作为被除数，小数作为除数，若二者余数不为0，则将小数作为被除数，余数作为除数，…直到余数为0。求最小公倍数则用两数的积除以最大公约数即可。）

def hcf(u,v):
    if v>u:
        u,v=v,u
    r=u%v
    while r!=0:
        u=v
        v=r
        r=u%v
    return v

def lcd(u,v,h):
    return u*v/h

u=int(input("请输入第一个整数："))
v=int(input("请输入第二个整数："))
h=hcf(u,v)
print("%d和%d的最大公约数为%d:"%(u,v,h))
l=lcd(u,v,h)
print("%d和%d的最小公倍数为%d:"%(u,v,l))

35.编程，统计列表中各数据的方差和标准差。主函数已给出，请编写计算方差的函数var。
（提示：方差的计算公式为： ∑Xi2/n-(∑Xi/n)2 ，其中，n为列表中元素个数，Xi为列表中的第i项。标准差则为方差的算术平方根。）

import math
def var(L1):
    s,psum=0,0
    for i in range(len(L1)):
        v=L1[i]
        s+=v
        psum+=v*v
    s=s/len(L1)
    mse=psum/len(L1)-s*s
    return mse

L1=[5,3,7,8,14,9,12,6]
dx=var(L1)
print('方差为：%.2f'%dx)
mse=math.sqrt(dx)
print('标准差为：%.2f'%mse)

36.主程序中已有一个排好序的列表，请编写函数insertList，将从键盘接收的整数按原来从小到大的排序规律插入到该列表中。

def insertList(L1,x):
    if x>L1[len(L1)-1]:
        L1.append(x)
        return
    for i in range(0,len(L1)):
        if x<L1[i]:
            L1.insert(i,x)
            break
    return

L1=[1,4,6,9,13,16,28,40,100]
x=int(input('请输入一个要插入的整数：'))
insertList(L1,x)
print(L1)

37.使用input函数与split("-")函数对字符串进行分割切片处理，首先，用input函数输入一个字符串，然后，split("-")函数对字符串分割数据类型为列表类型，最后，采用列表索引输出。

ss=input()
k=ss.split("-")
print("{}+{}".format(k[0],k[-1]))

38.爱因斯坦曾出过这样一道有趣的数学题：有一个长阶梯，若每步上2阶，最后剩1阶；若每步上3阶，最后剩2阶；若每步上5阶，最后剩4阶；若每步上6阶，最后剩5阶；只有每步上7阶，最后刚好一阶也不剩。请编程求解该阶梯至少有多少阶。

n=1
while True:
    if n%3==2:
        if n%5==4:
            if n%6==5:
                if n%7==0:
                    print(n)
                    break
                else:
                    n+=2
                    continue
            else:
                n+=2
                continue
        else:
            n+=2
            continue
    else:
        n+=2
        continue

39.matplotlib绘图库，绘制单条折线统计图

# 导入matplotlib绘图库
import matplotlib.pyplot as plt
# 定义两组列表数据
year = ['2015','2016', '2017', '2018', '2019']
price = [498.58, 492.40, 491.53, 445.60, 449.92]
# 使用plot()方法绘制折线统计图
plt.plot(year, price)  # year，price分别为点的横纵坐标
plt.show()  # 展示图片

运行结果

40.matplotlib绘图库，绘制双柱形统计图

# 导入需要的numpy，matplotlib库
import numpy as np
import matplotlib.pyplot as plt
year = ['2015', '2016', '2017', '2018', '2019']
countA = [176235.94, 69931.71, 279122.49, 169649.85, 396852.13]
countB = [246988.67, 107641.54, 156532.97, 276963.38, 206406.87]
x = np.arange(len(year))
width = 0.35  # 一个柱图的宽度
gap = x - width / 2
plt.bar(gap, countA, width=width, label='productA')  # gap为柱图的中心点，label为对应柱图的标签
plt.bar(gap + width, countB, width=width, label='productB')  # 
plt.xticks(x, year)  # 重写坐标轴标签
plt.legend()  # 增加图例
plt.show()

运行结果