python作业
基础练习
练习目标
函数
01.计算车费
题目描述
小红打车，起步价8元(3公里), 每公里收费 2 元，她打车行驶了 n 公里，通过函数封装并计算车费
输入描述
输入一个公里数
输出描述
输出应付车费
示例
输入：
5
输出：
12
def calculate_fare(distance):
base_price = 8 # 起步价
per_km_cost = 2 # 每公里费用
min_distance = 3 # 最小计费距离
if distance <= min_distance:
return base_price
else:
return base_price + (distance - min_distance) * per_km_cost
# 输入行驶的距离
n = float(input("请输入行驶的公里数："))
# 计算应付的车费
fare = calculate_fare(n)
print(f"应付车费为：{fare}元")
02.整数叠加
题目描述
读取一个0到1000之间的整数，并计算它各位数字之和
输入输出描述
输入一个[0,1000]之间的整数
输出该数字的各位数字之和
提示
需要使用内置函数 len() 或者 for循环
示例1
输入：
999
输出：
27
解释：
999各位数之和为9 + 9 + 9 = 27
def Integer_superposition(num):
sum_num = 0
while num > 0:
sum_num += num % 10 #累加
num //= 10
return(sum_num)
#输入整数
n = int(input("请输入整数："))
#计算数字之和
Sum_of_numbers = Integer_superposition(n)
print(f"数字之和为：{Sum_of_numbers}")
03.时间拆分
题目描述
输入分钟数，然后将该分钟数转换为年数和天数，假定一年有365天
输入描述
输入一个分钟数
输出描述
输出两行，第一行为年数，第二行为天数
示例
输入：
1000000000
输出：
1902
214
def convert_minutes_to_years_and_days(minutes):
# 假设一年有365天
days_per_year = 365
# 计算年数
years = minutes // (24 * 60 * days_per_year)
# 计算剩余分钟数
remaining_minutes = minutes % (24 * 60 * days_per_year)
# 将剩余分钟数转换为天数
days = remaining_minutes // (24 * 60)
return years, days
# 输入分钟数
minutes_input = int(input("请输入分钟数"))
# 调用函数转换分钟数为年数和天数
years, days = convert_minutes_to_years_and_days(minutes_input)
# 输出结果
print(f"年数为:{years}")
print(f"年数为:{days}")
04.回文素数
题目描述
回文素数是指一个数既是素数又是回文数，例如131既是素数也是回文数
输出显示前100个回文素数，每行显示10个
示例
2 3 5 7 11 101 131 151 181 191
def is_prime(num):
if num < 2:
return False
##for i in range(2, int(num**0.5)+1):
for i in range(2, int(num)):
if num % i == 0:
return False
return True
def reverse_num(num):
sum_num = ""
while num > 0:
sum_num += str(num % 10) #累加
num //= 10
return(int(sum_num))
##return int(str(num)[::-1])
count = 0
for i in range(2, 10000): # 假设回文素数不会超过9999
reversed_num = reverse_num(i)
if is_prime(i) and is_prime(reverse_num(i)) \
and i == reversed_num:
print(i, end=' ')
count += 1
if count % 10 == 0: # 每行显示10个
print()
05.反素数
题目描述
反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数
输出显示前100个反素数，每行显示10个
def is_prime(num):
if num < 2:
return False
##for i in range(2, int(num**0.5) + 1):
for i in range(2, int(num)):
if num % i == 0:
return False
return True
def reverse_number(num):
# sum_num = ""
# while num > 0:
# sum_num += str(num % 10) #累加
# num //= 10
# return int(sum_num)
return int(str(num)[::-1])
count = 0
result = []
for i in range(10000):
reversed_num = reverse_number(i)
if is_prime(i) and is_prime(reversed_num) \
and i != reversed_num:
result.append(i)
count += 1
if count == 100:
break
print(result)
# for i in range(0, len(result), 10):
# print(' '.join(map(str, result[i:i+10])))
06.双素数
题目描述
双素数是指一对差值为2的素数，例如3和5就是一对双素数，5和7也是一对双素数
输出显示小于1000的双素数
def is_prime(n):
if n <= 1:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
for i in range(2, 1000):
if is_prime(i): # 确保i是素数
for j in range(i+2, 1000, 2): # 检查差值为2的下一个数是否也是素数
if is_prime(j):
print(f"{i} 和 {j} 是一对双素数")
break
07.梅森素数
如果一个素数可以写成$2^p-1$的形式，其中p是某个正整数，那么这个素数就称作梅森素数
输出p≤31的所有梅森素数
for p in range(1, 32):
for i in range(2, 2 ** p - 1):
if (2 ** p - 1) % i == 0:
continue
print(2 ** p - 1)
# for p in range(1, 32):
# print(2 ** p - 1)
08.堆叠相加
题目描述
现有堆叠相加模式$a+aa+aaa+aaaa+aaaaa+......$
例如：$2+22+222+2222+22222$，其中a为2，且有5组数字
输入输出描述
输入两个数据分别为数字a和组数n
输出按照堆叠相加模式算出的和
示例
输入：
3 4
输出：
3702
解释：
3 + 33 + 333 + 3333 = 3702
def stack_addition(a, n):
result = 0
num_str = ""
for i in range(1, n + 1):
j = 1
num_str = ""
while j <= i:
num_str += str(a)
j += 1
result += int(num_str)
return result
a, n = map(int, input("请输入a,n(用空格隔开):").split())
print(stack_addition(a, n))
09.检测密码
题目描述
一些网站会给密码强加一些规则：
（1）密码必须至少有8个字符
（2）密码只能包含英文字母和数字
（3）密码应该至少包含两个数字
（4）密码应该至少包含两个大写字母
如果密码符合规则，输出Yes；否则输出No
输入输出描述
输入一串密码
输出该密码是否符合规则
示例1
输入：
123456ab
输出：
No
示例2
输入：
123abcABC
输出：
Yes
def check_password_strength(password):
# 规则1：密码必须至少有8个字符
if len(password) < 8:
return False
# 规则2：密码只能包含英文字母和数字
if not password.isalnum():
return False
# print("Python3".isalnum()) # 输出: True
# print("Python 3".isalnum()) # 输出: False，因为包含空格
# print("Python!".isalnum()) # 输出: False，因为包含非字母数字字符 '!'
# print("123456".isalnum()) # 输出: True
# print("".isalnum()) # 输出: False，因为字符串为空
# 规则3：密码应该至少包含两个数字
if sum(c.isdigit() for c in password) < 2:
return False
# password = "abc1"
# if sum(c.isdigit() for c in password) < 2:
# print("密码需要至少包含2个数字")
# else:
# print("密码强度足够")
# 规则4：密码应该至少包含两个大写字母
if sum(c.isupper() for c in password) < 2:
return False
# 如果所有规则都满足
return True
print("****************************************")
print("（1）密码必须至少有8个字符")
print("（2）密码只能包含英文字母和数字")
print("（3）密码应该至少包含两个数字")
print("（4）密码应该至少包含两个大写字母")
print("****************************************")
# 输入一串密码
password = input("请输入密码:")
# 输出该密码是否符合规则
if check_password_strength(password):
print("密码符合规则")
else :
print("密码不符合规则")
10.指定等级
题目描述
读入学生成绩，获取最高分best，然后根据下面的规则赋等级值：
（1）如果分数≥best-10，等级为A
（2）如果分数≥best-20，等级为B
（3）如果分数≥best-30，等级为C
（4）如果分数≥best-40，等级为D
（5）其他情况，等级为F
输入输出描述
输入两行，第一行输入学生人数n，第二行输入n个学生的成绩
输入n行，表示每个学生的成绩等级
示例
输入：
4
40 55 70 58
输出：
学生0分数为40，等级为C
学生1分数为55，等级为B
学生2分数为70，等级为A
学生3分数为58，等级为B
n = int(input())
scores = list(map(int, input().split()))
best = max(scores)
for i in range(n):
if scores[i] >= best - 10:
grade = 'A'
elif scores[i] >= best - 20:
grade = 'B'
elif scores[i] >= best - 30:
grade = 'C'
elif scores[i] >= best - 40:
grade = 'D'
else:
grade = 'F'
print(f'学生{i}分数为{scores[i]}，等级为{grade}')
拓展作业
w01. 斐波那契数列
题目描述
斐波那契数列是一种特殊的数列，很多生活和企业场景中都能见到满足该数列的数据排列方式；现在要求你封装一个用于获取斐波那契数列数据的功能函数，用于底层数据支持；
输入描述
输入一个整数n
输出描述
输出位置为n的斐波那契数列对应的数据
示例
输入：1
输出：1
输入：3
输出：2
输入：8
输出：21
# def fibonacci(n):
# if n <= 0:
# return "输入必须是一个正整数"
# elif n == 1 or n == 2:
# return 1
# else:
# a, b = 1, 1
# for i in range(3, n + 1):
# a, b = b, a + b
# return b
# # 测试代码
# a = int(input("斐波那契数列对应位置:"))
# b = fibonacci(a)
# print(f"位置为{a}的斐波那契数列对应的数据:{b}")
def fibonacci(n):
fib_sequence = [0, 1]
for i in range(2, n):
next_number = fib_sequence[i - 1] + fib_sequence[i - 2]
fib_sequence.append(next_number)
return fib_sequence[:n]
# 计算斐波那契数列的前10项
a = int(input("斐波那契数列对应位置:"))
scores = list(fibonacci(a + 1))
print(f"位置为{a}的斐波那契数列对应的数据:{scores[a]}")
w02. 密码等级校验
题目描述
按照用户输入密码的字符，判断用户的密码强度，基本要求如下
-
弱：都是数字，或者都是大写字母/小写字母组成的密码
-
中等：[数字、大写字母] 或者 [数字、小写字母] 或者 [大写字母、小写字母] 或者 [大小写字母、数字]组成的密码
-
强：[数字、大写字母] 或者 [数字、小写字母] 或者 [大写字母、小写字母]并结合特殊符号组成的密码
输入描述
用户输入一个字符串密码
输出描述
输出密码强度等级
示例
输入：abcdef
输出：弱密码
输入：abc123
输出：中等强度
输入：Abc123%
输出：强密码
def check_password_strength(password):
counte = 0
if any(char.isdigit() for char in password) :
##判断字符串中的所有字符是否都是数字。
counte += 1
if any(char.isupper() for char in password):
##检查字符串中的所有字母字符是否都是大写。
counte +=1
if any(char.islower() for char in password):
##检查字符串中的所有字符是否都是小写字母。
counte +=1
if not all(char.isalnum() for char in password):
##检查字符串是否由特殊字符组成。
counte +=1
return counte
example = input("请输入密码:")
if check_password_strength(example) == 1:
print("弱密码")
if check_password_strength(example) == 2 or check_password_strength(example) == 3:
print("中等强度")
if check_password_strength(example) == 4:
print("强密码")w03. 密码加密
题目描述
编写一个函数，实现密码的错位加密
编写一个函数，实现密码的错位解密
输入描述
输入一个字符串明文密码；
输入一个字符串密文数据；
输出描述
打印展示加密后的字符串密文
打印展示解密后的明文字符串
示例
输入：
abc # 明文
def # 密文
输出：
cde # 错位密文（具体错位可以自定义）
cde # 解密明文（具体错位可以自定义）
代码实现
-
下面代码已经实现了基本功能，但是存在BUG(请找出并修正它)
def encrypt(password, n=4):
"""加密函数"""
ep = ""
for i in str(password):
ac = ord(i)
ac += n
_ac = chr(ac)
ep += _ac
return ep
def decrypt(password, n=4):
"""解密函数"""
pwd = ""
for i in str(password):
ac = ord(i)
ac -= n
_ac = chr(ac)
pwd += _ac
return pwd
pd = input("请输入明文数据：")
print("加密后的数据：", encrypt(pd, 5))
pd2 = input("请输入密文数据：")
print("解密后的数据：", decrypt(pd2, 5))
def encrypt(password, n):
"""加密函数"""
ep = ""
for i in str(password):
ac = ord(i)
ac += n
if ac > 126 :
ac = ac - 126 + 33
else:
ac = ac
_ac = chr(ac)
ep += _ac
return ep
def decrypt(password, n):
"""解密函数"""
pwd = ""
for i in str(password):
ac = ord(i)
ac -= n
if ac < 33 :
ac = 126 - ( 33 - ac )
else:
ac = ac
_ac = chr(ac)
pwd += _ac
return pwd
pd = input("请输入明文数据：")
print("加密后的数据：", encrypt(pd, 5))
pd2 = input("请输入密文数据：")
print("解密后的数据：", decrypt(pd2, 5))