【Python练习题】Python小白必练100题答案-第81-97题

专栏导读

• 🌸 欢迎来到Python办公自动化专栏—Python处理办公问题，解放您的双手

• 🏳️‍🌈 博客主页：请点击——> 一晌小贪欢的博客主页求关注

• 👍 该系列文章专栏：请点击——>Python办公自动化专栏求订阅

• 🕷 此外还有爬虫专栏：请点击——>Python爬虫基础专栏求订阅

• 📕 此外还有python基础专栏：请点击——>Python基础学习专栏求订阅

• 文章作者技术和水平有限，如果文中出现错误，希望大家能指正🙏

• ❤️ 欢迎各位佬关注！ ❤️

文件操作与异常处理

第81题：文件读取

题目： 读取文本文件并统计行数、字符数

答案：

def analyze_file(filename):
    """分析文件内容"""
    try:
        with open(filename, 'r', encoding='utf-8') as file:
            lines = file.readlines()
            
        line_count = len(lines)
        char_count = sum(len(line) for line in lines)
        word_count = sum(len(line.split()) for line in lines)
        
        print(f"文件: {filename}")
        print(f"行数: {line_count}")
        print(f"字符数: {char_count}")
        print(f"单词数: {word_count}")
        
        return {
            'lines': line_count,
            'characters': char_count,
            'words': word_count
        }
        
    except FileNotFoundError:
        print(f"文件 {filename} 不存在")
        return None
    except Exception as e:
        print(f"读取文件时出错: {e}")
        return None

# 创建测试文件
with open('test.txt', 'w', encoding='utf-8') as f:
    f.write("Hello World\n")
    f.write("Python Programming\n")
    f.write("File Operations")

# 分析文件
result = analyze_file('test.txt')

输出示例：

文件: test.txt
行数: 3
字符数: 37
单词数: 5

知识点： 文件读取、异常处理、字符串操作

第82题：文件写入

题目： 将数据写入文件，支持追加模式

答案：

class FileWriter:
    def __init__(self, filename):
        self.filename = filename
    
    def write_data(self, data, mode='w'):
        """写入数据到文件"""
        try:
            with open(self.filename, mode, encoding='utf-8') as file:
                if isinstance(data, list):
                    for item in data:
                        file.write(str(item) + '\n')
                else:
                    file.write(str(data) + '\n')
            
            print(f"数据已{'追加' if mode == 'a' else '写入'}到 {self.filename}")
            return True
            
        except Exception as e:
            print(f"写入文件失败: {e}")
            return False
    
    def append_data(self, data):
        """追加数据到文件"""
        return self.write_data(data, 'a')
    
    def read_file(self):
        """读取文件内容"""
        try:
            with open(self.filename, 'r', encoding='utf-8') as file:
                content = file.read()
            print(f"文件内容:\n{content}")
            return content
        except FileNotFoundError:
            print(f"文件 {self.filename} 不存在")
            return None

# 演示文件写入
writer = FileWriter('output.txt')

# 写入初始数据
writer.write_data(['第一行数据', '第二行数据', '第三行数据'])

# 追加数据
writer.append_data('追加的数据')
writer.append_data(['更多追加数据1', '更多追加数据2'])

# 读取文件
writer.read_file()

输出示例：

数据已写入到 output.txt
数据已追加到 output.txt
数据已追加到 output.txt
文件内容:
第一行数据
第二行数据
第三行数据
追加的数据
更多追加数据1
更多追加数据2

知识点： 文件写入、追加模式、类的设计

第83题：CSV文件处理

题目： 读写CSV文件，处理表格数据

答案：

import csv
from datetime import datetime

class CSVProcessor:
    def __init__(self, filename):
        self.filename = filename
    
    def write_csv(self, data, headers=None):
        """写入CSV文件"""
        try:
            with open(self.filename, 'w', newline='', encoding='utf-8') as file:
                writer = csv.writer(file)
                
                if headers:
                    writer.writerow(headers)
                
                for row in data:
                    writer.writerow(row)
            
            print(f"CSV文件 {self.filename} 写入成功")
            return True
            
        except Exception as e:
            print(f"写入CSV失败: {e}")
            return False
    
    def read_csv(self):
        """读取CSV文件"""
        try:
            with open(self.filename, 'r', encoding='utf-8') as file:
                reader = csv.reader(file)
                data = list(reader)
            
            print(f"CSV文件 {self.filename} 读取成功，共 {len(data)} 行")
            return data
            
        except FileNotFoundError:
            print(f"CSV文件 {self.filename} 不存在")
            return None
        except Exception as e:
            print(f"读取CSV失败: {e}")
            return None
    
    def filter_data(self, column_index, value):
        """根据列值过滤数据"""
        data = self.read_csv()
        if not data:
            return []
        
        filtered = []
        for row in data:
            if len(row) > column_index and row[column_index] == value:
                filtered.append(row)
        
        print(f"过滤结果: 找到 {len(filtered)} 条匹配记录")
        return filtered

# 演示CSV处理
processor = CSVProcessor('students.csv')

# 准备学生数据
headers = ['姓名', '年龄', '成绩', '班级']
student_data = [
    ['张三', '20', '85', '计算机1班'],
    ['李四', '21', '92', '计算机1班'],
    ['王五', '19', '78', '计算机2班'],
    ['赵六', '20', '88', '计算机2班'],
    ['钱七', '22', '95', '计算机1班']
]

# 写入CSV
processor.write_csv(student_data, headers)

# 读取CSV
all_data = processor.read_csv()
print("\n所有数据:")
for row in all_data:
    print(row)

# 过滤数据
print("\n计算机1班学生:")
class1_students = processor.filter_data(3, '计算机1班')
for student in class1_students:
    print(student)

输出示例：

CSV文件 students.csv 写入成功
CSV文件 students.csv 读取成功，共 6 行

所有数据:
['姓名', '年龄', '成绩', '班级']
['张三', '20', '85', '计算机1班']
['李四', '21', '92', '计算机1班']
['王五', '19', '78', '计算机2班']
['赵六', '20', '88', '计算机2班']
['钱七', '22', '95', '计算机1班']

计算机1班学生:
过滤结果: 找到 3 条匹配记录
['张三', '20', '85', '计算机1班']
['李四', '21', '92', '计算机1班']
['钱七', '22', '95', '计算机1班']

知识点： CSV文件处理、数据过滤、文件读写

第84题：JSON数据处理

题目： 处理JSON格式数据的读写和解析

答案：

import json
from datetime import datetime

class JSONProcessor:
    def __init__(self, filename):
        self.filename = filename
    
    def save_json(self, data):
        """保存数据为JSON文件"""
        try:
            with open(self.filename, 'w', encoding='utf-8') as file:
                json.dump(data, file, ensure_ascii=False, indent=2)
            
            print(f"JSON数据已保存到 {self.filename}")
            return True
            
        except Exception as e:
            print(f"保存JSON失败: {e}")
            return False
    
    def load_json(self):
        """从JSON文件加载数据"""
        try:
            with open(self.filename, 'r', encoding='utf-8') as file:
                data = json.load(file)
            
            print(f"JSON数据已从 {self.filename} 加载")
            return data
            
        except FileNotFoundError:
            print(f"JSON文件 {self.filename} 不存在")
            return None
        except json.JSONDecodeError as e:
            print(f"JSON格式错误: {e}")
            return None
        except Exception as e:
            print(f"加载JSON失败: {e}")
            return None
    
    def update_json(self, key, value):
        """更新JSON数据中的特定键值"""
        data = self.load_json()
        if data is None:
            data = {}
        
        data[key] = value
        return self.save_json(data)
    
    def search_json(self, key):
        """在JSON数据中搜索键"""
        data = self.load_json()
        if not data:
            return None
        
        def search_recursive(obj, target_key):
            results = []
            if isinstance(obj, dict):
                for k, v in obj.items():
                    if k == target_key:
                        results.append(v)
                    elif isinstance(v, (dict, list)):
                        results.extend(search_recursive(v, target_key))
            elif isinstance(obj, list):
                for item in obj:
                    if isinstance(item, (dict, list)):
                        results.extend(search_recursive(item, target_key))
            return results
        
        results = search_recursive(data, key)
        print(f"搜索键 '{key}' 找到 {len(results)} 个结果")
        return results

# 演示JSON处理
processor = JSONProcessor('config.json')

# 创建配置数据
config_data = {
    "应用设置": {
        "名称": "我的应用",
        "版本": "1.0.0",
        "调试模式": True
    },
    "数据库配置": {
        "主机": "localhost",
        "端口": 3306,
        "用户名": "admin",
        "数据库名": "myapp"
    },
    "用户列表": [
        {"姓名": "张三", "角色": "管理员"},
        {"姓名": "李四", "角色": "用户"}
    ],
    "创建时间": datetime.now().strftime('%Y-%m-%d %H:%M:%S')
}

# 保存JSON
processor.save_json(config_data)

# 加载JSON
loaded_data = processor.load_json()
print("\n加载的配置:")
print(json.dumps(loaded_data, ensure_ascii=False, indent=2))

# 更新配置
processor.update_json("最后修改", datetime.now().strftime('%Y-%m-%d %H:%M:%S'))

# 搜索特定键
names = processor.search_json("姓名")
print(f"\n找到的姓名: {names}")

输出示例：

JSON数据已保存到 config.json
JSON数据已从 config.json 加载

加载的配置:
{
  "应用设置": {
    "名称": "我的应用",
    "版本": "1.0.0",
    "调试模式": true
  },
  "数据库配置": {
    "主机": "localhost",
    "端口": 3306,
    "用户名": "admin",
    "数据库名": "myapp"
  },
  "用户列表": [
    {
      "姓名": "张三",
      "角色": "管理员"
    },
    {
      "姓名": "李四",
      "角色": "用户"
    }
  ],
  "创建时间": "2024-01-15 10:30:45"
}

JSON数据已从 config.json 加载
JSON数据已保存到 config.json
搜索键 '姓名' 找到 2 个结果

找到的姓名: ['张三', '李四']

知识点： JSON数据处理、递归搜索、数据序列化

第85题：异常处理

题目： 实现完整的异常处理机制

答案：

class Calculator:
    def __init__(self):
        self.history = []
    
    def divide(self, a, b):
        """除法运算，包含异常处理"""
        try:
            if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
                raise TypeError("参数必须是数字类型")
            
            if b == 0:
                raise ZeroDivisionError("除数不能为零")
            
            result = a / b
            self.history.append(f"{a} ÷ {b} = {result}")
            return result
            
        except TypeError as e:
            print(f"类型错误: {e}")
            return None
        except ZeroDivisionError as e:
            print(f"数学错误: {e}")
            return None
        except Exception as e:
            print(f"未知错误: {e}")
            return None
        finally:
            print(f"计算完成，历史记录数: {len(self.history)}")
    
    def safe_input(self, prompt):
        """安全的用户输入"""
        while True:
            try:
                value = input(prompt)
                return float(value)
            except ValueError:
                print("请输入有效的数字")
            except KeyboardInterrupt:
                print("\n用户取消输入")
                return None
            except EOFError:
                print("\n输入结束")
                return None
    
    def batch_calculate(self, operations):
        """批量计算"""
        results = []
        errors = []
        
        for i, (a, b) in enumerate(operations):
            try:
                result = self.divide(a, b)
                if result is not None:
                    results.append((i, a, b, result))
                else:
                    errors.append((i, a, b, "计算失败"))
            except Exception as e:
                errors.append((i, a, b, str(e)))
        
        print(f"\n批量计算完成:")
        print(f"成功: {len(results)} 个")
        print(f"失败: {len(errors)} 个")
        
        if errors:
            print("\n错误详情:")
            for idx, a, b, error in errors:
                print(f"  操作 {idx}: {a} ÷ {b} -> {error}")
        
        return results, errors

# 演示异常处理
calc = Calculator()

print("异常处理演示:")

# 正常计算
print("\n1. 正常计算:")
result1 = calc.divide(10, 2)
print(f"结果: {result1}")

# 除零错误
print("\n2. 除零错误:")
result2 = calc.divide(10, 0)
print(f"结果: {result2}")

# 类型错误
print("\n3. 类型错误:")
result3 = calc.divide("10", 2)
print(f"结果: {result3}")

# 批量计算
print("\n4. 批量计算:")
operations = [
    (10, 2),    # 正常
    (15, 3),    # 正常
    (20, 0),    # 除零错误
    ("abc", 5), # 类型错误
    (100, 4)    # 正常
]

results, errors = calc.batch_calculate(operations)

print("\n成功的计算:")
for idx, a, b, result in results:
    print(f"  {a} ÷ {b} = {result}")

输出示例：

异常处理演示:

1. 正常计算:
计算完成，历史记录数: 1
结果: 5.0

2. 除零错误:
数学错误: 除数不能为零
计算完成，历史记录数: 1
结果: None

3. 类型错误:
类型错误: 参数必须是数字类型
计算完成，历史记录数: 1
结果: None

4. 批量计算:
计算完成，历史记录数: 2
计算完成，历史记录数: 2
数学错误: 除数不能为零
计算完成，历史记录数: 2
类型错误: 参数必须是数字类型
计算完成，历史记录数: 2
计算完成，历史记录数: 3

批量计算完成:
成功: 3 个
失败: 2 个

错误详情:
  操作 2: 20 ÷ 0 -> 计算失败
  操作 3: abc ÷ 5 -> 计算失败

成功的计算:
  10 ÷ 2 = 5.0
  15 ÷ 3 = 5.0
  100 ÷ 4 = 25.0

知识点： 异常处理、try-except-finally、自定义异常、批量处理

高级应用与综合项目

第86题：自定义异常

题目： 创建自定义异常类

答案：

# 自定义异常类
class InvalidAgeError(Exception):
    """年龄无效异常"""
    def __init__(self, age, message="年龄必须在0-150之间"):
        self.age = age
        self.message = message
        super().__init__(self.message)
    
    def __str__(self):
        return f"InvalidAgeError: 年龄 {self.age} 无效 - {self.message}"

class InsufficientFundsError(Exception):
    """余额不足异常"""
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        self.message = f"余额不足：当前余额 {balance}，尝试提取 {amount}"
        super().__init__(self.message)

class Person:
    def __init__(self, name, age):
        self.name = name
        self.set_age(age)
    
    def set_age(self, age):
        """设置年龄，包含验证"""
        if not isinstance(age, int):
            raise InvalidAgeError(age, "年龄必须是整数")
        
        if age < 0:
            raise InvalidAgeError(age, "年龄不能为负数")
        
        if age > 150:
            raise InvalidAgeError(age, "年龄不能超过150岁")
        
        self.age = age
        print(f"{self.name} 的年龄设置为 {age} 岁")

class BankAccount:
    def __init__(self, owner, initial_balance=0):
        self.owner = owner
        self.balance = initial_balance
    
    def withdraw(self, amount):
        """提取资金"""
        if amount <= 0:
            raise ValueError("提取金额必须大于0")
        
        if amount > self.balance:
            raise InsufficientFundsError(self.balance, amount)
        
        self.balance -= amount
        print(f"成功提取 {amount} 元，余额: {self.balance} 元")
        return self.balance
    
    def deposit(self, amount):
        """存入资金"""
        if amount <= 0:
            raise ValueError("存入金额必须大于0")
        
        self.balance += amount
        print(f"成功存入 {amount} 元，余额: {self.balance} 元")
        return self.balance

# 演示自定义异常
print("自定义异常演示:")

# 测试年龄异常
print("\n1. 年龄验证:")
try:
    person1 = Person("张三", 25)  # 正常
    person2 = Person("李四", -5)  # 负数年龄
except InvalidAgeError as e:
    print(f"捕获异常: {e}")

try:
    person3 = Person("王五", 200)  # 超龄
except InvalidAgeError as e:
    print(f"捕获异常: {e}")

try:
    person4 = Person("赵六", "abc")  # 非整数
except InvalidAgeError as e:
    print(f"捕获异常: {e}")

# 测试银行账户异常
print("\n2. 银行账户操作:")
account = BankAccount("张三", 1000)

try:
    account.deposit(500)  # 正常存款
    account.withdraw(200)  # 正常提款
    account.withdraw(2000)  # 余额不足
except InsufficientFundsError as e:
    print(f"捕获异常: {e}")
except ValueError as e:
    print(f"值错误: {e}")

try:
    account.withdraw(-100)  # 负数提款
except ValueError as e:
    print(f"值错误: {e}")

输出示例：

自定义异常演示:

1. 年龄验证:
张三 的年龄设置为 25 岁
捕获异常: InvalidAgeError: 年龄 -5 无效 - 年龄不能为负数
捕获异常: InvalidAgeError: 年龄 200 无效 - 年龄不能超过150岁
捕获异常: InvalidAgeError: 年龄 abc 无效 - 年龄必须是整数

2. 银行账户操作:
成功存入 500 元，余额: 1500 元
成功提取 200 元，余额: 1300 元
捕获异常: 余额不足：当前余额 1300，尝试提取 2000
值错误: 提取金额必须大于0

知识点： 自定义异常类、异常继承、异常信息定制

第87题：上下文管理器

题目： 实现文件操作的上下文管理器

答案：

import os
import shutil
from contextlib import contextmanager

class FileManager:
    """文件管理上下文管理器"""
    def __init__(self, filename, mode='r', encoding='utf-8'):
        self.filename = filename
        self.mode = mode
        self.encoding = encoding
        self.file = None
    
    def __enter__(self):
        print(f"打开文件: {self.filename}")
        try:
            self.file = open(self.filename, self.mode, encoding=self.encoding)
            return self.file
        except Exception as e:
            print(f"打开文件失败: {e}")
            raise
    
    def __exit__(self, exc_type, exc_value, traceback):
        if self.file:
            print(f"关闭文件: {self.filename}")
            self.file.close()
        
        if exc_type:
            print(f"发生异常: {exc_type.__name__}: {exc_value}")
            return False  # 不抑制异常
        
        print("文件操作完成")
        return True

@contextmanager
def safe_file_copy(source, destination):
    """安全文件复制上下文管理器"""
    backup_file = None
    try:
        # 如果目标文件存在，先备份
        if os.path.exists(destination):
            backup_file = destination + '.backup'
            shutil.copy2(destination, backup_file)
            print(f"已备份原文件到: {backup_file}")
        
        print(f"开始复制: {source} -> {destination}")
        yield source, destination
        
        # 复制成功，删除备份
        if backup_file and os.path.exists(backup_file):
            os.remove(backup_file)
            print("删除备份文件")
        
        print("文件复制成功")
        
    except Exception as e:
        print(f"复制失败: {e}")
        
        # 恢复备份
        if backup_file and os.path.exists(backup_file):
            if os.path.exists(destination):
                os.remove(destination)
            shutil.move(backup_file, destination)
            print("已恢复原文件")
        
        raise

class DatabaseConnection:
    """数据库连接模拟器"""
    def __init__(self, db_name):
        self.db_name = db_name
        self.connected = False
        self.transaction_active = False
    
    def __enter__(self):
        print(f"连接到数据库: {self.db_name}")
        self.connected = True
        self.transaction_active = True
        return self
    
    def __exit__(self, exc_type, exc_value, traceback):
        if exc_type:
            print(f"发生错误，回滚事务: {exc_value}")
            self.rollback()
        else:
            print("提交事务")
            self.commit()
        
        print(f"断开数据库连接: {self.db_name}")
        self.connected = False
        self.transaction_active = False
    
    def execute(self, sql):
        if not self.connected:
            raise RuntimeError("数据库未连接")
        print(f"执行SQL: {sql}")
        
        # 模拟SQL执行
        if "ERROR" in sql.upper():
            raise RuntimeError("SQL执行错误")
        
        return "执行成功"
    
    def commit(self):
        if self.transaction_active:
            print("事务已提交")
    
    def rollback(self):
        if self.transaction_active:
            print("事务已回滚")

# 演示上下文管理器
print("上下文管理器演示:")

# 1. 文件管理器
print("\n1. 文件管理器:")
with FileManager('test_context.txt', 'w') as f:
    f.write("这是测试内容\n")
    f.write("使用上下文管理器\n")

# 读取文件
with FileManager('test_context.txt', 'r') as f:
    content = f.read()
    print(f"文件内容: {content.strip()}")

# 2. 安全文件复制
print("\n2. 安全文件复制:")
try:
    with safe_file_copy('test_context.txt', 'copy_test.txt') as (src, dst):
        shutil.copy2(src, dst)
except Exception as e:
    print(f"复制异常: {e}")

# 3. 数据库连接
print("\n3. 数据库连接 - 正常操作:")
with DatabaseConnection('test_db') as db:
    db.execute("SELECT * FROM users")
    db.execute("INSERT INTO users VALUES (1, 'Alice')")

print("\n4. 数据库连接 - 异常处理:")
try:
    with DatabaseConnection('test_db') as db:
        db.execute("SELECT * FROM users")
        db.execute("INSERT ERROR INTO users")  # 故意出错
except Exception as e:
    print(f"捕获异常: {e}")

输出示例：

上下文管理器演示:

1. 文件管理器:
打开文件: test_context.txt
关闭文件: test_context.txt
文件操作完成
打开文件: test_context.txt
文件内容: 这是测试内容
使用上下文管理器
关闭文件: test_context.txt
文件操作完成

2. 安全文件复制:
开始复制: test_context.txt -> copy_test.txt
文件复制成功

3. 数据库连接 - 正常操作:
连接到数据库: test_db
执行SQL: SELECT * FROM users
执行SQL: INSERT INTO users VALUES (1, 'Alice')
提交事务
断开数据库连接: test_db

4. 数据库连接 - 异常处理:
连接到数据库: test_db
执行SQL: SELECT * FROM users
执行SQL: INSERT ERROR INTO users
发生错误，回滚事务: SQL执行错误
断开数据库连接: test_db
捕获异常: SQL执行错误

知识点： 上下文管理器、__enter__和__exit__方法、contextmanager装饰器

第88题：目录操作

题目： 实现目录的创建、遍历和管理

答案：

import os
import shutil
from pathlib import Path
from datetime import datetime

def list_directory_contents(directory, show_hidden=False, recursive=False):
    """列出目录内容"""
    try:
        path = Path(directory)
        if not path.exists():
            print(f"目录不存在: {directory}")
            return []
        
        if not path.is_dir():
            print(f"不是目录: {directory}")
            return []
        
        contents = []
        
        def scan_directory(current_path, level=0):
            indent = "  " * level
            items = list(current_path.iterdir())
            
            # 过滤隐藏文件
            if not show_hidden:
                items = [item for item in items if not item.name.startswith('.')]
            
            # 排序：目录在前，文件在后
            items.sort(key=lambda x: (x.is_file(), x.name.lower()))
            
            for item in items:
                item_info = {
                    'name': item.name,
                    'path': str(item),
                    'is_dir': item.is_dir(),
                    'size': item.stat().st_size if item.is_file() else 0,
                    'modified': datetime.fromtimestamp(item.stat().st_mtime),
                    'level': level
                }
                
                contents.append(item_info)
                
                # 显示信息
                size_str = f"{item_info['size']} bytes" if item.is_file() else "<DIR>"
                mod_time = item_info['modified'].strftime('%Y-%m-%d %H:%M:%S')
                print(f"{indent}{item.name} ({size_str}) - {mod_time}")
                
                # 递归处理子目录
                if recursive and item.is_dir():
                    try:
                        scan_directory(item, level + 1)
                    except PermissionError:
                        print(f"{indent}  [权限不足]")
        
        print(f"目录内容: {directory}")
        scan_directory(path)
        
        return contents
        
    except Exception as e:
        print(f"列出目录内容失败: {e}")
        return []

def create_directory_structure(base_path, structure):
    """创建目录结构"""
    try:
        base = Path(base_path)
        base.mkdir(parents=True, exist_ok=True)
        
        def create_items(current_path, items):
            for name, content in items.items():
                item_path = current_path / name
                
                if isinstance(content, dict):
                    # 创建目录
                    item_path.mkdir(exist_ok=True)
                    print(f"创建目录: {item_path}")
                    create_items(item_path, content)
                elif isinstance(content, str):
                    # 创建文件
                    item_path.write_text(content, encoding='utf-8')
                    print(f"创建文件: {item_path}")
                elif content is None:
                    # 创建空目录
                    item_path.mkdir(exist_ok=True)
                    print(f"创建空目录: {item_path}")
        
        create_items(base, structure)
        print(f"目录结构创建完成: {base_path}")
        return True
        
    except Exception as e:
        print(f"创建目录结构失败: {e}")
        return False

class DirectoryManager:
    def __init__(self, base_directory):
        self.base_path = Path(base_directory)
        self.base_path.mkdir(parents=True, exist_ok=True)
    
    def create_file(self, filename, content=""):
        """创建文件"""
        file_path = self.base_path / filename
        try:
            file_path.parent.mkdir(parents=True, exist_ok=True)
            file_path.write_text(content, encoding='utf-8')
            print(f"文件已创建: {file_path}")
            return True
        except Exception as e:
            print(f"创建文件失败: {e}")
            return False
    
    def delete_item(self, item_name):
        """删除文件或目录"""
        item_path = self.base_path / item_name
        try:
            if item_path.is_file():
                item_path.unlink()
                print(f"文件已删除: {item_path}")
            elif item_path.is_dir():
                shutil.rmtree(item_path)
                print(f"目录已删除: {item_path}")
            else:
                print(f"项目不存在: {item_path}")
                return False
            return True
        except Exception as e:
            print(f"删除失败: {e}")
            return False
    
    def copy_item(self, source, destination):
        """复制文件或目录"""
        src_path = self.base_path / source
        dst_path = self.base_path / destination
        
        try:
            if src_path.is_file():
                dst_path.parent.mkdir(parents=True, exist_ok=True)
                shutil.copy2(src_path, dst_path)
                print(f"文件已复制: {src_path} -> {dst_path}")
            elif src_path.is_dir():
                shutil.copytree(src_path, dst_path, dirs_exist_ok=True)
                print(f"目录已复制: {src_path} -> {dst_path}")
            else:
                print(f"源不存在: {src_path}")
                return False
            return True
        except Exception as e:
            print(f"复制失败: {e}")
            return False
    
    def get_directory_size(self, directory="."):
        """计算目录大小"""
        dir_path = self.base_path / directory
        total_size = 0
        file_count = 0
        dir_count = 0
        
        try:
            for item in dir_path.rglob('*'):
                if item.is_file():
                    total_size += item.stat().st_size
                    file_count += 1
                elif item.is_dir():
                    dir_count += 1
            
            print(f"目录统计 - {dir_path}:")
            print(f"  总大小: {total_size} bytes ({total_size/1024:.2f} KB)")
            print(f"  文件数: {file_count}")
            print(f"  目录数: {dir_count}")
            
            return {
                'total_size': total_size,
                'file_count': file_count,
                'dir_count': dir_count
            }
        except Exception as e:
            print(f"计算目录大小失败: {e}")
            return None

# 演示目录操作
print("目录操作演示:")

# 1. 创建目录结构
print("\n1. 创建项目目录结构:")
project_structure = {
    "src": {
        "main.py": "# 主程序文件\nprint('Hello World')",
        "utils": {
            "__init__.py": "",
            "helpers.py": "# 辅助函数\ndef helper():\n    pass"
        }
    },
    "tests": {
        "test_main.py": "# 测试文件\nimport unittest"
    },
    "docs": None,  # 空目录
    "README.md": "# 项目说明\n这是一个示例项目。"
}

create_directory_structure("demo_project", project_structure)

# 2. 列出目录内容
print("\n2. 列出目录内容:")
contents = list_directory_contents("demo_project", recursive=True)

# 3. 目录管理
print("\n3. 目录管理操作:")
manager = DirectoryManager("demo_project")

# 创建新文件
manager.create_file("config/settings.py", "# 配置文件\nDEBUG = True")

# 复制文件
manager.copy_item("README.md", "docs/README_copy.md")

# 计算目录大小
stats = manager.get_directory_size()

# 4. 最终目录结构
print("\n4. 最终目录结构:")
list_directory_contents("demo_project", recursive=True)

输出示例：

目录操作演示:

1. 创建项目目录结构:
创建目录: demo_project\src
创建文件: demo_project\src\main.py
创建目录: demo_project\src\utils
创建文件: demo_project\src\utils\__init__.py
创建文件: demo_project\src\utils\helpers.py
创建目录: demo_project\tests
创建文件: demo_project\tests\test_main.py
创建空目录: demo_project\docs
创建文件: demo_project\README.md
目录结构创建完成: demo_project

2. 列出目录内容:
目录内容: demo_project
docs (<DIR>) - 2024-01-15 10:30:45
src (<DIR>) - 2024-01-15 10:30:45
  utils (<DIR>) - 2024-01-15 10:30:45
    __init__.py (0 bytes) - 2024-01-15 10:30:45
    helpers.py (35 bytes) - 2024-01-15 10:30:45
  main.py (42 bytes) - 2024-01-15 10:30:45
tests (<DIR>) - 2024-01-15 10:30:45
  test_main.py (38 bytes) - 2024-01-15 10:30:45
README.md (31 bytes) - 2024-01-15 10:30:45

3. 目录管理操作:
文件已创建: demo_project\config\settings.py
文件已复制: demo_project\README.md -> demo_project\docs\README_copy.md
目录统计 - demo_project:
  总大小: 177 bytes (0.17 KB)
  文件数: 6
  目录数: 4

4. 最终目录结构:
目录内容: demo_project
config (<DIR>) - 2024-01-15 10:30:46
  settings.py (25 bytes) - 2024-01-15 10:30:46
docs (<DIR>) - 2024-01-15 10:30:45
  README_copy.md (31 bytes) - 2024-01-15 10:30:46
src (<DIR>) - 2024-01-15 10:30:45
  utils (<DIR>) - 2024-01-15 10:30:45
    __init__.py (0 bytes) - 2024-01-15 10:30:45
    helpers.py (35 bytes) - 2024-01-15 10:30:45
  main.py (42 bytes) - 2024-01-15 10:30:45
tests (<DIR>) - 2024-01-15 10:30:45
  test_main.py (38 bytes) - 2024-01-15 10:30:45
README.md (31 bytes) - 2024-01-15 10:30:45

知识点： 目录操作、Path对象、文件系统管理、递归遍历

第89题：日志记录

题目： 实现完整的日志记录系统

答案：

import logging
import os
from datetime import datetime
from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler

# 配置日志系统
def setup_logger(name, log_file, level=logging.INFO, max_bytes=1024*1024, backup_count=5):
    """设置日志记录器"""
    
    # 创建日志目录
    log_dir = os.path.dirname(log_file)
    if log_dir and not os.path.exists(log_dir):
        os.makedirs(log_dir)
    
    # 创建日志记录器
    logger = logging.getLogger(name)
    logger.setLevel(level)
    
    # 避免重复添加处理器
    if logger.handlers:
        return logger
    
    # 创建格式化器
    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S'
    )
    
    # 文件处理器（轮转）
    file_handler = RotatingFileHandler(
        log_file, 
        maxBytes=max_bytes, 
        backupCount=backup_count,
        encoding='utf-8'
    )
    file_handler.setLevel(level)
    file_handler.setFormatter(formatter)
    
    # 控制台处理器
    console_handler = logging.StreamHandler()
    console_handler.setLevel(logging.WARNING)  # 控制台只显示警告及以上级别
    console_formatter = logging.Formatter(
        '%(levelname)s - %(name)s - %(message)s'
    )
    console_handler.setFormatter(console_formatter)
    
    # 添加处理器
    logger.addHandler(file_handler)
    logger.addHandler(console_handler)
    
    return logger

class Calculator:
    def __init__(self):
        # 设置日志
        self.logger = setup_logger(
            'Calculator', 
            'logs/calculator.log',
            level=logging.DEBUG
        )
        self.logger.info("计算器初始化完成")
    
    def add(self, a, b):
        """加法运算"""
        self.logger.debug(f"执行加法: {a} + {b}")
        try:
            result = a + b
            self.logger.info(f"加法运算成功: {a} + {b} = {result}")
            return result
        except Exception as e:
            self.logger.error(f"加法运算失败: {a} + {b}, 错误: {e}")
            raise
    
    def divide(self, a, b):
        """除法运算"""
        self.logger.debug(f"执行除法: {a} / {b}")
        try:
            if b == 0:
                self.logger.warning(f"尝试除零: {a} / {b}")
                raise ZeroDivisionError("除数不能为零")
            
            result = a / b
            self.logger.info(f"除法运算成功: {a} / {b} = {result}")
            return result
        except Exception as e:
            self.logger.error(f"除法运算失败: {a} / {b}, 错误: {e}")
            raise
    
    def batch_calculate(self, operations):
        """批量计算"""
        self.logger.info(f"开始批量计算，共 {len(operations)} 个操作")
        results = []
        
        for i, (op, a, b) in enumerate(operations):
            try:
                self.logger.debug(f"执行操作 {i+1}: {a} {op} {b}")
                
                if op == '+':
                    result = self.add(a, b)
                elif op == '/':
                    result = self.divide(a, b)
                else:
                    raise ValueError(f"不支持的操作: {op}")
                
                results.append(result)
                
            except Exception as e:
                self.logger.error(f"操作 {i+1} 失败: {e}")
                results.append(None)
        
        success_count = sum(1 for r in results if r is not None)
        self.logger.info(f"批量计算完成，成功: {success_count}/{len(operations)}")
        
        return results

class ApplicationLogger:
    """应用程序日志管理器"""
    
    def __init__(self, app_name):
        self.app_name = app_name
        
        # 不同级别的日志文件
        self.loggers = {
            'debug': setup_logger(
                f'{app_name}.debug',
                f'logs/{app_name}_debug.log',
                logging.DEBUG
            ),
            'info': setup_logger(
                f'{app_name}.info',
                f'logs/{app_name}_info.log',
                logging.INFO
            ),
            'error': setup_logger(
                f'{app_name}.error',
                f'logs/{app_name}_error.log',
                logging.ERROR
            )
        }
    
    def debug(self, message):
        self.loggers['debug'].debug(message)
    
    def info(self, message):
        for logger in self.loggers.values():
            if logger.level <= logging.INFO:
                logger.info(message)
    
    def warning(self, message):
        for logger in self.loggers.values():
            if logger.level <= logging.WARNING:
                logger.warning(message)
    
    def error(self, message):
        for logger in self.loggers.values():
            if logger.level <= logging.ERROR:
                logger.error(message)
    
    def critical(self, message):
        for logger in self.loggers.values():
            logger.critical(message)

def log_function_calls(func):
    """函数调用日志装饰器"""
    logger = logging.getLogger(f'FunctionCall.{func.__name__}')
    
    def wrapper(*args, **kwargs):
        logger.info(f"调用函数 {func.__name__}，参数: args={args}, kwargs={kwargs}")
        start_time = datetime.now()
        
        try:
            result = func(*args, **kwargs)
            end_time = datetime.now()
            duration = (end_time - start_time).total_seconds()
            logger.info(f"函数 {func.__name__} 执行成功，耗时: {duration:.4f}秒")
            return result
        except Exception as e:
            end_time = datetime.now()
            duration = (end_time - start_time).total_seconds()
            logger.error(f"函数 {func.__name__} 执行失败，耗时: {duration:.4f}秒，错误: {e}")
            raise
    
    return wrapper

@log_function_calls
def complex_calculation(x, y, z):
    """复杂计算函数"""
    import time
    time.sleep(0.1)  # 模拟计算时间
    
    if z == 0:
        raise ValueError("z 不能为零")
    
    return (x + y) / z

# 演示日志记录
print("日志记录演示:")

# 1. 基本日志记录
print("\n1. 计算器日志:")
calc = Calculator()

# 执行一些计算
result1 = calc.add(10, 5)
print(f"10 + 5 = {result1}")

result2 = calc.divide(20, 4)
print(f"20 / 4 = {result2}")

# 尝试除零
try:
    calc.divide(10, 0)
except ZeroDivisionError as e:
    print(f"除零错误: {e}")

# 批量计算
operations = [
    ('+', 1, 2),
    ('/', 10, 2),
    ('/', 5, 0),  # 除零错误
    ('+', 3, 4)
]

results = calc.batch_calculate(operations)
print(f"批量计算结果: {results}")

# 2. 应用程序日志
print("\n2. 应用程序日志:")
app_logger = ApplicationLogger('MyApp')

app_logger.info("应用程序启动")
app_logger.debug("调试信息：初始化配置")
app_logger.warning("警告：配置文件缺少某些选项")
app_logger.error("错误：无法连接到数据库")

# 3. 函数调用日志
print("\n3. 函数调用日志:")

# 设置函数调用日志
func_logger = setup_logger(
    'FunctionCall.complex_calculation',
    'logs/function_calls.log',
    logging.INFO
)

# 执行函数
try:
    result = complex_calculation(10, 5, 3)
    print(f"计算结果: {result}")
except Exception as e:
    print(f"计算错误: {e}")

try:
    result = complex_calculation(10, 5, 0)  # 会出错
except Exception as e:
    print(f"计算错误: {e}")

print("\n日志文件已生成在 logs/ 目录中")
print("可以查看以下日志文件:")
print("- logs/calculator.log")
print("- logs/MyApp_debug.log")
print("- logs/MyApp_info.log")
print("- logs/MyApp_error.log")
print("- logs/function_calls.log")

输出示例：

日志记录演示:

1. 计算器日志:
10 + 5 = 15
20 / 4 = 5.0
WARNING - Calculator - 尝试除零: 10 / 0
ERROR - Calculator - 除法运算失败: 10 / 0, 错误: 除数不能为零
除零错误: 除数不能为零
批量计算结果: [3, 5.0, None, 7]

2. 应用程序日志:

3. 函数调用日志:
计算结果: 5.0
计算错误: z 不能为零

日志文件已生成在 logs/ 目录中
可以查看以下日志文件:
- logs/calculator.log
- logs/MyApp_debug.log
- logs/MyApp_info.log
- logs/MyApp_error.log
- logs/function_calls.log

知识点： 日志记录、日志级别、日志轮转、装饰器日志

第90题：配置文件

题目： 处理不同格式的配置文件

答案：

import configparser
import json
import os
from datetime import datetime

class ConfigManager:
    """配置文件管理器"""
    
    def __init__(self, config_dir='config'):
        self.config_dir = config_dir
        if not os.path.exists(config_dir):
            os.makedirs(config_dir)
    
    def create_ini_config(self, filename='app.ini'):
        """创建INI配置文件"""
        config = configparser.ConfigParser()
        
        # 添加配置节和选项
        config['DEFAULT'] = {
            'debug': 'True',
            'log_level': 'INFO',
            'max_connections': '100'
        }
        
        config['database'] = {
            'host': 'localhost',
            'port': '3306',
            'username': 'admin',
            'password': 'secret123',
            'database_name': 'myapp'
        }
        
        config['server'] = {
            'host': '0.0.0.0',
            'port': '8080',
            'workers': '4'
        }
        
        config['features'] = {
            'enable_cache': 'True',
            'enable_logging': 'True',
            'enable_metrics': 'False'
        }
        
        # 保存配置文件
        config_path = os.path.join(self.config_dir, filename)
        with open(config_path, 'w', encoding='utf-8') as f:
            config.write(f)
        
        print(f"INI配置文件已创建: {config_path}")
        return config_path
    
    def read_ini_config(self, filename='app.ini'):
        """读取INI配置文件"""
        config_path = os.path.join(self.config_dir, filename)
        
        if not os.path.exists(config_path):
            print(f"配置文件不存在: {config_path}")
            return None
        
        config = configparser.ConfigParser()
        config.read(config_path, encoding='utf-8')
        
        print(f"INI配置文件已读取: {config_path}")
        return config
    
    def create_json_config(self, filename='app.json'):
        """创建JSON配置文件"""
        config_data = {
            "application": {
                "name": "MyApplication",
                "version": "1.0.0",
                "debug": True,
                "environment": "development"
            },
            "database": {
                "type": "mysql",
                "host": "localhost",
                "port": 3306,
                "credentials": {
                    "username": "admin",
                    "password": "secret123"
                },
                "database_name": "myapp",
                "pool_size": 10
            },
            "server": {
                "host": "0.0.0.0",
                "port": 8080,
                "ssl_enabled": False,
                "cors_origins": ["http://localhost:3000", "https://myapp.com"]
            },
            "logging": {
                "level": "INFO",
                "file": "logs/app.log",
                "max_size": "10MB",
                "backup_count": 5
            },
            "features": {
                "cache": {
                    "enabled": True,
                    "ttl": 3600,
                    "max_size": 1000
                },
                "metrics": {
                    "enabled": False,
                    "endpoint": "/metrics"
                }
            },
            "created_at": datetime.now().isoformat()
        }
        
        config_path = os.path.join(self.config_dir, filename)
        with open(config_path, 'w', encoding='utf-8') as f:
            json.dump(config_data, f, ensure_ascii=False, indent=2)
        
        print(f"JSON配置文件已创建: {config_path}")
        return config_path
    
    def read_json_config(self, filename='app.json'):
        """读取JSON配置文件"""
        config_path = os.path.join(self.config_dir, filename)
        
        if not os.path.exists(config_path):
            print(f"配置文件不存在: {config_path}")
            return None
        
        try:
            with open(config_path, 'r', encoding='utf-8') as f:
                config_data = json.load(f)
            
            print(f"JSON配置文件已读取: {config_path}")
            return config_data
        except json.JSONDecodeError as e:
            print(f"JSON格式错误: {e}")
            return None
    
    def update_config(self, filename, section, key, value, config_type='ini'):
        """更新配置文件"""
        if config_type == 'ini':
            config = self.read_ini_config(filename)
            if config:
                if section not in config:
                    config.add_section(section)
                config.set(section, key, str(value))
                
                config_path = os.path.join(self.config_dir, filename)
                with open(config_path, 'w', encoding='utf-8') as f:
                    config.write(f)
                print(f"INI配置已更新: [{section}] {key} = {value}")
        
        elif config_type == 'json':
            config_data = self.read_json_config(filename)
            if config_data:
                if section not in config_data:
                    config_data[section] = {}
                config_data[section][key] = value
                config_data['updated_at'] = datetime.now().isoformat()
                
                config_path = os.path.join(self.config_dir, filename)
                with open(config_path, 'w', encoding='utf-8') as f:
                    json.dump(config_data, f, ensure_ascii=False, indent=2)
                print(f"JSON配置已更新: {section}.{key} = {value}")
    
    def get_config_value(self, filename, section, key, config_type='ini', default=None):
        """获取配置值"""
        if config_type == 'ini':
            config = self.read_ini_config(filename)
            if config and config.has_option(section, key):
                return config.get(section, key)
        
        elif config_type == 'json':
            config_data = self.read_json_config(filename)
            if config_data and section in config_data and key in config_data[section]:
                return config_data[section][key]
        
        return default

# 演示配置文件处理
print("配置文件处理演示:")

# 创建配置管理器
config_manager = ConfigManager()

# 1. 创建和读取INI配置
print("\n1. INI配置文件:")
ini_file = config_manager.create_ini_config()
ini_config = config_manager.read_ini_config()

print("\nINI配置内容:")
for section_name in ini_config.sections():
    print(f"[{section_name}]")
    for key, value in ini_config.items(section_name):
        print(f"  {key} = {value}")
    print()

# 2. 创建和读取JSON配置
print("\n2. JSON配置文件:")
json_file = config_manager.create_json_config()
json_config = config_manager.read_json_config()

print("\nJSON配置内容:")
print(json.dumps(json_config, ensure_ascii=False, indent=2))

# 3. 更新配置
print("\n3. 更新配置:")
config_manager.update_config('app.ini', 'database', 'port', '3307', 'ini')
config_manager.update_config('app.json', 'server', 'port', 9000, 'json')

# 4. 获取配置值
print("\n4. 获取配置值:")
db_host = config_manager.get_config_value('app.ini', 'database', 'host', 'ini')
server_port = config_manager.get_config_value('app.json', 'server', 'port', 'json')
print(f"数据库主机 (INI): {db_host}")
print(f"服务器端口 (JSON): {server_port}")

**输出示例:**

配置文件处理演示:

1. INI配置文件:
   INI配置文件已创建: config/app.ini
   INI配置文件已读取: config/app.ini

INI配置内容:
[database]
host = localhost
port = 3306
username = admin
password = secret123
database_name = myapp

[server]
host = 0.0.0.0
port = 8080
workers = 4

[features]
enable_cache = True
enable_logging = True
enable_metrics = False

2. JSON配置文件:
   JSON配置文件已创建: config/app.json
   JSON配置文件已读取: config/app.json

JSON配置内容:
{
“application”: {
“name”: “MyApplication”,
“version”: “1.0.0”,
“debug”: true,
“environment”: “development”
},
“database”: {
“type”: “mysql”,
“host”: “localhost”,
“port”: 3306
}
}

3. 更新配置:
   INI配置文件已读取: config/app.ini
   INI配置已更新: [database] port = 3307
   JSON配置文件已读取: config/app.json
   JSON配置已更新: server.port = 9000

4. 获取配置值:
   INI配置文件已读取: config/app.ini
   JSON配置文件已读取: config/app.json
   数据库主机 (INI): localhost
   服务器端口 (JSON): 9000

**知识点:** 配置文件处理、INI和JSON格式、配置管理

---

### 第91题：学生管理系统
**题目:** 综合应用 - 创建完整的学生管理系统

**答案:**
```python
class Student:
    def __init__(self, student_id, name, age, grade, subjects=None):
        self.student_id = student_id
        self.name = name
        self.age = age
        self.grade = grade
        self.subjects = subjects or {}
        self.enrollment_date = datetime.now().strftime('%Y-%m-%d')
    
    def add_score(self, subject, score):
        """添加科目成绩"""
        if subject not in self.subjects:
            self.subjects[subject] = []
        self.subjects[subject].append(score)
        print(f"已为学生 {self.name} 添加 {subject} 成绩: {score}")
    
    def get_average_score(self, subject=None):
        """获取平均成绩"""
        if subject:
            if subject in self.subjects and self.subjects[subject]:
                return sum(self.subjects[subject]) / len(self.subjects[subject])
            return 0
        
        # 计算总平均分
        all_scores = []
        for scores in self.subjects.values():
            all_scores.extend(scores)
        
        return sum(all_scores) / len(all_scores) if all_scores else 0
    
    def get_info(self):
        """获取学生信息"""
        return {
            'student_id': self.student_id,
            'name': self.name,
            'age': self.age,
            'grade': self.grade,
            'subjects': self.subjects,
            'average_score': round(self.get_average_score(), 2),
            'enrollment_date': self.enrollment_date
        }

class StudentManagementSystem:
    def __init__(self):
        self.students = {}
        self.next_id = 1
    
    def add_student(self, name, age, grade):
        """添加学生"""
        student_id = f"STU{self.next_id:04d}"
        student = Student(student_id, name, age, grade)
        self.students[student_id] = student
        self.next_id += 1
        
        print(f"学生添加成功: {student_id} - {name}")
        return student_id
    
    def remove_student(self, student_id):
        """删除学生"""
        if student_id in self.students:
            student_name = self.students[student_id].name
            del self.students[student_id]
            print(f"学生已删除: {student_id} - {student_name}")
            return True
        else:
            print(f"学生不存在: {student_id}")
            return False
    
    def find_student(self, student_id=None, name=None):
        """查找学生"""
        if student_id:
            return self.students.get(student_id)
        
        if name:
            for student in self.students.values():
                if student.name == name:
                    return student
        
        return None
    
    def list_students(self, grade=None):
        """列出学生"""
        students = list(self.students.values())
        
        if grade:
            students = [s for s in students if s.grade == grade]
        
        # 按平均成绩排序
        students.sort(key=lambda s: s.get_average_score(), reverse=True)
        
        print(f"\n学生列表 (共 {len(students)} 人):")
        print(f"{'学号':<10} {'姓名':<10} {'年龄':<5} {'年级':<8} {'平均分':<8}")
        print("-" * 50)
        
        for student in students:
            avg_score = student.get_average_score()
            print(f"{student.student_id:<10} {student.name:<10} {student.age:<5} "
                  f"{student.grade:<8} {avg_score:<8.2f}")
        
        return students
    
    def get_statistics(self):
        """获取统计信息"""
        if not self.students:
            return {}
        
        # 按年级统计
        grade_stats = {}
        all_scores = []
        
        for student in self.students.values():
            grade = student.grade
            if grade not in grade_stats:
                grade_stats[grade] = {'count': 0, 'total_score': 0}
            
            grade_stats[grade]['count'] += 1
            avg_score = student.get_average_score()
            grade_stats[grade]['total_score'] += avg_score
            all_scores.append(avg_score)
        
        # 计算各年级平均分
        for grade in grade_stats:
            count = grade_stats[grade]['count']
            total = grade_stats[grade]['total_score']
            grade_stats[grade]['average'] = total / count if count > 0 else 0
        
        stats = {
            'total_students': len(self.students),
            'grade_distribution': grade_stats,
            'overall_average': sum(all_scores) / len(all_scores) if all_scores else 0,
            'highest_score': max(all_scores) if all_scores else 0,
            'lowest_score': min(all_scores) if all_scores else 0
        }
        
        return stats
    
    def export_data(self, filename):
        """导出学生数据"""
        try:
            data = {
                'students': [student.get_info() for student in self.students.values()],
                'statistics': self.get_statistics(),
                'export_time': datetime.now().isoformat()
            }
            
            with open(filename, 'w', encoding='utf-8') as f:
                json.dump(data, f, ensure_ascii=False, indent=2)
            
            print(f"数据已导出到: {filename}")
            return True
        except Exception as e:
            print(f"导出失败: {e}")
            return False

# 演示学生管理系统
print("学生管理系统演示:")
sms = StudentManagementSystem()

# 添加学生
print("\n1. 添加学生:")
student_ids = [
    sms.add_student("张三", 18, "高一"),
    sms.add_student("李四", 17, "高一"),
    sms.add_student("王五", 19, "高二"),
    sms.add_student("赵六", 18, "高二"),
    sms.add_student("钱七", 16, "高一")
]

# 添加成绩
print("\n2. 添加成绩:")
for student_id in student_ids[:3]:
    student = sms.find_student(student_id)
    if student:
        student.add_score("数学", 85 + hash(student_id) % 15)
        student.add_score("语文", 80 + hash(student_id) % 20)
        student.add_score("英语", 75 + hash(student_id) % 25)

# 列出所有学生
print("\n3. 学生列表:")
sms.list_students()

# 按年级列出
print("\n4. 高一学生:")
sms.list_students(grade="高一")

# 统计信息
print("\n5. 统计信息:")
stats = sms.get_statistics()
print(f"总学生数: {stats['total_students']}")
print(f"整体平均分: {stats['overall_average']:.2f}")
print(f"最高分: {stats['highest_score']:.2f}")
print(f"最低分: {stats['lowest_score']:.2f}")

print("\n年级分布:")
for grade, data in stats['grade_distribution'].items():
    print(f"  {grade}: {data['count']}人, 平均分: {data['average']:.2f}")

# 导出数据
print("\n6. 导出数据:")
sms.export_data('students_data.json')

输出示例:

学生管理系统演示:

1. 添加学生:
学生添加成功: STU0001 - 张三
学生添加成功: STU0002 - 李四
学生添加成功: STU0003 - 王五
学生添加成功: STU0004 - 赵六
学生添加成功: STU0005 - 钱七

2. 添加成绩:
已为学生 张三 添加 数学 成绩: 92
已为学生 张三 添加 语文 成绩: 88
已为学生 张三 添加 英语 成绩: 85
已为学生 李四 添加 数学 成绩: 87
已为学生 李四 添加 语文 成绩: 91
已为学生 李四 添加 英语 成绩: 79

3. 学生列表:

学生列表 (共 5 人):
学号         姓名         年龄    年级      平均分   
--------------------------------------------------
STU0002    李四         17    高一      85.67
STU0001    张三         18    高一      88.33
STU0003    王五         19    高二      83.00
STU0004    赵六         18    高二      0.00
STU0005    钱七         16    高一      0.00

4. 高一学生:

学生列表 (共 3 人):
学号         姓名         年龄    年级      平均分   
--------------------------------------------------
STU0001    张三         18    高一      88.33
STU0002    李四         17    高一      85.67
STU0005    钱七         16    高一      0.00

5. 统计信息:
总学生数: 5
整体平均分: 51.40
最高分: 88.33
最低分: 0.00

年级分布:
  高一: 3人, 平均分: 58.00
  高二: 2人, 平均分: 41.50

6. 导出数据:
数据已导出到: students_data.json

知识点: 面向对象设计、数据管理、统计分析、文件导出

第92题：计算器程序

题目: 综合应用 - 创建功能完整的计算器程序

答案:

class Calculator:
    def __init__(self):
        self.history = []
        self.memory = 0
        self.last_result = 0
    
    def add(self, a, b):
        """加法"""
        result = a + b
        self._record_operation(f"{a} + {b}", result)
        return result
    
    def subtract(self, a, b):
        """减法"""
        result = a - b
        self._record_operation(f"{a} - {b}", result)
        return result
    
    def multiply(self, a, b):
        """乘法"""
        result = a * b
        self._record_operation(f"{a} × {b}", result)
        return result
    
    def divide(self, a, b):
        """除法"""
        if b == 0:
            raise ValueError("除数不能为零")
        result = a / b
        self._record_operation(f"{a} ÷ {b}", result)
        return result
    
    def power(self, base, exponent):
        """幂运算"""
        result = base ** exponent
        self._record_operation(f"{base} ^ {exponent}", result)
        return result
    
    def sqrt(self, number):
        """平方根"""
        if number < 0:
            raise ValueError("负数不能开平方根")
        result = number ** 0.5
        self._record_operation(f"√{number}", result)
        return result
    
    def factorial(self, n):
        """阶乘"""
        if n < 0:
            raise ValueError("负数没有阶乘")
        if not isinstance(n, int):
            raise ValueError("阶乘只能计算整数")
        
        result = 1
        for i in range(1, n + 1):
            result *= i
        
        self._record_operation(f"{n}!", result)
        return result
    
    def percentage(self, number, percent):
        """百分比计算"""
        result = number * (percent / 100)
        self._record_operation(f"{number} × {percent}%", result)
        return result
    
    def evaluate_expression(self, expression):
        """计算表达式"""
        try:
            # 简单的表达式求值（仅支持基本运算符）
            allowed_chars = set('0123456789+-*/().^ ')
            if not all(c in allowed_chars for c in expression):
                raise ValueError("表达式包含不支持的字符")
            
            # 替换^为**
            expression = expression.replace('^', '**')
            
            result = eval(expression)
            self._record_operation(expression, result)
            return result
        except Exception as e:
            raise ValueError(f"表达式计算错误: {e}")
    
    def memory_store(self, value):
        """存储到内存"""
        self.memory = value
        print(f"已存储到内存: {value}")
    
    def memory_recall(self):
        """从内存读取"""
        return self.memory
    
    def memory_clear(self):
        """清除内存"""
        self.memory = 0
        print("内存已清除")
    
    def memory_add(self, value):
        """内存加法"""
        self.memory += value
        print(f"内存值更新为: {self.memory}")
    
    def _record_operation(self, operation, result):
        """记录操作历史"""
        self.history.append({
            'operation': operation,
            'result': result,
            'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        })
        self.last_result = result
    
    def get_history(self, limit=10):
        """获取计算历史"""
        return self.history[-limit:] if limit else self.history
    
    def clear_history(self):
        """清除历史记录"""
        self.history.clear()
        print("历史记录已清除")
    
    def get_statistics(self):
        """获取使用统计"""
        if not self.history:
            return {}
        
        operations = [item['operation'] for item in self.history]
        results = [item['result'] for item in self.history]
        
        return {
            'total_calculations': len(self.history),
            'average_result': sum(results) / len(results),
            'max_result': max(results),
            'min_result': min(results),
            'most_recent': self.history[-1] if self.history else None
        }

class CalculatorInterface:
    def __init__(self):
        self.calc = Calculator()
    
    def run(self):
        """运行计算器界面"""
        print("=== Python 计算器 ===")
        print("支持的操作:")
        print("1. 基本运算: +, -, *, /")
        print("2. 高级运算: ^(幂), sqrt(平方根), !(阶乘)")
        print("3. 内存操作: ms(存储), mr(读取), mc(清除), m+(加到内存)")
        print("4. 其他: history(历史), clear(清除历史), stats(统计), quit(退出)")
        print()
        
        while True:
            try:
                user_input = input("请输入计算表达式或命令: ").strip()
                
                if user_input.lower() in ['quit', 'exit', 'q']:
                    print("感谢使用计算器！")
                    break
                
                elif user_input.lower() == 'history':
                    self._show_history()
                
                elif user_input.lower() == 'clear':
                    self.calc.clear_history()
                
                elif user_input.lower() == 'stats':
                    self._show_statistics()
                
                elif user_input.lower() == 'mc':
                    self.calc.memory_clear()
                
                elif user_input.lower() == 'mr':
                    memory_value = self.calc.memory_recall()
                    print(f"内存值: {memory_value}")
                
                elif user_input.lower().startswith('ms '):
                    try:
                        value = float(user_input[3:])
                        self.calc.memory_store(value)
                    except ValueError:
                        print("错误: 请输入有效数字")
                
                elif user_input.lower().startswith('m+ '):
                    try:
                        value = float(user_input[3:])
                        self.calc.memory_add(value)
                    except ValueError:
                        print("错误: 请输入有效数字")
                
                elif 'sqrt(' in user_input:
                    # 处理平方根
                    import re
                    match = re.search(r'sqrt\(([^)]+)\)', user_input)
                    if match:
                        number = float(match.group(1))
                        result = self.calc.sqrt(number)
                        print(f"结果: {result}")
                
                elif user_input.endswith('!'):
                    # 处理阶乘
                    number = int(user_input[:-1])
                    result = self.calc.factorial(number)
                    print(f"结果: {result}")
                
                else:
                    # 处理普通表达式
                    result = self.calc.evaluate_expression(user_input)
                    print(f"结果: {result}")
            
            except ValueError as e:
                print(f"错误: {e}")
            except Exception as e:
                print(f"未知错误: {e}")
    
    def _show_history(self):
        """显示计算历史"""
        history = self.calc.get_history()
        if not history:
            print("暂无计算历史")
            return
        
        print("\n=== 计算历史 ===")
        for i, item in enumerate(history, 1):
            print(f"{i}. {item['operation']} = {item['result']} ({item['timestamp']})")
        print()
    
    def _show_statistics(self):
        """显示使用统计"""
        stats = self.calc.get_statistics()
        if not stats:
            print("暂无统计数据")
            return
        
        print("\n=== 使用统计 ===")
        print(f"总计算次数: {stats['total_calculations']}")
        print(f"平均结果: {stats['average_result']:.2f}")
        print(f"最大结果: {stats['max_result']}")
        print(f"最小结果: {stats['min_result']}")
        if stats['most_recent']:
            recent = stats['most_recent']
            print(f"最近计算: {recent['operation']} = {recent['result']}")
        print()

# 演示计算器程序
print("计算器程序演示:")

# 创建计算器实例
calc = Calculator()

# 基本运算演示
print("\n1. 基本运算:")
print(f"10 + 5 = {calc.add(10, 5)}")
print(f"10 - 3 = {calc.subtract(10, 3)}")
print(f"6 × 7 = {calc.multiply(6, 7)}")
print(f"15 ÷ 3 = {calc.divide(15, 3)}")

# 高级运算演示
print("\n2. 高级运算:")
print(f"2^8 = {calc.power(2, 8)}")
print(f"√16 = {calc.sqrt(16)}")
print(f"5! = {calc.factorial(5)}")
print(f"200的15% = {calc.percentage(200, 15)}")

# 表达式计算
print("\n3. 表达式计算:")
print(f"(10 + 5) × 2 = {calc.evaluate_expression('(10 + 5) * 2')}")
print(f"2^3 + 4×5 = {calc.evaluate_expression('2^3 + 4*5')}")

# 内存操作
print("\n4. 内存操作:")
calc.memory_store(100)
print(f"内存值: {calc.memory_recall()}")
calc.memory_add(50)
print(f"内存值: {calc.memory_recall()}")

# 历史记录
print("\n5. 计算历史:")
history = calc.get_history(5)
for i, item in enumerate(history, 1):
    print(f"{i}. {item['operation']} = {item['result']}")

# 统计信息
print("\n6. 使用统计:")
stats = calc.get_statistics()
print(f"总计算次数: {stats['total_calculations']}")
print(f"平均结果: {stats['average_result']:.2f}")
print(f"最大结果: {stats['max_result']}")
print(f"最小结果: {stats['min_result']}")

输出示例:

计算器程序演示:

1. 基本运算:
10 + 5 = 15
10 - 3 = 7
6 × 7 = 42
15 ÷ 3 = 5.0

2. 高级运算:
2^8 = 256
√16 = 4.0
5! = 120
200的15% = 30.0

3. 表达式计算:
(10 + 5) × 2 = 30
2^3 + 4×5 = 28

4. 内存操作:
已存储到内存: 100
内存值: 100
内存值更新为: 150
内存值: 150

5. 计算历史:
1. 10 + 5 = 15
2. 10 - 3 = 7
3. 6 × 7 = 42
4. 15 ÷ 3 = 5.0
5. 2 ^ 8 = 256

6. 使用统计:
总计算次数: 10
平均结果: 55.7
最大结果: 256
最小结果: 4.0

知识点: 面向对象设计、异常处理、表达式求值、用户界面设计

第93题：密码生成器

题目: 实用工具 - 创建安全密码生成器

答案:

class PasswordGenerator:
    def __init__(self):
        self.lowercase = 'abcdefghijklmnopqrstuvwxyz'
        self.uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
        self.digits = '0123456789'
        self.special_chars = '!@#$%^&*()_+-=[]{}|;:,.<>?'
        self.ambiguous_chars = 'il1Lo0O'
    
    def generate_password(self, length=12, use_uppercase=True, use_lowercase=True, 
                         use_digits=True, use_special=True, exclude_ambiguous=False):
        """生成单个密码"""
        if length < 4:
            raise ValueError("密码长度至少为4位")
        
        # 构建字符集
        charset = ''
        required_chars = []
        
        if use_lowercase:
            chars = self.lowercase
            if exclude_ambiguous:
                chars = ''.join(c for c in chars if c not in self.ambiguous_chars)
            charset += chars
            required_chars.append(random.choice(chars))
        
        if use_uppercase:
            chars = self.uppercase
            if exclude_ambiguous:
                chars = ''.join(c for c in chars if c not in self.ambiguous_chars)
            charset += chars
            required_chars.append(random.choice(chars))
        
        if use_digits:
            chars = self.digits
            if exclude_ambiguous:
                chars = ''.join(c for c in chars if c not in self.ambiguous_chars)
            charset += chars
            required_chars.append(random.choice(chars))
        
        if use_special:
            charset += self.special_chars
            required_chars.append(random.choice(self.special_chars))
        
        if not charset:
            raise ValueError("至少需要选择一种字符类型")
        
        # 生成密码
        password_chars = required_chars[:]
        remaining_length = length - len(required_chars)
        
        for _ in range(remaining_length):
            password_chars.append(random.choice(charset))
        
        # 随机打乱字符顺序
        random.shuffle(password_chars)
        
        return ''.join(password_chars)
    
    def generate_multiple_passwords(self, count=5, **kwargs):
        """生成多个密码"""
        passwords = []
        for _ in range(count):
            password = self.generate_password(**kwargs)
            passwords.append(password)
        return passwords
    
    def check_password_strength(self, password):
        """检查密码强度"""
        score = 0
        feedback = []
        
        # 长度检查
        if len(password) >= 12:
            score += 2
        elif len(password) >= 8:
            score += 1
        else:
            feedback.append("密码长度至少应为8位")
        
        # 字符类型检查
        has_lower = any(c in self.lowercase for c in password)
        has_upper = any(c in self.uppercase for c in password)
        has_digit = any(c in self.digits for c in password)
        has_special = any(c in self.special_chars for c in password)
        
        char_types = sum([has_lower, has_upper, has_digit, has_special])
        score += char_types
        
        if not has_lower:
            feedback.append("建议包含小写字母")
        if not has_upper:
            feedback.append("建议包含大写字母")
        if not has_digit:
            feedback.append("建议包含数字")
        if not has_special:
            feedback.append("建议包含特殊字符")
        
        # 重复字符检查
        repeated_chars = len(password) - len(set(password))
        if repeated_chars > len(password) * 0.3:
            feedback.append("重复字符过多")
            score -= 1
        
        # 连续字符检查
        consecutive_count = 0
        for i in range(len(password) - 1):
            if ord(password[i+1]) - ord(password[i]) == 1:
                consecutive_count += 1
        
        if consecutive_count > 2:
            feedback.append("避免使用连续字符")
            score -= 1
        
        # 常见模式检查
        common_patterns = ['123', 'abc', 'qwe', 'password', '000', '111']
        for pattern in common_patterns:
            if pattern.lower() in password.lower():
                feedback.append(f"避免使用常见模式: {pattern}")
                score -= 1
                break
        
        # 确定强度等级
        if score >= 7:
            strength = "很强"
        elif score >= 5:
            strength = "强"
        elif score >= 3:
            strength = "中等"
        elif score >= 1:
            strength = "弱"
        else:
            strength = "很弱"
        
        return {
            'strength': strength,
            'score': max(0, score),
            'max_score': 8,
            'feedback': feedback,
            'details': {
                'length': len(password),
                'has_lowercase': has_lower,
                'has_uppercase': has_upper,
                'has_digits': has_digit,
                'has_special': has_special,
                'unique_chars': len(set(password)),
                'repeated_chars': repeated_chars
            }
        }
    
    def generate_memorable_password(self, word_count=3, separator='-', add_numbers=True):
        """生成易记忆的密码"""
        # 简单的单词列表（实际应用中可以使用更大的词典）
        words = [
            'apple', 'brave', 'cloud', 'dance', 'eagle', 'flame', 'grace', 'happy',
            'island', 'jungle', 'knight', 'light', 'magic', 'noble', 'ocean', 'peace',
            'quiet', 'river', 'storm', 'tiger', 'unity', 'voice', 'water', 'youth',
            'zebra', 'bright', 'strong', 'swift', 'gentle', 'golden'
        ]
        
        selected_words = random.sample(words, word_count)
        
        # 随机大写某些单词的首字母
        for i in range(len(selected_words)):
            if random.choice([True, False]):
                selected_words[i] = selected_words[i].capitalize()
        
        password = separator.join(selected_words)
        
        if add_numbers:
            # 添加随机数字
            numbers = str(random.randint(10, 999))
            password += numbers
        
        # 可选择添加特殊字符
        if random.choice([True, False]):
            password += random.choice('!@#$%')
        
        return password
    
    def save_passwords(self, passwords, filename='passwords.txt'):
        """保存密码到文件"""
        try:
            with open(filename, 'w', encoding='utf-8') as f:
                f.write(f"生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
                f.write("=" * 50 + "\n")
                for i, password in enumerate(passwords, 1):
                    strength_info = self.check_password_strength(password)
                    f.write(f"{i}. {password} (强度: {strength_info['strength']})\n")
            
            print(f"密码已保存到: {filename}")
            return True
        except Exception as e:
            print(f"保存失败: {e}")
            return False

# 演示密码生成器
print("密码生成器演示:")

# 创建密码生成器
pg = PasswordGenerator()

# 1. 生成基本密码
print("\n1. 基本密码生成:")
basic_password = pg.generate_password(length=12)
print(f"基本密码: {basic_password}")

# 2. 生成多个密码
print("\n2. 生成多个密码:")
multiple_passwords = pg.generate_multiple_passwords(
    count=3, 
    length=16, 
    exclude_ambiguous=True
)
for i, pwd in enumerate(multiple_passwords, 1):
    print(f"密码{i}: {pwd}")

# 3. 不同配置的密码
print("\n3. 不同配置的密码:")
configs = [
    {'length': 8, 'use_special': False, 'name': '简单密码'},
    {'length': 16, 'exclude_ambiguous': True, 'name': '无歧义密码'},
    {'length': 20, 'use_special': True, 'name': '复杂密码'}
]

for config in configs:
    name = config.pop('name')
    password = pg.generate_password(**config)
    print(f"{name}: {password}")

# 4. 易记忆密码
print("\n4. 易记忆密码:")
for i in range(3):
    memorable = pg.generate_memorable_password()
    print(f"易记密码{i+1}: {memorable}")

# 5. 密码强度检查
print("\n5. 密码强度检查:")
test_passwords = [
    "123456",
    "Password123",
    "MyStr0ng!P@ssw0rd",
    basic_password
]

for pwd in test_passwords:
    strength_info = pg.check_password_strength(pwd)
    print(f"\n密码: {pwd}")
    print(f"强度: {strength_info['strength']} ({strength_info['score']}/{strength_info['max_score']})")
    if strength_info['feedback']:
        print("建议:")
        for feedback in strength_info['feedback']:
            print(f"  - {feedback}")

# 6. 保存密码
print("\n6. 保存密码:")
all_passwords = [basic_password] + multiple_passwords
pg.save_passwords(all_passwords, 'generated_passwords.txt')

输出示例:

密码生成器演示:

1. 基本密码生成:
基本密码: K9#mP2$vX8qL

2. 生成多个密码:
密码1: R7@nF4&yU2sE9mK3
密码2: B5#wG8*pT6xN4hJ2
密码3: M9$dL3&vC7qR5kP8

3. 不同配置的密码:
简单密码: Kp9mX2vL
无歧义密码: R7nF4yU2sE9mK3pB
复杂密码: M9$dL3&vC7qR5kP8@nF4

4. 易记忆密码:
易记密码1: Apple-Brave-Cloud247!
易记密码2: dance-Eagle-flame89
易记密码3: Grace-happy-Island456@

5. 密码强度检查:

密码: 123456
强度: 很弱 (0/8)
建议:
  - 密码长度至少应为8位
  - 建议包含小写字母
  - 建议包含大写字母
  - 建议包含特殊字符
  - 避免使用常见模式: 123

密码: Password123
强度: 中等 (3/8)
建议:
  - 建议包含特殊字符
  - 避免使用常见模式: password

密码: MyStr0ng!P@ssw0rd
强度: 很强 (7/8)

密码: K9#mP2$vX8qL
强度: 很强 (8/8)

6. 保存密码:
密码已保存到: generated_passwords.txt

知识点: 随机数生成、字符串处理、密码安全、文件操作

第94题：文本分析器

题目: 数据分析 - 创建文本分析和统计工具

答案:

class TextAnalyzer:
    def __init__(self):
        self.text = ""
        self.analysis_results = {}
    
    def load_text(self, text):
        """加载文本"""
        self.text = text
        self.analysis_results = {}
        print(f"已加载文本，长度: {len(text)} 字符")
    
    def load_from_file(self, filename):
        """从文件加载文本"""
        try:
            with open(filename, 'r', encoding='utf-8') as f:
                self.text = f.read()
            self.analysis_results = {}
            print(f"已从文件加载文本: {filename}")
            print(f"文本长度: {len(self.text)} 字符")
            return True
        except Exception as e:
            print(f"文件加载失败: {e}")
            return False
    
    def basic_statistics(self):
        """基本统计信息"""
        if not self.text:
            return {}
        
        # 字符统计
        char_count = len(self.text)
        char_count_no_spaces = len(self.text.replace(' ', ''))
        
        # 单词统计
        words = self.text.split()
        word_count = len(words)
        
        # 行数统计
        lines = self.text.split('\n')
        line_count = len(lines)
        non_empty_lines = len([line for line in lines if line.strip()])
        
        # 段落统计（以空行分隔）
        paragraphs = [p.strip() for p in self.text.split('\n\n') if p.strip()]
        paragraph_count = len(paragraphs)
        
        # 句子统计（简单实现）
        import re
        sentences = re.split(r'[.!?]+', self.text)
        sentence_count = len([s for s in sentences if s.strip()])
        
        stats = {
            'characters': char_count,
            'characters_no_spaces': char_count_no_spaces,
            'words': word_count,
            'lines': line_count,
            'non_empty_lines': non_empty_lines,
            'paragraphs': paragraph_count,
            'sentences': sentence_count,
            'average_words_per_sentence': word_count / sentence_count if sentence_count > 0 else 0,
            'average_chars_per_word': char_count_no_spaces / word_count if word_count > 0 else 0
        }
        
        self.analysis_results['basic_stats'] = stats
        return stats
    
    def word_frequency(self, top_n=10, min_length=1):
        """词频统计"""
        if not self.text:
            return {}
        
        import re
        from collections import Counter
        
        # 提取单词（移除标点符号）
        words = re.findall(r'\b\w+\b', self.text.lower())
        
        # 过滤长度
        words = [word for word in words if len(word) >= min_length]
        
        # 统计频率
        word_freq = Counter(words)
        
        # 获取前N个最常见的单词
        top_words = word_freq.most_common(top_n)
        
        result = {
            'total_unique_words': len(word_freq),
            'top_words': top_words,
            'word_frequency_dict': dict(word_freq)
        }
        
        self.analysis_results['word_frequency'] = result
        return result
    
    def character_frequency(self):
        """字符频率统计"""
        if not self.text:
            return {}
        
        from collections import Counter
        
        # 所有字符频率
        char_freq = Counter(self.text.lower())
        
        # 字母频率
        letter_freq = Counter(c for c in self.text.lower() if c.isalpha())
        
        # 数字频率
        digit_freq = Counter(c for c in self.text if c.isdigit())
        
        # 标点符号频率
        punct_freq = Counter(c for c in self.text if not c.isalnum() and not c.isspace())
        
        result = {
            'all_characters': dict(char_freq.most_common()),
            'letters': dict(letter_freq.most_common()),
            'digits': dict(digit_freq.most_common()),
            'punctuation': dict(punct_freq.most_common())
        }
        
        self.analysis_results['char_frequency'] = result
        return result
    
    def readability_analysis(self):
        """可读性分析"""
        if not self.text:
            return {}
        
        import re
        
        # 基本统计
        words = self.text.split()
        sentences = re.split(r'[.!?]+', self.text)
        sentences = [s.strip() for s in sentences if s.strip()]
        
        if not words or not sentences:
            return {}
        
        # 计算平均值
        avg_words_per_sentence = len(words) / len(sentences)
        
        # 计算音节数（简化版本）
        def count_syllables(word):
            word = word.lower()
            vowels = 'aeiouy'
            syllable_count = 0
            prev_was_vowel = False
            
            for char in word:
                if char in vowels:
                    if not prev_was_vowel:
                        syllable_count += 1
                    prev_was_vowel = True
                else:
                    prev_was_vowel = False
            
            # 至少有一个音节
            return max(1, syllable_count)
        
        total_syllables = sum(count_syllables(word) for word in words)
        avg_syllables_per_word = total_syllables / len(words)
        
        # Flesch Reading Ease Score (简化版本)
        flesch_score = 206.835 - (1.015 * avg_words_per_sentence) - (84.6 * avg_syllables_per_word)
        
        # 可读性等级
        if flesch_score >= 90:
            reading_level = "非常容易"
        elif flesch_score >= 80:
            reading_level = "容易"
        elif flesch_score >= 70:
            reading_level = "较容易"
        elif flesch_score >= 60:
            reading_level = "标准"
        elif flesch_score >= 50:
            reading_level = "较难"
        elif flesch_score >= 30:
            reading_level = "难"
        else:
            reading_level = "非常难"
        
        result = {
            'flesch_score': round(flesch_score, 2),
            'reading_level': reading_level,
            'avg_words_per_sentence': round(avg_words_per_sentence, 2),
            'avg_syllables_per_word': round(avg_syllables_per_word, 2),
            'total_syllables': total_syllables
        }
        
        self.analysis_results['readability'] = result
        return result
    
    def sentiment_analysis(self):
        """情感分析（简化版本）"""
        if not self.text:
            return {}
        
        # 简单的情感词典
        positive_words = {
            'good', 'great', 'excellent', 'amazing', 'wonderful', 'fantastic', 
            'love', 'like', 'happy', 'joy', 'beautiful', 'perfect', 'best',
            'awesome', 'brilliant', 'outstanding', 'superb', 'marvelous'
        }
        
        negative_words = {
            'bad', 'terrible', 'awful', 'horrible', 'hate', 'dislike', 'sad',
            'angry', 'ugly', 'worst', 'disgusting', 'pathetic', 'useless',
            'disappointing', 'frustrating', 'annoying', 'boring', 'stupid'
        }
        
        import re
        words = re.findall(r'\b\w+\b', self.text.lower())
        
        positive_count = sum(1 for word in words if word in positive_words)
        negative_count = sum(1 for word in words if word in negative_words)
        neutral_count = len(words) - positive_count - negative_count
        
        # 计算情感分数
        if len(words) > 0:
            positive_ratio = positive_count / len(words)
            negative_ratio = negative_count / len(words)
            sentiment_score = positive_ratio - negative_ratio
        else:
            positive_ratio = negative_ratio = sentiment_score = 0
        
        # 确定整体情感
        if sentiment_score > 0.1:
            overall_sentiment = "积极"
        elif sentiment_score < -0.1:
            overall_sentiment = "消极"
        else:
            overall_sentiment = "中性"
        
        result = {
            'positive_words': positive_count,
            'negative_words': negative_count,
            'neutral_words': neutral_count,
            'positive_ratio': round(positive_ratio, 3),
            'negative_ratio': round(negative_ratio, 3),
            'sentiment_score': round(sentiment_score, 3),
            'overall_sentiment': overall_sentiment
        }
        
        self.analysis_results['sentiment'] = result
        return result
    
    def generate_report(self):
        """生成完整分析报告"""
        if not self.text:
            return "没有加载文本"
        
        # 执行所有分析
        basic_stats = self.basic_statistics()
        word_freq = self.word_frequency()
        char_freq = self.character_frequency()
        readability = self.readability_analysis()
        sentiment = self.sentiment_analysis()
        
        # 生成报告
        report = []
        report.append("=" * 60)
        report.append("文本分析报告")
        report.append("=" * 60)
        report.append(f"生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        report.append("")
        
        # 基本统计
        report.append("1. 基本统计信息")
        report.append("-" * 30)
        report.append(f"字符数: {basic_stats['characters']:,}")
        report.append(f"字符数(不含空格): {basic_stats['characters_no_spaces']:,}")
        report.append(f"单词数: {basic_stats['words']:,}")
        report.append(f"行数: {basic_stats['lines']:,}")
        report.append(f"非空行数: {basic_stats['non_empty_lines']:,}")
        report.append(f"段落数: {basic_stats['paragraphs']:,}")
        report.append(f"句子数: {basic_stats['sentences']:,}")
        report.append(f"平均每句单词数: {basic_stats['average_words_per_sentence']:.1f}")
        report.append(f"平均每词字符数: {basic_stats['average_chars_per_word']:.1f}")
        report.append("")
        
        # 词频统计
        report.append("2. 词频统计 (前10个)")
        report.append("-" * 30)
        report.append(f"独特单词数: {word_freq['total_unique_words']:,}")
        for word, count in word_freq['top_words']:
            report.append(f"{word}: {count}")
        report.append("")
        
        # 可读性分析
        report.append("3. 可读性分析")
        report.append("-" * 30)
        report.append(f"Flesch阅读难度分数: {readability['flesch_score']}")
        report.append(f"阅读难度等级: {readability['reading_level']}")
        report.append(f"平均每句单词数: {readability['avg_words_per_sentence']}")
        report.append(f"平均每词音节数: {readability['avg_syllables_per_word']}")
        report.append("")
        
        # 情感分析
        report.append("4. 情感分析")
        report.append("-" * 30)
        report.append(f"整体情感: {sentiment['overall_sentiment']}")
        report.append(f"情感分数: {sentiment['sentiment_score']}")
        report.append(f"积极词汇: {sentiment['positive_words']} ({sentiment['positive_ratio']:.1%})")
        report.append(f"消极词汇: {sentiment['negative_words']} ({sentiment['negative_ratio']:.1%})")
        report.append(f"中性词汇: {sentiment['neutral_words']}")
        report.append("")
        
        # 字符频率（前10个字母）
        report.append("5. 字符频率 (前10个字母)")
        report.append("-" * 30)
        letter_items = list(char_freq['letters'].items())[:10]
        for char, count in letter_items:
            report.append(f"{char}: {count}")
        
        return "\n".join(report)
    
    def save_report(self, filename='text_analysis_report.txt'):
        """保存分析报告到文件"""
        try:
            report = self.generate_report()
            with open(filename, 'w', encoding='utf-8') as f:
                f.write(report)
            print(f"分析报告已保存到: {filename}")
            return True
        except Exception as e:
            print(f"保存报告失败: {e}")
            return False

# 演示文本分析器
print("文本分析器演示:")

# 创建分析器实例
analyzer = TextAnalyzer()

# 示例文本
sample_text = """
Python is an amazing programming language that is widely used in various fields.
It has a simple and readable syntax, making it perfect for beginners.
Python is also powerful enough for advanced applications like machine learning,
web development, and data analysis. The language emphasizes code readability
and allows programmers to express concepts in fewer lines of code.

Many companies use Python for their projects because it's efficient and versatile.
The Python community is very supportive and provides excellent documentation.
Overall, Python is a fantastic choice for both new and experienced programmers.
"""

# 加载文本
print("\n1. 加载文本:")
analyzer.load_text(sample_text)

# 基本统计
print("\n2. 基本统计:")
basic_stats = analyzer.basic_statistics()
for key, value in basic_stats.items():
    print(f"{key}: {value}")

# 词频统计
print("\n3. 词频统计 (前5个):")
word_freq = analyzer.word_frequency(top_n=5)
print(f"独特单词数: {word_freq['total_unique_words']}")
for word, count in word_freq['top_words']:
    print(f"{word}: {count}")

# 可读性分析
print("\n4. 可读性分析:")
readability = analyzer.readability_analysis()
for key, value in readability.items():
    print(f"{key}: {value}")

# 情感分析
print("\n5. 情感分析:")
sentiment = analyzer.sentiment_analysis()
for key, value in sentiment.items():
    print(f"{key}: {value}")

# 字符频率（前5个字母）
print("\n6. 字符频率 (前5个字母):")
char_freq = analyzer.character_frequency()
letter_items = list(char_freq['letters'].items())[:5]
for char, count in letter_items:
    print(f"{char}: {count}")

# 生成完整报告
print("\n7. 完整分析报告:")
report = analyzer.generate_report()
print(report[:500] + "..." if len(report) > 500 else report)

# 保存报告
print("\n8. 保存报告:")
analyzer.save_report('sample_text_analysis.txt')