Python编程题

已于 2024-12-16 19:20:16 修改
阅读量1.2k 收藏 29
点赞数 20
文章标签： python 前端 开发语言
于 2024-12-16 18:25:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoyushashasha/article/details/144515160
版权

24-25-1Python基础知识作业

7-1 求三位数各位数字

n = int(input())
if n < 0:
    n = -n
 
one = n % 10
hundred = n // 100
ten = n // 10 % 10
print(one,ten,hundred)

7-2 简易计算器

a=int(input())
b=int(input())
print("{} + {} = {}".format(a,b,a+b))
print("{} - {} = {}".format(a,b,a-b))
print("{} * {} = {}".format(a,b,a*b))
print("{} / {} = {}".format(a,b,a/b))

7-3 求圆周长和面积

r = int(input())
print("{:.2f} {:.2f}".format(3.14159 * r * 2, 3.14159 * r * r))

7-4 英文字母的大小写转换

a, b = input().split()
print("{},{}".format(a.lower(), b.upper()))

7-5 4位整数的数位和

num = list(map(int,input()))
print(sum(num))

代码解释

  1. 输入读取:

    • input(): 从用户那里读取一行输入，返回一个字符串。

  2. 字符转换为整数列表:

    • map(int, input()): 对输入的每个字符应用 int 函数，将字符转换为整数。
    • list(...): 将 map 对象转换为列表，得到每个数字的整数列表。

  3. 计算和:

    • sum(num): 计算列表 num 中所有整数的和。

功能说明

  • 该代码从用户输入中读取一串数字字符。
  • 将每个字符转换为整数，并计算这些整数的总和。
  • 输出结果是这些数字的和。

示例

如果用户输入 123：

  • input() 返回字符串 '123'。
  • map(int, input()) 将其转换为整数 1, 2, 3。
  • list(...) 将其变为 [1, 2, 3]。
  • sum(num) 计算出 6，然后输出。

7-6 交换两个整数

a , b = input().split()
a , b = b , a
print("a={} b={}".format(a,b))

7-7 字符串加密

s = input()
m = ""

for i in s:
    if i.islower():
        i = chr((ord(i) - ord('a') + 3) % 26 + ord('a'))
    elif i.isupper():
        i = chr((ord(i) - ord('A') + 5) % 26 + ord('A'))
    m += i

print(m)

当然，下面是这一段代码的详细解释：

目标

对小写字母进行 Caesar cipher 加密，偏移量为 3。

代码详解

if c.islower():
    result += chr(ord('a') + ((ord(c) - ord('a')) + 3) % 26)

  1. c.islower():

    • 检查字符 c 是否为小写字母。如果是，执行加密操作。

  2. ord(c):

    • 获取字符 c 的 ASCII 值。例如，ord('a') 返回 97。

  3. ord(c) - ord('a'):

    • 计算字符 c 在字母表中的位置。例如，对于 c = 'b'，计算结果是 ord('b') - ord('a') = 1。

  4. ((ord(c) - ord('a')) + 3) % 26:

    • 将字母表位置加上偏移量 3。
    • 使用 % 26 确保结果在 0 到 25 之间，这样可以循环回到字母表开头。

  5. ord('a') + ...:

    • 将偏移后的字母表位置转换回 ASCII 值。例如，如果结果是 4，加上 ord('a') 就得到 ord('e')。

  6. chr(...):

    • 将新的 ASCII 值转换回字符。

  7. result += ...:

    • 将加密后的字符追加到 result 字符串中。

示例

假设 c = 'b'：

  • ord('b') - ord('a') = 1
  • 1 + 3 = 4
  • 4 % 26 = 4
  • ord('a') + 4 = 101
  • chr(101) = 'e'

因此，'b' 被加密为 'e'。

7-8 去掉重复的字符

s = input()  # 读取输入字符串
m = ""       # 初始化一个空字符串用于存储结果

for i in s:  # 遍历输入字符串的每个字符
    if i not in m:  # 如果字符不在结果字符串中
        m = m + i   # 将字符添加到结果字符串中

print(m)  # 输出去重后的结果

7-9 对角线 - 实验3 简单的计算及输入输出

import math
length = float(input())
width = float(input())
dui = math.sqrt(length**2 + width**2)
print("对角线长度为:{:.1f}cm.".format(dui))

7-10 游客检票

m = int(input())
n = int(input())

y = (6 * n - 8 * m) / (n - m)
x = (8 - y) * m
z = x / (10 - y)

print("原有排队游客份数:{:.1f}, 每分钟新到游客份数:{:.1f}, 10口同开需{:.1f}分钟清零待检票游客.".format(x, y, z))

3a7bfd81280ca67065a36d0be535e4f.png
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

24-25-1Python程序控制结构习题

7-1 jmu-python-汇率兑换

m = input()
n = int(m[1:])
if m[0] == "R":
    print("${:.2f}".format(n / 6.0))
elif m[0] == "$":
    print("R{:.2f}".format(n * 6.0))

当然可以！这段代码的目的是在两种货币之间进行转换。具体来说，它根据输入的字符串决定是从“R”转换为“ ”，还是从“ ”，还是从“ ”，还是从“”转换为“R”。以下是详细的解释：

n = int(m[1:])
  • m[1:] 提取输入字符串的第二个字符到最后一个字符（即去掉第一个字符“R”或“$”）。
  • int() 将提取的字符串转换为整数，这个整数代表货币的数值部分。

7-2 24小时制

time = input()

# 分割输入的时间为小时和分钟
hours, minutes = map(int, time.split(':'))

# 判断是AM还是PM
if hours == 0:
    period = 'AM'
    hours = 12
elif hours < 12:
    period = 'AM'
elif hours == 12:
    period = 'PM'
else:
    period = 'PM'
    hours -= 12

# 输出格式化的12小时制时间
print("{}:{} {}".format(hours, minutes, period))

当然可以！这段代码的目的是将输入的时间字符串解析为整数形式的小时和分钟。以下是详细解释：

hours, minutes = map(int, time.split(':'))

  1. time.split(':'):

    • split(':') 方法用于将字符串 time 按照 : 分割成一个列表。
    • 例如，输入 21:11 会被分割成 ['21', '11']。

  2. map(int, ...):

    • map() 函数会将指定的函数（这里是 int）应用到 split 生成的列表的每一个元素上。
    • int 函数将字符串转换为整数。
    • 所以 ['21', '11'] 会被转换为 [21, 11]。

  3. hours, minutes = ...:

    • 这是一个解包（unpacking）操作，将 map 返回的结果（即 [21, 11]）分别赋值给 hours 和 minutes。
    • hours 会得到 21，minutes 会得到 11。

这行代码的作用是：

  • 将输入的时间字符串按 : 分割。
  • 将分割后的字符串部分转换为整数。
  • 分别赋值给 hours 和 minutes 变量。

7-3 输入一个数，判断是不是水仙花数

n = int(input())
ge = int(n % 10)  # 个位
shi = int(n // 10 % 10)  # 十位
bai = int(n // 100)  # 百位

if n >= 100 : # 水仙花数是一个三位整数
    if ge**3 + shi**3 + bai**3 == n:
        print("该数是水仙花数")
    else:
        print("该数不是水仙花数")
else:
    print("输入错误，不是一个三位数")

7-4 输出某年某月的天数

year = int(input())
month = int(input())
day = 0

if 1 <= month <= 12:
    if month in [1, 3, 5, 7, 8, 10, 12]:
        day = 31
    elif month in [4, 6, 9, 11]:
        day = 30
    elif month == 2:
        if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
            day = 29
        else:
            day = 28
    print("{}年{}月是{}天".format(year, month, day))
else:
    print("输入错误，月份不正确")

import calendar

year = int(input())
month = int(input())

days = calendar.monthrange(year, month)[1]
print("{}年{}月是{}天".format(year, month, days))


days = calendar.monthrange(year, month)[1]
  • calendar.monthrange(year, month) 返回一个元组 (weekday, num_days)。
  • [1] 访问元组中的第二个元素 num_days，即该月的总天数。
  • days 变量被赋值为该月的总天数。

示例

假设用户输入的年份是 2023，月份是 10，那么：

year = 2023
month = 10

days = calendar.monthrange(year, month)[1]
  • calendar.monthrange(2023, 10) 返回 (6, 31)，表示 2023 年 10 月的第一天是星期六，该月有 31 天。
  • [1] 访问元组中的第二个元素 31，所以 days 的值为 31。

总结

days = calendar.monthrange(year, month)[1] 这段代码的作用是获取指定年份和月份的总天数，并将其赋值给变量 days。

7-5 输出一个数的因子

n = int(input())
y = []

for i in range(1, n + 1):
    if n % i == 0:
        y.append(i)

print(y)

代码解释

1. 输入整数 n

n = int(input())
  • input()：从用户那里获取输入，返回的是一个字符串。
  • int()：将输入的字符串转换为整数类型。
  • n：存储用户输入的整数。

2. 初始化空列表 y

y = []
  • y：创建一个空列表，用于存储 n 的所有因数。

3. 循环遍历从 1 到 n 的所有整数

for i in range(1, n + 1):
  • range(1, n + 1)：生成从 1 到 n 的整数序列（包括 n）。
  • for i in range(1, n + 1):：遍历这个序列中的每一个整数 i。

4. 判断 i 是否是 n 的因数

if n % i == 0:
  • n % i：计算 n 除以 i 的余数。
  • if n % i == 0:：如果余数为 0，说明 i 是 n 的因数。

5. 将因数 i 添加到列表 y 中

y.append(i)
  • y.append(i)：将 i 添加到列表 y 的末尾。

6. 输出列表 y

print(y)
  • print(y)：打印列表 y，其中包含 n 的所有因数。

示例

假设用户输入 n = 12，那么程序的执行过程如下：

  1. 输入:

    • n = 12

  2. 初始化列表:

    • y = []

  3. 循环遍历:

    • i = 1: 12 % 1 == 0，1 是因数，y = [1]
    • i = 2: 12 % 2 == 0，2 是因数，y = [1, 2]
    • i = 3: 12 % 3 == 0，3 是因数，y = [1, 2, 3]
    • i = 4: 12 % 4 == 0，4 是因数，y = [1, 2, 3, 4]
    • i = 6: 12 % 6 == 0，6 是因数，y = [1, 2, 3, 4, 6]
    • i = 12: 12 % 12 == 0，12 是因数，y = [1, 2, 3, 4, 6, 12]

  4. 输出:

    • print(y)：输出 [1, 2, 3, 4, 6, 12]

总结

这段代码的作用是找出用户输入的整数 n 的所有因数，并将这些因数存储在一个列表中，最后打印出这个列表。

7-6 sdut-显示指定范围的素数并求和

m, n = input().split()
m = int(m)
n = int(n)
list = []
sum = 0

for i in range(m, n + 1):
    for j in range(2, i):
        if i % j == 0:
            break
    else:
        list.append(i)
        sum += i

for i in range(0, len(list)):
    print(list[i], end='')
    if (i + 1) % 5 != 0 and i + 1 != len(list):
        print(' ', end='')
    else:
        print()

print("amount={} sum={}".format(len(list), sum))

好的！我们可以使用 str.format() 方法来格式化输出。以下是修改后的代码：

m, n = input().split()
m = int(m)
n = int(n)
i_list = []
sum = 0

for i in range(m, n + 1):
    for j in range(2, i):
        if i % j == 0:
            break
    else:
        i_list.append(i)
        sum += i

for i in range(0, len(i_list)):
    print(i_list[i], end='')
    if (i + 1) % 5 != 0 and i + 1 != len(i_list):
        print(' ', end='')
    else:
        print()

print("amount={} sum={}".format(len(i_list), sum))

代码解释

  1. 输入 m 和 n:

    • m, n = input().split()：从用户那里获取输入，并将其按空格分割成两个部分。
    • m = int(m) 和 n = int(n)：将分割后的字符串转换为整数类型。

  2. 初始化列表和变量:

    • i_list = []：用于存储素数的列表。
    • sum = 0：用于累加素数的总和。

  3. 找出 [m, n] 范围内的素数:

    • for i in range(m, n + 1):：遍历从 m 到 n 的所有整数。
    • for j in range(2, i):：对于每个 i，检查从 2 到 i-1 的所有整数 j，看是否存在 j 使得 i % j == 0。
    • if i % j == 0:：如果存在这样的 j，说明 i 不是素数，跳出内层循环。
    • else:：如果内层循环正常结束（没有找到 j 使得 i % j == 0），说明 i 是素数，将其添加到 i_list 中，并累加到 sum。

  4. 输出素数列表:

    • for i in range(0, len(i_list)):：遍历素数列表 i_list。
    • print(i_list[i], end='')：打印当前素数，不换行。
    • if (i + 1) % 5 != 0 and i + 1 != len(i_list):：如果当前素数不是每行的第 5 个，并且不是最后一个素数，打印一个空格。
    • else:：否则，换行。

  5. 输出素数的总数和总和:

    • print("amount={} sum={}".format(len(i_list), sum))：使用 str.format() 方法格式化输出素数的总数和总和。

示例

假设用户输入 m = 2 和 n = 15，那么程序的执行过程如下：

  1. 输入:

    • m = 2
    • n = 15

  2. 初始化:

    • i_list = []
    • sum = 0

  3. 找出素数:

    • i = 2: 素数，i_list = [2], sum = 2
    • i = 3: 素数，i_list = [2, 3], sum = 5
    • i = 4: 不是素数
    • i = 5: 素数，i_list = [2, 3, 5], sum = 10
    • i = 6: 不是素数
    • i = 7: 素数，i_list = [2, 3, 5, 7], sum = 17
    • i = 8: 不是素数
    • i = 9: 不是素数
    • i = 10: 不是素数
    • i = 11: 素数，i_list = [2, 3, 5, 7, 11], sum = 28
    • i = 12: 不是素数
    • i = 13: 素数，i_list = [2, 3, 5, 7, 11, 13], sum = 41
    • i = 14: 不是素数
    • i = 15: 不是素数

  4. 输出素数列表:

    • 2 3 5 7 11
    • 13

  5. 输出总数和总和:

    • amount=6 sum=41

总结

这段代码的功能是找出给定范围内的所有素数，并按每行 5 个的格式输出这些素数，最后使用 str.format() 方法格式化输出素数的总数和它们的总和。

7-7 编程求一个字符串中有多少个字母和数字字符。

s = input()
num = 0

for i in s:
    if "A" <= i <= "Z" or "a" <= i <= "z" or "0" <= i <= "9":
        num += 1

print(num)

7-8 斐波那契数列—实验2

print("0   1   1   2   3   5   8   13   21   34   55   89   ")

7-9 输出100以内的偶数，每5个换行

for i in range(1, 101):
    if i % 2 == 0:
        print('{} '.format(i), end='')
    if i % 10 == 0:
        print()

7-10 n行n列的三角形星星图形

n = int(input())

for i in range(1, n + 1):
    print('*' * i)

7-11 使用沃利斯公式估算圆周率的值

n = int(input())

pi = 1.0
for i in range(1, n // 2 + 1):# 1000项有500对
    pi *= (2 * i) / (2 * i - 1) #第一个数
    pi *= (2 * i) / (2 * i + 1) #第二个数

pi *= 2 #pi/2移项
print("{:.12f}".format(pi))

7-12 火车站行李费的收费

n = float(input())
if n > 0:
    if n > 50:
        total = (n - 50) * 0.5 + 10
    else:
        total = n * 0.2
    print("应付的行李费是：{:.2f}".format(total))
else:
    print("非法输入")

7-13 商场做周年庆活动

n = float(input())

if n < 0:
    print("非法输入！")
elif 1000 <= n < 2000:
    m = n * 0.9
    print("用户可以享受9折优惠，需支付金额为：{:.1f}".format(m))
elif 2000 <= n < 3000:
    m = n * 0.8
    print("用户可以享受8折优惠，需支付金额为：{:.1f}".format(m))
elif n >= 3000:
    m = n * 0.7
    print("用户可以享受7折优惠，需支付金额为：{:.1f}".format(m))
else:
    m = int(n)
    print("用户没有折扣，需支付金额为：{:.1f}".format(m))

7-14 设计一个“计算器”

n = int(input())
m = int(input())
s = input()

if s == '+':
    result = n + m
    print("{}+{}={}".format(n, m, result))
elif s == '-':
    result = n - m
    print("{}-{}={}".format(n, m, result))
elif s == '*':
    result = n * m
    print("{}*{}={}".format(n, m, result))
elif s == '/':
    if m == 0:
        print("除数不能为0！")
    else:
        result = n / m
        print("{}/{}={}".format(n, m, result))

7-15 计算水费

x = float(input())

if x <= 15:
    y = 4 * x / 3
else:
    y = 2.5 * x - 17.5

print(round(y, 2))

7-16 判断是否允许登机

ticket, security = map(int, input().split(','))

if ticket == 0:
    print("没有机票不能登机")
elif security == 0:
    print("未通过安检，不能登机")
else:
    print("请登机")

7-17 分支–将百分制转换为五级积分制

score = int(input())

if 90 <= score <= 100:
    grade = 5
elif 80 <= score < 90:
    grade = 4
elif 70 <= score < 80:
    grade = 3
elif 60 <= score < 70:
    grade = 2
else:
    grade = 1

print("{}分对应的五分制为{}".format(score, grade))

7-18 p019车牌限号

plate = input().strip()  # 输入车牌号

# 提取车牌号的最后一位字符
last_char = plate[-1]

# 检查最后一位是否是奇数
if last_char in '13579':
    print("YES")
else:
    print("NO")

7-19 zust-sy3-9 吹气球

v, m, n = map(int, input().split(','))

if v <= 0 or m <= 0 or m <= n:
    print("Valid")
else:
    days = 0
    current_volume = 0
    while current_volume <= v:
        days += 1
        current_volume += m
        if current_volume > v:
            break
        current_volume -= n
    print(days)

24-25-1Python组合数据类型（实验）

7-1 jmu-python-从列表中删除元素

n = int(input())
for i in range(n):
    a = input().split()
    x = input()
    a = [j for j in a if x != j]
    print(*a)

这段代码用于从输入的字符串列表中移除特定的元素。以下是详细解释：

步骤解析

  1. 读取组数：

    • n = int(input())：从标准输入读取一个整数，表示接下来有多少组数据需要处理。

  2. 循环处理每组数据：

    • for _ in range(n):：循环 n 次，处理每一组数据。

  3. 输入处理：

    • a = input().split()：读取一行输入，将其按空格分割成一个列表 a。
    • x = input()：读取要删除的元素 x。

  4. 过滤列表：

    • a = [j for j in a if j != x]：使用列表推导式创建一个新列表，包含 a 中所有不等于 x 的元素。

  5. 输出结果：

    • print(*a)：使用解包运算符 * 将列表 a 中的元素打印出来，元素之间自动用空格分隔。如果列表为空，输出为空行。

示例

输入

2
apple banana orange
banana
cat dog bird
dog

输出

apple orange
cat bird

关键点

  • 列表推导式：用于高效地过滤列表。
  • 解包运算符 *：用于将列表元素按空格分隔打印。
  • 灵活性：适用于处理多个数据组，每组数据可以有不同的列表和要移除的元素。

7-2 计算 11+12+13+…+m

m = int(input())
sum = 0
for i in range(11, m + 1):
    sum += i
print("sum = {}".format(sum))

7-3 统计并输出字符串中小写元音字母的个数

m=input()
sum=0
for i in m:
    if i=='a' or i=='e' or i=='i' or i=='o' or i=='u':
        sum+=1
print(sum)

y = 'aeiou'
s = input()
sum = 0
for i in s:
    if i in y:
        sum+= 1
print(sum)

7-4 计算各对应位乘积之和

n, m = map(int, input().split())
n = abs(n)
m = abs(m)
sum = 0

while 1:
    if(n==0 and m==0):
        break
    x = n % 10  # 取 n 的最后一位
    y = m % 10  # 取 m 的最后一位
    sum += (x * y)  # 计算对应位的乘积并累加
    n //= 10  # 去掉 n 的最后一位
    m //= 10  # 去掉 m 的最后一位

print(sum)

7-5 列表或元组的数字元素求和(难)

# 读取输入并使用 eval 解析为 Python 对象
a = eval(input())

# 初始化空列表、空字符串和求和变量
l = []
s = ''
sum = 0

# 遍历输入对象中的每个元素
for i in a:
    # 如果元素是整数，直接累加到 sum
    if(type(i) == type(1)):
        sum += i
    # 如果元素是字符串，跳过
    elif(type(i) == type(s)):
        continue
    # 如果元素是列表或元组，遍历其中的元素
    elif(type(i) == type(l)):
        for j in i:
            # 如果子元素是整数，累加到 sum
            if(type(j) == int):
                sum += int(j)
    # 如果元素是其他可迭代对象（如元组），遍历其中的元素
    else:
        for j in i:
            sum += j

# 输出求和结果
print(sum)

7-6 能被3,5和7整除的数的个数（用集合实现）

sum=0
n,m=input().split()
n=int(n)
m=int(m)
for i in range(n,m):
        if(i%105==0):
            sum+=1
print(sum)

7-7 大于身高的平均值

x =list(map(int,input().split()))
sum=0
for i in x:
    sum+=i
    
ave=sum/len(x)

for i in x:
    if (i>ave):
        print(i,end=' ')

7-8 列表去重

a = list(eval(input()))  # 读取输入并解析为列表
b = []  # 用于存储不重复的元素

# 遍历输入列表
for i in a:
    if i not in b:  # 如果元素不在 b 中，添加到 b
        b.append(i)

# 输出不重复的元素，按要求格式化输出
for i in b:
    if i == b[-1]:  # 如果是最后一个元素，直接输出
        print(i)
    else:  # 否则在后面加上空格
        print(i, end=' ')

7-9 缩写期刊名

n = int(input())  # 读取测试数据的组数
for i in range(n):
    words = input().lower().split()  # 将输入转换为小写并拆分为单词列表
    result = []
    
    for word in words:
        if len(word) > 4:
            result.append(word[0:4] + ".")  # 长度超过4的单词截取前4个字母并加上句号
        else:
            result.append(word)  # 长度不超过4的单词保持不变
    
    print(" ".join(result))  # 将结果列表中的单词用空格连接并输出

7-10 成绩统计

n = int(input())  # 读取班级人数
scores = list(map(int, input().split()))  # 读取成绩并转换为整数列表

# 计算最高分、最低分、平均分和不及格人数
max = max(scores)
min = min(scores)
average = sum(scores) / n
fail = sum(1 for score in scores if score < 60)
# 1 是用来计数的。每当找到一个不及格的分数（小于 60），就生成一个 1。
# sum(...) 会把这些 1 加起来，得到不及格学生的总人数。

# 输出结果
print("Max: {}".format(max))
print("Min: {}".format(min))
print("Ave: {:.1f}".format(average))
print("Fail: {}".format(fail))

fail = 0
for i in scores:
    if i < 60:
        fail += 1

fail = sum(1 for score in scores if score < 60) # 等价于

7-11 找出不是公共的元素

m = input().split()
n = input().split()
k = []
for i in m:
    if i not in n and i not in k:
        k.append(i)
for i in n:
    if i not in m and i not in k:
        k.append(i)
print(' '.join(k))

7-12 找列表中最大元素的下标

a = list(map(int, input().split(",")))  # 读取输入并转换为整数列表
m = max(a)  # 找到列表中的最大值

# 遍历列表，打印所有最大值的下标
for i in range(len(a)):
    if a[i] == m:
        print(i)

7-13 将数据排序

a=list(map(int,input().split()))
a.sort()
for i in a:
    print(i,end=" ")

7-14 求整数序列中出现次数最多的数

from collections import Counter

# 读取输入并转换为整数列表
a = list(map(int, input().split()))

# 统计每个整数的出现次数
count = Counter(a)

# 找到出现次数最多的整数及其次数
m, max_count = count.most_common(1)[0]

# 使用 format 格式化输出
print("{} {}".format(m, max_count))

7-15 统计正数和负数的个数

# 读取输入并转换为整数列表
nums = list(map(int, input().split(',')))

# 初始化计数器和总和
x = 0  # 正数计数
y = 0  # 负数计数
total = 0

# 遍历列表统计正数、负数并计算总和
for num in nums:
    if num > 0:
        x += 1
    elif num < 0:
        y += 1
    total += num

# 计算平均值
avg = total / len(nums)

# 输出正数和负数的个数
print("{},{}".format(x, y))

# 输出平均值，保留两位小数
print("{:.2f}".format(avg))

24-25-1Python函数（实验）

6-1 编写函数计算薪资

def salary(sales):
    a = 5000
    if sales <= 10000:
        return a
    elif 10000 < sales <= 20000:
        return a + (sales * 0.1)
    elif 20000 < sales <= 50000:
        return a + (sales * 0.15)
    elif 50000 < sales <= 100000:
        return a + (sales * 0.2)
    else:
        return a + (sales * 0.25)

6-2 整数数位和

def digitSum(v):
    s = str(v)
    sum = 0
    for x in s:
        sum += int(x)
    return sum

6-3 成绩绩点计算

def GPA(*lst):
    avg = 0.0
    for i in lst:
        if i >= 90:
            avg += 4.5
        elif i >= 80:
            avg += 3
        elif i >= 70:
            avg += 1.5
        elif i >= 60:
            avg += 1
    avg = avg / len(lst)
    print("{:.2f}".format(avg))

6-4 接收n个数字，求这些参数之和

def sum_func(*args):
    return sum(args)

6-5 求期末总评成绩

def score(quiz,usual,end,quiz_rate=0.3,usual_rate=0.15):
    end_rate = 1-quiz_rate-usual_rate
    exam = quiz*quiz_rate+usual*usual_rate+end*end_rate
    return exam

6-6 使用函数求素数和

def prime(p):
    flag =0
    # 1 不是素数 2 是
    if p==1:
        return False
    for i in range(2, p):
        if p % i == 0:
            flag = 1
    if flag ==1:
        return False
    else:
        return True
 
 
def PrimeSum(m, n):
    sum = 0
    for i in range(m, n + 1):
        if prime(i):
            sum += i
    return sum

6-7 jmu-python-函数-圆形生成器

import math
def getCircleArea(r):
    return math.pi*r*r
 
def get_rList(n):
    list=[]
    for i in range(n):
        x=eval(input())
        list.append(x)
    return list

6-8 编写函数求短语的缩写词

def acronym(phrase):
    phrase = phrase.upper().split()
    res = ""
    for i in range(len(phrase)):
        x = phrase[i][0]
        res += x
    return res

7-1 求忽略正负号的整数平均值

a = eval(input())
a = [abs(i) for i in a]
print("{:.2f}".format(sum(a) / len(a)))

7-2 整数逆序输出

s=input()
s=s[::-1]
print(int(s))

24-25-1Python类和对象（实验）

7-2 设计一个行星类

from math import pi

qt = input().split()
n = qt[0]
r = int(qt[1])
q = int(qt[2])

volume = r**3 * pi * 4 / 3
surface_area = r**2 * 4 * pi
density = q / volume

print("{}的体积={:.7f}，表面积={:.7f}，密度={:.7f}".format(n, volume, surface_area, density))

7-3 设计一个句子Sentence类

# 输入字符串
s = input()

# 计算字符数和单词列表
ccnt = len(s)
words = s.split()
wcnt = len(words)

# 转换为大写
daxie = s.upper()

# 输出
print("输入的字符串是：{}，共有{}个字符。".format(s, ccnt))
print("其中有单词：{}，共有{}个单词。".format(words, wcnt))

# 输出大写版本
print("输入的字符串是：{}，共有{}个字符。".format(daxie, ccnt))
print("其中有单词：{}，共有{}个单词。".format(daxie.split(), wcnt))

7-4 银行账户BankAccount类

# 读取初始余额和操作数
balance = int(input().strip())
n = int(input().strip())

# 设置当前余额
current = balance

# 处理每个操作
for i in range(n):
    op, amt = input().split()
    amt = int(amt)
    
    if op == 'w':  # 提款
        if current >= amt:
            current -= amt
        else:
            print("Insufficient balance.", end="")
    elif op == 'd':  # 存款
        current += amt
    
    # 输出当前余额
    print("balance: {}".format(current))

7-5 宿舍谁最高

n = int(input().strip())
dorms = {}

for i in range(n):
    d, name, h, w = input().strip().split()
    h = int(h)
    
    if d not in dorms or h > dorms[d][1]:
        dorms[d] = (name, h, w)

for d in sorted(dorms):
    name, h, w = dorms[d]
    print(d, name, h, w)

7-6 sdut-Time类的定义与使用

# 读取输入的三个整数
h, m, s = map(int, input().split())

# 处理秒钟和进位
if s >= 60:
    s = 0

# 处理分钟和进位
if m >= 60:
    m = 0

# 处理小时
if h > 12:
    h = 12

# 格式化并输出结果
print("{:02}:{:02}:{:02}".format(h, m, s))

24-25-1Python异常处理（实验）

6-1-1 具有异常处理能力的CircleException类

    def __init__(self,eid=1003,message='Radius Less Than Zero'):
        self.eid=eid
        self.message=message

    def Area(self,radius):
        if radius <=0:
            raise CircleException(eid=1003, message='Radius Less Than Zero')
        else:
            print("Area={:.2f}".format(radius * radius * math.pi))
class ExceptionDemo(CircleException):
    pass

7-1 jmu-分段函数l

try:
    x = float(input())
    if x <= -2:
        y = -2 * x - 1
    elif -2 < x <= 1:
        y = 3
    else:
        y = 2 * x + 1
    print("y={:.2f}".format(y))
except ValueError:
    print("Input Error!")

7-2 try-except-else异常

try:
    A = int(input())
    result = 20 / A
    print("20除以{}的结果是: {:.2f}".format(A, result))
    print("没有出现异常")
except ValueError:
    print("值错误，您必须输入数值")
except ZeroDivisionError:
    print("算术错误，您不能输入0")

7-3 jmu-python-异常-学生成绩处理基本版

n = int(input())
s = 0
cnt = 0
for i in range(n):
    try:
        x = input()
        x = int(x)
        s += x
        cnt += 1
    except:
        print('Error for data "{}"! Break'.format(x))
        break

if cnt == n:
    print('All OK')
    print('avg grade = {:.2f}'.format(s / n))
print('Process Completed')
Python编程题汇总
Closer9的博客
04-20 1万+
Python编程复习 1.1找出列表中单词最长的一个 找出列表中单词最长的一个 def test(): a = ["hello", "world", "yoyo", "congratulations"] length = len(a[0]) # 在列表中循环 for i in a: if len(i) > length: length = i return length print(test()) 1.2摄
python常见编程题
种一棵树，最好的结果是十年前，其次是现在！
08-01 504
python常见基础编程题
python常见编程题集囊
weixin_45656490的博客
07-13 591
Python经典编程题
Python常见编程题2
黄雄进的博客
01-05 285
创建一个代表银行的账户对象，启动100个线程，每个线程向该账户存入1元，最后查询总额 """ 例如：创建一个代表银行的账户对象，启动100个线程，每个线程向该账户存入1元，最后查询总额 """ from threading import Thread, Lock from time import sleep # 创建一个账户类 class Account: def __init__...
吐血总结！20道Python面试题集锦（附答案）
weixin_45342712的博客
07-13 4188
Python是目前编程领域最受欢迎的语言。在本文中**，我将总结Python面试中最常见的20个问题。** 每道题都提供参考答案，希望能够帮助你在2019年求职面试中脱颖而出，找到一份高薪工作。这些面试题涉及Python基础知识、Python编程、数据分析以及Python函数库等多个方面。 Q1、Python中的列表和元组有什么区别？ Q2、Python的主要功能是什么？ Python是一种解释...
大一python编程题库和答案-Python编程练习题.pdf
06-13
这份题库旨在帮助初学者巩固Python编程基础，通过一系列练习题来提高编程能力。下面将详细解释其中涉及的知识点： 1. **整除与条件判断**： 在第一个题目中，要求找出所有能被17整除的三位数。这里使用了`range()`...
答案100道Python编程题及答案(一).doc
06-13
【Python编程基础与实践】 1. **循环与数学计算**： 在题目1中，球落下反弹的问题展示了Python中循环结构的应用。通过`for`循环计算球落地10次后的总距离和第10次反弹的高度。计算时，每次循环累加球下落和反弹的...
Python编程题Python编程题.zip
06-30
Python编程题
【Python编程题】Python编程助教面试题(Python Programming Assistant Interview
12-28
【Python编程题】Python编程助教面试题 (Python Programming Assistant Interview Question) 人事面 第一次面试是人事面，也就是问一下个人情况，问了一下几个问题（原句记不清了，差不多这个意思）： 【Python编程...
Python编程题.zip
11-09
Python编程题.zip是一个压缩包，其中包含了与Python编程相关的练习或问题集，命名为"programming-questions-master"。这个文件很可能是某个Python编程课程、在线挑战平台或者编程竞赛的题目集合。接下来，我们将深入...
Python经典练习题
03-26
经典例题，熟练Python。
Python 常见笔试程序题——不定期更新
weixin_43545004的博客
12-08 547
1.冒泡排序 #sort.py def Sort(list): for j in range(len(list) - 1): count = 0 for i in range(0,len(list) - 1 - j): if list[i] &gt; list[i + 1]: list[i],lis...
python必考程序题,python必考题答案
chatgpt001的博客
01-04 1093
鸭子类型是动态类型语言判断一个对象是不是某种类型时使用的方法，也叫做鸭子判定法。简单的说，鸭子类型是指判断一只鸟是不是鸭子，我们只关心它游泳像不像鸭子、叫起来像不像鸭子、走路像不像鸭子就足够了。换言之，如果对象的行为跟我们的预期是一致的（能够接受某些消息），我们就认定它是某种类型的对象。bytesbytearraymemoryviewStringIOBytesIOGzipFilesocketstrbytes），其中file-like对象都能支持read和write。
【2023Python程序设计期末复习】程序填空题题型整理（带解析）
m0_50957668的博客
12-25 4047
仅供班级复习使用，无含金量
真香！值得收藏的30道Python练手题（附详细答案）
Python学习与数据挖掘
10-26 5349
来源丨Python极客专栏今天给大家分享30道Python练习题，建议大家先独立思考一下解题思路，再查看答案。1. 已知一个字符串为 “hello_world_yoyo”，如何得到一个队列 [“hello”,”world”,”yoyo”] ？使用 split 函数，分割字符串，并且将数据转换成列表类型：test = 'hello_world_yoyo' print(test.split("_")) 12 结果：['hello', 'world', 'yoyo']2.
25道Python练手题（附详细答案），赶紧收藏！Python入门|Python学习
热门推荐
2301_78095812的博客
12-06 2万+
迭代之后发现第二个分隔符，是不是还有一个分隔符的索引，这个时候我们继续向字符串进行切片，切片的开始位置是你的 i 这个位置的指针，结束的位置是第二个 - 的指针，那遵循左闭右开，所以我们 is 这个单词，也可以添加进列表。就这样一直到最后呢，当我们去迭代到最后一个字符 n 的时候，发现后面是没有横杆分隔符了，这个时候我们需要进行处理一下，需要进行去判断一下，如果我们迭代到的字符是最后一个字符，那么我们进行切片的时候，就应该从哪个地方切呢？“ 请你写出：小明的较小的妹妹的年龄。“我年龄的立方是个 4 位数。
python 蓝桥杯填空题
牛牛博士博客
03-05 2590
python 蓝桥杯填空题
python代码练习4
这个人很白的博客
06-09 582
古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？ a,b,c=2,0,0 d=int(input("请输入月份:")) for i in range(1,d): c+=b a,b=c,a print("兔子数量:",(a+b+c)) 一个整数，它加上100后是一个完全平方数，再加上16...
python 编程题
最新发布
07-05
Python编程题通常涉及各种算法、数据结构和实际应用场景的练习，旨在帮助学习者提高编程技能。它们可以涵盖基础操作如变量、控制流、函数等，也可以延伸到更高级的主题，比如递归、列表推导式、异常处理、文件操作、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值