Python基础题

问题1

编写一个程序，找到2000年至3200年（包括在内）中所有可被7整除但不能被5整除的所有数字，得到的数字按逗号分隔，打印在一行上。

# 编写一个程序，找到2000年至3200年（包括在内）中所有可被7整除但不能被5整除的所有数字，得到的数字按逗号分隔，打印在一行上。
result = []
for i in range(2000, 3201):
    if i % 7 == 0 and i % 5 != 0:
        result.append(str(i))

# 将结果按逗号分隔打印在一行上
print(",".join(result))

问题2

用户输入一个数字，算出指定数字的阶乘

# 编写一个程序，用户输入一个数字，算出指定数字的阶乘
# 例如：用户输入5，程序计算5的阶乘 5*4*3*2*1
# 5*4*3*2*1 = 120
num = int(input("请输入一个数字："))
result = 1
for i in range(1, num+1):
    result *= i
print("%d的阶乘是：%d" % (num, result))

# 使用递归实现
num = int(input("请输入一个数字："))
def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n-1)
print(factorial(num))

问题3

编写一个程序，该程序接收控制台以逗号分隔的数字序列，并生成包含每个数字的列表和元组，假设，向程序提供以下输入：34岁，67年，55岁，33岁，12日，98年；则输出为：[34'，‘67'，‘55'，‘33'，‘12'，‘98']('34'，'67"，'55'，'33'，‘12'，‘98')

# > 编写一个程序，该程序接收控制台以逗号分隔的数字序列，并生成包含每个数字的列表和元组，假设，向程序提供以下输入：34岁，67年，55岁，33岁，12日，98年；则输出为：
# `[34'，‘67'，‘55'，‘33'，‘12'，‘98']('34'，'67"，'55'，'33'，‘12'，‘98')`

#使用正则表达式匹配数字
import re

str = "34岁，67年，55岁，33岁，12日，98年"
list = re.findall(r"\d+",str)
tuple = tuple(list)
print(list)

问题4

定义一个至少有两个方法的类：一、getString:从控制台输入获取字符串；二、printString:打印大写母的字符串， 并写出简单的测试函数来测试类方法。

# 定义一个至少有两个方法的类：一、getString:从控制台输入获取字符串；二、printString:打印大写母的字符串，
# 并写出简单的测试函数来测试类方法。

# 定义一个类 有两个方法
class Test001:
    def __init__(self):
        self.s = ""

    def getString(self):
        self.s = input("请输入字符串：")

    def printString(self):
        print(self.s.upper())

# 测试函数
def test():
    test001 = Test001()
    test001.getString()
    test001.printString()

# 调用测试函数
test()

问题5

# 编写一个程序，以逗号分隔的单词序列作为输入，按照字母顺序对每个单词进行排序，并通过逗号分隔的序列来打印单词。
# 假设向程序输入：without,hello,bag,world;则输出为：bag,hello,without,world;

str = "without,hello,bag,world"
str_list = str.split(",")
str_list.sort()
str = ",".join(str_list)
print(str)

问题6

# 编写一个程序，以一系列空格分隔的单词作为输入，并在删除所有重复的单词后，按字母顺序排序后打印这些单词。
# 假设向程序输入： hello world and practice makes perfect and hello world again 则输出为： again and hello makes perfect practice world

str = "hello world and practice makes perfect and hello world again"
str_list = str.split(" ")
str_list = list(set(str_list))
str_list.sort()
print(" ".join(str_list))

问题7

# 编写一个程序，接收一系列以逗号分隔的4位二进制数作为输入，然后检查它们是否可被5整除，可被5整除的数字将以逗号分隔的顺序打印。
# 例：0100,0011,1010,1001那么输出应该是：1010

str = "0100,0011,1010,1001"
str = str.split(',')
result = []
for i in str:
    # int(i,2) 将二进制转换为十进制
    if int(i,2) % 5 == 0:
        result.append(i)
print(','.join(result))

问题8

# 编写一个程序，找到1000到3000之间并且所有位数均为偶数的所有数字，比如2000,2002等；获得的数字都以逗号分隔的顺序，打印在一行上。


def find_even_number():  # 定义一个函数来查找所有位数均为偶数的数字
    result = []  # 初始化结果列表
    for i in range(1000, 3001):  # 遍历1000到3000之间的所有数字
        flag = True  # 初始化标志位为True
        for j in str(i):  # 将数字转换为字符串并遍历每一位
            if int(j) % 2 != 0:  # 如果当前位不是偶数
                flag = False  # 将标志位设为False
                break  # 退出当前循环
        if flag:  # 如果标志位仍为True
            result.append(str(i))  # 将该数字添加到结果列表中
    return result  # 返回结果列表

print(','.join(find_even_number()))

问题9

# 编写一个接受句子并计算字母和数字的程序。假设程序输入：Hello world!123则输出应该是：字母10数字3

str = "Hello world!123"  # 初始化字符串
letters = 0  # 初始化字母计数
digits = 0  # 初始化数字计数
for i in str:  # 遍历字符串中的每个字符
    if i.isalpha():  # 如果字符是字母
        letters += 1  # 字母计数加1
    elif i.isdigit():  # 如果字符是数字
        digits += 1  # 数字计数加1

print("字母%d数字%d" % (letters, digits))  # 输出字母和数字的计数

问题10

# 编写一个程序，计算a+aa+aaa+aaaa的值，给定的数字作为a的值。假设为程序提供了以下输入：9；输出应该是：11106

# int() 函数用于将一个字符串或数字转换为整型。
a = input("请输入一个数字：")
n1 = int("%s" % a)
n2 = int("%s%s" % (a, a))
n3 = int("%s%s%s" % (a, a, a))
n4 = int("%s%s%s%s" % (a, a, a, a))

print(n1 + n2 + n3 + n4)

问题11

sort 函数用于对列表进行原地排序。它接受两个可选参数：key 和 reverse。

• key 是一个函数，用于从每个列表元素中提取一个用于比较的值。可以使用 lambda 表达式来定义这个函数。
• reverse 是一个布尔值。如果设置为 True，列表元素将按降序排序。默认值为 False。

在你的代码中，sort 函数使用了 key 参数：

tuples.sort(key=lambda x: (x[0], x[1], x[2]))

这个 lambda 表达式 (x[0], x[1], x[2]) 指定了排序的优先级：首先按 name 排序，然后按 age 排序，最后按 height 排序。

# 您需要编写一个程序，按升序对（名称，年龄，高度）元组进行排序，其中name是字符串，age和height是数字，元组由控制台输入。
# 排序标准是：
# 1:根据名称排序；
# 2:然后根据年龄排序；
# 3:然后按分数排序。
# 优先级是name>age>得分。
# 如果给出以下元组作为程序的输入：
# Tom, 19， 80： John, 20,90： Jony, 17,91： Jony, 17,93： Json, 21,85

#  定义上述元组
tuples = [('Tom', 19, 80), ('John', 20, 90), ('Jony', 17, 91), ('Jony', 17, 93), ('Json', 21, 85)]
#  对元组进行排序
tuples.sort(key=lambda x: (x[0], x[1], x[2]))

问题12

# 问题：编写一个程序，来计算每个单词出现的频率，按字母顺序对键进行排序后输出。
# 假设程序输入：
# New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3.
# 则输出应该是：
# 2: 2
# 3. : 1
# 3?: 1
# New:1
# Python: 5
# Read: 1
# and:1
# between: 1
# choosing: 1
# or:2
# to: 1

# 解决方案：使用collections模块中的defaultdict类，它可以接受一个工厂函数作为参数，如int、list、set等。
# 例如，可以使用int来创建一个简单的计数器。
# 也可以使用list来创建一个列表，用于保存所有单词。
# 也可以使用set来创建一个集合，用于保存唯一的单词。
# 也可以使用lambda来创建一个匿名函数，用于返回0。
# 也可以使用自定义函数来创建一个复杂的数据结构。
# 例如，下面的代码使用int来创建一个简单的计数器。
from collections import defaultdict

def word_count(str):  # 定义一个函数word_count，接受一个字符串参数
    words = str.split()  # 将字符串按空格分割成单词列表
    # 创建一个defaultdict，用于计数 单词:次数
    counts = defaultdict(int)  # 创建一个defaultdict，默认值为0，用于计数
    for word in words:  # 遍历每个单词
        counts[word] += 1  # 计数器加1
        
    return counts  # 返回计数结果

if __name__ == '__main__':  # 如果当前模块是主模块
    str = 'New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3.'  # 定义输入字符串
    counts = word_count(str)  # 调用word_count函数，计算单词频率
    # items函数返回一个包含所有字典项的列表，每个字典项是一个(key, value)对。
    counts = sorted(counts.items())  # 将计数结果按字母顺序排序
    for word, count in counts:  # 遍历排序后的结果
        print('%s: %s' % (word, count))  # 打印每个单词及其出现的次数

问题13

# 问题：定义一个类，它具有类参数并具有相同的实例参数。
# 提示：定义一个实例参数，需要在init方法中添加它。您可以使用构造参数初始化对象，也可以稍后设置该值

class JoJoPerson:
    # 定义类参数
    name = "JoJo"

    def __init__(self, name=None):
        # 定义实例参数
        self.name = name

jojo = JoJoPerson("Dio")
print(JoJoPerson.name)
print(jojo.name)

问题14

# 问题：定义两个函数，输入两个数字字符串，一个返回两个数字字符串的和，一个拼接两个数字字符串
# 解决：使用int()函数将字符串转换为数字，然后进行计算
def add(x, y):
    return int(x) + int(y)

def concat(x, y):
    return x + y


print(add('1', '2'))
print(concat('1', '2'))

问题15：map与lambda

• 问题：编写一个程序，可以使用map()构造一个列表，其中的元素是[1,2,3,4,5,6,7,8,9,10]中元素的平方。
• 提示：使用map()生成列表。使用lambda定义匿名函数

# 问题：编写一个程序，可以使用map()构造一个列表，其中的元素是[1,2,3,4,5,6,7,8,9,10]中元素的平方。
# 提示：使用map()生成列表。使用lambda定义匿名函数

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 使用map()和lambda函数生成平方列表
map = map(lambda x: x ** 2, list1)
# 遍历map对象并打印结果
for i in map:
    print(i)

问题16： 父子类

# 问题：定义一个名为American的类及其子类NewYorker。
# 提示：使用类子类(ParentClass)来定义子类。

# 1. 定义一个名为American的类
class American:
    # 2. 定义一个方法sayHello，打印"Hello, I am an American!"
    def sayHello(self):
        print("Hello, I am an American!")
    pass


# 2. 定义一个名为NewYorker的类，继承自American类
class NewYorker(American):
    # 3. 定义一个方法sayHello，打印"Hello, I am a New Yorker!"
    def sayHello(self):
        print("Hello, I am a New Yorker!")


# 4. 创建NewYorker类的实例
am = NewYorker()
# 5. 调用sayHello方法
am.sayHello()

问题17：工具类

问题：定义一个名为Circle的类，可以用半径来构造。Circle类有一个可以计算面积的方法。

# 问题：定义一个名为Circle的类，可以用半径来构造。Circle类有一个可以计算面积的方法。
class Circle:
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

# 测试代码
if __name__ == "__main__":
    circle = Circle(5)
    print(f"Circle with radius {circle.radius} has area: {circle.area()}")

问题18：异常

#请引发RuntimeError异常。
raise RuntimeError("这是一个运行时错误")

问题19：try-catch

问题：编写一个函数来计算5/0，并使用try/except来捕获异常

# 问题：编写一个函数来计算5/0，并使用try/except来捕获异常

def divide_by_zero():
    try:
        result = 5 / 0
    except ZeroDivisionError as e:
        print(f"捕获到异常：{e}")
    else:
        print(f"结果是：{result}")

if __name__ == "__main__":
    divide_by_zero()
# 运行结果：
# 捕获到异常：division by zero

问题20：正则匹配

问题：假设我们有一些“[email protected]”格式的电子邮件地址，请编写程序打印给定的电子邮件地址的公司名称；用户名和公司名都只由字母组成。
示例：如果下面的电子邮件地址作为程序的输入：[email protected]，分别打印用户名和公司名

#问题：假设我们有一些“[email protected]”格式的电子邮件地址，请编写程序打印给定的电子邮件地址的公司名称；用户名和公司名都只由字母组
# 成。
# 示例：如果下面的电子邮件地址作为程序的输入：[email protected]
# 分别打印用户名和公司名

# 解决方案：正则表达式
import re
email = "[email protected]"
reg = r"([a-zA-Z]+)@([a-zA-Z]+)\.com"
result = re.findall(reg, email)
print("用户名:", result[0][0])
print("公司名:", result[0][1])

问题21：递归

使用递归函数，计算斐波那契数列的前n项

# 使用递归函数，计算斐波那契数列的前n项
def fibonacci(n):
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]
    else:
        fib = fibonacci(n - 1)
        fib.append(fib[-1] + fib[-2])
        return fib

# 测试函数
print(fibonacci(10))

问题22：random模块

问题：请编写一个程序，随机生成一个列表，从1到1000（含1000），有5个数字，可以被5和7整除。

# 问题：请编写一个程序，随机生成一个列表，从1到1000（含1000），有5个数字，可以被5和7整除。
import random
list = random.sample([i for i in range(1, 1001) if i % 5 == 0 and i % 7 == 0], 5)
print(list)

i for i 是列表生成式的一部分，用于生成一个新的列表。它的意思是：对于每个在前面定义的范围或条件中符合条件的 i，将 i 添加到新的列表中。

在你的代码中，完整的列表生成式是：

[i for i in range(1, 1001) if i % 5 == 0 and i % 7 == 0]

这段代码的意思是：

• range(1, 1001) 生成从 1 到 1000 的所有整数。
• if i % 5 == 0 and i % 7 == 0 筛选出可以同时被 5 和 7 整除的数字。
• i for i 表示将每个符合条件的 i 添加到新的列表中。

最终，这段代码生成了一个包含所有满足条件的数字的列表。

random.sample(population, k)

• population：要从中抽取样本的序列或集合。
• k：要抽取的样本数量。

问题23：打乱顺序

# 随机打乱序列的顺序
# 1. 使用 random.shuffle() 函数
import random
li = [1, 2, 3, 4, 5]
random.shuffle(li)
print(li)  # 打乱后的序列顺序是随机的

问题24：删除重复的值

问题：对于给定的列表[12,24,35,24,88,120,155,88,120,155]，编写一个程序来打印这个列表-删除所有重复的值与原始顺序保留。

# 问题：对于给定的列表[12,24,35,24,88,120,155,88,120,155]，编写一个程序来打印这个列表-删除所有重复的值与原始顺序保留。

# 解决方案：使用集合来删除重复的值，然后将其转换回列表以保持原始顺序。
# 代码：
def remove_duplicates(input_list):
    # 使用集合来删除重复的值
    seen = set()
    result = []
    for item in input_list:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result

# 测试代码
if __name__ == "__main__":
    input_list = [12, 24, 35, 24, 88, 120, 155, 88, 120, 155]
    print("原始列表:", input_list)
    result = remove_duplicates(input_list)
    print("删除重复值后的列表:", result)

问题25：父子类与空实现

定义一个类Person和它的两个子类：Male和Female。所有的类都有一个方法“getGender”,它可以打印“Male”为男性类，“Female”为女性类。

# 问题：定义一个类Person和它的两个子类：Male和Female。所有的类都有一个方法“getGender”,它可以打印“Male”为男性类，“Female”为女性类。

# 解决方案：
class Person:
    def getGender(self):
        raise NotImplementedError("Subclasses must implement this method")

class Male(Person):
    def getGender(self):
        return "Male"

class Female(Person):
    def getGender(self):
        return "Female"

# 测试代码
if __name__ == '__main__':
    male = Male()
    female = Female()
    print(male.getGender())
    print(female.getGender())

问题26：统计字符数量

问题：请编写一个程序，计算并打印由控制台输入的字符串中的每个字符的数量。
示例：如果下面的字符串作为程序的输入：abcdefgab;
那么，程序的输出应该是：a,2c,2 b,2 e,1 d,1 g,1 f,1;

# 问题：请编写一个程序，计算并打印由控制台输入的字符串中的每个字符的数量。
# 示例：如果下面的字符串作为程序的输入：abcdefgab;
# 那么，程序的输出应该是：a,2c,2 b,2 e,1 d,1 g,1 f,1;
def count_characters(s):
    # 创建一个空字典来存储字符及其出现次数
    char_count = {}

    # 遍历字符串中的每个字符
    for char in s:
        # 如果字符已经在字典中，则将其计数加1
        if char in char_count:
            char_count[char] += 1
        # 如果字符不在字典中，则将其添加到字典中，初始计数为1
        else:
            char_count[char] = 1

    # 返回字符计数字典
    return char_count
# 主函数
if __name__ == '__main__':
    # 从控制台读取输入字符串
    input_string = "abcdefgab"
    # 调用函数计算字符数量
    result = count_characters(input_string)
    # 打印结果
    print(result)

问题27：反转字符串

问题：请编写一个程序，从控制台接收一个字符串，并以相反的顺序打印出来。
示例：如果下面的字符串作为程序的输入：rise to vote sir;
那么，程序的输出应该是：ris etov ot esir;

# 问题：请编写一个程序，从控制台接收一个字符串，并以相反的顺序打印出来。
# 示例：如果下面的字符串作为程序的输入：rise to vote sir;
# 那么，程序的输出应该是：ris etov ot esir;

str = "rise to vote sir"
str = str[::-1]
print(str)

问题28：鸡兔同笼

问题：写一个程序来解决一个中国古代的经典难题：我们数农场里的鸡和兔子中有35个头和94条腿。我们有多少只兔子和多少只鸡？

# 问题：写一个程序来解决一个中国古代的经典难题：我们数农场里的鸡和兔子中有35个头和94条腿。我们有多少只兔子和多少只鸡？
# 解决方案：我们可以使用代数来解决这个问题。设鸡的数量为x，兔子的数量为y。
# 根据题意，我们可以得到以下两个方程：
# 1. x + y = 35  (头的数量)
# 2. 2x + 4y = 94 (腿的数量)
# 我们可以通过解这个方程组来找到x和y的值。
# 下面是一个Python程序来解决这个问题：
def solve_chickens_and_rabbits(heads, legs):
    # 设鸡的数量为x，兔子的数量为y
    # 根据题意，我们可以得到以下两个方程：
    # 1. x + y = heads  (头的数量)
    # 2. 2x + 4y = legs (腿的数量)

    # 将第一个方程变形为 y = heads - x
    # 然后将其代入第二个方程中
    for x in range(heads + 1):
        y = heads - x
        if 2 * x + 4 * y == legs:
            return x, y

    return None

# 测试函数
if __name__ == '__main__':
    heads = 35
    legs = 94
    result = solve_chickens_and_rabbits(heads, legs)

    if result:
        chickens, rabbits = result
        print(f"鸡的数量: {chickens}, 兔子的数量: {rabbits}")
    else:
        print("没有找到符合条件的解。")