[python基礎]裝飾器、迭代器、生成器

裝飾器

裝飾器本質上是一個Python函數，它可以讓其他函數在不需要做任何程式碼變動的前提下增加額外功能，裝飾器的返回值也是一個函數物件
它經常用於有切面需求的場景，比如：插入紀錄檔、效能測試、事務處理、快取、許可權校驗等場景。裝飾器是解決這類問題的絕佳設計，有了裝飾器，我們就可以抽離出大量與函數功能本身無關的程式碼並繼續重用

1、函數呼叫

#定義一個函數
def hi(mes="我要玩亞索"):
    return "中路是我的,"+mes


print(hi())
# 拷貝函數
greet = hi
print(greet())

try:
	# 刪除原函數
    del hi
    print(hi())
except Exception as e:
    print("函數已被刪除")
finally:
    print(greet())

2、函數中呼叫函數

def hi(name="銳雯"):
    print("now you are inside the hi() function")

    def greet():
        return "now you are inside the greet() function"

    def welcone():
        return "now you are inside the welcome() function"

    print(greet())
    print(welcone())
    print("now you are back in the hi() function")


hi()

try:
	# 在主函數中呼叫hi函數中的greet函數
    greet()
except Exception as e:
    print("函數不存在")

3、函數呼叫返回函數呼叫

def hi(name="銳雯"):
    def greet():
        return "now you are inside the greet() function"

    def welcome():
        return "now you are inside the welcome() function"

    if name=="銳雯":
        return greet
    else:
        return welcome


a = hi()
print(a)
print(a())
a = hi("亞索")
print(a())

4、函數傳參–傳入函數引數

def hi():
    return "It's a nice day"


def doSomethingToSee(func):
    print(func())
    print("I should do something")


doSomethingToSee(hi)

5、函數傳入函數引數返回函數呼叫

def a_new_decorator(a_func):
    def wrapTheFunction():
        print("在函數呼叫前我正在做一些無聊的事情")
        a_func()
        print("終於結束函數呼叫了，我都快累死了")

    return wrapTheFunction


def a_function_requiring_decoration():
    print("我是一個需要裝飾的函數")


a_function_requiring_decoration()
a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)
a_function_requiring_decoration()

上面的函數a_new_decorator就是一個裝飾器
現在python允許裝飾器呼叫使用@語法糖

下面使用@語法糖重構上述裝飾器:

import functools


def a_new_decorator(a_func):
    def wrapTheFunction():
        print("在函數呼叫前我正在做一些無聊的事情")
        a_func()
        print("終於結束函數呼叫了，我都快累死了")

    return wrapTheFunction


@a_new_decorator
def a_function_requiring_decoration():
    print("我是一個需要裝飾的函數")


print(a_function_requiring_decoration.__name__)
a_function_requiring_decoration()

上述語法糖"@a_new_decorator"等價於 未重構之前的「a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)「

注意：

我們發現「a_function_requiring_decoration._name_」返回的是wrapTheFunction，也就是說原函數在經歷裝飾器後函數的名字和函數的註釋、檔案都被修改成了裝飾器閉包內的函數

為了防止這種情況的出現

我們匯入一個模組

import functools/from functools import wraps

import functools


def a_new_decorator(a_func):
	@functools.wraps(a_func)
    def wrapTheFunction():
        print("在函數呼叫前我正在做一些無聊的事情")
        a_func()
        print("終於結束函數呼叫了，我都快累死了")

    return wrapTheFunction


@a_new_decorator
def a_function_requiring_decoration():
    print("我是一個需要裝飾的函數")


print(a_function_requiring_decoration.__name__)
a_function_requiring_decoration()

就可以解決這個問題了

也可以通過以下兩個方法:

1. 使用decorator.py檔案
   decorator.py 是一個非常簡單的裝飾器加強包。你可以很直觀的先定義包裝函數wrapper()，再使用decorate(func, wrapper)方法就可以完成一個裝飾器。
   decorator.py實現的裝飾器能完整保留原函數的name，doc和args
   唯一有問題的就是inspect.getsource(func)返回的還是裝飾器的原始碼需要改成inspect.getsource(func._wrapped_)

import decorator

import decorator
import datetime
# 裝飾器的優化


def wrapper(func, *args, **kwargs):
    print("我正在裝扮自己")
    return func(*args, **kwargs)


def logging(func):
    # 用wrapper裝飾func
    return decorator.decorate(func, wrapper)


# @logging
def hi():
    print("my name is Q")


a= logging(hi)
a()

2. 使用 wrapt檔案

import wrapt

wrapt是一個功能非常完善的包，用於實現各種裝飾器
使用wrapt實現的裝飾器不需要擔心之前inspect中遇到的所有問題，因為它都幫你處理了，甚至inspect.getsource(func)也準確無誤

import wrapt

@wrapt.decorator
def logging(wrapped, instance, *args, **kwargs):
    print("我是個裝飾器的外套")
    return wrapped(*args, **kwargs)

@logging
def sayHi(*args, **kwargs):
    print("Hi")

sayHi()

帶引數的裝飾器

1.基於函數實現的裝飾器

在裝飾器外再套一層裝飾器，專門用於向裝飾器內部傳遞引數

import functools

def add_2_somenumber(num, add_num=1):
    print("---1---")
    def know_whatToDo(func):
        print("---2---")
        @functools.wraps(func)
        def wirte_function_name(*arg, **kwargs):
            print("---3---")
            print(func.__name__, " was called at here")
            print("as a result, the answer is %d" % (num + add_num))
            return func(*arg, **kwargs)
        return wirte_function_name
    return know_whatToDo

@add_2_somenumber(2,3)
def print_result():
    print("開始活動了")
    print("---4---")


print_result()

2.基於類實現的裝飾器

裝飾器函數其實是這樣一個介面約束
它必須接受一個callable物件作為引數，然後返回一個callable物件
在Python中一般callable物件都是函數
但也有例外，只要某個物件過載了__call__()方法，那麼這個物件就是callable的

在class物件中:

_init_:用來傳遞引數
_call_:用來構建裝飾器

# 裝飾類
import functools


class logit(object):
    def __int__(self, logfile="out.log"):
        self.login_file = logfile

    def __call__(self, func):
        @functools.wraps(func)
        def wrapped_function(*arg, **kwarg):
            login_string = func.__name__+" was called "
            print(login_string)
            return func(*arg, **kwarg)
        return wrapped_function


@logit(logfile="out.log")
def myfunc_test():
    print("這是類裝飾器的產生")


myfunc_test()

1、裝飾器原則：
      1）不能修改原函數
      2）不能修改呼叫方式
2、裝飾器通過巢狀函數和閉包實現
3、裝飾器執行順序：洋蔥法則
4、裝飾器通過語法糖「@」修飾
5、謹記裝飾器返回的是持有被裝飾函數參照的閉包函數的參照這條原則

常用的裝飾器

屬性有三個裝飾器：setter, getter, deleter ，都是在property()的基礎上做了一些封裝
因為setter和deleter是property()的第二和第三個引數，不能直接套用@語法

class Classmate:
    def __init__(self):
        self.age = 15

    @property
    def set_name(self, value):
        self.name = value

student = Classmate()
student.name="Q"
print(student.age)
print(student.name)

有了@property裝飾器的瞭解，這兩個裝飾器的原理是差不多的
@staticmethod返回的是一個staticmethod類物件
@classmethod返回的是一個classmethod類物件
他們都是呼叫的是各自的__init__()建構函式

迭代器

from collections.abc import Iterable
from collections.abc import Iterator

content = list()
content = [x*x for x in range(10)]
print(type(content))

可以發現 常見的列表、字典、集合、元祖、字串都屬於迭代物件

print(isinstance([], Iterable))
print(isinstance((), Iterable))
print(isinstance({}, Iterable))
print(isinstance("", Iterable))

迭代物件都可以通過for遍歷

for i in content:
    print(i, end=" ")
print()

類能不能是迭代物件呢？

class ClassMate(object):
    def __init__(self):
        self.names = []

    def add_name(self, name):
        self.names.append(name)


student = ClassMate()
student.add_name("老王")
student.add_name("小張")
student.add_name("小李")
print(isinstance(student, Iterable))

發現普通的類不是可迭代物件
只用噹噹類物件中出現__iter__方法時，該類就變成了可迭代物件

class ClassMate(object):
    def __init__(self):
        self.names = []

    def add_name(self, name):
        self.names.append(name)

    def __iter__(self):
        pass


student = ClassMate()
student.add_name("老王")
student.add_name("小張")
student.add_name("小李")
# 當類物件中出現__iter__方法時，該類就變成了可迭代物件
print(isinstance(student, Iterable))

# 我們使用for迴圈遍歷，發現還是不能夠迭代類物件
# 這時候我們就可以使用類中的一個方法__next__,使其迭代物件
try:
    for i in student:
        print(i)
except Exception as e:
    print("不能夠進行迭代")

1. 通過一個可迭代的類來呼叫原本自身類的迭代

class ClassMate(object):
    def __init__(self):
        self.names = []
        self.index = 0

    def add_name(self, name):
        self.names.append(name)

    def __iter__(self):
        # 返回一個可以迭代的物件
        return ClassRoom(self)

    def __next__(self):
        if self.index+1 <= len(self.names):
            result = self.names[self.index]
            self.index += 1
            return result
        else:
            # 如果沒有這句話，物件將會一直返回None
            # 這裡報錯StopIteration，並停止迭代
            raise StopIteration


class ClassRoom(object):
    def __init__(self, obj):
        self.index = 0
        self.obj = obj

    def __iter__(self):
        pass

    def __next__(self):
        if self.index + 1 <= len(self.obj.names):
            result = self.obj.names[self.index]
            self.index += 1
            return result
        else:
            # 如果沒有這句話，物件將會一直返回None
            # 這裡報錯StopIteration，並停止迭代
            raise StopIteration


student = ClassMate()
student.add_name("老王")
student.add_name("小張")
student.add_name("小李")
for i in student:
    print(i)

2. 自己迭代

class ClassMate(object):
    def __init__(self):
        self.names = []
        self.index = 0

    def add_name(self, name):
        self.names.append(name)

    def __iter__(self):
        # 返回一個可以迭代的物件
        return self

    def __next__(self):
        if self.index+1 <= len(self.names):
            result = self.names[self.index]
            self.index += 1
            return result
        else:
            # 如果沒有這句話，物件將會一直返回None
            # 這裡報錯StopIteration，並停止迭代
            raise StopIteration


student = ClassMate()
student.add_name("老王")
student.add_name("小張")
student.add_name("小李")
for i in student:
    print(i)

生成器

生成器是一種特殊的迭代器
普通的生成器
只需要把迭代器生成時的中括號改成小括號

def get_test1(num):
    print(num)
    i = 0
    print(i, end=" ")
    while i < num:
        print(i, end=" ")
        ret = yield i
        i += 1


n = get_test1(10)
for i in range(10):
    next(n)


def get_test2(num):
    print(num)
    i = 0
    print(i, end=" ")
    while i < num:
        print(i, end=" ")
        ret = yield i
        print(ret)
        i += 1


n1 = get_test2(10)
next(n1)
n1.send("hahahaha")
next(n1)

當函數呼叫時出現了yield，它就變成了一個生成器
生成器可以通過_next_來獲取資料

obj.send(msg)當程式進行時，使yield呼叫擁有返回值，其值為send傳輸過去的msg

注意:send方法呼叫時必須先呼叫next方法開始迭代生成

當子函數執行到yield時，程式會先將數值返回個函數呼叫，然後停止等待，一直到下一次獲取生成器中資料時才啟動