Python 从入门到放弃 - Lesson 4 迭代器、装饰器、序列化

文章目录

函数即变量
高阶函数
嵌套函数
装饰器基础版
装饰器进阶版
装饰器终极版
列表生成式
生成器
函数式生成器
yield进阶示例
可迭代对象
迭代器
json序列化
pickle序列化

装饰器

在不改变函数和函数调用方法的前提下，实现扩充函数的功能。其依赖三个基本要素

1. 函数即变量
2. 高阶函数
3. 嵌套函数

函数即变量

函数与变量的定义基本原理都是将内容存放到内存，将变量名和函数名作为指针指向内容的内存空间地址，唯一的区别就是变量在内空间存放的是变量值，而函数在内存空间存放的是函数体，其本质上也就是一块字符串

高阶函数

高阶函数包含两大特征

以一个函数名作为高阶函数的参数

def deco(func):
    print("Starting function")
    func()

def test():
    print("Testing")

# 使用函数test作为函数deco的参数，则函数deco是一个高阶函数
deco(test)

def deco(func):

print("Starting function")

func()

def test():

print("Testing")

# 使用函数test作为函数deco的参数，则函数deco是一个高阶函数

deco(test)

高阶函数返回值可以是一个函数名（即函数所在的内存空间地址）

def deco(func):
    print("Starting function")
    return func

def test():
    print("Testing")

#  运行deco(test)将打印一行信息后返回test函数的内存空间地址，deco是一个高阶函数
myfunc = deco(test)

# 运行myfunc()实际上是运行deco(test)返回的内存地址中的函数体，即test函数的内容
myfunc()

test()  # 执行test函数

def deco(func):

print("Starting function")

return func

def test():

print("Testing")

# 运行deco(test)将打印一行信息后返回test函数的内存空间地址，deco是一个高阶函数

myfunc = deco(test)

# 运行myfunc()实际上是运行deco(test)返回的内存地址中的函数体，即test函数的内容

myfunc()

test() # 执行test函数

如果将上面例子中的myfunc = deco(test)修改为 test = deco(test), 则相当于替换了函数test的内存地址，同时deco函数体内继续用test()的方式调用函数而不影响原有功能，这就是装饰器的雏形

嵌套函数

在函数体中再定义一个函数，这个函数的作用域仅在当前函数中

def deco():
    # 定义内部函数test, 此函数仅能在deco内部访问
    def test():
        print("Testing")
    # 返回这个内部函数的内存地址
    return test

deco()
# 直接访问test函数将报错
# test()

def deco():

# 定义内部函数test, 此函数仅能在deco内部访问

def test():

print("Testing")

# 返回这个内部函数的内存地址

return test

deco()

# 直接访问test函数将报错

# test()

上面例子中调用deco()将返回内部函数test所在的内存空间地址，通过print(deco())可以看到返回类似以下的结果

<function deco.<locals>.test at 0x00000130675D29D8>

1	<function deco.<locals>.test at 0x00000130675D29D8>

将这个返回值赋予一个变量，再执行这个变量，即可执行这个内部函数的函数体

def deco():
    # 定义内部函数test, 此函数仅能在deco内部访问
    def test():
        print("Testing")
    return test

func = deco()  # deco()返回test函数的内存地址，赋值给变量func，此时func也就成了一个函数（函数即变量）
func()  # 调用函数

def deco():

# 定义内部函数test, 此函数仅能在deco内部访问

def test():

print("Testing")

return test

func = deco() # deco()返回test函数的内存地址，赋值给变量func，此时func也就成了一个函数（函数即变量）

func() # 调用函数

装饰器基础版

结合上面三个部分的内容，高阶函数的两种特征和嵌套函数

# 定义高阶函数deco,接收一个函数func作为参数（即函数内存地址）
def deco(func):
    # 定义内部函数wrapper,打印一条信息后，调用从父函数继承来的参数func并执行
    def wrapper():
        print("From warpper")
        func()  # 调用作为参数传入的函数（即下面原本的origin函数）
    # 返回wrapper函数的内存地址
    return wrapper

def origin():
    print("From origin")

# 先将originh函数的内存地址作为参数传递给deco函数，然后origin函数的内存地址被替换成deco函数返回的wrapper函数的内存地址
origin = deco(origin)

#执行函数origin，实际上是执行了函数wrapper的函数体
origin()

# 定义高阶函数deco,接收一个函数func作为参数（即函数内存地址）

def deco(func):

# 定义内部函数wrapper,打印一条信息后，调用从父函数继承来的参数func并执行

def wrapper():

print("From warpper")

func() # 调用作为参数传入的函数（即下面原本的origin函数）

# 返回wrapper函数的内存地址

return wrapper

def origin():

print("From origin")

# 先将originh函数的内存地址作为参数传递给deco函数，然后origin函数的内存地址被替换成deco函数返回的wrapper函数的内存地址

origin = deco(origin)

#执行函数origin，实际上是执行了函数wrapper的函数体

origin()

以上例子已经完全实现了装饰器的基本要求，即：

1. 不改变函数本身
2. 不改变函数的调用方式
3. 实现对原函数的功能扩展

同时对于origin = deco(origin)这种表达式，python提供了专门的装饰器专用语法,在定义函数的上面加上

@deco  # 加载装饰器
def origin():
    print("From origin")

@deco # 加载装饰器

def origin():

print("From origin")

装饰器进阶版

基本版的装饰器实现了简单的装饰功能，但如果原函数是带参数的，还需要稍作修改

# 定义高阶函数deco,接收一个函数func作为参数（即函数内存地址）
def deco(func):
    def wrapper(*args, **kwargs):  # 接收原函数内存地址被替换后传递过来的参数
        print("From warpper")
        func(*args, **kwargs)  # 参数重新传递给原函数以保证功能的一致性
    # 返回wrapper函数的内存地址
    return wrapper

@deco
def origin(name):
    print("%s From origin" % name)


# 调用origin函数实际上等同于调用了wrapper函数，参数name同样也传递给了函数wrapper
origin("Bob")

# 定义高阶函数deco,接收一个函数func作为参数（即函数内存地址）

def deco(func):

def wrapper(*args, **kwargs): # 接收原函数内存地址被替换后传递过来的参数

print("From warpper")

func(*args, **kwargs) # 参数重新传递给原函数以保证功能的一致性

# 返回wrapper函数的内存地址

return wrapper

@deco

def origin(name):

print("%s From origin" % name)

# 调用origin函数实际上等同于调用了wrapper函数，参数name同样也传递给了函数wrapper

origin("Bob")

装饰器终极版

多样化的装饰器，装饰不同函数时赋予不同的功能

def out_deco(func_type):
    # 定义高阶函数deco,接收一个函数func作为参数（即函数内存地址）
    def deco(func):
        def wrapper(*args, **kwargs):  # 接收原函数内存地址被替换后传递过来的参数
            if func_type == "N":
                print("Mode N")
            if func_type == "A":
                print("Mode A")
            func(*args, **kwargs)  # 参数重新传递给原函数以保证功能的一致性

        # 返回wrapper函数的内存地址
        return wrapper

    return deco


'''
out_deco(N)函数返回值为deco，@out_deco(N)等同于@deco，即还是以deco作为真正的装饰器（origin1 = deco(origin1)），只是是参数func_type会向下继承;
deco(origin1)执行后返回wrapper，即origin1 = wrapper，那么origin1("参数") = wrapper("参数")，实现最终的装饰；
由于参数_type的继承，可以根据最初指定装饰器时的参数执行不同动作
'''


@out_deco("N")
def origin1(name):
    print("Welcome %s" % name)


@out_deco("A")
def origin2(age):
    print("Age is %s" % age)


# 调用origin1函数实际上等同于调用了wrapper函数，参数name同样也传递给了函数wrapper
origin1("Bob")
origin2(18)

def out_deco(func_type):

# 定义高阶函数deco,接收一个函数func作为参数（即函数内存地址）

def deco(func):

def wrapper(*args, **kwargs): # 接收原函数内存地址被替换后传递过来的参数

if func_type == "N":

print("Mode N")

if func_type == "A":

print("Mode A")

func(*args, **kwargs) # 参数重新传递给原函数以保证功能的一致性

# 返回wrapper函数的内存地址

return wrapper

return deco

'''

out_deco(N)函数返回值为deco，@out_deco(N)等同于@deco，即还是以deco作为真正的装饰器（origin1 = deco(origin1)），只是是参数func_type会向下继承;

deco(origin1)执行后返回wrapper，即origin1 = wrapper，那么origin1("参数") = wrapper("参数")，实现最终的装饰；

由于参数_type的继承，可以根据最初指定装饰器时的参数执行不同动作

'''

@out_deco("N")

def origin1(name):

print("Welcome %s" % name)

@out_deco("A")

def origin2(age):

print("Age is %s" % age)

# 调用origin1函数实际上等同于调用了wrapper函数，参数name同样也传递给了函数wrapper

origin1("Bob")

origin2(18)

生成器generator

列表生成式

x = [ i*2 for i in range(10)]  # i*2可以是其他更复杂的表达式，如将将i传递给函数func(i)
print(x)

1 2	x = [ i2 for i in range(10)] # i2可以是其他更复杂的表达式，如将将i传递给函数func(i) print(x)

生成器

y = (i*2 for i in range(10))
print(type(y))
# 生成器每次循环只生成当前需要读取的值放入内存
for i in y:
    print(i)

# 使用__next__方法访问生成器的下一个值
z = (i*2 for i in range(5))
print("Var z".center(20, "="))
print(z.__next__())
print(z.__next__())
print(next(z))
print(next(z))

y = (i*2 for i in range(10))

print(type(y))

# 生成器每次循环只生成当前需要读取的值放入内存

for i in y:

print(i)

# 使用__next__方法访问生成器的下一个值

z = (i*2 for i in range(5))

print("Var z".center(20, "="))

print(z.__next__())

print(next(z))

函数式生成器

# 斐波那契数列函数
def fib(maxnum):
    '''
    表达式a, b = b, a + b实际上相当于
    t = (b, a + b)
    a = t[0]
    b = t[1]
    '''
    n, a, b = 0, 0, 1
    while n &lt; maxnum:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'Done'


print("Fuction fib".center(20, "="))
fib(10)

# 斐波那契数列函数

def fib(maxnum):

'''

表达式a, b = b, a + b实际上相当于

t = (b, a + b)

a = t[0]

b = t[1]

'''

n, a, b = 0, 0, 1

while n < maxnum:

print(b)

a, b = b, a + b

n = n + 1

return 'Done'

print("Fuction fib".center(20, "="))

fib(10)

使用yield关键字将函数变成一个生成器

print("Generator fib".center(20, "="))
def fib(maxnum):
    n, a, b = 0, 0, 1
    while n &lt; maxnum:
        # yield 将函数变成了一个generator
        yield b
        a, b = b, a + b
        n = n + 1
    # 返回值用于生成器的StopIteration异常时返回值
    return 'Done'


f = fib(10)
print(f)
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
for i in f:
    print(i)

print("Generator fib".center(20, "="))

def fib(maxnum):

n, a, b = 0, 0, 1

while n < maxnum:

# yield 将函数变成了一个generator

yield b

a, b = b, a + b

n = n + 1

# 返回值用于生成器的StopIteration异常时返回值

return 'Done'

f = fib(10)

print(f)

print(f.__next__())

for i in f:

print(i)

yield进阶示例

一个协程式的消费者-生存者雏形

import time

# 定义消费者生成器
def consumer(name):
    print("【%s】准备吃包子啦" % name)
    while True:
        baozi = yield
        print("包子【%s】号上桌了，被【%s】吃了一口" % (baozi, name))


def producer():
    # 生成两个消费者并初始化
    c1 = consumer("张三")
    c2 = consumer("李四")
    c1.__next__()
    c2.__next__()
    # 循环制作10个包子
    for i in range(1,10):
        print("包子【%s】号制作完成" % i)
        time.sleep(1)
        # send方法将包子传递给yield作为值
        c1.send(i)
        c2.send(i)


producer()

import time

# 定义消费者生成器

def consumer(name):

print("【%s】准备吃包子啦" % name)

while True:

baozi = yield

print("包子【%s】号上桌了，被【%s】吃了一口" % (baozi, name))

def producer():

# 生成两个消费者并初始化

c1 = consumer("张三")

c2 = consumer("李四")

c1.__next__()

c2.__next__()

# 循环制作10个包子

for i in range(1,10):

print("包子【%s】号制作完成" % i)

time.sleep(1)

# send方法将包子传递给yield作为值

c1.send(i)

c2.send(i)

producer()

迭代器

可迭代对象

列表，字典，元组，字符串都是可迭代对象，数字不是

from collections import Iterable

print(isinstance([], Iterable))  # True
print(isinstance({}, Iterable))  # True
print(isinstance(1234, Iterable))  # False
print(isinstance("abcd", Iterable))  # True
print(isinstance((x for x in range(10)), Iterable))  # True

from collections import Iterable

print(isinstance([], Iterable)) # True

print(isinstance({}, Iterable)) # True

print(isinstance(1234, Iterable)) # False

print(isinstance("abcd", Iterable)) # True

print(isinstance((x for x in range(10)), Iterable)) # True

迭代器

可以通过next方法获取下一个对象

from collections import Iterator

print(isinstance([1, 2, 3, 4], Iterator))  # False
print(isinstance((x for x in range(10)), Iterator))  # True
# iter函数将一个可迭代对象转换成一个迭代器
it = iter([1, 2, 3, 4])
print(isinstance(it, Iterator))  # True
print(next(it))
print(next(it))
print(it.__next__())

from collections import Iterator

print(isinstance([1, 2, 3, 4], Iterator)) # False

print(isinstance((x for x in range(10)), Iterator)) # True

# iter函数将一个可迭代对象转换成一个迭代器

it = iter([1, 2, 3, 4])

print(isinstance(it, Iterator)) # True

print(next(it))

print(it.__next__())

序列化

json序列化

json序列号只能处理简单的字符类型的对象，如字符串、列表、字典等

import json

dic1 = {
    "广州": {
        "花都": "001",
        "越秀": "002",
        "海珠": "003",
        "黄埔": "004"
    },
    "深圳": {
        "宝安": "011",
        "龙华": "012",
        "福田": "013"
    }
}

# json序列化
with open("json.dump", "w") as fw:
    print(json.dumps(dic1))
    fw.write(json.dumps(dic1))  # 等同于json.dump(dic1, fw)

# json反序列化
with open("json.dump", "r") as fr:
    data = json.loads(fr.read()) # 等同于json.load(dic1, fr)
    print(data)

import json

dic1 = {

"广州": {

"花都": "001",

"越秀": "002",

"海珠": "003",

"黄埔": "004"

"深圳": {

"宝安": "011",

"龙华": "012",

"福田": "013"

}

# json序列化

with open("json.dump", "w") as fw:

print(json.dumps(dic1))

fw.write(json.dumps(dic1)) # 等同于json.dump(dic1, fw)

# json反序列化

with open("json.dump", "r") as fr:

data = json.loads(fr.read()) # 等同于json.load(dic1, fr)

print(data)

pickle序列化

pickle序列化与json序列化用法基本一直，但pickle序列化支持几乎所有Python数据类型（不支持生成器），pickle序列化后的对象为二进制对象

import pickle

dic1 = {
    "广州": {
        "花都": "001",
        "越秀": "002",
        "海珠": "003",
        "黄埔": "004"
    },
    "深圳": {
        "宝安": "011",
        "龙华": "012",
        "福田": "013"
    },
    "iter1": iter([1, 2, 3, 4])  # 迭代器对象
}

# pickle序列化
with open("pickle.dump", "wb") as fw:
    print(pickle.dumps(dic1))
    fw.write(pickle.dumps(dic1))  # 等同于pickle.dump(dic1, fw)

# pickle反序列化
with open("pickle.dump", "rb") as fr:
    data = pickle.loads(fr.read())  # 等同于pickle.load(dic1, fr)
    print(data)
    # 还原迭代器对象并调用其__next__方法
    print(data["iter1"].__next__())
    print(data["iter1"].__next__())

import pickle

dic1 = {

"广州": {

"花都": "001",

"越秀": "002",

"海珠": "003",

"黄埔": "004"

"深圳": {

"宝安": "011",

"龙华": "012",

"福田": "013"

"iter1": iter([1, 2, 3, 4]) # 迭代器对象

}

# pickle序列化

with open("pickle.dump", "wb") as fw:

print(pickle.dumps(dic1))

fw.write(pickle.dumps(dic1)) # 等同于pickle.dump(dic1, fw)

# pickle反序列化

with open("pickle.dump", "rb") as fr:

data = pickle.loads(fr.read()) # 等同于pickle.load(dic1, fr)

print(data)

# 还原迭代器对象并调用其__next__方法

print(data["iter1"].__next__())

跨目录调用

# 导入必要模块
import os
import sys

# 获取程序根目录
root_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# 加入环境变量
sys.path.append(root_path)

# 导入其他目录的模块
from conf import config
from main import main

# 导入必要模块

import os

import sys

# 获取程序根目录

root_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

# 加入环境变量

sys.path.append(root_path)

# 导入其他目录的模块

from conf import config

from main import main

原文链接：Python 从入门到放弃 - Lesson 4 迭代器、装饰器、序列化，转载请注明来源！

一	二	三	四	五	六	日
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30

装饰器

函数即变量

高阶函数

以一个函数名作为高阶函数的参数

高阶函数返回值可以是一个函数名（即函数所在的内存空间地址）

嵌套函数

装饰器基础版

装饰器进阶版

装饰器终极版

生成器generator

列表生成式

生成器

函数式生成器

yield进阶示例

迭代器

可迭代对象

迭代器

序列化

json序列化

pickle序列化

跨目录调用

发表回复 取消回复

发表回复取消回复