试了下用ChatGPT来秒Python程序设计的课后习题作业-CSDN博客

本文链接：https://blog.csdn.net/agelee/article/details/135994351

试了下用ChatGPT来秒Python程序设计的课后习题作业。

1、编写程序，求1～100间所有奇数的和。

# 初始化奇数和为0
odd_sum = 0

# 循环遍历1到100的奇数
for number in range(1, 101, 2):
    odd_sum += number

# 打印结果
print("1到100间所有奇数的和为:", odd_sum)

2、编写程序，输入两个数，比较它们的大小并输出其中较大者。

# 输入两个数
num1 = float(input("请输入第一个数: "))
num2 = float(input("请输入第二个数: "))

# 比较两个数的大小
if num1 > num2:
    larger_num = num1
elif num1 < num2:
    larger_num = num2
else:
    print("两个数相等")
    # 如果两个数相等，可以选择在此处进行适当的处理

# 输出较大者
print("较大的数是:", larger_num)

3、编写程序，输入一年份，判断该年份是否是闰年并输出结果。

闰年的判断规则一般有两个条件：如果年份能够被4整除，但不能被100整除，或者能够被400整除，那么该年就是闰年。

# 输入年份
year = int(input("请输入一个年份: "))

# 判断是否为闰年
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print(year, "年是闰年")
else:
    print(year, "年不是闰年")

4、给定字符串"Python language"：（a）写出表达式，显示第一个字符。（b）写出表达式，显示最后一个字符。

答案：

(a) 表达式显示第一个字符：

first_char = "Python language"[0]
print(first_char)

输出结果将是：

(b) 表达式显示最后一个字符：

last_char = "Python language"[-1]
print(last_char)

输出结果将是：

5、符串S长度为偶数：（a）写出显示前半段字符串的表达式。（b）写出显示后半段字符串的表达式

答案：

(a) 表达式显示前半段字符串：

S = "abcdefgh"
first_half = S[:len(S)//2]
print(first_half)

这里使用了切片操作 S[:len(S)//2]，其中 len(S)//2 计算了字符串的中点位置。这样，first_half 就包含了字符串的前半段。

(b) 表达式显示后半段字符串：

S = "abcdefgh"
second_half = S[len(S)//2:]
print(second_half)

这里使用了切片操作 S[len(S)//2:]，其中 len(S)//2 计算了字符串的中点位置。这样，second_half 就包含了字符串的后半段。

6.编写一个名为list_sum的函数，接收一个数字的列表，返回累计和；

def list_sum(numbers):
    total = 0
    for num in numbers:
        total += num
    return total

# 示例用法
my_list = [1, 2, 3, 4, 5]
result = list_sum(my_list)
print("累计和:", result)

7.设计一个字典，并编写程序，用户输入内容作为键，然后输出字典中对应的值，如果用户输入的键不存在，则输出“您输入的键不存在！”

# 设计一个简单的字典
my_dict = {
    "apple": "A fruit that grows on trees.",
    "python": "A high-level programming language.",
    "ocean": "A large body of saltwater."
}

# 用户输入
user_input = input("请输入一个键: ")

# 查找字典中对应的值
if user_input in my_dict:
    print("对应的值:", my_dict[user_input])
else:
    print("您输入的键不存在！")

2024.02.02

8.编写一个程序，找出所有的水仙花数（所谓水仙花数，就是一个3位数等于各位数字的立方和，则称这个数为水仙花数。）。

水仙花数（Narcissistic Number）是指一个n位数，其各位数字的n次方之和等于它本身。对于3位数来说，水仙花数是指百位、十位和个位的数字各自的立方和等于这个3位数本身。以下是一个查找所有3位水仙花数的简单程序：

# 查找所有的水仙花数
for num in range(100, 1000):
    # 获取百位、十位和个位数字
    digit1 = num // 100
    digit2 = (num % 100) // 10
    digit3 = num % 10

    # 判断是否为水仙花数
    if num == digit1**3 + digit2**3 + digit3**3:
        print(num)

在这个程序中，range(100, 1000)用于遍历所有3位数，然后通过整除和取余运算分别获取百位、十位和个位数字。最后，判断是否为水仙花数，如果是则打印出来。

运行这个程序，你将得到所有的3位水仙花数。

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

这是一个数学问题，可以通过编程求解。我们需要找到一个数，它除以2余1，除以3余2，除以5余4，除以6余5，而除以7则不余。以下是一个简单的Python程序来解决这个问题：

def find_steps():
    x = 1  # 从1开始尝试
    while True:
        if x % 2 == 1 and x % 3 == 2 and x % 5 == 4 and x % 6 == 5 and x % 7 == 0:
            return x
        x += 1

# 调用函数找到符合条件的阶梯数
result = find_steps()
print("阶梯至少有", result, "阶。")

这个程序使用一个循环，从1开始尝试每一个数字，直到找到符合条件的阶梯数。

10.设计一个验证用户密码程序，用户只有三次机会输入错误，不过如果用户输入的内容中包含“*”则不计算在内。

以下是一个简单的Python程序，用于验证用户密码，允许用户三次机会输入密码，但是如果密码中包含 "*"，则不计算在内：

def validate_password():
    correct_password = "secret"
    attempts_left = 3

    while attempts_left > 0:
        user_input = input("请输入密码: ")

        # 检查密码是否包含 "*"
        if '*' in user_input:
            print("密码中不允许包含 '*' 符号，请重新输入。")
            continue

        # 验证密码是否正确
        if user_input == correct_password:
            print("密码正确，登录成功！")
            break
        else:
            attempts_left -= 1
            print(f"密码错误，您还有 {attempts_left} 次尝试机会。")

    if attempts_left == 0:
        print("您已经用尽了所有尝试机会，登录失败。")

# 调用函数进行密码验证
validate_password()

11.Python中使用if、elif、else在大多数情况下效率要比全部使用 if 要高，但根据一般的统计规律，一个班的成绩一般服从正态分布，也就是说平均成绩一般集中在70~80分之间，请根据此统计规律，完成下面程序的编写：按照100分制，90分及以上成绩为A，80到90（不包括90）为B，60到80（不包括80）为C，60以下为D，写一个程序，当用户输入分数，自动转换为ABCD的形式打印。

你可以使用 if、elif 和 else 结构来实现这个分数转换程序。以下是一个示例：

# 获取用户输入的分数
score = float(input("请输入您的成绩（0-100）: "))

# 分数转换为ABCD形式
if 90 <= score <= 100:
    grade = 'A'
elif 80 <= score < 90:
    grade = 'B'
elif 60 <= score < 80:
    grade = 'C'
elif 0 <= score < 60:
    grade = 'D'
else:
    grade = '无效分数'

# 打印结果
print(f"您的成绩对应的等级是：{grade}")

在这个程序中，根据用户输入的分数，使用 if、elif 和 else 来判断分数所在的区间，并将其转换为相应的等级。请注意，这里使用了连续的范围判断，确保用户输入的分数在有效范围内。

12.在这个程序中，根据用户输入的分数，使用 `if`、`elif` 和 `else` 来判断分数所在的区间，并将其转换为相应的等级。请注意，这里使用了连续的范围判断，确保用户输入的分数在有效范围内。下面是一个简单的Python函数，用于判断传入的字符串参数是否为回文联：

def is_palindrome_couplet(s):
    # 去除空格和标点符号，并转为小写
    clean_s = ''.join(c.lower() for c in s if c.isalnum())

    # 判断是否为回文联
    return clean_s == clean_s[::-1]

# 测试示例
couplet1 = "上海自来水来自海上"
couplet2 = "Python is fun"

print(f"\"{couplet1}\" 是否为回文联: {is_palindrome_couplet(couplet1)}")
print(f"\"{couplet2}\" 是否为回文联: {is_palindrome_couplet(couplet2)}")

在这个函数中，首先通过 isalnum() 方法去除字符串中的空格和标点符号，然后将字符串转换为小写。最后，通过判断字符串是否与其反向字符串相等，来确定是否为回文联。在测试示例中，第一个字符串是回文联，而第二个字符串不是。

13.定义一个类继承于int类型，并实现一个特殊功能：当传入的参数是字符串的时候，返回该字符串中所有字符的ASCII码的和（使用ord()获得一个字符的ASCII码值）。

可以定义一个继承自 int 类型的新类，并在其构造函数中实现特殊的功能。以下是一个示例：

class CustomInt(int):
    def __new__(cls, value):
        if isinstance(value, str):
            # 如果传入的是字符串，则计算ASCII码的和
            ascii_sum = sum(ord(char) for char in value)
            obj = super().__new__(cls, ascii_sum)
        else:
            # 如果传入的不是字符串，调用父类的构造函数
            obj = super().__new__(cls, value)
        return obj

# 测试示例
result1 = CustomInt(123)  # 传入整数
result2 = CustomInt("hello")  # 传入字符串

print(result1)  # 输出：123
print(result2)  # 输出：532（'h'的ASCII码是104，'e'是101，'l'是108，'l'是108，'o'是111，总和为532）

在这个例子中，CustomInt 类继承自 int，并覆盖了 __new__ 方法。当传入的参数是字符串时，计算字符串中所有字符的ASCII码的和，然后调用父类的构造函数。当传入的参数是其他类型（如整数）时，调用父类的构造函数，保持其原有行为。

14.定义一个单词（Word）类继承字符串，重写比较操作符，当两个Word类对象进行比较时，根据单词的长度来比较大小。要求：实例化时如果传入的是带空格的字符串，则取第一个空格前的单词作为参数。

下面是一个满足你要求的 Word 类的实现，它继承自字符串，并重写了比较操作符，以便根据单词的长度来进行比较：

class Word(str):
    def __new__(cls, value):
        # 如果传入的是带空格的字符串，则取第一个空格前的单词
        if ' ' in value:
            value = value.split()[0]
        obj = super().__new__(cls, value)
        return obj

    def __lt__(self, other):
        return len(self) < len(other)

    def __le__(self, other):
        return len(self) <= len(other)

    def __eq__(self, other):
        return len(self) == len(other)

    def __ne__(self, other):
        return len(self) != len(other)

    def __gt__(self, other):
        return len(self) > len(other)

    def __ge__(self, other):
        return len(self) >= len(other)

# 测试示例
word1 = Word("apple")
word2 = Word("banana")
word3 = Word("kiwi")

print(word1 < word2)  # 输出：True（"apple"长度为5，"banana"长度为6）
print(word2 == word3)  # 输出：False（"banana"长度为6，"kiwi"长度为4）

在这个例子中，Word 类继承自字符串，覆盖了 __new__ 方法，以便在实例化时取带空格的字符串的第一个空格前的单词。同时，重写了比较操作符，使得比较基于单词的长度。

15.假设有一个英文文本文件，编写程序读取其内容，并将其中的大写字母变为小写字母，小写字母变为大写字母。你可以使用Python来读取文本文件的内容，并进行大小写字母的转换。以下是一个简单的示例：

# 读取文件内容
file_path = 'path/to/your/file.txt'  # 替换为实际文件路径
try:
    with open(file_path, 'r') as file:
        content = file.read()
except FileNotFoundError:
    print(f"文件 '{file_path}' 不存在。")
    exit()

# 进行大小写字母的转换
converted_content = content.swapcase()

# 打印转换后的内容
print("转换后的内容：")
print(converted_content)

在这个示例中，open 函数用于打开文件，read 方法用于读取文件内容。然后，swapcase 方法用于将大写字母转换为小写字母，小写字母转换为大写字母。最后，打印转换后的内容。

请确保替换 file_path 的值为你实际的文本文件路径。