惬意上手Python —— 装饰器和内置函数

1. Python装饰器

 Python中的装饰器是一种特殊类型的函数，它允许用户在不修改原函数代码的情况下，增加或修改函数的行为。

具体来说,装饰器的工作原理基于Python的函数也是对象这一事实，可以被赋值给变量、作为参数传递给其他函数或者作为其他函数的返回值。装饰器通常接受一个函数作为输入，并返回一个新的函数，这个新函数通常会包含原函数的一些额外功能。

1.1 闭包 

闭包是一个函数与其相关的词法环境的结合，这使得该函数可以在外部作用域中访问本地于其创建环境的变量和参数。 

简单来说，闭包就是函数嵌套函数，内部函数可以使用外部函数的变量。下面是一个简单的示例。

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

closure = outer_function(10)
print(closure(5))  # 输出 15

在这个例子中，outer_function是一个外部函数，它接受一个参数 x并返回一个内部函数inner_function。inner_function是一个闭包，因为它可以访问到其创建环境的变量x。当我们调用outer_function(10)时，它返回一个新的函数closure，这个函数可以访问到外部函数的变量x。然后我们调用closure(5)，实际上就是调用inner_function(5)，并将x的值设为10，因此最终输出结果为15。

1.2 Python装饰器

 

实现一个装饰器通常需要以下几个步骤：

1. 定义装饰器函数：首先，我们需要定义一个装饰器函数，它接受一个函数作为参数，并返回一个新的函数。这个新的函数通常会包含原始函数的调用和一些额外的操作。
2. 创建内部函数：在装饰器函数中，我们需要创建一个内部函数，它的作用是封装原始函数的调用和额外的操作。这个内部函数可以接收任意数量的参数和关键字参数，以便能够处理原始函数的调用。
3. 调用原始函数：在内部函数中，我们首先调用原始函数，并将其结果保存到一个变量中。然后，我们可以对原始函数的结果进行一些额外的操作，例如修改、过滤或记录日志等。
4. 返回新函数：最后，我们将内部函数返回为新的函数。这个新的函数将替代原始函数，并在被调用时执行内部函数的逻辑。
5. 应用装饰器：一旦装饰器函数定义完成，我们就可以将其应用到需要装饰的函数上。这可以通过使用@语法来实现，或者通过显式地将装饰器函数作为参数传递给原始函数。

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before function call")
        result = func(*args, **kwargs)
        print("After function call")
        return result
    return wrapper

@my_decorator
def my_function():
    print("Inside function")

my_function()

在这个例子中，my_decorator是一个装饰器函数，它接受一个函数作为参数并返回一个新的函数。这个新的函数被称为wrapper，它会在调用原始函数之前和之后执行一些额外的操作。

我们使用@my_decorator语法来应用装饰器到my_function函数上。当我们调用my_function()时，实际上是调用了wrapper()函数，并在其中执行了原始的my_function()函数。

输出结果：

Before function call
Inside function
After function call

 下面的代码是一个使用多个装饰器的代码，希望能帮助到你：

import time


def demo1(fun):
    def demo2():
        print("demo2中层开始")
        fun()
        time.sleep(2)
        print('睡了两秒,demo2中层结束')

    return demo2


def demo3(fun):
    def demo4():
        print("demo4外层开始")
        start = time.time()
        fun()
        print("用时：", abs(start - time.time()))
        print("外层结束")
    return demo4


@demo3
@demo1
def demo5():
    print("demo5内层开始")
    while True:
        if int(input("输入7，内层才会结束")) == 7:
            break
    print("内层结束")


demo5()

输出结果：

demo4外层开始
demo2中层开始
demo5内层开始
输入7，内层才会结束1
输入7，内层才会结束2
输入7，内层才会结束7
内层结束
睡了两秒,demo2中层结束
用时： 14.538939952850342
外层结束

 在这个例子中，demo1和demo3是两个装饰器，它们分别在demo5函数执行前后添加了一些打印语句和计时功能。demo5函数是一个无限循环，等待用户输入数字7才会结束。

这个函数被demo1和demo3装饰器修饰后，会在执行前后添加额外的打印语句和计时功能。这样，当我们调用demo5函数时，实际上是在执行经过装饰后的函数，从而实现了在不修改原函数代码的情况下为其添加额外功能的目的。

当使用多个装饰器时，哪个装饰糖（就是带@的语句）离函数进，就先执行哪个。

其实说白了装饰就是添加功能，进入哪个装饰器，就会添加哪个装饰器内部函数的语句，这就叫装饰。

2. Python内置函数

Python中的聂志函数很多，不便一一解释，下面仅举几个常用的函数为例子。

1.len()：计算字符串、列表、元组等长度。

s = "hello"
print(len(s))  # 输出：5

2.type()：获取变量的类型。

a = 123
print(type(a))  # 输出：

3.str()：将其他类型的数据转换为字符串类型。

num = 123
print(str(num))  # 输出："123"

4.list()：将可迭代对象转换为列表类型。

tup = (1, 2, 3)
print(list(tup))  # 输出：[1, 2, 3]

 5.tuple()：将可迭代对象转换为元组类型

lst = [1, 2, 3]
print(tuple(lst))  # 输出：(1, 2, 3)

6.dict()：将键值对序列转换为字典类型。

items = [("key1", "value1"), ("key2", "value2")]
print(dict(items))  # 输出：{'key1': 'value1', 'key2': 'value2'}

7.set()：将可迭代对象转换为集合类型。

lst = [1, 2, 3, 3]
print(set(lst))  # 输出：{1, 2, 3}

8.range()：生成一个整数序列。

for i in range(5):
    print(i)  # 输出：0 1 2 3 4

9.enumerate()：同时返回可迭代对象的索引和元素。

lst = ["apple", "banana", "orange"]
for index, value in enumerate(lst):
    print(index, value)  # 输出：0 apple，1 banana，2 orange

10.zip()：将多个可迭代对象的元素打包成一个个元组，然后返回由这些元组组成的列表。

names = ["Tom", "Jerry", "Mike"]
ages = [18, 20, 22]
print(list(zip(names, ages)))  # 输出：[('Tom', 18), ('Jerry', 20), ('Mike', 22)]

over,持续更新中