(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 模块