(4)P_PY(草稿)

目录：

1、装饰器

2、列表生成式

3、生成器

4、斐波那契额

4、迭代器

5、json & pickle 模块

一、装饰器：

装饰器：
定义：本质是函数，（功能：装饰其他函数）就是为其他函数添加附加功能
原则：1、不能修改被装饰的函数的源代码
         2、不能改变被装饰的函数的调用方式

实现装饰器知识储备：
    1、函数即“变量”
    2、高阶函数
            a、把一个函数名当作实参传给另外一个函数（在不修改被装饰函数源代码的情况下为其添加功能）
            b、返回值中包含函数名(不修改函数的调用方式)
    3、嵌套函数

高阶函数 + 嵌套函数 ==》 装饰器


test:

 def foo():
     print('in the foo')
     bar()
 foo()
cale = lambda x:x*3    #匿名函数  直接赋值给变量   没有函数名
cale(3)                # 调用

'''
def foo():
    print('in the foo')
    bar()

foo()                          #肯定会报错，因为在定义之前bar()函数还未定义
def bar():
    print('in the bar')
'''

'''
#定义一个高阶函数
import time
def bar():
    time.sleep(3)
    print('in the bar')

def test1(func):
    start_time = time.time()
    func()
    stop_time = time.time()
    print('the func run time is %s' %(stop_time - start_time))

test1(bar)         #在不改变bar的情况下 添加了新的功能，但是bar的调用方式改变了
'''

'''
import time
def bar():
    time.sleep(3)
    print('in the bar')

def test1(func):
    print(func)
    return func

#print(test1(bar))
bar = test1(bar)
bar()        # run bar
'''

'''
#嵌套函数
def foo():
    print('in the fooo')
    def bar():           #相当与定义了一个bar的局部变量，只能在函数内部调用
        print('in the bar')
    bar()   #只能在函数内部调用
foo()
'''

'''
#初级
#定义装饰器
import time
def timer(func):     #timer(test1)  就是func=test1   #嵌套
    def deco():
        start_time = time.time()
        func()            # 运行test1()
        stop_time = time.time()
        print('the func run time is %s' %(stop_time - start_time))
    return deco   #高阶函数


@timer      # 就相当于 test1 = timer(test1)
def test1():
    time.sleep(3)
    print('in the test1')

@timer
def test2():
    time.sleep(3)
    print('in the test2')

#test1 = timer(test1)   #当不希望出现这个时  用上面的@timer
test1()           # ------>deco
test2()
'''

'''
#当调用的函数有参数时
#大部分环境使用如下方式
import time
def timer(func):     #timer(test1)  func=test1   #嵌套
    def deco(*args,**kwargs):                            #接受多个参数
        start_time = time.time()
        func(*args,**kwargs)            # 运行test1()
        stop_time = time.time()
        print('the func run time is %s' %(stop_time - start_time))
    return deco   #高阶函数


@timer      # 就相当于 test1 = timer(test1)
def test1():
    time.sleep(2)
    print('in the test1')

@timer
def test2(name,age):
    time.sleep(2)
    print('in the test2')

#test1 = timer(test1)   #当不希望出现这个时
test1()           # ------>deco
test2('laiang',18)
'''

 为多个函数添加认证功能：

import time
user,passwd = 'laiand','abc123'
def auth(func):
    def wrapper(*args,**kwargs):
        username = input("Username:").strip()   #去掉左右空格
        password = input("Password:").strip()
        if user == username and passwd == password:
            print('33[35;1mUser has passwd authentication33[0m')
            func(*args,**kwargs)
        else:
            exit('033[35;1mInvalid username or password33[0m')
    return wrapper

@auth
def index():
    print('welcom to index page')

@auth
def home():
    print('welcom to index home')

@auth
def bbs():
    print('welcom to index bbs')

index()
home()
bbs()

二、列表生成式

现有列表a = [0,11,22,33,44,55,66,77,88,99,110]，把列表里的每个值加1，如何操作：

方式一：

a = [0,11,22,33,44,55,66,77,88,99,110]
b = []             #定义一个空列表
for i in a:        #循环a 里的每一个元素
    b.append(i+1)  #把每一个元素加1扩展到b 里面
a = b
print(a)

 方式二：

在原列表基础上修改

a = [0,11,22,33,44,55,66,77,88,99,110]
for index,i in enumerate(a):
    a[index] += 1
print(a)

 方式三：

a = [0,11,22,33,44,55,66,77,88,99,110]
a = map(lambda x:x+1,a)
for i in a:print(i)

列表生成式：   作用就是     使代码更简洁

a = [i+1 for i in range(10)]   #循环每一个数 再加一  
print(a)

三、生成器

当列表包含大量元素时，读取的时候会占用大量内存，造成空间浪费，

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素？这样就不必创建完整的list，从而节省大量的空间。

在Python中，这种一边循环一边计算的机制，称为生成器：generator

1、创建一个generator

方法一：

　　把一个列表生成式的[]改成()，就创建了一个generator：

>>> a = [x*x for x in range(11)]
>>> a
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>
>>> b = (x*x for x in range(11))
>>> b
<generator object <genexpr> at 0x7f6d80711870>
>>>

 可以直接打印出list的每一个元素

如果要打印生成器的每一个元素   通过next()函数来实现：

>>> b = (x*x for x in range(11))
>>> b
<generator object <genexpr> at 0x7f6d80711870>
>>>
>>> next(b)
0
>>>
>>> next(b)
1
>>> next(b)
4
>>> next(b)
9
>>> next(b)
16
>>> next(b)
25

生成器  只是给你准备了一个生成算法  需要的时候才生成   从而节省内存，只有在调用的时候才会生成相应数据

只记录当前的位置  只有一个__next__()方法  ,在2.x里是next()

四、斐波拉契数列

def fib(max):
    n,a,b = 0,0,1
    while n < max:
        print(b)
        a,b = b,a + b
        n = n + 1
    return 'done'
fib(7)

只需要把print(b)改为yield b就可以，把fib函数变成generator

def fib(max):
    n,a,b = 0,0,1
    while n < max:
        #print(b)
        yield b
        a,b = b,a + b
        n = n + 1
    return 'done'
f = fib(7)
print(f)
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())

<generator object fib at 0x000001D052442BA0>
1
1
2
3

 如果一个函数定义中包含yield关键字，那么这个函数就是一个generator，每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行

把函数改成generator后，基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代

for i in fib(9):
    print(i)

但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

g = fib(5)
while True:
    try:
        x=next(g)
        print('g:',x)
    except StopIteration as e:
        print('Generator return value:',e.value)
        break

g: 1
g: 1
g: 2
g: 3
g: 5
Generator return value: done

Process finished with exit code 0

五、迭代器

可以直接作用于for循环的数据类型有以下几种：一类是集合数据类型，如list、tuple、dict、set、str等，一类是generator，包括生成器和带yield的generator function。

这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。可以使用isinstance()判断一个对象是否是Iterable对象：

*可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用iter()函数：

isinstance(iter([]), Iterator)
isinstance(iter('abc'), Iterator)

小结

凡是可作用于for循环的对象都是Iterable类型；（可迭代类型）

凡是可作用于next()函数的对象都是Iterator类型，（迭代器类型）它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的，例如：




六、json & pickle 模块