Python 课程3-進階主題

前言

        在编程的高级阶段，掌握文件处理、异常处理、面向对象编程（OOP）、迭代器、生成器以及装饰器等概念将大大增强你对 Python 的理解和应用能力。这些主题不仅是编写高效、健壮程序的关键，也是现代编程技术的核心要素。

        通过文件处理，你将学习如何高效地读写数据文件，尤其是在处理 CSV 文件时的便捷方法；通过异常处理，你将能够编写容错性强的代码，避免程序因意外错误而崩溃；通过面向对象编程，你将理解如何设计灵活、模块化的代码，并通过继承与多态性实现更好的代码复用。迭代器与生成器将帮助你优化程序性能，尤其是在处理大规模数据时；而装饰器则是一种强大的工具，能让你轻松地为函数或类增加功能。

---

目录

1. 文件处理

   • 文件打开与关闭（open()、close()）
   • 文件读写（read()、write()、with 语句）
   • 读写 CSV 文件

2. 错误与异常处理

   • 常见异常类型
   • 使用 try-except 语句处理异常
   • 自定义异常

3. 面向对象编程（OOP）

   • 类与对象
   • 定义类与方法
   • 继承与多态
   • 封装与继承

4. 迭代器与生成器

   • 迭代器（iter()、next()）
   • 使用生成器（yield）

5. 装饰器（Decorator）

   • 函数装饰器
   • 常见的 Python 装饰器应用

---

1. 文件处理

文件打开与关闭（open()、close()）

在 Python 中，文件处理通常需要通过 open() 函数来打开文件，进行读写操作后，需要使用 close() 函数来关闭文件，释放资源。

# 打开文件并写入内容
file = open('example.txt', 'w')
file.write('Hello, Python!')
file.close()

 

文件读写（read()、write()、with 语句）

Python 提供了 read() 和 write() 函数来进行文件读写操作。此外，with 语句可以自动管理文件的打开和关闭，避免忘记关闭文件。

# 使用 with 语句读写文件
with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

 

读写 CSV 文件

CSV 文件是最常见的数据存储格式之一。Python 提供了 csv 模块来轻松处理 CSV 文件的读写。

import csv

# 写入 CSV 文件
with open('data.csv', 'w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(['Name', 'Age', 'Gender'])
    writer.writerow(['Alice', 30, 'Female'])

# 读取 CSV 文件
with open('data.csv', 'r') as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

---

2. 错误与异常处理

常见异常类型

Python 中有多种常见的异常类型，例如：

• ValueError: 当传入无效参数时发生。
• TypeError: 当数据类型不符合预期时发生。
• IndexError: 当尝试访问列表中不存在的索引时发生。

使用 try-except 语句处理异常

使用 try-except 语句可以捕获异常，防止程序崩溃，并提供自定义的错误处理逻辑。

try:
    num = int(input("请输入一个数字: "))
except ValueError:
    print("输入的不是有效数字")

自定义异常

可以定义自己的异常类，通过继承 Exception 类来实现自定义异常。

class CustomError(Exception):
    pass

def check_value(value):
    if value < 0:
        raise CustomError("值不能为负数")

try:
    check_value(-1)
except CustomError as e:
    print(e)

 

---

3. 面向对象编程（OOP）

类与对象

类是对象的蓝图。通过定义类和创建对象，可以将现实世界中的实体和行为映射到代码中。

class Dog:
    def __init__(self, name):
        self.name = name

    def bark(self):
        print(f"{self.name} 正在叫！")

dog1 = Dog("小黑")
dog1.bark()  # 输出：小黑 正在叫！

定义类与方法

类可以包含属性（变量）和方法（函数）。方法可以通过 self 访问类的属性。

继承与多态

继承允许一个类继承另一个类的属性和方法，多态允许子类重写父类的方法，实现不同的行为。

class Animal:
    def speak(self):
        print("动物在发声")

class Cat(Animal):
    def speak(self):
        print("猫在喵喵叫")

cat1 = Cat()
cat1.speak()  # 输出：猫在喵喵叫

封装与继承

封装是面向对象编程的核心原则之一。可以通过定义私有属性和方法，将类的内部实现隐藏起来。

class Person:
    def __init__(self, name, age):
        self._name = name  # 受保护的属性
        self.__age = age   # 私有属性

    def get_age(self):
        return self.__age

p = Person("Alice", 30)
print(p.get_age())  # 输出：30

 

---

4. 迭代器与生成器

迭代器（iter()、next()）

迭代器是支持迭代协议的对象。可以使用 iter() 创建迭代器，使用 next() 获取下一个元素。

my_list = [1, 2, 3]
iterator = iter(my_list)
print(next(iterator))  # 输出：1
print(next(iterator))  # 输出：2

使用生成器（yield）

生成器是特殊的迭代器，可以通过 yield 关键字逐步返回值，每次调用生成器时，它会暂停并保存当前的状态。

def my_generator():
    yield 1
    yield 2
    yield 3

gen = my_generator()
print(next(gen))  # 输出：1
print(next(gen))  # 输出：2

---

5. 装饰器（Decorator）

函数装饰器

装饰器是 Python 中的一种设计模式，可以在不修改函数本身的情况下，动态地为函数增加功能。

def decorator(func):
    def wrapper():
        print("函数开始执行")
        func()
        print("函数执行结束")
    return wrapper

@decorator
def say_hello():
    print("Hello, World!")

say_hello()

常见的 Python 装饰器应用

装饰器可以用于日志记录、权限验证、性能监控等场景，下面列出几个常见的装饰器应用场景及示例代码。

1. 日志记录装饰器

        当我们希望在函数执行前后自动记录日志信息时，可以使用装饰器。这样可以确保不修改原函数代码的情况下为函数添加日志功能。

import time

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"开始执行函数: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"函数 {func.__name__} 执行结束")
        return result
    return wrapper

@log_decorator
def greet(name):
    print(f"你好, {name}")

greet("小明")

输出：

开始执行函数: greet
你好, 小明
函数 greet 执行结束

2. 计时器装饰器

通过装饰器可以为某个函数添加执行时间统计的功能，这在优化代码性能时特别有用。

import time

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

@timer_decorator
def slow_function():
    time.sleep(2)
    print("函数执行中...")

slow_function()

输出：

函数执行中...
函数 slow_function 执行时间: 2.002 秒

3. 权限验证装饰器

装饰器可以用于权限验证，先检查用户是否有权限执行某个函数，再决定是否执行该函数。

def check_permission(func):
    def wrapper(user):
        if user["is_admin"]:
            return func(user)
        else:
            print("无权限执行此操作")
    return wrapper

@check_permission
def delete_user(user):
    print(f"用户 {user['username']} 已被删除")

user1 = {"username": "小张", "is_admin": False}
user2 = {"username": "管理员", "is_admin": True}

delete_user(user1)  # 输出: 无权限执行此操作
delete_user(user2)  # 输出: 用户 管理员 已被删除

4. 缓存装饰器

在需要频繁调用某个函数并且结果相同的情况下，装饰器可以用来缓存结果，以提高程序的性能。

def cache_decorator(func):
    cache = {}
    
    def wrapper(*args):
        if args in cache:
            print("从缓存中获取结果")
            return cache[args]
        else:
            result = func(*args)
            cache[args] = result
            print("计算并缓存结果")
            return result
    return wrapper

@cache_decorator
def slow_add(a, b):
    time.sleep(2)  # 模拟计算延迟
    return a + b

print(slow_add(3, 4))  # 计算并缓存结果
print(slow_add(3, 4))  # 从缓存中获取结果

输出：

计算并缓存结果
7
从缓存中获取结果
7

5. 输入验证装饰器

可以通过装饰器验证函数的输入是否符合要求，避免错误输入引发的函数错误。

def validate_input(func):
    def wrapper(a, b):
        if not isinstance(a, int) or not isinstance(b, int):
            raise ValueError("参数必须是整数")
        return func(a, b)
    return wrapper

@validate_input
def add(a, b):
    return a + b

print(add(3, 5))  # 输出: 8
# print(add(3, "5"))  # 抛出异常: ValueError: 参数必须是整数

---

结论

        通过本教程的学习，你已经掌握了 Python 高级编程的多个重要概念，包括文件处理、异常处理、面向对象编程、迭代器与生成器，以及装饰器的使用。熟练掌握这些高级技术，将帮助你编写更高效、更健壮的程序，在处理复杂项目时能够游刃有余。这些工具和技术是构建现代应用程序的关键，无论是开发大型项目，还是优化日常编程任务，都是不可或缺的编程技能。