with语句和上下文管理器详解、最佳实践、示例

合集 - python高级(31)

1.创建进程2023-07-232.Process类语法详解2023-07-233.进程间通信2023-07-234.进程池2023-07-235.进程间的锁和信号量2023-07-236.根据进程编号杀死指定进程os.kill2023-07-237.守护进程2023-07-238.线程2023-07-289.实现多线程多任务的步骤2023-07-2810.threading.Thread类详解2023-07-2811.守护线程&&threading.enumerate()2023-07-2812.python线程并行执行与java的线程并行执行的对比2023-07-2913.IO密集型任务与CPU密集型任务2023-07-2914.多线程共享全局变量的问题2023-07-2915.多线程共享资源之竞态条件2023-07-2916.互斥锁2023-07-2917.死锁2023-07-2918.线程池2023-07-2919.进程与线程的对比2023-07-2920.闭包2023-08-2621.闭包之nonlocal关键字的作用2023-08-2622.闭包之作用2023-08-2623.闭包之可能引起的问题2023-08-2624.弱引用2023-08-2625.装饰器2023-08-2726.装饰器示例2023-08-2727.property 属性2023-08-27

28.with语句和上下文管理器详解、最佳实践、示例2023-08-29

29.生成器2023-08-2930.深浅拷贝2023-08-3031.正则表达式2023-08-30

收起

说明

with语句是Python中一种用于管理资源的机制，它与上下文管理器紧密相关。

上下文管理器是一个对象（因此自定义时需要创建一个类），它定义了在进入和退出特定代码块（称为上下文）时要执行的操作。

使用with语句和上下文管理器可以确保资源的正确分配和释放，以及在使用完资源后进行清理工作，从而提高代码的可读性和可维护性。

 

 

with语句

作用:  简化try...except...finlally的处理流程，让读写文件变得更加简洁安全。

语法：

?

1 2	with expression [as target]: 　　with_body

　　

with语句是一种优雅的资源管理机制，它在特定代码块的进入和退出时自动调用上下文管理器的相关方法，以确保资源的正确分配和释放。以下是一些with语句的最佳实践、典型用例和详细解释：

最佳实践：

1. 自动资源管理： 使用with语句可以确保资源（如文件、网络连接、数据库连接等）在使用后被正确关闭、释放或清理，从而避免资源泄露和错误。

2. 代码清晰简洁： with语句可以显著提高代码的可读性和可维护性，因为它将资源的分配和释放操作封装在一个代码块中，减少了代码中的重复性。

3. 异常处理： 上下文管理器的__exit__方法可以用于处理异常情况，确保资源在代码块内部发生异常时也能得到正确释放。

 

典型用例：

1. 文件操作： 使用with语句来自动管理文件的打开和关闭操作。

   with open("1.txt", "r") as file:  # 使用with语句，不用手动执行f.close()方法，会自动执行
       file_data = file.read()
       print(file_data)

    

2. 数据库连接： 使用with语句来管理数据库连接的打开和关闭。   

            

import sqlite3

with sqlite3.connect("mydb.db") as db:  # 自动创建mydb.db文件
    cursor = db.cursor()
    cursor.execute("SELECT * FROM user")
    result = cursor.fetchall()
    print(result)
# 数据库连接会在上下文退出时自动关闭

 

?

1 2 3 4 5 6

CREATE TABLE "user" (   "id" INTEGER NOT NULL,   "username" TEXT,   "password" TEXT,   PRIMARY KEY ("id") );

INSERT INTO "main"."user"("id", "username", "password") VALUES (1, 'Allen', '123456');

　　

            

        

3. 网络连接： 使用with语句来管理网络连接的打开和关闭。

   import socket
   
   with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
       sock.connect(("127.0.0.1", 80))
       sock.sendall(b"Hello, server!")
   # 网络连接会在上下文退出时自动关闭

解释说明：

   with语句通过调用上下文管理器对象的__enter__和__exit__方法来实现资源的自动管理。在进入with代码块时，__enter__方法被调用，它可以进行资源的分配、初始化或其他必要的操作，并返回一个在上下文中使用的对象（可选）。

在退出with代码块时，无论代码块是正常退出还是由于异常退出，__exit__方法都会被调用。__exit__方法可以执行资源的释放、清理或其他必要的操作。如果代码块正常退出，exc_type、exc_value和traceback参数都为None，表示没有发生异常。如果代码块由于异常退出，这些参数提供了关于引发的异常的信息，可以在__exit__方法中进行相应处理。

class MyContext:  # 定义上下文管理器类
    def __enter__(self):
        print("Entering the context")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting the context")
        if exc_type:
            print(f"An exception of type {exc_type} occurred: {exc_value}")
        # 返回False将异常继续传播，返回True将异常屏蔽
        return False


with MyContext() as context:  # with 关键字 + 上下文管理器对象
    print("Inside the context")
    # 通过抛出异常来模拟异常情况
    # raise ValueError("Something went wrong")
print("Outside the context")

输出：

?

1 2 3 4

Entering the context Inside the context Exiting the context Outside the context

　

总之，with语句是一种优雅的资源管理工具，它有助于确保资源的正确使用和释放，提高代码的可读性和可维护性。在文件操作、数据库连接、网络连接等场景下，使用with语句可以大大简化代码，同时减少错误和异常情况的发生。　

上下文管理器

 

上下文管理器的构建：

上下文管理器需要定义两个特殊方法：__enter__和__exit__。

• __enter__(self)：在进入代码块时执行，通常用于资源的分配和初始化操作。它可以返回一个与上下文相关的对象，如果不需要返回值，也可以省略返回语句。

• __exit__(self, exc_type, exc_value, traceback)：在退出代码块时执行，无论代码块是正常退出还是由于异常退出。通常用于资源的释放和清理操作。它的参数提供了关于引发的异常的信息，如果代码块正常退出，这些参数都为None。

with语句的使用：

使用with语句可以自动调用上下文管理器的__enter__和__exit__方法，确保资源的适当分配和释放。

class FileManager:  # 1. 自定义上下文管理器类
    def __init__(self, filename, mode):  # 1.1 通过__init__初始化上下文管理器对象
        self.filename = filename
        self.mode = mode
        self.file = None

    def __enter__(self):  # 1.2 执行with 语句之前自动执行
        print("__enter__")
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_value, traceback): # 1.3 执行with 语句之后自动执行
        print("__exit__")
        if self.file:
            self.file.close()


# 2. 使用上下文管理器打开文件，不用手动关闭
with FileManager("1.txt", "r") as file:  # with  上下文管理器对象 as 别名
    content = file.read()
    print(content)

# 文件已在上下文退出时自动关闭

输出结果：

?

1 2 3

__enter__ Allen __exit__

　　

初始化方法__init__，用于给上下文管理器对象初始化，__enter__方法做资源相关操作，__exit__方法做收尾、资源清理的工作。

另外常见的with 语句已隐含了__init__、__enter__、__exit__方法的操作。也可以自定义上下文管理器类与with关键字一起使用。

最佳实践和示例：

• 文件操作： 上下文管理器常用于处理文件操作，确保文件在使用后被正确关闭。

  with open("example.txt", "r") as file:
      content = file.read()
      print(content)
  # 文件已在上下文退出时自动关闭

• 数据库连接： 使用上下文管理器可以确保数据库连接在使用后被关闭。

  import sqlite3
  
  class DatabaseManager:
      def __init__(self, db_name):
          self.db_name = db_name
          self.conn = None
      
      def __enter__(self):
          self.conn = sqlite3.connect(self.db_name)
          return self.conn
      
      def __exit__(self, exc_type, exc_value, traceback):
          if self.conn:
              self.conn.close()
  
  # 使用上下文管理器操作数据库
  with DatabaseManager("mydb.db") as db:
      cursor = db.cursor()
      cursor.execute("SELECT * FROM users")
      result = cursor.fetchall()
      print(result)
  # 数据库连接已在上下文退出时自动关闭

• 临时修改环境： 使用上下文管理器可以在代码块中临时修改环境变量或配置，并在退出时恢复原始状态。

  import os
  
  class TempEnvironment:
      def __init__(self, variable, value):
          self.variable = variable
          self.value = value
          self.old_value = None
      
      def __enter__(self):
          self.old_value = os.environ.get(self.variable)
          os.environ[self.variable] = self.value
      
      def __exit__(self, exc_type, exc_value, traceback):
          if self.old_value is None:
              del os.environ[self.variable]
          else:
              os.environ[self.variable] = self.old_value
  
  # 使用上下文管理器临时修改环境变量
  with TempEnvironment("DEBUG_MODE", "1"):
      # 执行需要调试模式的操作
      pass
  # 离开上下文时，环境变量恢复原始状态

   

通过 @contextmanager 的装饰器实现上下文管理器

通过@contextmanager装饰器，可以更轻松地创建自定义的上下文管理器，而不需要显式定义类并实现__enter__和__exit__方法。这种方法基于生成器函数，利用yield语句将资源的分配和释放操作隔离开来。

@contextmanager装饰器详解：  应用于生成器函数上

@contextmanager装饰器来自于Python标准库中的contextlib模块。它用于将一个生成器函数转换为上下文管理器，其中生成器的yield语句之前的代码负责资源的分配，yield语句之后的代码负责资源的释放。

from contextlib import contextmanager


@contextmanager
def my_context():
    # 进入上下文前的操作，相当于__enter__方法
    print("Entering the context")
    resource = "resource"
    try:
        yield resource  # 将资源返回给with语句的as变量
    finally:
        # 退出上下文后的操作，相当于__exit__方法
        print("Exiting the context")


# 使用@contextmanager装饰的生成器函数作为上下文管理器
with my_context() as res:
    print(f"Inside the context: {res}")
# 离开上下文时，自动执行资源释放操作

输出结果：

?

1 2 3

Entering the context Inside the context: resource Exiting the context

　　

示例1：简单文件读写操作

from contextlib import contextmanager


@contextmanager
def open_file(filename, mode):
    file = open(filename, mode)
    try:
        yield file
    finally:
        file.close()


# 使用自定义上下文管理器读写文件
with open_file("1.txt", "r") as file:
    content = file.read()
    print(content)
# 文件会在上下文退出时自动关闭

输出：Allen

示例2：数据库连接

import sqlite3
from contextlib import contextmanager


@contextmanager
def database_connection(db_name):
    conn = sqlite3.connect(db_name)
    try:
        yield conn
    finally:
        conn.close()


# 使用自定义上下文管理器操作数据库
with database_connection("mydb.db") as db:
    cursor = db.cursor()
    cursor.execute("SELECT * FROM user")
    result = cursor.fetchall()
    print(result)
# 数据库连接会在上下文退出时自动关闭

输出：[(1, 'Allen', '123456')]

最佳实践：

1. 使用@contextmanager装饰器可以简化上下文管理器的定义，尤其适用于简单的资源管理场景。

2. 在生成器函数中，通过yield语句将资源暴露给代码块，这样在进入和退出上下文时都能使用这个资源。

3. 在try块中进行资源的分配，将资源返回给代码块后，finally块用于资源的释放和清理。

4. 使用@contextmanager装饰器的上下文管理器没有__exit__方法，所以无法屏蔽异常，如果需要特定的异常处理，可以在生成器函数中进行处理。

总之，@contextmanager装饰器提供了一种简单且优雅的方法来定义上下文管理器，适用于许多资源管理场景。然而，对于更复杂的上下文管理器，仍然可能需要使用传统的类方式来实现。

'''
使用@contextmanager装饰器创建上下文管理器时，确实无法直接在生成器函数中实现完整的异常屏蔽和处理，
因为没有__exit__方法来捕获异常。
然而，你可以在生成器函数中使用try和except语句来捕获并处理特定的异常，从而实现类似的异常处理逻辑。
'''

from contextlib import contextmanager


@contextmanager
def safe_division(divisor):
    try:
        yield 1 / divisor
    except ZeroDivisionError:
        print("Division by zero occurred!")
    

# 使用自定义上下文管理器处理异常
with safe_division(0) as result:
    if result is None:
        print("Result is not available due to exception.")
    else:
        print("Result:", result)

 

 输出：

?

1 2 3 4 5 6 7

Traceback (most recent call last):   File "D:\allen_class\python\base\base\042with语句和上下文管理器\06装饰器实现上下文管理器04-处理异常.py", line 19, in <module>     with safe_division(0) as result:   File "D:\Install_soft\python\Lib\contextlib.py", line 139, in __enter__     raise RuntimeError("generator didn't yield") from None RuntimeError: generator didn't yield Division by zero occurred!

　　

在上面的示例中，safe_division生成器函数允许你尝试执行除法操作，并在发生ZeroDivisionError异常时捕获并打印错误消息。尽管不能实现完全的异常屏蔽，但通过在生成器函数中进行异常处理，你可以为特定的异常情况提供处理逻辑，以便代码块内部仍能继续执行。

这种方法的限制在于，你只能为特定的异常提供处理逻辑，而不能实现完全的上下文管理器异常屏蔽和处理。如果需要更复杂的异常处理，可能需要使用传统的类方式来定义上下文管理器，以便完全控制异常处理逻辑。

总结：@contextmanager装饰器提供了一种轻量级的创建上下文管理器的方法，但在处理异常方面存在一些限制。如果需要更灵活的异常处理，可以考虑使用传统的上下文管理器类，以实现更复杂的异常屏蔽和处理逻辑。