1. __new__ 方法#

• 作用：负责创建对象，是类实例化过程的第一步。它会分配内存并返回新创建的对象实例。

• 执行时机：在对象创建时，优先于 __init__ 执行。

• 定义：

  1
  def __new__(cls, *args, **kwargs):
  2
      # cls 是当前准备实例化的类
  3
      # 必须返回一个类的实例（通常使用 super().__new__(cls)）
  

• 特点：

  • __new__ 是一个类方法，由类调用。
  • 常用于实现单例模式或自定义对象的创建过程。

• 示例：

  1
  class MyClass:
  2
      def __new__(cls, *args, **kwargs):
  3
          print("Executing __new__")
  4
          instance = super().__new__(cls)
  5
          return instance
  6
  
  7
      def __init__(self, value):
  8
          print("Executing __init__")
  9
          self.value = value
  10
  
  11
  obj = MyClass(42)
  12
  # 输出：
  13
  # Executing __new__
  14
  # Executing __init__
  

2. __init__ 方法#

• 作用：负责初始化对象，即为新创建的对象设置属性或执行其他初始化操作。

• 执行时机：在对象创建后立即执行。

• 定义：

  1
  def __init__(self, *args, **kwargs):
  2
      # self 是新创建的实例对象
  

• 特点：

  • __init__ 是一个实例方法，由实例调用。
  • 用于设置对象的初始状态。

• 示例：

  1
  class MyClass:
  2
      def __init__(self, value):
  3
          print("Initializing object")
  4
          self.value = value
  5
  
  6
  obj = MyClass(42)
  7
  # 输出：
  8
  # Initializing object
  

对比总结#

当需要定制对象的创建逻辑时，可以重写 __new__ 方法，并结合 __init__ 方法完成对象的完整初始化。

1. 元类的作用#

元类控制类的创建过程。

通过元类，你可以在类被创建时定制类的行为、属性和方法。例如，你可以在类定义时自动添加方法、修改类的属性，或者动态地改变类的行为。

2. 如何定义元类#

元类通常是继承自 type 类的。Python 中的所有类本质上都是 type 的实例。因此，type 本身就是一个元类，控制着类的创建。

• type 是 Python 内置的元类，它定义了类的创建规则。

元类的基本使用步骤：

1. 定义一个元类，继承自 type。
2. 在元类中重写 __new__ 或 __init__ 方法，用来定制类的创建过程。
3. 在定义类时，指定使用这个元类。

3. 元类的工作原理#

在类被定义时，元类会对类进行“修改”。元类主要通过两个方法来定制类的行为：

• __new__(cls, name, bases, dct) -> cls：在类被创建时调用，用来创建类对象。
• __init__(cls, name, bases, dct)：在类对象创建后调用，可以用来对类进行初始化和修改。

4. 示例：使用元类#

下面是一个使用元类的示例：

1
# 定义一个元类
2
class MyMeta(type):
3
    def __new__(cls, name, bases, dct):
4
        # 自动添加一个类属性
5
        dct['class_name'] = name
6
        # 通过 super 调用 type 的 __new__ 方法，返回创建的类
7
        return super().__new__(cls, name, bases, dct)
8

9
# 使用 MyMeta 元类定义一个类
10
class MyClass(metaclass=MyMeta):
11
    pass
12

13
# 实例化 MyClass
14
obj = MyClass()
15

16
# 打印类属性 class_name
17
print(obj.class_name)  # 输出 'MyClass'

在上面的例子中，MyMeta 是一个元类，它在创建 MyClass 类时，自动添加了一个 class_name 属性。

5. 元类的应用场景#

• 类的自动创建：元类可以在类创建时，自动生成或修改类的属性和方法。例如，自动添加一些通用的工具方法。
• 验证类定义：元类可以检查类的定义是否符合特定要求，例如，确保类具有某些方法或属性。
• 类的继承控制：元类可以控制类的继承关系，修改继承自父类的行为。
• Singleton 模式：通过元类，可以实现单例模式，确保一个类只有一个实例。

6. 更复杂的元类示例#

1
# 定义一个元类
2
class SingletonMeta(type):
3
    _instances = {}
4

5
    def __call__(cls, *args, **kwargs):
6
        # 检查是否已经创建实例
7
        if cls not in cls._instances:
8
            cls._instances[cls] = super().__call__(*args, **kwargs)
9
        return cls._instances[cls]
10

11
# 使用 SingletonMeta 元类实现单例模式
12
class SingletonClass(metaclass=SingletonMeta):
13
    pass
14

15
# 创建两个实例
16
a = SingletonClass()
17
b = SingletonClass()
18

19
print(a is b)  # 输出 True，说明 a 和 b 是同一个实例

在这个例子中，SingletonMeta 是一个元类，它确保 SingletonClass 只有一个实例。

7. 总结#

• 元类是用来创建类的类，它可以定制类的行为、属性等。
• 元类本质上是 Python 中的一个强大工具，能够在类的创建过程中动态修改类。
• 元类通常继承自 type，并通过重写 __new__ 和 __init__ 来修改类的创建和初始化行为。
• 元类在一些高级应用中非常有用，比如实现单例模式、自动生成代码、验证类结构等。

举个例子：#

1
def outer_function(x):
2
    def inner_function(y):
3
        return x + y  # 这里的 x 是 outer_function 的局部变量
4
    return inner_function  # 返回 inner_function 函数对象
5

6
closure = outer_function(10)  # 调用外部函数，传入 10
7
print(closure(5))  # 调用返回的函数，并传入 5，结果是 15

解释：#

4. outer_function 定义了一个局部变量 x，并返回了 inner_function。
5. inner_function 使用了外部函数 outer_function 的局部变量 x。
6. 当我们调用 outer_function(10) 时，返回了 inner_function 函数对象，并且这个函数“记住了” x=10。
7. 即使 outer_function 已经执行完毕，inner_function 依然能够访问到 x 的值。

这就是闭包的基本特性：即使外部函数的作用域已经结束，内部函数仍然可以访问外部函数的变量。

闭包常用于延迟计算、封装函数、装饰器等场景中。

装饰器的基本语法#

1
def decorator(func):
2
    def wrapper():
3
        print("Before function call")
4
        func()
5
        print("After function call")
6
    return wrapper
7

8
@decorator
9
def say_hello():
10
    print("Hello, World!")
11

12
say_hello()

输出：

1
Before function call
2
Hello, World!
3
After function call

解释： 8. decorator是装饰器函数，它接受一个函数func作为参数。 9. wrapper是一个封装了func的函数，在它内部你可以添加额外的逻辑。 10. @decorator语法相当于func = decorator(func)，即在不修改func的情况下增强其功能。 11. 当你调用say_hello()时，实际调用的是wrapper()，它会先执行一些自定义逻辑，然后再执行原始的func()。

带参数的装饰器#

1
import time
2
import functools
3

4
def cost(cost=True):
5
    def decorator(func):
6
        @functools.wraps(func)
7
        def wrapper(*args, **kwargs):
8
            print('calling decorated function')
9
            t1 = time.time()
10
            result = func(*args, **kwargs)
11
            t2 = time.time()
12
            if cost:
13
                print('%s function cost: %s ms' % (func.__name__, (t2 - t1) * 1000))
14
            return result
15
        return wrapper
16
    return decorator
17

18

19
@cost()
20
def add(x, y):
21
    print('calling add function')
22
    return x + y
23

24
# add(1, 2) 相当于执行 cost(cost=True)(add)(1, 2)

装饰器的多个嵌套使用#

你可以同时使用多个装饰器来装饰同一个函数。

[!NOTE] > 靠近原函数的先进行装饰后执行，离原函数远的后装饰先执行

1
def decorator1(func):
2
    print('Decorator 1')
3
    def wrapper1(*args, **kwargs):
4
        print("这是第一个装饰器")
5
        return func(*args, **kwargs)
6
    return wrapper1
7

8

9
def decorator2(func):
10
    print('Decorator 2')
11
    def wrapper2(*args, **kwargs):
12
        print("这是第二个装饰器")
13
        return func(*args, **kwargs)
14
    return wrapper2
15

16

17
@decorator1  # 此处即 test = decorator1(decorator2(test))
18
@decorator2  # 此处即 test = decorator2(test)
19
def test():
20
    print("这是原函数")
21

22

23
test()

输出：

1
Decorator 2
2
Decorator 1
3
这是第一个装饰器
4
这是第二个装饰器
5
这是原函数

使用functools.wraps保留原函数的信息#

当使用装饰器时，原函数的元数据（如函数名、文档字符串等）会丢失。为了保留这些信息，可以使用functools.wraps。

1
from functools import wraps
2

3
def decorator(func):
4
    @wraps(func)
5
    def wrapper(*args, **kwargs):
6
        print("Before function call")
7
        return func(*args, **kwargs)
8
    return wrapper
9

10
@decorator
11
def say_hello():
12
    """This is a greeting function."""
13
    print("Hello, World!")
14

15
print(say_hello.__name__)  # 输出: say_hello
16
print(say_hello.__doc__)   # 输出: This is a greeting function.

总结#

• 装饰器是一个函数，它用于修改或增强其他函数的功能。
• 使用@decorator语法来应用装饰器。
• 装饰器可以自定义传入参数。
• 通过functools.wraps可以保留原函数的元数据。

1. 使用类的 __new__ 方法#

__new__ 方法用于控制类的实例化过程。通过重写 __new__ 方法，可以确保类只创建一个实例。

1
class Singleton:
2
    _instance = None
3

4
    def __new__(cls):
5
        if cls._instance is None:
6
            cls._instance = super(Singleton, cls).__new__(cls)
7
        return cls._instance
8

9
# 测试
10
a = Singleton()
11
b = Singleton()
12
print(a is b)  # 输出: True，a 和 b 是同一个实例

2. 使用装饰器#

可以使用装饰器来实现单例模式，通过缓存类的实例来确保只创建一个实例。

1
def singleton(cls):
2
    instances = {}
3
    def wrapper(*args, **kwargs):
4
        if cls not in instances:
5
            instances[cls] = cls(*args, **kwargs)
6
        return instances[cls]
7
    return wrapper
8

9
@singleton
10
class Singleton:
11
    pass
12

13
# 测试
14
a = Singleton()
15
b = Singleton()
16
print(a is b)  # 输出: True，a 和 b 是同一个实例

3. 使用元类#

通过定义元类来控制类的创建过程，确保类只有一个实例。

1
class SingletonMeta(type):
2
    _instances = {}
3

4
    def __call__(cls, *args, **kwargs):
5
        if cls not in cls._instances:
6
            cls._instances[cls] = super().__call__(*args, **kwargs)
7
        return cls._instances[cls]
8

9
class Singleton(metaclass=SingletonMeta):
10
    pass
11

12
# 测试
13
a = Singleton()
14
b = Singleton()
15
print(a is b)  # 输出: True，a 和 b 是同一个实例

4. 使用 import#

1
class My_Singleton(object):
2
    pass
3

4

5
my_singleton = My_Singleton()
6

7

8
# use
9
from singleton import my_singleton

总结#

• __new__ 方法：最常用的单例模式实现，确保只有一个实例。
• 装饰器：通过缓存实例并返回同一实例实现单例。
• 元类：通过重写元类的 __call__ 方法，确保类实例唯一。
• 使用 import。

迭代器的基本概念#

• 可迭代对象（Iterable）：是一个可以返回一个迭代器的对象。比如，列表、元组、字典、字符串等都可以作为可迭代对象。可迭代对象需要实现 __iter__() 方法。
• 迭代器对象（Iterator）：是一个实现了 __iter__() 方法并且有 __next__() 方法的对象。通过 __next__() 方法可以获取下一个元素，直到没有元素为止（此时会抛出 StopIteration 异常）。

创建迭代器#

当我们通过 iter() 函数将一个可迭代对象转换为迭代器时，它会返回一个实现了 __iter__() 和 __next__() 方法的对象。

示例：#

1
# 可迭代对象：列表
2
my_list = [1, 2, 3]
3

4
# 将列表转换为迭代器
5
my_iterator = iter(my_list)
6

7
# 使用 next() 获取迭代器的元素
8
print(next(my_iterator))  # 输出: 1
9
print(next(my_iterator))  # 输出: 2
10
print(next(my_iterator))  # 输出: 3
11
# 再调用 next() 会抛出 StopIteration 异常
12
print(next(my_iterator))  # 抛出 StopIteration 异常

在 for 循环中，Python 会自动处理迭代器和 StopIteration 异常：

1
for item in my_list:
2
    print(item)

迭代器的实现#

你可以自定义一个迭代器类，必须实现 __iter__() 和 __next__() 方法。__iter__() 返回迭代器对象本身，__next__() 返回下一个元素，并在遍历完所有元素后抛出 StopIteration 异常。

1
class MyIterator:
2
    def __init__(self, start, end):
3
        self.current = start
4
        self.end = end
5

6
    def __iter__(self):
7
        return self  # 返回迭代器对象本身
8

9
    def __next__(self):
10
        if self.current >= self.end:
11
            raise StopIteration  # 当迭代结束时抛出异常
12
        self.current += 1
13
        return self.current - 1
14

15
# 创建迭代器
16
my_iter = MyIterator(0, 5)
17

18
# 使用迭代器
19
for num in my_iter:
20
    print(num)

输出：

1
0
2
1
3
2
4
3
5
4

总结#

• 迭代器是实现了 __iter__() 和 __next__() 方法的对象。
• __iter__() 方法返回迭代器对象本身，__next__() 方法返回下一个元素，直到遍历完所有元素时抛出 StopIteration 异常。
• 你可以通过 iter() 函数将一个可迭代对象转换为迭代器，并通过 next() 函数或 for 循环逐个访问其元素。

生成器的创建#

生成器有两种常见的创建方式：

12. 生成器函数：使用 yield 关键字。
13. 生成器表达式：类似列表推导式，但使用小括号。

1. 生成器函数#

生成器函数看起来和普通函数一样，不同之处在于它使用了 yield 来返回值，而不是 return。

1
def my_generator():
2
    yield 1
3
    yield 2
4
    yield 3
5

6
gen = my_generator()
7

8
# 使用 next() 函数获取生成器的下一个值
9
print(next(gen))  # 输出: 1
10
print(next(gen))  # 输出: 2
11
print(next(gen))  # 输出: 3
12

13
# 再调用 next() 会抛出 StopIteration 异常
14
print(next(gen))  # 抛出 StopIteration 异常

2. 生成器表达式#

生成器表达式的语法类似于列表推导式，但是它使用圆括号 () 来创建生成器，而不是方括号 []。

1
gen = (x * x for x in range(5))
2

3
# 使用 next() 获取生成器的值
4
print(next(gen))  # 输出: 0
5
print(next(gen))  # 输出: 1
6
print(next(gen))  # 输出: 4
7
print(next(gen))  # 输出: 9
8
print(next(gen))  # 输出: 16
9

10
# 再调用 next() 会抛出 StopIteration 异常
11
print(next(gen))  # 抛出 StopIteration 异常

生成器的优势#

14. 内存节省：生成器一次生成一个值，不会将所有数据保存在内存中，因此特别适合处理大数据集或流数据。
15. 惰性求值：生成器只有在需要时才会计算下一个值，因此对于某些操作来说，性能更高。
16. 简洁易懂：生成器函数和生成器表达式比传统的迭代器更简洁，减少了额外的代码。

总结#

• 生成器 是一种特殊的迭代器，使用 yield 来生成一个值，直到生成器没有更多值时抛出 StopIteration 异常。
• 生成器节省内存并支持惰性求值，特别适合处理大规模数据或流数据。
• 可以通过生成器函数或生成器表达式来创建生成器。
• 生成器的优点包括内存高效、性能优越和代码简洁。

GIL 的核心作用#

1. 线程安全：

   • CPython 使用引用计数来管理内存，而 GIL 的存在避免了多线程同时修改对象引用计数导致的竞争条件（Race Condition），从而简化了内存管理和内置数据结构的线程安全实现。
   • 无需为每个对象单独加锁，降低了代码复杂性。

2. 单线程执行：

   • 无论有多少个线程或 CPU 核心，GIL 强制同一时间只有一个线程能执行 Python 字节码，其他线程需等待锁的释放。

GIL 的影响#

1. 多线程性能瓶颈：

   • CPU 密集型任务：多线程无法利用多核 CPU 并行计算（例如数值计算），性能可能不如单线程甚至多进程。
   • I/O 密集型任务：影响较小，因为线程在等待 I/O（如文件读写、网络请求）时会主动释放 GIL，允许其他线程运行。

2. 替代方案：

   • 多进程（multiprocessing模块）：每个进程有独立的 GIL，可绕过限制，充分利用多核。
   • 异步编程（asyncio等）：单线程内通过协程处理高并发 I/O 任务，避免线程切换开销。
   • C 扩展：在 C 语言层释放 GIL（如 NumPy、Cython 中的with nogil块），实现并行计算。
   • 其他解释器：Jython（基于 JVM）或 IronPython（基于.NET）没有 GIL，但生态支持较弱。

GIL 存在的原因#

• 历史与兼容性：CPython 早期依赖 GIL 简化设计，后续移除会导致破坏性变更，影响大量 C 扩展和单线程性能。
• 实现复杂性：无 GIL 的线程安全需对内存管理和核心对象进行细粒度加锁，可能增加复杂性和性能开销。

争议与未来#

• 社区讨论：Python 社区多次尝试移除 GIL（如 Python 3.2 的gilectomy项目），但常因性能损失或兼容性问题未成功。
• 潜在改进：Python 3.12 引入的“无 GIL 构建选项”（PEP 703）是实验性尝试，允许在编译时禁用 GIL，但尚未成为默认行为。

总结#

• 适用场景：
  • 多线程适合 I/O 密集型任务（如网络请求、文件处理）。
  • 多进程或混合编程（C 扩展）适合 CPU 密集型任务。
• 设计权衡：GIL 以多核并行性为代价，换取了 CPython 实现的简洁与线程安全。

通过理解 GIL 的机制及其影响，开发者可以合理选择并发模型，优化 Python 程序性能。

1. 浅拷贝（Shallow Copy）#

• 定义：浅拷贝会创建一个新的对象，但新的对象中包含的元素是对原对象中元素的引用（即指向相同的内存地址）。

• 实现方式：可以使用以下方法实现浅拷贝：

  • copy.copy() 方法（需要导入 copy 模块）
  • [:] 切片操作（适用于列表等序列类型）
  • list()、dict() 构造函数（对于列表和字典）

• 特点：

  • 对于不可变对象（如数字、字符串、元组），浅拷贝和原对象共享相同的值。
  • 对于可变对象（如列表、字典），浅拷贝和原对象的嵌套对象共享引用，修改嵌套对象会影响到原对象。

• 示例：

1
import copy
2

3
original = [1, 2, [3, 4]]
4
shallow_copy = copy.copy(original)
5

6
# 修改嵌套对象
7
shallow_copy[2][0] = 99
8
print(original)       # 输出：[1, 2, [99, 4]]，原对象受到影响
9
print(shallow_copy)   # 输出：[1, 2, [99, 4]]

2. 深拷贝（Deep Copy）#

• 定义：深拷贝会递归地复制原对象及其所有嵌套对象，创建一个完全独立的新对象。
• 实现方式：使用 copy.deepcopy() 方法（需要导入 copy 模块）。
• 特点：
  • 深拷贝的对象与原对象完全独立。
  • 修改深拷贝对象的任何部分（包括嵌套对象）都不会影响原对象。
• 示例：

1
import copy
2

3
original = [1, 2, [3, 4]]
4
deep_copy = copy.deepcopy(original)
5

6
# 修改嵌套对象
7
deep_copy[2][0] = 99
8
print(original)       # 输出：[1, 2, [3, 4]]，原对象未受影响
9
print(deep_copy)      # 输出：[1, 2, [99, 4]]

对比总结#

如果处理的数据结构中包含嵌套的可变对象，并且需要确保独立性，应优先选择深拷贝。

1. 什么是协程？#

协程（Coroutine） 是一种用户态的轻量级线程，可以在单线程中实现并发。它由程序显式控制任务的切换，不依赖于操作系统的调度。

• 特点：

  1. 协作式调度：协程主动让出控制权（通过 await 或 yield），任务间的切换是手动调度的。
  2. 单线程运行：多个协程共享一个线程，不能并行。
  3. 高效：由于没有线程上下文切换和锁机制，开销比线程小。
  4. 非阻塞：适合 I/O 密集型任务，如网络请求、文件操作。

• 协程示例（Python）：

  1
  import asyncio
  2
  
  3
  async def task1():
  4
      print("Task 1: Start")
  5
      await asyncio.sleep(1)  # 模拟异步 I/O
  6
      print("Task 1: End")
  7
  
  8
  async def task2():
  9
      print("Task 2: Start")
  10
      await asyncio.sleep(2)
  11
      print("Task 2: End")
  12
  
  13
  asyncio.run(asyncio.gather(task1(), task2()))
  14
  # 输出：
  15
  # Task 1: Start
  16
  # Task 2: Start
  17
  # Task 1: End
  18
  # Task 2: End
  

2. 什么是线程？#

线程（Thread） 是操作系统调度的基本单位，一个进程可以包含多个线程。线程共享进程的内存空间和资源。

• 特点：

  1. 内存共享：线程间可以共享数据，但需要加锁来防止竞争条件（如 threading.Lock）。
  2. 并发：在 Python 中受限于 GIL（全局解释器锁），多个线程在同一时刻只能有一个线程执行 Python 字节码。
  3. 适用场景：I/O 密集型任务。

• 线程示例（Python）：

  1
  import threading
  2
  import time
  3
  
  4
  def task(name):
  5
      print(f"{name}: Start")
  6
      time.sleep(1)
  7
      print(f"{name}: End")
  8
  
  9
  t1 = threading.Thread(target=task, args=("Thread 1",))
  10
  t2 = threading.Thread(target=task, args=("Thread 2",))
  11
  t1.start()
  12
  t2.start()
  13
  t1.join()
  14
  t2.join()
  

3. 什么是进程？#

进程（Process） 是操作系统资源分配的基本单位，每个进程有独立的内存空间。进程之间通过 IPC（进程间通信）进行数据传递。

• 特点：

  1. 独立性：进程之间彼此隔离，互不影响。
  2. 并行：多个进程可以在多核 CPU 上真正实现并行。
  3. 适用场景：CPU 密集型任务。

• 进程示例（Python）：

  1
  from multiprocessing import Process
  2
  import time
  3
  
  4
  def task(name):
  5
      print(f"{name}: Start")
  6
      time.sleep(1)
  7
      print(f"{name}: End")
  8
  
  9
  p1 = Process(target=task, args=("Process 1",))
  10
  p2 = Process(target=task, args=("Process 2",))
  11
  p1.start()
  12
  p2.start()
  13
  p1.join()
  14
  p2.join()
  

4. 协程、线程和进程的对比#

5. 总结#

• 协程：在单线程内实现高效并发，适用于 I/O 密集型任务，轻量但不能并行。
• 线程：操作系统管理的并发单元，适合 I/O 密集型任务，但在 Python 中受 GIL 限制，无法利用多核。
• 进程：独立的并行执行单元，适用于 CPU 密集型任务，开销大但性能强。