python

题目描述：

接收用户输入4个字符串（字符串之间用空格分隔），利用该输入构建一个列表（长度大于4）。输出该列表的后三个元素。

输入：

hah fsd ere wrwe

输出：

[‘fsd’,’ere’,’wrwe’]

# 获取用户输入
user_input = input()，split()

# 输出最后三个元素
print(user_input[-3:])

题目描述：

请接受用户输入一个人的名字，以及这个人说的一句话（二者之间用空格隔开），并按照类似如下的方式输出：董宇辉说：“听世界的声音，保留自己的观点！”(引号为英文状态下的符号)

输入：

董宇辉 听世界的声音，保留自己的观点！

输出：

董宇辉说：“听世界的声音，保留自己的观点！”

s = input().split()
print(f'{s[1]}说："{s[2]}"')

题目描述：

定义一个函数is_prime,参数为n，判断数字n是否为素数，

并能显示相应的提示信息（参考样例）。

请接收用户输入的数字，并调用函数is_prime判断该数字

是否为素数。

注：

1.如有需要import math，

2.接受用户输入的函数input必须放在入口函数内，如下所示：

if name == “main“:

​ n = int(input())

​ print(round(area(n),2))

输入：

6

输出：

数字6不是一个素数

输入：

5

输出：

数字5是一个素数

import math

# 判断是否为素数的函数
def is_prime(n):
    if n < 2:
        print(f"数字{n}不是一个素数")
        return
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            print(f"数字{n}不是一个素数")
            return
    print(f"数字{n}是一个素数")

# 主程序入口
if __name__ == "__main__":
    n = int(input())
    is_prime(n):

题目描述：

请接收用户输入一个数字n，判断该数字是否为完全平方数，如果是输出：数字n为完全平方数；如果不是输出：

数字n不是完全平方数

输入1：

3

输出1：

3不是一个完全平方数

输入2：

4

输出2：

4是一个完全平方数

import math

# 读取用户输入
n = int(input())

# 计算平方根并判断是否为整数
if math.isqrt(n) ** 2 == n:
    print(f"{n}是一个完全平方数")
else:
    print(f"{n}不是一个完全平方数")

题目描述：

接收用户输入的三个整数x,y,z，请把这三个数由小到大输出。

输入：

32 45 16

输出

16 32 45

注：45后面有个空格

a=input().split()
b=[int(i)for i in a]
b.sort()
for i in b:
	print(i,end=" ")

题目描述：定义一个函数total(设置1个形参，接收int类型的消息)， 计算分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前n(n<=20)项之和并返回值(保留2位小数)。

在入口函数中，接收用户输入 的数值n，调用total函数计算上述分数序列的前n项之和。

注：接受用户输入的函数input必须放在入口函数内，如下所示：

if name == “main“: n = int(input()) print(round(area(n),2))

输入： 2

输出： 3.5

输入： 3

输出： 5.17

输入： 4

输出： 6.77

def total(n):
	numerator = 2.0 # 第一项的分子
  	denominator = 1.0 # 第一项的分母
  	sum_total = 0.0
  	for _ in range(n):
  		sum_total += numerator / denominator
		new_numerator = numerator + denominator
		new_denominator = numerator
		numerator, denominator = new_numerator, new_denominator
  	return round(sum_total, 2)
if __name__ == "__main__":
  	n = int(input())
	print(total(n))

题目描述：编写函数reverse_str，接收一个字符串，得到相反顺序的字符串并返回。（举例：如接收的字符串为f123，返回值为321f）。

在入口函数中，接收 用户输入的字符串，然后调用函数reverse_str，得到相反顺序的字符串并输出。

注：接受用户输入的函数input必须放在入口函数内，如下所示：

if name == “main“: n = int(input()) print(round(area(n),2))

输入： f123

输出： 321f

输入： 1245

输出： 5421

def reverse_str(s):
	return s[::-1]

if __name__ == "__main__":
  	s = input().strip()
	print(reverse_str(s))

请编写代码打开excel文件（路径：../pythontest_grades.xls）,请接收用户输入的n （2<= n <= 6）读取工作表Sheet1中该第n列第1到26行的数据（行从0开始计数）， 然后计算平均分，结果保留两位小数，并输出。

注：需要导入模块 import xlrd from xlutils import copy

输入： 3

输出： 94.23

输入： 5

输出： 99.77

import xlrd
from xlutils import copy
def calculate_average(n):
  	\# 打开 Excel 文件
	workbook = xlrd.open_workbook('../pythontest_grades.xls')
	sheet = workbook.sheet_by_name('Sheet1')
  
  	total = 0
  	count = 0
  
  	\# 读取第 n 列的第 1 到 26 行数据（行号从 0 开始）
  	for row in range(1, 27): # 行 1 到 26（对应索引 1 到 25）
		cell_value = sheet.cell_value(row, n) 
		if isinstance(cell_value, (int, float)):
			total += cell_value
			count += 1

  	\# 计算平均值，保留两位小数
  	average = total / count if count != 0 else 0.0
  	return round(average, 2)

if __name__ == "__main__":
  	n = int(input().strip())
  	if 2 <= n <= 6:
   		average_score = calculate_average(n)
   		print(average_score)
  	else:
  		print("输入的n不在2到6之间")

题目描述： 建立一个列表friends = [‘lili’,’xiaoxiao’,’zhang’,’maomao’]，然后接收用户输入一个列表中已经存在的元素值，计算该元素在列表中的索引位置，并输出索引值

输入： lili

输出： 0

friends = ['lili', 'xiaoxiao', 'zhang', 'maomao']
name = input().strip()
index = friends.index(name)
print(index)

题目描述：

接收用户输入的当月利润p（单位是元），企业发放的奖金根据利润提成。利润p低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，求应发放奖金总数并输出（单位为元）。

输入1：

80000

输出1：

8000.0

输入2：

160000

输出2：

14500.0

输入3：

240000

输出4：

19500.0

输入5：

410000

输出5：

27800.0

p=float(input())
if p<=100000:
	price=p*0.1
elif p<=200000:
	price=10000+(p-100000)*0.075
elif p<=400000:
	price=10000+7500+(p-200000)*0.05
elif p<=600000:
	price=10000+7500+10000+(p-400000)*0.03
elif p<=1000000:
	price=10000+7500+10000+6000+(p-600000)*0.015
else:
	price=10000+7500+10000+6000+6000+(p-1000000)*0.01
print(price)

题目描述：一个数如果恰好等于它的因子(除它本身之外的因子)之和，这个数就称为“完数”。

请编写代码，请接收用户输入的数字n（2<n<=1000），找出2-n之间的完数，存储在一个数字列表中并输出。

输入：

8

输出：

[6]

# 获取用户输入
n = int(input())
# 定义结果列表
perfect_numbers = []

# 检查每个数是否为完数
for num in range(2, n):
    # 找出所有因子（不包括自身）
    factors = [i for i in range(1, num) if num % i == 0]
    # 如果因子之和等于原数，就是完数
    if sum(factors) == num:
        perfect_numbers.append(num)

# 输出结果
print(perfect_numbers)

题目描述：

接收用户输入4个数值（数值之间用空格分隔），利用该输入构建一个列表。定义一个数值列表num_list = [1,3,5,6],将两个列表的对应元素相加，将和存储到另一个列表中，并输出最后结果列表

​ 注：如果输入的数值不足4个，请输出“数值少于4个”

输入：

4 6 7 9

输出：

[5, 9, 12, 15]

# 获取用户输入
user_input = input("请输入4个数值（用空格分隔）：")
# 分割输入
input_list = user_input.strip().split()

# 检查输入个数
if len(input_list) < 4:
    print("数值少于4个")
else:
    # 转换为整数列表
    input_numbers = list(map(int, input_list[:4]))
    # 定义原列表
    num_list = [1, 3, 5, 6]

    # 用下标方式逐个相加
    result = []
    for i in range(4):
        result.append(input_numbers[i] + num_list[i])

    # 输出结果
    print(result)

题目描述：

定义一个字典

stu_info = [{‘name’:’mary’,’tid’:1001,’title’:’操作系统’},

​ {‘name’:’mary’,’tid’:1001,’title’:’计算机网络’},

​ {‘name’:’jerry’,’tid’:1002,’title’:’操作系统’},

​ {‘name’:’jerry’,’tid’:1002,’title’:’数据结构’},

​ {‘name’:’jack’,’tid’:1003,’title’:’操作系统’},

​ {‘name’:’jack’,’tid’:1003,’title’:’计算机网络’},

​ {‘name’:’jack’,’tid’:1003,’title’:’数据结构’}]

接收用户输入（用空格分隔），从输出中提取用户数据，分别作为键name、tid、title对应的值

生成一个学生信息字典，追加到列表stu_info中，然后基于列表stu_info，对学生信息进行汇总，

形式类似如下：

[{‘name’: ‘mary’, ‘tid’: 1001, ‘title’: [‘操作系统’, ‘计算机网络’]},

{‘name’: ‘jerry’, ‘tid’: 1002, ‘title’: [‘操作系统’, ‘数据结构’]},

{‘name’: ‘jack’, ‘tid’: 1003, ‘title’: [‘操作系统’, ‘计算机网络’, ‘数据结构’]}]

最后，输出类似格式的汇总结果。

输入：

david 1004 网络安全

输出：

[{‘name’: ‘mary’, ‘tid’: 1001, ‘title’: [‘操作系统’, ‘计算机网络’]},

{‘name’: ‘jerry’, ‘tid’: 1002, ‘title’: [‘操作系统’, ‘数据结构’]},

{‘name’: ‘jack’, ‘tid’: 1003, ‘title’: [‘操作系统’, ‘计算机网络’, ‘数据结构’]},

{‘name’: ‘david’, ‘tid’: ‘1004’, ‘title’: [‘网络安全’]}]

stu_info=[
	{'name':'mary','tid':1001,'title':'操作系统'},
	{'name':'mary','tid':1001,'title':'计算机网络'},
	{'name':'jerry','tid':1002,'title':'操作系统'},
	{'name':'jerry','tid':1002,'title':'数据结构'},
	{'name':'jack','tid':1003,'title':'操作系统'},
	{'name':'jack','tid':1003,'title':'计算机网络'},
	{'name':'jack','tid':1003,'title':'数据结构'}
]
ip=input().strip().split()
if len(ip)==3:
	name,tid,title=ip
    new_info={'name':ip[0],'tid':ip[1],'title':ip[2]}
    stu_info.append(new info)
	
    sum={}
    for student in stu_info:
        key=(student['name'],student['tid'])
        if key not in sum:
            sum[key]={'name':student['name'],'tid':student['tid'],'title':[]}
        sum[key]['title'].append(student['title'])
result=list(sum.values())
print(result)

题目描述：

请编写代码打开excel文件（路径：../pythontest_grades.xls）,请接收用户输入的n

（1<= n <= 26）读取工作表Sheet1中该第n行第2-6列的数据（列从0开始计数），

然后计算最低分，并输出。

注：需要导入模块

import xlrd

from xlutils import copy

输入：

5

输出：

62.0

输入：

8

输出：

76.0

import xlrd
from xlutils import copy
if __name__ == '__main__':
    n = int(input())  # 用户输入的行号（从1开始）
    if 1 <= n <= 26:
        # 打开 Excel 文件
        workbook = xlrd.open_workbook('../pythontest_grades.xls')
        sheet = workbook.sheet_by_name('Sheet1')
    row_values = sheet.row_values(n - 1)[2:7]  # 取第2到6列数据（列索引2~6）
    # 计算并输出最低分
	print(min(row_values))
else:
	print("输入超出范围")

知识点：函数

题目描述：编写函数istriangle（设置3个参数，分别接收3条边的数值），

判断并输出该三角形的类型（直角三角形，等边三角形，等腰三角形，

其它三角形，不是三角形）。在入口函数中，接收用户输入的三角形

3条边长（数字之间使用空格分隔），调用istriangle函数，输出三角形类型信息。

注：接受用户输入的函数input必须放在入口函数内，如下所示：

if name == “main“:

​ n = int(input())

​ print(round(area(n),2))

输入：

3 4 5

输出：

直角三角形

输入：

3 5 7

输出：

其它三角形

输入：

3 4 4

输出：

等腰三角形

输入：

3 3 3

输出：

等边三角形

输入：

1 1 2

输出：

不是三角形

def istriangle(a, b, c):
    if a + b <= c or b + c <= a or a + c <= b:
        print("不是三角形")
    elif a == b == c:
        print("等边三角形")
    elif a == b or b == c or a == c:
        print("等腰三角形")
	elif a*a==b*b+c*c or b*b==a*a+c*c or c*c==a*a+b*b:
        print("直角三角形")
    else:
        print("其三角形")

if __name__ == '__main__':
    n = list(map(int, input().split()))
    istriangle(n[0], n[1], n[2])

题目描述：

定义一个列表num_list = [1,3,5,7,8],请编写代码对该列表进行切片并输出切片结果，切片的起始位置由用户输入（起始数字和终止数字请用空格分隔）。注：用户输入的位置不合理（如不在列表的起始范围内），请输出提示信息：切片位置不合理

输入1：

3 2

输出1：

切片位置不合理

输入2：

-6 2

输出2：

超出索引范围

输入3：

3 5

输出3：

[7,8]

num_list = [1, 3, 5, 7, 8]
try:
	start, end = map(int, input().split())
	if start < -len(num_list) or end > len(num_list) or end < -len(num_list) or start > len(num_list):
		print("超出索引范围")
	elif start > end:
		print("切片位置不合理")
	else:
		print(num_list[start:end])
except:
	print("输入格式错误")

题目描述：

定义一个列表friends = [‘lili’,’xiaoxiao’,’zhang’,’maomao’]，然后使用input语句接收用户的输入，将friends列表中索引为用户输入的值的元素弹出，最后输出列表friends 。

输入：

1

输出：

[‘lili’,’zhang’,’maomao’]

friends = ['lili', 'xiaoxiao', 'zhang', 'maomao']
index = int(input())
friends.pop(index)
print(friends)

题目描述：

请一次接收用户输入的4个数字（注意：数字必须是个位数，数字之间使用空格分隔），

请计算能组成多少个互不相同且无重复数字的三位数，将这些数字存在一个列表中，并输出

该结果列表。

输入：

2 2 4 5

输出：

[245, 254, 425, 452, 524, 542]

nums = list(map(int, input().split()))
result = []

for i in nums:
    for j in nums:
        for k in nums:
            if i != j and j != k and i != k:
                num = i * 100 + j * 10 + k
                if num not in result:
                    result.append(num)

print(result)

题目描述：

使用两个变量分别表示名和姓，其中名指向字符串“ada”，姓指向字符串“lovelace”然后合并这两个值以显示姓名，并输出姓名信息

输入：

无

输出：

ada lovelace

样例输入：

无

样例输出：

ada lovelace

first_name = "ada"
last_name = "lovelace"
full_name = first_name + " " + last_name
print(full_name)

题目描述：

定义一个字典dic_1 = {‘k1’:[],’k2’:[]}，接收用户输入10个数字，数字之间使用空格分隔，

将这些数字存储在一个列表中，将列表中索引为奇数的元素追加到键k1对应的空列表中，索引

为偶数的元素追加到键k2对应的空列表中

输入：

2 3 4 5 6 7 7 7 8 2

输出：

{‘k1’: [3, 5, 7, 7, 2], ‘k2’: [2, 4, 6, 7, 8]}

dic_1 = {'k1': [], 'k2': []}
nums = list(map(int, input().split()))
for i in range(len(nums)):
    if i % 2 == 0:
        dic_1['k2'].append(nums[i])
    else:
        dic_1['k1'].append(nums[i])
print(dic_1)

题目描述：接收用户输入多个字符串（字符串之间用空格分隔），利用该输入构建一个列表。遍历该列表，把列表中的每个元素首字母大写，并输出

输入：rose david peter

输出：Rose David Peter

words = input().split()
for word in words:
    print(word.title())

题目描述：

请接收用户输入的5个数字（数字之间使用空格分隔），创建一个长度为5的数字列表，将该数字列表与列表scores=[56,78,90,43,23]中的对应元素相加，并将结果放到新的列表list3中，并输出列表list3

输入：

10 20 10 30 10

输出：

[66,98,100,73,33]

scores = [56, 78, 90, 43, 23]
numlist = list(map(int, input().split()))
list3 = [scores[i] + numlist[i] for i in range(5)]
print(list3)

输入M N K三个数字，空格分隔，在百位、十位、个位能够出现大于1并且小于（M、N、K）的数 ，请计算能组成多少个互不相同且无重复数字的三位数？

输入：

M N K

输出：

组成的数字，每行一个

样例输入：

3 4 5

样例输出：

123

124

132

134

213

214

231

234

M, N, K = map(int, input().split())
result = []
for i in range(M):
    for j in range(N):
        for k in range(K):
            if i != j and i != k and j != k:
                result.append(int(f"{i}{j}{k}"))
result = sorted(result)
for num in result:
    print(num)

题目描述：

​ 定义一个嵌套字典

infos = {“meimei”:{“language”:”python”,’book’:”hongloumeng”},”panpan”:{“language”:”java”,’book’:”shanguoyanyi”}}

存储用户的喜好信息，，然后接收用户输入一个人的名字，然后输出类似的信息：

meimei喜欢读hongloumeng,如果用户不存在，输出提示信息：该用户不存在

输入1：

panpan

输出1：

panpan喜欢读shanguoyanyi

输入2：

haohao

输出2：

该用户不存在

infos = {
    "meimei": {"language": "python", "book": "hongloumeng"},
    "panpan": {"language": "java", "book": "shanguoyanyi"}
}

name = input()
if name in infos:
	print(f"{name}喜欢读{infos[name]['book']}")
else:
	print("该用户不存在")

题目描述：

定义一个字典bikes = {‘color’: ‘red’, ‘year’: 1980, ‘local’: ‘shanghai’}，接收用户输入的一个键，查询该键对应的值，如果用户输入的键存在就输出其对应的值，否则，输出类似信息：字典bikes中没有brand键

输入1：

brand

输出1：

字典bikes中没有brand键

输入2：

color

输出2：

red

bikes = {'color': 'red', 'year': 1980, 'local': 'shanghai'}
key = input()
if key in bikes:
	print(bikes[key])
else:
	print(f"字典bikes中没有{key}键")

知识点：函数

题目描述：

定义一个函数factors，求任意一个整数n的因数并返回。

调用函数factors，求出用户输入的数字的因数并输出。

注：接受用户输入的函数input必须放在入口函数内，如下所示：

if name == “main“:

​ n = int(input())

​ print(round(area(n),2))

输入：

6

输出：

[1, 2, 3，6]

def factors(n):
    return [i for i in range(1, n + 1) if n % i == 0]

if __name__ == "__main__":
    n = int(input())
    print(factors(n))

题目：一个数如果恰好等于它的因子(除它本身之外的因子)之和，这个数就称为“完数”。例如6=1＋2＋3.请

接收用户输入的一个数（2-99之间），判断其是否位完数，如果是完数输出类似的

信息：数字6是完数；否则输出类似的信息：数字5不是完数

输入1：

6

输出1：

数字6是完数

输入2：

5

输出2：

数字5不是完数

def wanshu(n):
    sum = 0
    for i in range(1, n):
        if n % i == 0:
            sum += i
    if sum == n:
        print(f"数字{n}是完数")
    else:
        print(f"数字{n}不是完数")

if __name__ == "__main__":
    n = int(input())
    if 2 <= n <= 99:
        wanshu(n)
    else:
        print("输入不在有效范围（2-99）内")

题目描述：

定义一个列表friends = [‘lili’,’xiaoxiao’,’zhang’,’maomao’]，然后使用input语句接收用户的输入，插入到friends列表中索引为1的位置。然后输出friends列表。

输入：

nana

输出：

[‘lili’,’nana’,’xiaoxiao’,’zhang’,’maomao’]

friends = ['lili', 'xiaoxiao', 'zhang', 'maomao']
new_friend = input()
friends.insert(1, new_friend)
print(friends)

题目描述：

请编写代码打开excel文件（路径：../pythontest_grades.xls）,请接收用户输入的n

（1<= n <= 26）读取工作表Sheet1中该第n行第2-6列的数据（列从0开始计数），

然后计算最低分，并输出。

注：需要导入模块

import xlrd

from xlutils import copy

输入：

5

输出：

62.0

输入：

8

输出：

76.0

import xlrd
from xlutils import copy

n = int(input())  # 用户输入的行号（从1开始）
if 1 <= n <= 26:
	# 打开 Excel 文件
	workbook = xlrd.open_workbook('../pythontest_grades.xls')
	sheet = workbook.sheet_by_name('Sheet1')

	# Excel 中行和列都是从0开始，n 是从1开始，所以要减 1
	row_values = sheet.row_values(n - 1)[2:7]  # 取第2到6列数据（列索引2~6）
	print(min(row_values))
else:
	print("输入超出范围")

题目描述：

使用input语句接收用户输入的多个学生的成绩，成绩之间使用空格分隔，编写代码将用户输入的成绩放在一个数字列表中，请计算这些学生的平均分并输出

输入：

50 60 70 80 95

输出：

71

scores = list(map(int, scores_input.split()))
# 计算平均分
average = sum(scores) // len(scores)
# 输出平均分
print(average)

题目描述：编写函数average_stu_grade，设置一个参数接收存储

学生成绩信息的字典（请参考测试用例），计算每个人的平均

成绩(保留2位小数)，并按照平均成绩从高到低进行排序并返回值。

在入口函数中，定义一个字典

stu_grade={‘李晓’:{‘os’:80,’network’:75,’datastruct’:90},’王梓’:{‘computer’:80,’algorithm’:90}}

接收用户的输入（参考测试样例），在’李晓’的成绩中追加一个键值对

（如：’computer’:73）调用函数average_stu_grade统计字典stu_grade_1中学生的平均成绩

并按照平均成绩从高到低进行排序，输出排序结果。

（提示：在函数average_stu_grade中需要 import operator）

注：

1.务必按照要求编写函数average_stu_grade，否则无法通过测试点

2.调用函数的操作放在入口函数内，如下所示：

if name == “main“:

​ print(round(area(n),2))

输入：

computer 73

输出：

{‘王梓’: 85.0, ‘李晓’: 79.5}

import operator

def average_stu_grade(stu_dict):
    result = {}
    for name, courses in stu_dict.items():
        avg = round(sum(courses.values()) / len(courses), 2)
        result[name] = avg
    sorted_result = dict(sorted(result.items(), key=operator.itemgetter(1), reverse=True))
    return sorted_result

if __name__ == "__main__":
    stu_grade = {
        '李晓': {'os': 80, 'network': 75, 'datastruct': 90},
        '王梓': {'computer': 80, 'algorithm': 90}
    }

    subject, score = input().split()
    stu_grade['李晓'][subject] = int(score)
    
    stu_grade_1 = stu_grade
    print(average_stu_grade(stu_grade_1))

题目描述：

根据用户输入的排除词（词之间用空格分隔），建立排除词库列表，将分词统计字典

counts = {‘i’: 1, ‘am’: 1, ‘a’: 2, ‘teacher’: 2, ‘he’: 1, ‘is’: 1, ‘also’: 1}中

在排除词库列表中的词相关的键值对删掉

输入：

i am

输出：

{‘a’: 2, ‘teacher’: 2, ‘he’: 1, ‘is’: 1, ‘also’: 1}

exclude_words = input().split()  # 获取排除词列表
counts = {'i': 1, 'am': 1, 'a': 2, 'teacher': 2, 'he': 1, 'is': 1, 'also': 1}
    
# 使用字典推导式过滤排除词
filtered_counts = {word: count for word, count in counts.items() if word not in exclude_words}
print(filtered_counts)

知识点：函数

题目描述：

请定义函数isleap（参数为year），判断某年是否为闰年,

并输出相应的信息。接收用户输入的年份，调用函数isleap,

判断该年是否为闰年并输出提示信息。输出信息请参考样例。

注：接受用户输入的函数input必须放在入口函数内，如下所示：

if name == “main“:

year = int(input())

isleap(year)

输入：

2000

输出：

2000年是闰年

输入：

2004

输出：

2004年是闰年

输入：

2003

输出：

2003年不是闰年

def isleap(year):
    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
        print(f"{year}年是闰年")
    else:
        print(f"{year}年不是闰年")

if __name__ == "__main__":
    year = int(input())
    isleap(year)

知识点：函数

题目描述：编写函数total（设置参数n，接收一个int类型的消息）,

求出”1/(12)-1/(23)+1/(34)-1/45+…)”前n项的和（保留2位小数）并返回值。

在入口函数中，接收用户输入的数值n，然后调用函数total，求出前n项的和并输出。

注：接受用户输入的函数input必须放在入口函数内，如下所示：

if name == “main“:

​ n = int(input())

​ print(round(area(n),2))

输入：

4

输出：

0.37

def total(n):
    sum = 0
    for i in range(1, n + 1):
        term = 1 / (i * (i + 1))
        if i % 2 == 0:
            sum -= term
        else:
            sum += term
    return round(sum, 2)

if __name__ == "__main__":
    n = int(input())
    print(total(n))

题目：

猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个

第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下

的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。

请接收用户输入的数字n(1-10之间)，输出第n天没吃之前的桃子数量

输入：

9

输出：

4

n=1

day=int(input())

for i in range(0,10-day):

	n=(n+1)*2

print(n)

题目描述：

现有一个分词统计字典counts = {‘i’: 1, ‘am’: 1, ‘a’: 2, ‘teacher’: 2, ‘he’: 1, ‘is’: 1, ‘also’: 1}

编写代码利用用户输入（使用空格分隔）分别作为键和值（必须是数字）增加到字典counts中，

然后对字典进行排序，并输出排序结果

输入：

good 3

输出：

{‘i’: 1, ‘am’: 1, ‘he’: 1, ‘is’: 1, ‘also’: 1, ‘a’: 2, ‘teacher’: 2, ‘good’: 3}

counts = {'i': 1, 'am': 1, 'a': 2, 'teacher': 2, 'he': 1, 'is': 1, 'also': 1}
user_input = input()  # 输入格式如：good 3
word, count = user_input.split()
counts[word] = int(count)

sorted_counts = dict(sorted(counts.items(), key=lambda item: item[1]))
    
print(sorted_counts)

题目描述：

定义一个列表friends = [‘lili’,’xiaoxiao’,’zhang’,’maomao’]，然后使用input语句接收用户的输入一个friends列表中已经包含的一个元素，将该元素从friends列表中删除。

输入：

maomao

输出：

[‘lili’,’xiaoxiao’,’zhang’]

friends = ['lili', 'xiaoxiao', 'zhang', 'maomao']
name = input()
friends.remove(name)
print(friends)

知识点：函数

题目描述：

定义函数days,参数为date，能够根据日期计算其是该年

的第几天并返回值。接收用户输入的日期(年月日用空格分隔)，然后调用函数days计算用户

输入的日期是那一年的第几天并输出。

注：

1.如果需要对用户输入进行类型转换，请在函数内进行处理；

2.请直接输出函数的返回值；

3.接受用户输入的函数input必须放在入口函数内，如下所示：

if name == “main“:

​ n = int(input())

​ print(round(area(n),2))

输入：

2000 5 2

输出：

123

输入：

2004 5 2

输出：

123

输入：

1993 5 2

输出：

122

def days(date):
    # 拆分输入并转换为整数
    year, month, day = map(int, date.split())

    # 每月的天数（平年）
    month_days = [31, 28, 31, 30, 31, 30,
                  31, 31, 30, 31, 30, 31]
    
    # 判断是否为闰年，若是则2月变29天
    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
        month_days[1] = 29
    
    # 累加前面月份的天数 + 当前天
    return sum(month_days[:month - 1]) + day

if __name__ == "__main__":
    date = input()
    print(days(date))

题目描述：

定义一个列表list1 = [1,2,3]，然后使用input语句接收用户输入，将该输入作为元素（元素之间用空格分隔），编写代码对其进行分割后依次追加到列表list1中,计算列表的长度，并输出。

输入：

​ 4 5 6

输出：

6

list1=[1,2,3]

i=input().split()

for num in range(len(i)):

	list1.append(i[num])

print(len(list1))

知识点：函数

题目描述：

定义一个getMax函数（设置3个形参，接收int类型的消息）,返回三个数中的最大值。在入口函数中，接收用户输入的

数字（数字之间使用空格分隔），强制转换为int类型后，再调用getMax函数计算三个数中的最大值，

并输出。

注：接受用户输入的函数input必须放在入口函数内，如下所示：

if name == “main“:

​ n = int(input())

​ print(round(area(n),2))

输入：

3 6 4

输出：

6

输入：

10 5 9

输出：

10

def getMax(a, b, c):
    return max(a, b, c)

if __name__ == "__main__":
    nums = input().split()  # 接收输入并按空格分割
    a, b, c = map(int, nums)  # 转换为三个整数
    print(getMax(a, b, c))  # 调用函数并输出结果

题目描述：

编写代码，输入一个人的名字，然后先后输出这个名字的大写 小写 首字母大写

输入：

ada lovelace

输出：

ADA LOVELACE

ada lovelace

Ada Lovelace

样例输入：

ada lovelace

样例输出：

ADA LOVELACE

ada lovelace

Ada Lovelace

name = input()

print(name.upper())   # 全部大写
print(name.lower())   # 全部小写
print(name.title()) 

题目描述：

定义一个列表friends，包含元素依次为lili,xiaoxiao,zhang,maomao，然后使用input语句接收用户的输入，将friends列表中索引为1的元素的值改为用户输入的值。

输入：

nana

输出：

[‘lili’,’nana’,’zhang’,’maomao’]

friends = ['lili', 'xiaoxiao', 'zhang', 'maomao']
new_name = input()
friends[1] = new_name
print(friends)

题目描述：

请使用input语句接收用户输入的数字N，然后编写代码生成从1开始到N的数字列表，并输出该数字列表

输入：

5

输出：

[1,2,3,4,5]

N = int(input())
num_list = list(range(1, N + 1))
print(num_list)

题目描述：接收用户输入的一个3位数(100-999之间的数字)，判断该数字是否为“水仙花数”，

所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身。

例如：153是一个“水仙花数”，因为153=13＋53＋3**3。如果

是水仙花数请输出类似的信息：数字153是水仙花数；否则输出类似

的信息：数字15不是水仙花数

输入1：

369

输出1：

数字369不是水仙花数

输入2：

153

输出2：

数字153是水仙花数

num = int(input())
a = num // 100           # 百位
b = (num // 10) % 10     # 十位
c = num % 10             # 个位
if a**3 + b**3 + c**3 == num:
	print(f"数字{num}是水仙花数")
else:
	print(f"数字{num}不是水仙花数")
#特别注意双斜线表示整数除法，单斜线是浮点除法

题目描述：编写函数join_list（设置两个参数，分别接收一个列表消息），

合并两个列表并返回新的列表。在入口函数中，定义两个列表，即：

ls1 = [‘xx’,’yy’,’hh’]，ls2 = [‘haohao’,’mei’]，接收用户输入在

ls1中追加一个元素，测试函数join_list能够正确将这两个列表合并，

输出合并结果。

注：

1.务必按照要求编写函数join_list，否则无法通过测试点

2.调用函数的操作放在入口函数内，如下所示：

if name == “main“:

​ print(round(area(n),2))

输入：

david

输出：

[‘xx’, ‘yy’, ‘hh’, ‘david’, ‘haohao’, ‘mei’]

def join_list(list1, list2):
    return list1 + list2

if __name__ == "__main__":
    ls1 = ['xx', 'yy', 'hh']
    ls2 = ['haohao', 'mei']
    new_element = input()
    ls1.append(new_element)
    result = join_list(ls1, ls2)
    print(result)

题目描述：

定义一个列表friends = [‘lili’,’xiaoxiao’,’zhang’,’maomao’]，然后使用input语句接收用户的输入，追加到friends列表中，最后输出friends列表

输入：

nana

输出：

[‘lili’,’xiaoxiao’,’zhang’,’maomao’,’nana’]

friends = ['lili', 'xiaoxiao', 'zhang', 'maomao']
new_friend = input()
friends.append(new_friend)
print(friends)

题目描述：

现有两个字典dict1 = {‘color’: ‘red’, ‘year’: 1980},dict2 = {‘local’: ‘shanghai’}用于描述

自行车的属性，请编写代码接收用户输入的两个字符串信息（使用空格分隔），分别作为键和值增加到dict2字典中，

然后合并字典dict1和字典dict2，最后输出两个字典合并的结果

输入：

user mingming

输出：

{‘color’: ‘red’, ‘year’: 1980, ‘local’: ‘shanghai’, ‘user’: ‘mingming’}

dict1 = {'color': 'red', 'year': 1980}
dict2 = {'local': 'shanghai'}

key, value = input().split()
dict2[key] = value  # 在dict2中添加新的键值对

newdict=dict1
newdict.update(dict2)   # 合并dict2到merged_dict

print(newdict)

题目描述：

现有一个字典notes = {‘小明’:{‘fruits’:[‘apple’,’strawberry’],’cost’:89},’小丽’:{‘fruits’:[orange’,’berry’],’cost’:87}}

记录了用户购买的水果和花费（cost）信息，请编写代码，根据用户输入，获取用户的名字（只能是小明或小丽）、

购买的水果和花费（cost）信息，请使用空格分隔这几个信息，然后根据这些信息修改字典notes，并输出notes

输入：

小明 banana 10

输出：

{‘小明’: {‘fruits’: [‘apple’, ‘strawberry’, ‘banana’], ‘cost’: 99}, ‘小丽’: {‘fruits’: [‘orange’, ‘berry’], ‘cost’: 87}}

notes = {
        '小明': {'fruits': ['apple', 'strawberry'], 'cost': 89},
        '小丽': {'fruits': ['orange', 'berry'], 'cost': 87}
    }

user, fruit, cost_str = input().split()
cost = int(cost_str)

# 修改字典

notes[user]['fruits'].append(fruit)
notes[user]['cost'] += cost

print(notes)

题目描述：接收用户输入多名同学的python课程设计成绩（数字之间用空格分隔），并将其存储在

成绩列表grades中，然后编写程序将这些同学的成绩转换为相应的等级A（大于90分）、

B（大于等于80分且小于90分）、C（大于等于70分且小于80分）、

D（大于等于60分且小于70分）、E（小于60分），将对应的等级存储levels列表中，

并输出列表levels

输入：

55 66 70 82 90 100

输出：

[‘E’, ‘D’, ‘C’, ‘B’, ‘A’, ‘A’]

grades = list(map(int, input().split()))
levels = []
for score in grades:
    if score > 90:
        levels.append('A')
    elif 80 <= score <= 90:
        levels.append('B')
    elif 70 <= score < 80:
        levels.append('C')
    elif 60 <= score < 70:
        levels.append('D')
    else:
        levels.append('E')

print(levels)

题目描述：编写函数join_dict（设置两个参数，分别接收一个字典

类型的消息），合并两个字典并返回新的字典。在入口函数中，

定义两个字典，即：dict1 = {‘xx’: 2, ‘yy’: 2, ‘vc’: 2},

dict2 = {‘df’: 2, ‘er’: 2}，接收用户输入在dict1中添加一个键值

对（键和值用空格分隔），测试函数join_dict能够正确将这两个字典

合并，输出结果。

注：

1.务必按照要求编写函数join_list，否则无法通过测试点

2.调用函数的操作放在入口函数内，如下所示：

if name == “main“:

​ print(round(area(n),2))

输入：

ee 2

输出：

{‘xx’: 2, ‘yy’: 2, ‘vc’: 2, ‘ee’: ‘2’, ‘df’: 2, ‘er’: 2}

def join_dict(d1, d2):
    new_dict = d1.copy()
    new_dict.update(d2)
    return new_dict

if __name__ == "__main__":
    dict1 = {'xx': 2, 'yy': 2, 'vc': 2}
    dict2 = {'df': 2, 'er': 2}
    key, value = input().split()
    dict1[key] = value  # 不进行类型转换，保留字符串
    result = join_dict(dict1, dict2)
    print(result)

题目描述：

输入一段文字，利用jieba进行分词，对列表中的词进行词频统计，统计后将词作为键，

词出现的次数作为值，按照词频从低到高排序，最后结果存储在字典里，然后输出统计结果

注：需要导入下列三个模块

import jieba

import operator

import logging

并执行下面代码：

jieba.setLogLevel(logging.INFO)

输入：

一场花开让岁月含香爱春天更爱春色满园春色满园关不住

输出：

{‘一场’: 1, ‘花开’: 1, ‘让’: 1, ‘岁月’: 1, ‘含香爱’: 1, ‘春天’: 1, ‘更爱’: 1, ‘关不住’: 1, ‘春色满园’: 2}

import jieba
import operator
import logging

jieba.setLogLevel(logging.INFO)

if __name__ == "__main__":
    text = input()
    words = jieba.lcut(text)

freq = {}
for word in words:
    if word.strip():  # 去除空词
        freq[word] = freq.get(word, 0) + 1

# 根据词频从低到高排序

sorted_freq = dict(sorted(freq.items(), key=operator.itemgetter(1)))

print(sorted_freq)

知识点：函数

题目描述：

定义函数area，接收圆的半径r作为参数，返回圆的面积。请接收用户的输入

作为实参传递给半径r，然后调用函数area计算圆的面积并输出（保留2位小数）。

注：

1.导入必要的模块 from math import pi；保留两位小数使用round函数

2. 接受用户输入的函数input必须放在入口函数内，如下所示：

if name == “main“:

​ n = int(input())

​ print(round(area(n),2))

输入：

3

输出：

28.27

from math import pi

def area(r):
    return pi * r * r

if __name__ == "__main__":
    n = int(input())
    print(round(area(n), 2))

题目描述：一球从100米高度自由落下，每次落地后反跳回原高度的一半，再落下。

接收用户输入一个数字n（在1-10之间），求该球在第n次落地时共经过多少米并输出类似的信息：

该球第2次落地时，共经过了200米；求第n次反弹多高并输出类似的信息：该球

第2次反弹25米。

输入：

3

输出：

该球第3次落地时，共经过了250.0米

该球第3次反弹12.5米

n = int(input())

height = 100  # 初始高度
total = 0     # 总共经过的距离
rebound = height / 2  # 第一次反弹高度

total += height  # 第一次下落
for i in range(2, n + 1):
    total += 2 * rebound  # 下落 + 再弹起
    rebound /= 2  # 下次弹起高度

print(f"该球第{n}次落地时，共经过了{total}米")
print(f"该球第{n}次反弹{rebound}米")

知识点：函数

题目描述：回文数是一个正向和逆向都相同的整数,如123454321，9889。

编写一个函数huiwen判断一个整数是否是回文数,如果是输出消息：该数字是回文。

否则，输出消息：该数字不是回文。在入口函数中，接收用户输入的一串数字，

然后调用函数huiwen判断该数字是否为回文。

注：接受用户输入的函数input必须放在入口函数内，如下所示：

if name == “main“:

​ n = int(input())

​ print(round(area(n),2))

输入：

123454321

输出：

该数字是回文

输入：

124543525

输出：

该数字不是回文

def huiwen(n):
	s=str(n)
	if s == s[::-1]:
		print(“该数字是回文")
	else:
		return "该数字不是回文"
if __name__ == "__main__":
	n=int(input())
	print(huiwen(n))

题目描述：

接收用户输入多个字符串（字符串之间用空格分隔），利用该输入构建一个列表。输出该列表中，索引为偶数的元素

输入：

fsa asf rewr ewrew hgj kl

输出：

fsa
rewr
hgj

data = input().split()
for i in range(len(data)):
    if i%2==0:
        print(data[i])

题目描述：

现有一个学生成绩姓名列表：[‘mary’,’jerry’,’jack’,’peter’,’rose’]，对应的成绩列表是[80,65,75,85,60],请编写代码接收用户的输入，分别向两个列表里追加一名学生的姓名和对应的成绩（姓名和成绩使用空格分隔），然后输出信息恭喜最终成绩最高分的同学，鼓励最低分同学(注：输出信息中的标点符号为英文状态下的符号)

输入：

david 77

输出：

恭喜peter同学获得最高分,rose请继续努力！

names = ['mary', 'jerry', 'jack', 'peter', 'rose']
grades = [80, 65, 75, 85, 60]

s = input().split()
name = s[0]
grade = int(s[1])

names.append(name)
grades.append(grade)

max_index = grades.index(max(grades))
min_index = grades.index(min(grades))

print(f"恭喜{names[max_index]}同学获得最高分,{names[min_index]}请继续努力！")

定义一个表示学生类Student,生成实例时需要传递学生姓名和多门课程成绩，每个实例对象有name、grades_list属性，分别存储学生姓名和多门课程成绩，需要在类中定义total方法（计算并返回学生的总成绩）、定义aver方法（计算并返回学生的平均分,请使用round函数保留两位小数）、定义maxGrade方法（计算并返回学生的最高分）、定义minGrade方法（计算并返回学生的最低分）、定义print_result方法输出学生成绩统计信息。

在入口函数中，依次接收用户输入的名字和多门课程的成绩，这些数据之间使用空格分隔，然后调用Student类生成实例，再调用print_result方法输出成绩统计信息（输出信息中的符号为英文状态下的标点符号），具体形式参考测试用例，再输出该实例的name属性值。

输入：

lili 56 78 89

输出：

lili的成绩统计分析结果如下：

总成绩是:223

平均分是:74.33

最高分是:89

最低分是:56

lili

class Student:
    def __init__(self, name, *grades):
        self.name = name
        self.grades_list = list(grades)

    def total(self):
        return sum(self.grades_list)
    
    def aver(self):
        return round(sum(self.grades_list) / len(self.grades_list), 2)
    
    def maxGrade(self):
        return max(self.grades_list)
    
    def minGrade(self):
        return min(self.grades_list)
    
    def print_result(self):
        print(f"{self.name}的成绩统计分析结果如下:")
        print(f"总成绩是: {self.total()}")
        print(f"平均分是: {format(self.aver(), '.2f')}")
        print(f"最高分是: {self.maxGrade()}")
        print(f"最低分是: {self.minGrade()}")

if __name__ == "__main__":
    data = input().split()
    name = data[0]
    grades = list(map(int, data[1:]))
    student = Student(name, *grades)
    student.print_result()
    print(student.name)