python_

1.type函数动态创建类

# 定义两个基类
class MyBaseClass1:
    def base_method1(self):
        print("This is base method 1.")

class MyBaseClass2:
    def base_method2(self):
        print("This is base method 2.")

# 使用 type() 动态创建一个类，并指定两个基类
MyDynamicClass = type('MyClass', (MyBaseClass1, MyBaseClass2), {'x': 5, 'double_x': lambda self: self.x * 2})

# 创建类的实例
obj = MyDynamicClass()

# 访问类的属性、方法以及继承的基类方法
print(obj.x)            # 输出: 5
print(obj.double_x())   # 输出: 10
obj.base_method1()      # 输出: This is base method 1.
obj.base_method2()      # 输出: This is base method 2.

在这个例子中，我们定义了两个基类 MyBaseClass1 和 MyBaseClass2，然后使用 type() 创建了一个名为 MyClass 的类，它同时继承了这两个基类。这个类有一个属性 x 和一个方法 double_x，同时也继承了两个基类的方法 base_method1 和 base_method2。创建实例后，我们可以通过实例访问类的属性、方法以及继承的基类方法。

需要注意的是，虽然可以通过多继承来实现这种功能，但在实际使用中，多继承可能会引起一些复杂性和歧义性，所以需要谨慎使用。

2.  __slots__函数

__slots__ 是一个特殊的类属性，用于在Python中限制类实例可以拥有的属性。通过使用 __slots__，你可以明确地定义一个类可以拥有的属性名称，从而限制实例在运行时无法动态地添加新的属性。

使用 __slots__ 有以下几个优点：

1. 节省内存： 在Python中，每个对象的属性都是存储在一个字典中。当你创建许多实例时，这个字典会占用很大的内存。使用 __slots__ 可以避免这种情况，因为每个实例只需分配固定的空间来存储定义在 __slots__ 中的属性。

2. 提升访问速度： 由于实例的属性是存储在一个字典中的，属性的访问速度相对较慢。使用 __slots__ 可以在一定程度上提高属性的访问速度，因为属性的名称是固定的，不需要进行字典查找。

3. 限制属性名称： __slots__ 可以限制类实例可以拥有的属性名称，防止不经意间添加新的属性，从而帮助你在代码中更准确地控制属性的使用。

以下是一个使用 __slots__ 的示例：

class Person:
    __slots__ = ('name', 'age')

    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person('Alice', 30)
print(person.name)  # 输出: Alice
print(person.age)   # 输出: 30

# 尝试添加新属性，会引发 AttributeError
# person.address = '123 Main St.'

在这个示例中，Person 类使用了 __slots__ 属性，限制了实例只能拥有 name 和 age 两个属性。如果你尝试为实例添加新的属性（比如 address），会引发 AttributeError，因为这些属性没有被定义在 __slots__ 中。

需要注意的是，__slots__ 并不适合所有情况，它通常用于需要高性能和内存优化的场景，以及对类实例的属性进行严格控制的情况。

3. @typechecked注解

`@typechecked` 不是Python标准库中的内置注解，而是来自第三方库 `typeguard` 的注解。`typeguard` 是一个用于类型检查的工具，它可以在运行时检查函数的参数和返回值的类型是否符合预期。它基于类型提示来执行类型检查，帮助在开发过程中捕获潜在的类型错误。

使用 `@typechecked` 注解需要安装 `typeguard` 库。你可以使用以下命令来安装：

pip install typeguard

然后，你可以在代码中使用 `@typechecked` 注解来进行类型检查。下面是一个示例：

from typeguard import typechecked

@typechecked
def add_numbers(a: int, b: int) -> int:
return a + b

result = add_numbers(3, 4) # 正常运行，结果为 7
result = add_numbers(3.5, 4) # 类型错误，会引发 TypeCheckError

 

在这个示例中，`@typechecked` 注解应用在 `add_numbers` 函数上。这意味着函数的参数和返回值将会在运行时进行类型检查。当传入的参数类型不符合类型提示时，会引发 `TypeCheckError` 错误。

需要注意的是，`typeguard` 的类型检查是在运行时进行的，与静态类型检查器（例如 `mypy`）不同。它可以帮助在开发过程中捕获类型错误，但由于是在运行时进行检查，可能会稍微降低程序的性能。如果你希望在开发过程中增加类型安全性，可以考虑使用类似 `typeguard` 的工具。

4. @property注解

@property 是一个装饰器（注解），用于将类方法转换为属性，使得你可以像访问属性一样访问这个方法，而不需要使用函数调用的形式。这在面向对象编程中非常有用，可以提供更加直观的访问方式，并允许你在访问属性时添加一些逻辑。

下面是一个示例，演示如何使用 @property 装饰器：

class Circle:
    def __init__(self, radius):
        self._radius = radius  # 使用下划线前缀来表示这是一个受保护的属性

    @property
    def radius(self):
        print("Getting radius")
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("Radius cannot be negative")
        print("Setting radius")
        self._radius = value

    @property
    def area(self):
        return 3.14 * self._radius ** 2

circle = Circle(5)
print(circle.radius)  # 输出: Getting radius  5
print(circle.area)    # 输出: 78.5

circle.radius = 7     # 输出: Setting radius
print(circle.radius)  # 输出: Getting radius  7

在这个示例中，Circle 类有一个名为 radius 的属性，使用 @property 装饰器将 radius() 方法转化为属性。同时，使用 @radius.setter 装饰器定义了一个用于设置 radius 的方法。还有一个名为 area 的只读属性，可以直接计算圆的面积。

通过使用 @property 和相应的装饰器，我们可以在类中创建伪属性，这些伪属性的访问和设置方式更像是在访问和设置属性，而实际上是在调用方法。这使得代码更加直观和易于理解。

5.setattr方法

在Python中，setattr() 是一个内置函数，用于设置对象的属性值。它接受三个参数：对象、属性名和属性值。这个函数可以在运行时动态地设置对象的属性，无论是已经存在的属性还是新创建的属性。

setattr() 函数的语法如下：

setattr(object, attribute_name, value)

• object：要设置属性的对象。
• attribute_name：要设置的属性名。
• value：要设置的属性值。

以下是一个示例，演示如何使用 setattr() 设置对象的属性：

class Person:
    pass

person = Person()

# 使用 setattr() 设置对象的属性
setattr(person, 'name', 'Alice')
setattr(person, 'age', 30)

print(person.name)  # 输出: Alice
print(person.age)   # 输出: 30

在这个示例中，我们创建了一个名为 Person 的类，然后使用 setattr() 设置了一个名为 name 和一个名为 age 的属性。

需要注意的是，setattr() 可以用来设置对象的任何属性，但在使用它时要小心，确保属性名和属性值的类型正确，并且不会覆盖原有的属性或方法。

6. getattr

def not_implemented(callback_name):
    def _callback(*args, **kwargs):
        print('none')
        return None

    # logger.debug(f'callback for {callback_name} is not implemented, will do nothing')
    return _callback

这段代码定义了一个函数 `not_implemented(callback_name)`，该函数返回一个占位的回调函数。当某个回调函数未实现时，可以使用这个占位函数来避免错误。让我解释一下这段代码的作用：

- `not_implemented(callback_name)`：这是一个外层函数，接受一个参数 `callback_name`，该参数是未实现的回调函数的名称。

- `_callback(*args, **kwargs)`：内层函数 `_callback` 是一个占位的回调函数，它不执行任何操作，只是返回 `None`。这个函数可以接受任意数量的位置参数 `args` 和关键字参数 `kwargs`。

- `return _callback`：外层函数返回内层的占位回调函数 `_callback`。

这段代码的目的是，当某个回调函数未实现时，你可以使用 `not_implemented` 函数来获得一个占位的回调函数。例如，假设你有一个字典 `strategy_callbacks` 存储了各种策略的回调函数。如果某个策略的某个回调函数未实现，你可以使用这个占位函数来填充相应位置，避免调用未定义的函数。

 binding[name] = getattr(self.strategy_class, name, not_implemented(name))

这段代码的作用是将特定属性绑定到策略类的对应属性，如果属性在策略类中不存在，则绑定一个占位的回调函数。让我逐步解释这段代码：

- `binding[name]`：这是一个字典的键，用于存储属性名 `name` 对应的值。

- `getattr(self.strategy_class, name, not_implemented(name))`：这是一个函数调用，用于获取对象的属性。具体地，它尝试从 `self.strategy_class` 中获取属性 `name`。如果 `name` 存在于 `self.strategy_class` 中，则获取该属性的值；如果不存在，则返回一个占位的回调函数，该回调函数是通过 `not_implemented(name)` 调用得到的。

- `not_implemented(name)`：这是一个函数调用，返回一个占位的回调函数，当属性未实现时可以用作默认值。

综合起来，这段代码的目的是将策略类中的特定属性与一个占位回调函数进行绑定，以便在属性未实现时使用默认值。这在动态地处理策略类的属性时可以确保代码不会出现错误，而是使用占位的回调函数来占据位置。

# -*- coding: utf-8 -*-
class MyStrategy:
    def my_callback(self):
        print("This is my_callback.")


def not_implemented(callback_name):
    def _callback(*args, **kwargs):
        print('none')
        return None

    # logger.debug(f'callback for {callback_name} is not implemented, will do nothing')
    return _callback


strategy_instance = MyStrategy()

binding = {}

# 假设属性 my_callback 在 strategy_instance 中未定义
name = "my_callback"
binding[name] = getattr(strategy_instance, name, not_implemented(name))

# 调用绑定的属性，如果不存在则使用占位回调函数
binding[name]()  # 输出：This is my_callback.
# 假设属性 my_callback 在 strategy_instance 中未定义
name2 = "my_callback2"
binding[name2] = getattr(strategy_instance, name2, not_implemented(name))

# 调用绑定的属性，如果不存在则使用占位回调函数
binding[name2]()  # 输出：none

 或者不传递对象实例，直接传递类

# strategy_instance = MyStrategy()

binding = {}

# 假设属性 my_callback 在 strategy_instance 中未定义
name = "my_callback"
binding[name] = getattr(MyStrategy, name, not_implemented(name))

# 调用绑定的属性，如果不存在则使用占位回调函数
binding[name](MyStrategy, 'zz')  # 输出：This is my_callback.