各种类型的题目

更新: 2025/2/24 字数: 0 字 时长: 0 分钟

简单题目

效果操作

文字跑马灯

"""
实现文字跑马灯效果（在命令行执行此代码）
"""
import os
import time

content = '拼搏到无能为力，努力到感动自己。          '
while True:
    os.system('cls')
    print(content)
    time.sleep(0.5)
    content = content[1:] + content[0]

运算操作

英公制转换

"""
英制单位转公制单位（英寸 ---> 厘米）
"""
x = float(input("请输入长度（英寸）："))
print(f'{x}英寸 = {2.54 * x}厘米')

求和运算

# 实现1~100求和
print(sum(range(1, 101)))     # 输出：5050
# 实现1~100偶数求和
print(sum(range(2, 101, 2)))  # 输出：2550
# 实现1~100奇数求和
print(sum(range(1, 101, 2)))  # 输出：2500

计算阶乘

"""
输入一个正整数N，求N的阶乘
"""
import math

n = int(input("请输入一个正整数："))
print(f'该正整数的阶乘为：{math.factorial(n)}')

乘法口诀表

"""
输出9X9的乘法口诀表
"""
for x in range(1, 10):
    for y in range(1, x + 1):
        print(f'{y} * {x} = {x * y}', end='\t')
    print()

周长面积

"""
输入圆的半径计算圆的周长和面积
"""
import math

radius = float(input("请输入圆的半径："))
print(f'圆的周长：{2 * math.pi * radius:.2f}')
print(f'圆的面积：{math.pi * radius ** 2:.2f}')

"""
输入三角形的三条边长度，判断能否构成三角形，若能构成计算其周长面积
规则：任意两边长度和大于第三边长度
"""
a = float(input("请输入第一条边的长度："))
b = float(input("请输入第二条边的长度："))
c = float(input("请输入第三条边的长度："))
if a + b > c and b + c > a and a + c > b:
    # 计算周长
    perimeter = a + b + c
    # 海伦公式计算面积
    half = perimeter / 2
    area = (half * (half - a) * (half - b) * (half - c)) ** 0.5
    print(f'三角形的周长为:{perimeter}')
    print(f'三角形的面积为:{area}')
else:
    print(f'{a}, {b}, {c} 这三条边不能构成三角形')

判断闰年

"""
输入一个年份，判断这个年份是不是闰年
规则：四年一闰，百年不闰，四百年又闰
"""
year = int(input("请输入年份："))
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
    print(f'{year}年是闰年')
else:
    print(f'{year}年不是闰年')

反转操作

正整数反转

"""
输入一个正整数，将其进行反转，要求不能使用字符串反转
"""
n = int(input("请输入一个正整数："))
total = 0
while n != 0:
    total = total * 10 + n % 10
    n //= 10
print(f'反转后的数为：{total}')

键值互换

"""
对字典中的键与值进行互换
"""
ditc_1 = {'A': 1, 'B': 2, 'C': 3}
ditc_2 = dict(zip(ditc_1.values(), ditc_1.keys()))
print(ditc_2)  # 输出：{1: 'A', 2: 'B', 3: 'C'}

逆向插入元素

"""
向列表中逆向插入100000个元素
数字顺序：0 1 2 3 4 5 6 7 8...
保存顺序：99999 99998 99997...
"""
# 方法一
nums = []
for i in range(100000):
    nums.append(i)
nums.reverse()

# 方法二
nums = []
for i in range(100000):
    nums.insert(0, i)

我们在电脑上运行这两种算法，可看到“方法一”相比“方法二”耗时更短。这是因为列表在底层采用的是“顺序存储”，在“方法二”中每次在下标0的位置插入元素，那么就需要把列表中现有元素全部往后移动一个位置，腾出下标0号位置，再将元素添加进去。由于每次都需要移动元素位置，所以“方法二”的效率就比较糟糕了。

数学题目

判断质数

"""
输出一个正整数判断其是不是质数
规则：1不是质数，2是唯一一个偶数质数（素数）
"""
n = int(input("请输入一个正整数："))
# 开根的原因就是，如果前半部分没有约数，那么后半部分也不会有约数
for i in range(2, int(n ** 0.5) + 1):
    if n % i == 0:
        print(f'{n}不是质数')
        break
else:
    if n == 1:
        print(f'{n}不是质数')
    else:
        print(f'{n}是质数')

公约公倍

"""
找出两个正整数的最大公约数（两个数所有公共因子中最大的数）和最小公倍数（两个数所有公共倍数中最小的数）
"""
# 最大公约数
def gcd(x, y):
    # 普通方法
    for i in range(x, 0, -1):
        if x % i == 0 and y % i == 0:
            print(f'最大公约数为：{i}')
            break
    # 欧几里得算法（辗转求余数法）
    while y % x != 0:
        x, y = y % x, x
    print(x)

# 最小公倍数
def lcm(x, y):
    return x * y // gcd(x, y)

斐波拉切数

"""
输出第40个斐波拉切数
规则：斐波拉切数列指一个数列从第3项开始，每一项都等于前两项之和。
例如：1 1 2 3 5 8 13 21 34
"""
# 使用变量交换累加的方法来计算斐波拉切数
def fib():
    a, b = 0, 1
    for _ in range(40):
        a, b = a + b, a
    return a

游戏玩家

斗地主

"""
用一个列表保存54张扑克牌，先洗牌，按斗地主的发牌方式把牌发给三个玩家，每个人17张牌，剩余3张，拥有红心3的玩家为地主，多的3张牌发给地主玩家，若红心3在剩余的3张，则随机分发，抽到红心3的玩家为地主，其余两个玩家将抽到的一张牌给到地主玩家，最后把每个玩家的手上的牌显示出来
"""
import random

# 正牌花色
suites = ['黑桃', '红心', '草花', '方块']
# 正牌序号
face = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
# 副牌
king = ['大王', '小王']
# 整副牌
cards = king + [f'{s}{f}' for s in suites for f in face]
# 洗牌
random.shuffle(cards)
# 发牌
player_1 = cards[:-3][::3]
player_2 = cards[:-3][1::3]
player_3 = cards[:-3][2::3]
# 确定地主
if '红心3' in player_1:
    print('余牌：', cards[-3:])
    print('地主：', player_1 + cards[-3:])
    print('农民：', player_2)
    print('农民：', player_3)
elif '红心3' in player_2:
    print('余牌：', cards[-3:])
    print('农民：', player_1)
    print('地主：', player_2 + cards[-3:])
    print('农民：', player_3)
elif '红心3' in player_3:
    print('余牌：', cards[-3:])
    print('农民：', player_1)
    print('农民：', player_2)
    print('地主：', player_3 + cards[-3:])
else:
    # 抽牌
    surplus = cards[-3:]
    player_1_get, player_2_get, player_3_get = random.sample(surplus, k=3)
    if player_1_get == '红心3':
        print('余牌：', [surplus])
        print('地主：', player_1 + surplus)
        print('农民：', player_2)
        print('农民：', player_3)
    elif player_2_get == '红心3':
        print('余牌：', surplus)
        print('农民：', player_1)
        print('地主：', player_2 + surplus)
        print('农民：', player_3)
    else:
        print('余牌：', surplus)
        print('农民：', player_1)
        print('农民：', player_2)
        print('地主：', player_3 + surplus)

五人分鱼

"""
ABCDE五个人捕捞了很多鱼，第二天A第一个醒来，把鱼分为5份，扔掉多余的1条，拿走自己的一份，后面BCDE依次醒来，都按照同样的操作来分鱼，问他们最少捕捞了多少的鱼。
"""
fish = 6
while True:
    total = fish
    for _ in range(5):
        if (total - 1) % 5 != 0:
            break
        total = (total - 1) // 5 * 4
    else:
        break
    fish += 5
print(fish)  # 输出：3121

幸存者游戏

"""
一条船上有30个人，船坏了，需要把其中15个人扔到海里，其他人才能活下来，所有人围成一圈，从1开始报数，报到9的人被扔到海里，直到最后剩15个人幸存下来，问原先幸存者所在的位置下标。
"""
# 普通方法
# 活人为0，共30个
people = [0 for _ in range(30)]
# 报数
cry = 0
# 下标
index = 0
while True:
    # 只有活人参与报数
    if people[index % 30] == 0:
        cry += 1
        # 报数到9的倍数变为死人为1
        if cry % 9 == 0:
            people[index % 30] = 1
            # 判断剩余活人
            if people.count(0) == 15:
                break
    index += 1

for i, j in enumerate(people):
    if j == 1:
        print(i, end=', ')  # 输出：4, 5, 6, 7, 8, 11, 15, 17, 18, 21, 22, 23, 25, 26, 29

# 快速方法
person = [i for i in range(1, 31)]
for _ in range(15):
    person = person[9:] + person[:8]
for i in range(1, 31):
    print('活' if i in person else '死', end='')  # 输出：活活活活死死死死死活活死活活活死活死死活活死死死活死死活活死

例如：

# 使用 any() 函数  
lst1 = [False, False, True]  
print(any(lst1))  # 输出: True，因为lst1中至少有一个元素为True  
  
# 使用 all() 函数  
lst2 = [True, True, True]  
print(all(lst2))  # 输出: True，因为lst2中所有元素都为True  
  
lst3 = [True, False, True]  
print(all(lst3))  # 输出: False，因为lst3中不是所有元素都为True

尽管any()和all()不是逻辑运算符，但它们在某些情况下可以与逻辑运算符（如and和or）产生类似的效果，特别是在处理复杂的逻辑条件时。它们提供了一种更简洁、更直观的方式来处理集合中的逻辑条件。

成员运算符：用于检查一个值是否存在于一个序列中（如列表、元组或字符串），返回布尔值。例如，in和not in。

my_list = [1, 2, 3]  
print(2 in my_list)   # 检查2是否在my_list中

身份运算符：用于比较两个对象的内存地址是否相同，即它们是否是同一个对象。主要包括is和is not。

a = [1, 2, 3]  
b = a
print(a is b)    # 检查a和b是否是同一个对象

枚举

枚举（Enumeration, 简称 Enum） 是一种特殊的数据类型，用于定义一组带有名称的常量。枚举中的每个成员都有一个名字和值，通常用于表示一组相关的常量值，使代码更具可读性和可维护性。在编程中，“枚举”常常指的是对一组值进行遍历，通常会将这些值与索引（或标识符）配对。

使用枚举的场景

枚举最常用于描述一组有固定成员的集合，比如一周的七天、颜色、交通信号灯的状态等。使用枚举可以避免魔法数字（magic numbers），使代码更清晰明了。

创建枚举

Python 提供了 enum 模块用于定义枚举。定义枚举时，我们需要继承 Enum 类。

示例：定义简单的枚举

from enum import Enum

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

在这个例子中，Color 是一个枚举类，其中 RED、GREEN 和 BLUE 是枚举成员，它们分别对应数值 1、2 和 3。

访问枚举成员

枚举成员可以通过名称或值来访问：

通过名称访问：

print(Color.RED)       # 输出：Color.RED
print(Color.RED.name)  # 输出：RED
print(Color.RED.value) # 输出：1

通过值访问：

print(Color(1))  # 输出：Color.RED

枚举的特点

1. 不可变性：枚举成员是不可变的，定义后其值不会改变。
2. 唯一性：每个枚举成员都是唯一的，不能有相同的值。即使在同一个枚举中有两个成员值相同，只有第一个成员有效。
3. 迭代性：枚举类型可以迭代。

示例：迭代枚举

for color in Color:
    print(color)
# 输出：
# Color.RED
# Color.GREEN
# Color.BLUE

自动赋值

有时，我们希望枚举成员的值是自动生成的，可以使用 auto() 函数来实现。

示例：自动赋值的枚举

from enum import Enum, auto

class Direction(Enum):
    NORTH = auto()
    SOUTH = auto()
    EAST = auto()
    WEST = auto()

for direction in Direction:
    print(direction, direction.value)

auto() 会为每个枚举成员自动分配一个整数值，默认从 1 开始。

枚举的用途

• 状态机：枚举常用于表示有限状态机中的状态。
• 常量组：定义一组不可改变的常量，避免使用魔法数字。
• 条件判断：用来清晰地表示不同的条件。

示例：作为状态机

class TrafficLight(Enum):
    RED = 1
    YELLOW = 2
    GREEN = 3

def signal(light):
    if light == TrafficLight.RED:
        print("Stop!")
    elif light == TrafficLight.YELLOW:
        print("Get Ready!")
    elif light == TrafficLight.GREEN:
        print("Go!")

signal(TrafficLight.RED)    # 输出：Stop!

枚举成员的比较

枚举成员可以进行比较，只能使用身份（即 is）或相等性（即 ==）比较。

示例：枚举比较

if Color.RED is Color.RED:
    print("Same color")
if Color.RED == Color.GREEN:
    print("Different color")

小结：

• 枚举用于定义一组带名称的常量。
• 枚举成员有名称和值，通过名称或值来访问。
• 枚举不可变且唯一。
• 枚举可以提高代码的可读性和维护性，常用于表示固定的常量组或有限状态。

通过枚举，你可以轻松管理代码中的一组相关常量，减少硬编码的魔法数字问题。

2. Enum 类

• 用途：Enum 是 Python 中用于定义一组带名称的常量的类。它主要用于表示一组固定的、不可变的、有意义的值，比如状态、颜色、星期等。
• 返回值：Enum 本身是一个类，枚举成员是 Enum 类的实例，具有唯一的名称和值。

示例：

from enum import Enum

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

# 访问枚举成员
print(Color.RED)          # 输出：Color.RED
print(Color.RED.value)    # 输出：1

特点：

• Enum 用于创建一组唯一的常量，并且常量值和名字之间有映射关系。
• 它的主要目的是提高代码的可读性和可维护性，避免使用魔法数字。
• 可以用于条件判断、状态表示等情境。

总结：

Enum 是用于定义一组常量的工具，确保常量的唯一性和可读性。

---

总结对比：

特性	enumerate(可迭代对象)	Enum 类
主要功能	为可迭代对象的元素提供索引值	定义一组带名称的常量
返回值	包含索引和值的元组迭代器	枚举类的成员，具有名称和值
用途	在循环中同时获取元素和索引	描述固定状态、常量组
常见使用场景	遍历列表、元组等时需要获取索引	表示颜色、状态、星期等固定值
是否可迭代	是（返回迭代器）	是（可以遍历枚举成员）

enumerate() 是一种在迭代过程中获取索引的简便工具，而 Enum 是一种更高层次的抽象，用于定义固定常量。两者的用途完全不同。

• 枚举继承：如果一个变量的取值只有有限个选项，可以考虑使用枚举类型，虽然 Python 中没有定义枚举类型的语法，但是可以通过继承 enum 标准库里的 Enum 类来实现枚举类型。

# 引入Enum枚举类型
from enum import Enum

class Suite(Enum):
    SPADE = 0
    HEART = 1
    CLUB = 2
    DIAMOND = 3

for item in Suite:
    print(item.name, item.value)
'''
输出：
SPADE 0
HEART 1
CLUB 2
DIAMOND 3
'''

建议

在定义符号常量的时候，使用枚举类型通常是最佳的选择，而且代码的可读性也会大大提高，这是因为符号常量的表现力是优于字面常量的。