【Python快速入门和实践010】Python进阶与扩展

最新推荐文章于 2024-09-15 22:31:42 发布

Seraphina_Lily

最新推荐文章于 2024-09-15 22:31:42 发布

阅读量634

点赞数 27

分类专栏： Python快速入门和实践文章标签： python 开发语言

本文链接：https://blog.csdn.net/2403_83044722/article/details/141174456

版权

Python快速入门和实践专栏收录该内容

20 篇文章 4 订阅

订阅专栏

10. 进阶与扩展

10.1 设计模式

设计模式是一套被反复使用的、经过分类编目的、共同的知识库，用来描述在软件设计过程中的一些不断重复发生的问题以及该问题的解决方案。下面我们将介绍几种常用的 Python 设计模式，并给出具体的代码示例。

10.1.1 单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点。

示例代码：

class Singleton:
    _instance = None

    @staticmethod
    def get_instance():
        if Singleton._instance is None:
            Singleton._instance = Singleton()
        return Singleton._instance

    def __init__(self):
        if Singleton._instance is not None:
            raise Exception("Singleton instance already exists.")
        else:
            # 初始化逻辑
            pass

# 使用
singleton1 = Singleton.get_instance()  # 创建第一个实例
singleton2 = Singleton.get_instance()  # 创建第二个实例，实际上与第一个相同
# 输出: <__main__.Singleton object at 0x7f5d3c6b0e80>
# 输出: <__main__.Singleton object at 0x7f5d3c6b0e80>
assert singleton1 is singleton2

10.1.2 工厂模式

工厂模式提供了一个创建对象的接口，但允许子类决定实例化哪一个类。工厂方法使得一个类的实例化延迟到其子类。

示例代码：

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

class Cat(Animal):
    def make_sound(self):
        return "Meow!"

class AnimalFactory:
    @staticmethod
    def create_animal(animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            raise ValueError(f"Invalid animal type: {animal_type}")

# 使用
dog = AnimalFactory.create_animal("dog")  # 创建 Dog 实例
# 输出: Woof!
print(dog.make_sound())
cat = AnimalFactory.create_animal("cat")  # 创建 Cat 实例
# 输出: Meow!
print(cat.make_sound())

10.1.3 装饰器模式

装饰器模式允许向对象添加新功能，同时保持良好的封装性。这是通过创建包装对象来实现的，这些包装对象包含被装饰的对象。

示例代码：

def uppercase_decorator(func):
    def wrapper():
        original_result = func()
        modified_result = original_result.upper()
        return modified_result
    return wrapper

@uppercase_decorator
def greet():
    return "hello there"

# 使用
# 输出: HELLO THERE
print(greet())

10.2 性能优化与调优

性能优化涉及提高代码的效率，减少资源消耗，加快执行速度。以下是几种常见的性能优化策略：

10.2.1 利用内置函数和库

Python 的标准库提供了许多高效的功能，利用它们通常比自己编写算法更快。

示例：

import time
import math

start_time = time.time()
result = [math.sqrt(x) for x in range(1000000)]  # 使用内置的 math.sqrt 函数
end_time = time.time()
# 输出: Time taken: 0.001000 seconds (假设值)
print(f"Time taken: {end_time - start_time:.6f} seconds")

10.2.2 使用列表推导式

列表推导式通常比循环构建列表更快。

示例：

numbers = [1, 2, 3, 4, 5]
squares = [num ** 2 for num in numbers]  # 使用列表推导式
# 输出: [1, 4, 9, 16, 25]
print(squares)

10.2.3 避免全局变量

全局变量的访问通常较慢，尽量使用局部变量。

示例：

def use_local_variable():
    local_var = 0
    for i in range(1000000):
        local_var += i
    return local_var

# 使用
result = use_local_variable()  # 使用局部变量
# 输出: 499999500000
print(result)

10.3 常用Python编程实践与技巧

10.3.1 使用上下文管理器

上下文管理器能够自动管理资源的生命周期，比如文件的打开和关闭。

示例：

with open('example.txt', 'w') as file:
    file.write("Hello, world!")  # 文件自动关闭

# 输出: File 'example.txt' created with content: Hello, world!

10.3.2 使用生成器表达式

生成器表达式允许延迟计算，节省内存。

示例：

numbers = (i for i in range(10))  # 使用生成器表达式
for number in numbers:
    print(number)  # 每次迭代时才计算下一个值
# 输出: 0
# 输出: 1
# 输出: 2
# ...
# 输出: 9

10.3.3 使用命名元组

命名元组使数据结构更清晰且易于理解。

示例：

from collections import namedtuple

Person = namedtuple('Person', ['name', 'age'])
bob = Person(name='Bob', age=30)
# 输出: Bob
print(bob.name)

10.3.4 使用类型注解

类型注解是在 Python 3.5 中引入的一个特性，它允许你在代码中指定变量、函数参数和返回值的类型。这有助于提高代码的可读性和可维护性，同时也可以帮助开发者更好地理解和使用代码。虽然 Python 是一种动态类型的语言，类型注解并不会影响代码的实际执行，但它们可以被 IDE 和静态类型检查工具如 mypy 所利用，以提供更好的开发体验。

1. 基础类型注解

首先，我们可以为变量和函数参数添加类型注解。

示例：

def greet(name: str) -> str:
    return f"Hello, {name}!"

# 使用
print(greet("Alice"))  # 输出: Hello, Alice!

在这个例子中，我们声明了 greet 函数接受一个 str 类型的参数 name，并且返回值也是 str 类型。

2. 复合类型和容器类型

对于复合类型（如列表、字典等），我们可以使用来自 typing 模块的类型别名。

示例：

from typing import List, Tuple

def sum_list(numbers: List[int]) -> int:
    return sum(numbers)

# 使用
print(sum_list([1, 2, 3]))  # 输出: 6

这里我们使用 List[int] 表示 numbers 参数应该是一个整数列表。

3. 可选类型

如果某个参数可以为 None，我们可以使用 Optional 类型。

示例：

from typing import Optional

def safe_divide(num1: int, num2: Optional[int] = None) -> Optional[float]:
    if num2 is None or num2 == 0:
        return None
    return num1 / num2

# 使用
print(safe_divide(10, 2))  # 输出: 5.0
print(safe_divide(10, 0))  # 输出: None
print(safe_divide(10))     # 输出: None

在这个例子中，num2 参数可以是 int 或者 None，函数的返回值也可能是 float 或 None。

4. 类型别名

为了简化复杂的类型注解，我们可以定义类型别名。

示例：

from typing import List

Point = List[int]

def calculate_distance(p1: Point, p2: Point) -> float:
    return ((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)**0.5

# 使用
print(calculate_distance([0, 0], [3, 4]))  # 输出: 5.0

这里我们定义了一个 Point 类型别名，它是一个整数列表。

5. 类型检查

你可以使用像 mypy 这样的工具来进行类型检查。下面是一个简单的例子，展示了如何安装和使用 mypy。

示例：

pip install mypy

然后你可以运行 mypy 命令来检查你的脚本文件。

mypy script.py

如果 mypy 发现任何类型错误，它会报告这些错误。

6. 类型注解的高级用法

泛型：使用 typing.Generic 来创建泛型类或函数。
联合类型：使用 typing.Union 来表示多个可能的类型。
协议：使用 typing.Protocol 来定义抽象类型，类似于接口。

示例：

from typing import Generic, TypeVar, Union

T = TypeVar('T')

class Stack(Generic[T]):
    def __init__(self) -> None:
        self.items: List[T] = []

    def push(self, item: T) -> None:
        self.items.append(item)

    def pop(self) -> T:
        return self.items.pop()

def process_data(data: Union[int, str]) -> None:
    print(f"Processing data: {data}")

# 使用
stack = Stack[int]()
stack.push(1)
print(stack.pop())  # 输出: 1
process_data("text")  # 输出: Processing data: text

在这个例子中，我们定义了一个泛型类 Stack 和一个可以接受多种类型的函数 process_data。

类型注解可以帮助开发者更好地理解代码，并且在开发过程中提供额外的类型安全保证。虽然类型注解不会改变代码的行为，但是它们可以极大地提高代码的质量和可维护性。