上一篇:Python基础篇_修饰符(Decorators)【中】@property、@<attribute_name>.setter、@<attribute_name>.deleter、@functools.lru_cache(maxsize=None)
Python基础篇_修饰符(Decorators)【下】
- Python基础篇_修饰符(Decorators)【下】
-
- 一、修饰符一般特点
- 二、常用的修饰符以及用法举例
-
- 7) @abc.abstractmethod,抽象方法 @abc.abstractmethod,抽象方法)
- 8) @functools.singledispatch,函数重载 @functools.singledispatch,函数重载)
- 9) @contextlib.contextmanager,上下文管理 @contextlib.contextmanager,上下文管理)
Python基础篇_修饰符(Decorators)【下】
Python中有多种修饰符,这些修饰符用于指定方法的特殊行为或属性,也是用于修改函数行为的特殊参数。
一、修饰符一般特点
- 修饰符只能用于类定义中,不能用于普通函数中
- 属性修饰符是可叠加的,也就是说,一个方法可以同时被多个属性修饰符修饰
二、常用的修饰符以及用法举例
7) @abc.abstractmethod,抽象方法
@abc.abstractmethod
用于指示一个方法是抽象的,这意味着这个方法必须在任何非抽象的子类中被重写。它属于abc
模块,即抽象基类模块。
当你定义一个抽象基类并使用@abc.abstractmethod
装饰器标记一个方法时,任何子类都必须实现这个方法,否则它将引发TypeError
。
示例1: AbstractClassExample
类的抽象方法my_abstract_method
python
import abc
class AbstractClassExample(metaclass=abc.ABCMeta):
@abc.abstractmethod
def my_abstract_method(self):
pass
class ConcreteClass(AbstractClassExample):
def my_abstract_method(self):
print("This is the implementation of the abstract method.")
# 下面的代码将引发TypeError,因为my_abstract_method在BrokenClass中未被实现。
# class BrokenClass(AbstractClassExample):
# pass
在这个例子中,AbstractClassExample是一个抽象基类,它有一个抽象方法my_abstract_method
任何继承自AbstractClassExample的子类都必须实现my_abstract_method方法
ConcreteClass是一个实现了该方法的子类
尝试创建一个没有实现该方法的子类(如被注释掉的BrokenClass)将引发TypeError
示例2:Vehicle
类的抽象方法start
、stop
python
import abc
class Vehicle(metaclass=abc.ABCMeta):
@abc.abstractmethod
def start(self):
pass
@abc.abstractmethod
def stop(self):
pass
class Car(Vehicle):
def start(self):
print("Car started!")
def stop(self):
print("Car stopped!")
class Bike(Vehicle):
def start(self):
print("Bike started!")
def stop(self):
print("Bike stopped!")
# 下面的代码将引发TypeError,因为Vehicle是一个抽象基类,要求子类必须实现start和stop方法。
# class Train(Vehicle):
# pass
在这个例子中,AbstractClassExample是一个抽象基类,它有一个抽象方法my_abstract_method
任何继承自AbstractClassExample的子类都必须实现my_abstract_method方法
ConcreteClass是一个实现了该方法的子类
尝试创建一个没有实现该方法的子类(如被注释掉的BrokenClass)将引发TypeError
示例3:Shape
类的抽象方法area
python
import abc
class Shape(metaclass=abc.ABCMeta):
@abc.abstractmethod
def area(self):
pass
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14 * self.radius ** 2
class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
# 下面的代码将引发TypeError,因为Shape是一个抽象基类,要求子类必须实现area方法。
# class Triangle(Shape):
# pass
在这个例子中,Shape是一个抽象基类,有一个抽象方法area。任何子类必须实现这个方法。
Circle和`Rectangle`都是Shape的子类,并实现了area方法。
尝试创建一个没有实现该方法的子类(如被注释掉的Triangle)将引发TypeError
8) @functools.singledispatch,函数重载
@functools.singledispatch
是functools
模块提供的一个装饰器,用于实现多分派。具体来说,它可以将函数重定向到其他函数,基于第一个参数的类型。
示例1:foo
方法重载
python
from functools import singledispatch
# 定义一个使用 @singledispatch 的函数
@singledispatch
def foo(arg):
raise NotImplementedError("Unsupported type for foo")
# 定义一个具体的实现,用于处理字符串类型的参数
@foo.register(str)
def _(arg):
return f"You provided a string: {arg}"
# 定义一个具体的实现,用于处理整数类型的参数
@foo.register(int)
def _(arg):
return f"You provided an integer: {arg}"
# 使用函数
print(foo("Hello"))
print(foo(42))
print(foo(0.5))
python
# 执行结果
You provided a string: Hello
You provided an integer: 42
NotImplementedError: Unsupported type for foo
示例2:bar
方法重载
python
from functools import singledispatch
# 定义一个使用 @singledispatch 的函数
@singledispatch
def bar(arg):
raise NotImplementedError("Unsupported type for bar")
# 定义一个具体的实现,用于处理字符串类型的参数
@bar.register(str)
def _(arg):
return f"You provided a string: {arg}"
# 定义一个具体的实现,用于处理整数类型的参数
@bar.register(int)
def _(arg):
return f"You provided an integer: {arg}"
# 定义一个具体的实现,用于处理列表类型的参数
@bar.register(list)
def _(arg):
return f"You provided a list: {arg}"
# 使用函数
print(bar("Hello"))
print(bar(42))
print(bar([1, 2, 3]))
print(bar(0.5))
python
# 执行结果
You provided a string: Hello
You provided an integer: 42
You provided a list: [1, 2, 3]
NotImplementedError: Unsupported type for bar
示例3:baz
方法重载
python
from functools import singledispatch
# 定义一个使用 @singledispatch 的函数
@singledispatch
def baz(arg):
raise NotImplementedError("Unsupported type for baz")
# 定义一个具体的实现,用于处理字符串类型的参数
@baz.register(str)
def _(arg):
return f"You provided a string: {arg}"
# 定义一个具体的实现,用于处理整数类型的参数
@baz.register(int)
def _(arg):
return f"You provided an integer: {arg}"
# 定义一个具体的实现,用于处理列表类型的参数
@baz.register(list)
def _(arg):
return f"You provided a list: {arg}"
# 定义一个更通用的实现,用于处理其他类型
@baz.register
def _(arg):
return f"You provided an unknown type: {type(arg)}"
# 使用函数
print(baz("Hello"))
print(baz(42))
print(baz([1, 2, 3]))
print(baz(0.5))
python
# 执行结果
You provided a string: Hello
You provided an integer: 42
You provided a list: [1, 2, 3]
You provided an unknown type: <class 'float'>
9) @contextlib.contextmanager,上下文管理
@contextlib.contextmanager
用于简化上下文管理器的创建。上下文管理器允许你在代码的某个特定部分设置一个上下文,该上下文在其他部分可能无法访问或可能更改。常见的使用场景包括文件操作、线程锁等。
使用 @contextlib.contextmanager
装饰器可以使您以声明式方式编写上下文管理器,而无需实现 __enter__
和 __exit__
方法。这对于简化某些上下文管理任务非常有用。
示例1:名为 timer
的上下文管理器
接受一个名称参数并打印出开始和结束时间
python
import contextlib
import time
@contextlib.contextmanager
def timer(name):
print(f"Starting {name}")
start_time = time.time()
try:
yield
finally:
end_time = time.time()
print(f"{name} took {end_time - start_time} seconds")
with timer("my_operation"):
# 在这里执行需要计时的操作
time.sleep(2)
# 执行结果
Starting my_operation
my_operation took 2.00 seconds
示例2:名为 redirect_stdout
的上下文管理器
将标准输出(通常显示在控制台)重定向到一个指定的文件
python
import contextlib
import os
@contextlib.contextmanager
def redirect_stdout(file_path):
"""将标准输出重定向到指定的文件"""
original_stdout = sys.stdout
try:
with open(file_path, 'w') as f:
sys.stdout = f
yield
finally:
sys.stdout = original_stdout
# 使用重定向输出的上下文管理器
with redirect_stdout('output.txt'):
print("This message will be written to the file.")
示例3:名为 thread_lock
的上下文管理器
接受一个 threading.Lock
对象作为参数。这个上下文管理器确保在 with
语句块中的代码在执行时被线程锁定
python
import contextlib
import threading
@contextlib.contextmanager
def thread_lock(lock):
"""
使用线程锁的上下文管理器
:param lock: threading.Lock 对象
"""
lock.acquire()
try:
yield
finally:
lock.release()
# 创建一个线程锁对象
lock = threading.Lock()
# 使用线程锁的上下文管理器
with thread_lock(lock):
# 在此块中的代码将被线程锁定,确保同一时间只有一个线程可以执行这段代码
print("Doing critical section of code...")
may the odds be ever in your favor ~