c

codeye

V1

2022/10/27阅读:19主题:默认主题

在 Python 中,函数是第一类对象

函数在 Python 中是第一类对象,这意味着:

函数是对象--它们可以被引用,传递到一个变量,也可以从其他函数返回。 函数可以被定义在另一个函数中--一个内部函数--也可以作为参数传递给另一个函数。

def say_name():
    print("Guido van Rossum")


def say_nationality():
    print("Netherlands")


def say(func):
    return func


say(say_name)()
say(say_nationality)()
Output:

Guido van Rossum
Netherlands

这里我们将两个不同的函数引用(不是括号内的)作为参数发送给say函数,该函数再次返回引用。

这就是内部函数的工作方式。

def say():

    def say_name():
        print("Guido van Rossum")

    def say_nationality():
        print("Netherlands")

    say_name()
    say_nationality()

say()
Output:

Guido van Rossum
Netherlands

装饰器

你已经看到函数就像Python中的其他对象一样,现在让我们举个例子来看看Python装饰器的魔力。


def say(func):

    def employer():
        print("说说你的事。")

    def say_name():
        print("我的名字是Guido van Rossum。")

    def say_nationality():
        print("我来自荷兰。")

    def wrapper():
         employer() #雇主()
        say_name()
        say_nationality()
        func()

    return wrapper

@say
def start_interview():
    print("真正的面试开始了...")

start_interview()

输出:

说些关于你的事情。
我的名字是Guido van Rossum。
我来自荷兰。
真正的面试开始了...

这里当我们调用start_interview方法时。它进入装饰函数say,定义了雇主、say_name、say_nationality和包装函数,最后它返回包装函数的引用,并在调用者函数start_interview的地方调用它。

用参数装饰函数

我们还可以装饰一个带参数的函数。我们可以在封装函数中使用*args**kwargs接受这些参数。


def say(func):

    def wrapper(*args, **kwargs):
        func(*args, **kwargs)
    return wrapper

@say
def greet(name):
    print("Hello {}".format(name))

greet("Goutom")
输出:

Hello Goutom

从装饰过的函数返回 当你的装饰函数返回一些东西时会发生什么?就是从包装器中返回调用者函数。让我们看一个例子来理解这一点。

def my_decorator(func):

    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def doubled(number):
    return number*2

print(doubled(10))
Output:

20

自检

在Python中,自省是指一个对象在运行时了解其自身属性的能力。例如,一个函数知道它自己的名字和文档。让我们打印 doubled 函数的名字。

print(doubled.__name__)
Output:

wrapper

但它应该是被加倍的。在被装饰后,我们的双倍函数对其身份产生了混淆,因为它是从 wrapper 函数中被调用的。为了解决这个问题,装饰器应该在wrapper函数中使用@functools.wraps装饰器,这将保留原函数的信息。在添加这个装饰器后,它将加倍返回其原始名称。

一个现实世界的例子

让我们写一个装饰器,它将计算函数的执行时间(以秒为单位)并在控制台中打印出来。

import functools
import time


def timer(func):

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        value = func(*args, **kwargs)
        end_time = time.perf_counter()
        run_time = end_time - start_time
        print("Finished {} in {} secs".format(repr(func.__name__), round(run_time, 3)))
        return value

    return wrapper
Now let's use this decorator:

@timer
def doubled_and_add(num):
    res = sum([i*2 for i in range(num)])
    print("Result : {}".format(res))

doubled_and_add(100000)
doubled_and_add(1000000)
Output:

Result : 9999900000
Finished ‘doubled_and_add’ in 0.0119 secs
Result : 999999000000
Finished ‘doubled_and_add’ in 0.0897 secs

现在我们来使用这个装饰器。

注册插件

装饰器不一定要包装它们所装饰的函数。他们也可以简单地注册一个函数的存在,并返回它的非包装。例如,这可以用来创建一个轻量级的插件架构。

PLUGINS = dict()

def register(func):
    PLUGINS[func.__name__] = func
    return func

@register
def add(a, b):
    return a+b

@register
def multiply(a, b):
    return a*b

def operation(func_name, a, b):
    func = PLUGINS[func_name]
    return func(a, b)

print(PLUGINS)
print(operation('add', 2, 3))
print(operation('multiply', 2, 3))
Output :

{‘add’: <function add at 0x7fb27f7a8620>, ‘multiply’: <function multiply at 0x7fb27f7a88c8>}
5
6

@register装饰器只是在全局PLUGINS dict中存储了一个对被装饰函数的引用。注意,在这个例子中,你不需要写一个内部函数或使用@functools.wraps,因为你返回的是未经修改的原始函数。

这种简单的插件架构的主要好处是,你不需要维护一个存在哪些插件的列表。这个列表是在插件自己注册时创建的。这使得添加一个新的插件变得非常简单:只需定义函数并使用@register来装饰它。

装饰类

有两种不同的方法可以在类上使用装饰器。第一种是通过装饰类的方法或装饰整个类。

几个内置的类装饰器

一些内置在 Python 中的常用装饰器是 @classmethod, @staticmethod, 和 @property。@classmethod 和 @staticmethod 装饰器用于定义类命名空间内的方法,这些方法与该类的特定实例没有关系。@property装饰器用于定制类属性的getters和setters。展开下面的方框,可以看到一个使用这些装饰器的例子。你可以在这里了解更多关于内置装饰器的信息。

让我们看一个例子。

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        ""获取半径的值""
        return self._radius

    @radius.setter
    def radius(self, value):
        ""设置半径,如果是负值,则引发错误"""
        if value >=0:
            self._radius = value
        else:
            raise ValueError("
半径必须为正")

    @property
    def area(self):
        "
"计算圆内的面积""
        return self.pi() * self.radius**2

    def cylinder_volume(self, height):
        "
"计算以圆为底的圆柱体的体积""
        return self.面积 * 高度

    @classmethod
    def unit_circle(cls):
        "
"创建半径为1的圆的工厂方法""
        return cls(1)

    @classmethod
    def pi():
        "
"π的值,不过可以用math.pi代替""
        return 3.1415926535

在这个类中:

.cylinder_volume()是一个常规方法。

.radius是一个可变的属性:它可以被设置成不同的值。

然而,通过定义一个setter方法,我们可以做一些错误测试以确保它不会被设置为一个无意义的负数。属性作为属性被访问,没有括号。

.area是一个不可变的属性:没有.setter()方法的属性不能被改变。即使它被定义为一个方法,它也可以作为一个属性被检索,不需要括号。

.unit_circle()是一个类方法。它不与Circle的一个特定实例绑定。类方法经常被用作工厂方法,可以创建该类的特定实例。

.pi()是一个静态方法。它并不真正依赖于Circle类,除了它是其命名空间的一部分。静态方法可以在一个实例或类上调用。

在控制台中测试。


>> c = Circle(5)
>>> c.radius
5

>> c.面积
78.5398163375

>> c.半径=2
>> c.面积
12.566370614

>>> c.面积=100
AttributeError: 不能设置属性

>> c.圆柱体_体积(高度=4)
50.265482456

>> c.radius = -1
ValueError。半径必须是正数

>> c = Circle.unit_circle()
>> c.radius
1

>> c.pi()
3.1415926535

>>> Circle.pi()
3.1415926535

装饰一个类方法

这里我们使用之前创建的定时器装饰器。


class Calculator:

    def __init__(self, num):
        self.num = num

    @timer
    def doubled_and_add(self):
        res = sum([i * 2 for i in range(self.num)])
        print("Result : {}".format(res))

c = Calculator(10000)
c.doubled_and_add()
Output:

Result : 99990000
Finished 'doubled_and_add' in 0.001 secs
Decorate a class
@timer
class Calculator:

    def __init__(self, num):
        self.num = num
        import time
        time.sleep(2)

    def doubled_and_add(self):
        res = sum([i * 2 for i in range(self.num)])
        print("Result : {}".format(res))

c = Calculator(100)
Output:

Finished 'Calculator' in 2.001 secs

装饰一个类并不能装饰它的方法。在这里,@timer只测量实例化类的时间。

嵌套装饰器

def hello(func):
    def wrapper():
        print("Hello")
        func()
    return wrapper

def welcome(func):

    def wrapper():
        print("Welcome")
        func()
    return wrapper

@hello
@welcome
def say():
    print("Greeting Dome")

say()
Output:

Hello
Welcome
Greeting Dome

把这看成是装饰器按照它们列出的顺序被执行。换句话说,@hello调用@welcome,后者调用say()

带有参数的装饰器

这里repeat处理装饰器的参数。


def repeat(*args_, **kwargs_):

    def inner_function(func):

        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(args_[0]):
                func(*args, **kwargs)
        return wrapper

    return inner_function


@repeat(4)
def say(name):
    print(f "Hello {name}")

say("World")

输出:


Hello World
Hello World
Hello World
Hello World

你好,世界 你好,世界 你好,世界 你好,世界

有状态的装饰器

我们可以使用一个装饰器来跟踪状态。作为一个简单的例子,我们将创建一个装饰器来计算一个函数被调用的次数。


def count_calls(func):

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        wrapper.num_calls += 1
        print(f"Call {wrapper.num_calls} of {func.__name__!r}")
        return func(*args, **kwargs)

    wrapper.num_calls = 0
    return wrapper


@count_calls
def say():
    print("Hello!")

say()
say()
say()
say()
print(say.num_calls)

输出:


Call 1 of 'say'
Hello!
Call 2 of 'say'
Hello!
Call 3 of 'say'
Hello!
Call 4 of 'say'
Hello!
4

对'say'的调用1

你好!

调用'say'的第2次

你好!

调用'say'的3

你好!

呼叫4的 "说"。

你好!

4

对该函数的调用次数存储在包装函数的函数属性num_calls中。

作为装饰器的类

维护状态的最好方法是使用类。如果我们想使用类作为装饰器,它需要在其 .init() 方法中把 func 作为一个参数。此外,这个类需要是可调用的,这样它就可以代替被装饰的函数。为了使一个类可以被调用,我们实现了特殊的 .call() 方法。


class CountCalls。
    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.num_calls = 0

    def __call__(self, *args, **kwargs):
        self.num_calls += 1
        print(f "调用{self.num_calls}的{self.func.__name__!r}")
        return self.func(*args, **kwargs)


@CountCalls
def say():
    print("Hello!")

say()
say()
say()
say()
print(say.num_calls)

输出过程:

对'say'的调用1 你好! 调用'say'的第2次 你好! 调用'say'的3 你好! 呼叫4的 "说"。 你好! 4

带参数的基于类的装饰器


class CountCalls:
    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.num_calls = 0

    def __call__(self, *args, **kwargs):
        self.num_calls += 1
        print(f"Call {self.num_calls} of {self.func.__name__!r}")
        return self.func(*args, **kwargs)


@CountCalls
def say():
    print("Hello!")

say()
say()
say()
say()
print(say.num_calls)
Output:

Call 1 of 'say'
Hello!
Call 2 of 'say'
Hello!
Call 3 of 'say'
Hello!
Call 4 of 'say'
Hello!
4
Class-Based Decorators with Arguments
class ClassDecorator(object):

    def __init__(self, arg1, arg2):
        print("Arguements of decorator %s, %s" % (arg1, arg2))
        self.arg1 = arg1
        self.arg2 = arg2

    def __call__(self, func):
        functools.update_wrapper(self, func)

        def wrapper(*args, **kwargs):
            return func(*args, **kwargs)
        return wrapper

@ClassDecorator("arg1""arg2")
def print_args(*args):
    for arg in args:
        print(arg)

print_args(1, 2, 3)
Output:

Arguements of decorator arg1, arg2
1
2
3

几个实例扩展和基础用法总结。

分类:

后端

标签:

后端

作者介绍

c
codeye
V1