40道进阶的Python练习题

大家好，我是程序媛学姐，今天为大家梳理了40道进阶的Python练习题，方便大家学习参考。

1. 编写一个Python程序实现自定义装饰器，用于记录函数执行时间

题目描述：
编写一个Python程序，实现一个自定义装饰器，用于记录函数执行时间。装饰器可以作为一个函数，接受一个函数作为参数，并返回一个新的函数来增强原函数的功能。在这个例子中，将创建一个装饰器，用于记录函数的执行时间，并将结果打印出来。

示例代码：

import time

def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        execution_time = end_time - start_time
        print(f"函数 {
     
     func.__name__} 的执行时间为: {
     
     execution_time} 秒")
        return result
    return wrapper

# 使用装饰器来增强函数功能
@timer_decorator
def example_function():
    time.sleep(2)  # 模拟函数执行时间为2秒
    print("函数执行完毕")

# 调用被装饰的函数
example_function()

代码解析：

1. 首先导入了time模块，用于获取函数执行时间。
2. 定义了一个名为timer_decorator的装饰器函数，该函数接受一个函数作为参数，并返回一个新的函数wrapper。
3. 在wrapper函数内部，先记录函数执行开始的时间start_time，然后调用原函数func，并获取其返回值result。
4. 计算函数执行结束的时间end_time，并计算出函数执行时间execution_time。
5. 打印出函数的执行时间，并返回原函数的结果。
6. 使用装饰器@timer_decorator来装饰需要记录执行时间的函数example_function。
7. 调用被装饰的函数example_function，它会自动记录并打印出执行时间。

2. 创建一个Python上下文管理器，用于测量一段代码的执行时间

题目描述：
创建一个Python上下文管理器，用于测量一段代码的执行时间。上下文管理器是Python中用于管理资源的一种机制，可以在进入和退出代码块时执行特定操作，比如在进入代码块时记录开始时间，在退出代码块时计算执行时间并输出结果。

示例代码：

import time

class TimerContextManager:
    def __enter__(self):
        self.start_time = time.time()
        return self
    
    def __exit__(self, exc_type, exc_value, traceback):
        self.end_time = time.time()
        execution_time = self.end_time - self.start_time
        print(f"代码块的执行时间为: {
     
     execution_time} 秒")

# 使用上下文管理器来测量代码执行时间
with TimerContextManager():
    time.sleep(2)  # 模拟代码块执行时间为2秒
    print("代码块执行完毕")

代码解析：

1. 首先导入了time模块，用于获取代码执行时间。
2. 创建了一个名为TimerContextManager的上下文管理器类，该类实现了__enter__和__exit__方法。
3. 在__enter__方法中，记录了进入代码块时的开始时间start_time。
4. 在__exit__方法中，获取了退出代码块时的结束时间end_time，并计算出代码块的执行时间execution_time。
5. 在__exit__方法中，打印出代码块的执行时间。
6. 使用with语句来使用上下文管理器，进入代码块时会自动调用__enter__方法，退出代码块时会自动调用__exit__方法，从而实现了对代码执行时间的测量和输出。

3. 使用Python实现二分查找算法用于已排序列表

题目描述：
使用Python实现二分查找算法，用于已排序列表。二分查找算法是一种高效的搜索算法，适用于已排序的数据集。它通过比较中间元素与目标值的大小关系来缩小搜索范围，从而快速找到目标元素的位置或判断目标元素是否存在。

示例代码：

def binary_search(sorted_list, target):
    low = 0
    high = len(sorted_list) - 1

    while low <= high:
        mid = (low + high) // 2
        if sorted_list[mid] == target:
            return mid  # 找到目标元素，返回索引
        elif sorted_list[mid] < target:
            low = mid + 1  # 目标元素在右侧区域
        else:
            high = mid - 1  # 目标元素在左侧区域

    return -1  # 没有找到目标元素，返回-1

# 测试二分查找算法
sorted_list = [1, 3, 5, 7, 9, 11, 13, 15]
target = 7
result = binary_search(sorted_list, target)
if result != -1:
    print(f"目标元素 {
     
     target} 在列表中的索引为: {
     
     result}")
else:
    print(f"目标元素 {
     
     target} 不在列表中")

代码解析：

1. 定义了一个名为binary_search的函数，接受一个已排序列表和目标值作为参数。
2. 使用变量low和high分别表示搜索区间的起始和结束位置。
3. 使用while循环进行二分查找，直到找到目标元素或搜索区间缩小到空集。
4. 在每次循环中，计算中间位置mid，并根据中间元素与目标值的大小关系调整搜索区间。
5. 如果找到目标元素，返回其索引；否则，返回-1表示未找到。
6. 使用示例数据进行二分查找测试，并输出结果。

4. 编写一个Python程序解析JSON字符串并使用递归提取特定信息

题目描述：
编写一个Python程序，解析JSON字符串并使用递归提取特定信息。JSON（JavaScript Object Notation）是一种常用的数据交换格式，Python中的json模块提供了解析和处理JSON数据的功能。在这个例子中，将编写一个程序，从JSON字符串中递归提取特定键的值。

示例代码：

import json

def extract_value(data, key):
    if isinstance(data, dict):  # 如果是字典类型
        if key in data:  # 如果键存在于字典中
            print(f"找到键 {
     
     key} 的值为: {
     
     data[key]}")
        for k, v in data.items():  # 递归处理字典的每个键值对
            extract_value(v, key)
    elif isinstance(data, list):  # 如果是列表类型
        for item in data:  # 递归处理列表的每个元素
            extract_value(item, key)
    # 其他情况（基本类型或无法处理的类型）不做处理

# 测试JSON解析和提取特定信息
json_data = '''
{
    "name": "John",
    "age": 30,
    "pets": [
        {"name": "Rover", "type": "dog"},
        {"name": "Whiskers", "type": "cat"}
    ],
    "address": {
        "city": "New York",
        "zipcode": "10001"
    }
}
'''

parsed_data = json.loads(json_data)  # 解析JSON字符串为Python对象
key_to_extract = "name"  # 要提取的键名
extract_value(parsed_data, key_to_extract)

代码解析：

1. 首先导入了json模块，用于解析和处理JSON数据。
2. 定义了一个名为extract_value的函数，接受两个参数：JSON数据和要提取的键名。
3. 使用递归方式处理JSON数据，如果数据是字典类型，则递归处理每个键值对；如果是列表类型，则递归处理每个元素。
4. 在递归过程中，如果找到指定键名，则打印对应的值。
5. 测试时，使用了一个包含各种数据类型（字典、列表）的JSON字符串，并解析为Python对象。
6. 调用extract_value函数提取特定键的值，并输出结果。

5. 开发一个Python脚本，使用requests库自动下载给定URL的文件

题目描述：
开发一个Python脚本，使用requests库自动下载给定URL的文件。requests是一个常用的HTTP库，可以方便地发送HTTP请求和处理响应。在这个例子中，编写一个Python脚本，通过发送HTTP GET请求来下载指定URL的文件，并保存到本地。

示例代码：

import requests

def download_file(url, save_path):
    response = requests.get(url)  # 发送HTTP GET请求
    if response.status_code == 200:  # 如果响应状态码为200（表示请求成功）
        with open(save_path, 'wb') as file:  # 以二进制写入模式打开文件
            file.write(response.content)  # 将响应内容写入文件
        print(f"文件下载成功，保存路径为: {
     
     save_path}")
    else:
        print("文件下载失败")

# 测试文件下载功能
file_url = 'https://example.com/sample.pdf'  # 替换为实际文件的URL
save_location = 'sample.pdf'  # 文件保存路径（相对或绝对路径）
download_file(file_url, save_location)

代码解析：

1. 首先导入了requests库，用于发送HTTP请求和处理响应。
2. 定义了一个名为download_file的函数，接受两个参数：文件的URL和保存路径。
3. 使用requests.get方法发送HTTP GET请求，并获取响应对象response。
4. 检查响应状态码是否为200（表示请求成功），如果是则将响应内容写入文件。
5. 使用with open(...)语句打开文件，并以二进制写入模式将响应内容写入文件。
6. 在下载成功时打印保存路径，下载失败时提示错误信息。
7. 测试时，替换file_url为实际文件的URL，save_location为文件保存路径（可以是相对路径或绝对路径）。
8. 调用download_file函数进行文件下载操作。

6. 实现一个自定义异常类，并在try-except块中处理它

题目描述：
实现一个自定义异常类，并在try-except块中处理它。异常是在程序执行过程中遇到错误或异常情况时抛出的对象，Python中可以自定义异常类来表示特定的错误类型，并在代码中进行捕获和处理。

示例代码：

class CustomError(Exception):
    def __init__(self, message="发生自定义异常"):
        self.message = message
        super().__init__(self.message)

def example_function():
    raise CustomError("这是一个自定义异常示例")

try:
    example_function()
except CustomError as e:
    print(f"捕获到自定义异常: {
     
     e.message}")

代码解析：

1. 定义了一个名为CustomError的自定义异常类，继承自Exception基类。
2. 在CustomError类的__init__方法中，可以指定异常的错误消息，默认为"发生自定义异常"。
3. 编写了一个示例函数example_function，其中使用raise关键字抛出了一个自定义异常对象。
4. 在try-except块中，使用try语句执行example_function，并使用except语句捕获自定义异常类CustomError。
5. 在捕获到自定义异常时，输出异常的错误消息。

7. 编写一个Python程序使用嵌套列表进行矩阵乘法

题目描述：
编写一个Python程序，使用嵌套列表进行矩阵乘法。矩阵乘法是线性代数中的重要运算，通过对两个矩阵的对应元素进行乘法和求和来得到新的矩阵。

示例代码：

def matrix_multiply(matrix1, matrix2):
    rows1 = len(matrix1)
    cols1 = len(matrix1[0])
    rows2 = len(matrix2)
    cols2 = len(matrix2[0])

    if cols1 != rows2:
        raise ValueError("矩阵尺寸不匹配，无法进行矩阵乘法")

    result = [[0 for _ in range(cols2)] for _ in range(rows1)]
    
    for i in range(rows1):
        for j in range(cols2):
            for k in range(cols1):
                result[i][j] += matrix1[i][k] * matrix2[k][j]

    return result

# 测试矩阵乘法函数
matrix1 = [[1, 2], [3, 4]]
matrix2 = [[5, 6], [7, 8]]
result_matrix = matrix_multiply(matrix1, matrix2)
for row in result_matrix:
    print(row)

代码解析：

1. 定义了一个名为matrix_multiply的函数，接受两个嵌套列表作为参数，分别表示两个矩阵。
2. 获取矩阵的行数和列数，并进行尺寸检查，如果矩阵尺寸不匹配则抛出ValueError异常。
3. 创建一个结果矩阵，用于存储矩阵乘法的结果，初始化为全零矩阵。
4. 使用三重循环计算矩阵乘法，遍历第一个矩阵的每一行，第二个矩阵的每一列，以及对应位置的元素进行乘法和累加。
5. 返回计算得到的结果矩阵。
6. 测试时，定义两个示例矩阵matrix1和matrix2，调用matrix_multiply函数进行矩阵乘法运算，并打印结果矩阵。

8. 创建一个Python脚本使用BeautifulSoup或Scrapy从网站上抓取数据

题目描述：
创建一个Python脚本，使用BeautifulSoup或Scrapy库从网站上抓取数据。BeautifulSoup和Scrapy都是Python中常用的网页解析库，可以用于从网页中提取数据。在这个例子中，编写一个程序，使用BeautifulSoup或Scrapy来抓取指定网站的数据。

示例代码（使用BeautifulSoup）：

import requests
from bs4 import BeautifulSoup

def fetch_data(url):
    response = requests.get(url)
    if response.status_code == 200:
        soup = BeautifulSoup(response.content, 'html.parser')
        # 在这里编写代码来解析网页并提取数据
        # 以下是一个示例：提取所有h1标签的文本内容
        headings = soup.find_all('h1')
        for heading in headings:
            print(heading.text)
    else:
        print("请求失败")

# 测试抓取数据功能
url_to_fetch = 'https://example.com'  # 替换为实际网站的URL
fetch_data(url_to_fetch)

代码解析：

1. 首先导入了requests库和BeautifulSoup模块。
2. 定义了一个名为fetch_data的函数，接受一个URL作为参数，用于抓取指定网站的数据。
3. 使用requests.get方法发送HTTP GET请求，并获取响应对象response。
4. 检查响应状态码是否为200（表示请求成功），然后使用BeautifulSoup将响应内容解析为HTML文档。
5. 在fetch_data函数中，可以编写代码来解析网页并提取需要的数据，这里以提取所有h1标签的文本内容为例。
6. 测试时，替换url_to_fetch为实际网站的URL，调用fetch_data函数进行数据抓取，并打印提取的数据。

9. 开发一个使用argparse处理用户输入并执行特定操作的Python命令行工具

题目描述：
开发一个使用argparse处理用户输入并执行特定操作的Python命令行工具。argparse是Python内置的命令行参数解析模块，可以帮助我们创建具有参数选项的命令行工具。在这个例子中，将编写一个Python脚本，使用argparse处理用户输入的命令行参数，并根据参数执行相应的操作。

示例代码：

import argparse

def operation_add(a, b):
    return a + b

def operation_subtract(a, b):
    return a - b

def operation_multiply(a, b):
    return a * b

def operation_divide(a, b):
    if b == 0:
        raise ValueError("除数不能为0")
    return a / b

# 创建argparse解析器
parser = argparse.ArgumentParser(description="执行数学运算")

# 添加命令行参数选项
parser.add_argument('operation', choices=['add', 'subtract', 'multiply', 'divide'], help="选择要执行的操作")
parser.add_argument('operand1', type=float, help="输入第一个操作数")
parser.add_argument('operand2', type=float, help="输入第二个操作数")

# 解析命令行参数
args = parser.parse_args()

# 根据用户输入的操作执行相应的函数
if args.operation == 'add':
    result = operation_add(args.operand1, args.operand2)
elif args.operation == 'subtract':
    result = operation_subtract(args.operand1, args.operand2)
elif args.operation == 'multiply':
    result = operation_multiply(args.operand1, args.operand2)
elif args.operation == 'divide':
    try:
        result = operation_divide(args.operand1, args.operand2)
    except ValueError as e:
        print(e)
        result = None

# 输出计算结果
if result is not None:
    print(f"计算结果为: {
     
     result}")

代码解析：

1. 首先导入了argparse模块，用于处理命令行参数。
2. 定义了四个数学运算的函数：operation_add、operation_subtract、operation_multiply、operation_divide。
3. 创建了一个argparse解析器，并添加了命令行参数选项：operation（操作类型）、operand1（第一个操作数）、operand2（第二个操作数）。
4. 使用parser.parse_args()方法解析命令行参数，并将解析结果保存在args变量中。
5. 根据用户输入的操作类型执行相应的函数，并计算结果。
6. 如果执行除法操作时遇到除数为0的情况，抛出ValueError异常并捕获输出错误信息。
7. 最后输出计算结果或错误信息。

10. 实现一个Python生成器，无限生成斐波那契数列

下面是实现无限生成斐波那契数列的Python生成器的代码示例：

def fibonacci_generator():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# 创建斐波那契数列生成器对象
fib_gen = fibonacci_generator()

# 生成并打印斐波那契数列的前10个数
for _ in range(10):
    print(next(fib_gen))

这段代码定义了一个名为fibonacci_generator的生成器函数，使用yield语句实现了无限生成斐波那契数列的功能。生成器函数内部使用了一个while True循环来不断生成斐波那契数列的元素。在每次迭代中，生成器函数通过yield语句产生当前的斐波那契数，并在下一次迭代时更新a和b的值。

通过使用生成器对象fib_gen，可以不断调用next(fib_gen)来获取下一个斐波那契数列的元素，并通过循环打印出前10个斐波那契数。由于生成器是惰性生成的，因此它可以无限地生成斐波那契数列中的元素，而不会消耗大量的内存。

11. 编写一个Python程序使用凯撒密码加密和解密文本消息

下面是一个使用凯撒密码加密和解密文本消息的Python程序示例：

def caesar_cipher(text, shift, decrypt=False):
    result = ''
    for char in text:
        if char.isalpha():  # 只加密和解密字母字符
            if char.islower():
                base = ord('a')
            else:
                base = ord('A')
            shifted = (ord(char) - base + shift) % 26 + base
            if decrypt:
                shifted = (ord(char) - base - shift) % 26 + base
            result += chr(shifted)
        else:
            result += char
    return result

# 加密消息示例
message = "Hello, World!"
encrypted_message = caesar_cipher(message, shift=3)
print("加密后的消息:", encrypted_message)

# 解密消息示例
decrypted_message = caesar_cipher(encrypted_message, shift=3, decrypt=True)
print("解密后的消息:", decrypted_message)

这个程序定义了一个名为caesar_cipher的函数，用于实现凯撒密码的加密和解密操作。函数接受三个参数：text表示要加密或解密的文本消息，shift表示移位的数量，decrypt表示是否解密（默认为False，即加密操作）。

在caesar_cipher函数中，使用了for循环遍历文本消息中的每个字符。对于字母字符，根据移位数量进行加密或解密操作，并将结果拼接到最终的加密或解密后的结果中。对于非字母字符（如空格、标点符号等），直接将其添加到结果中，不进行加密或解密处理。

在示例中，先加密了一条消息"Hello, World!"，然后对加密后的消息进行解密操作，并打印出加密和解密后的结果。通过这个程序，可以实现简单的凯撒密码加密和解密功能。

12. 开发一个Python脚本使用mysql-connector-python库与MySQL数据库交互

下面是一个使用mysql-connector-python库与MySQL数据库交互的Python脚本示例：

import mysql.connector

# 连接MySQL数据库
def connect_to_mysql(host, user, password, database):