python 小白成长周记三 内置函数，装饰器 之（函数即变量，高阶函数，嵌套函数，） 生成器，迭代器

装饰器：本质是函数 

定义：本质是用来装饰的（装饰其他函数）就是为其他函数添加附加功能

原则：1.不能修改被装饰的函数的源代码

      2.不能修改被装饰的函数的调用方式

实现装饰器知识储备：

1函数即“变量”

2高阶函数

       a:把一个函数名当做一个实参传给另一个函数（在不修改被装饰函数源代码的轻快下为其添加功能）

       b：返回值中包含函数名（不修改函数的调用方式）

       满足任一条件就可以叫做高阶函数

3.嵌套函数

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

#函数即变量

#示范一：
def foo():
    print('in the foo')
foo()

#示范二：
def bar():
    print('in the bar')
def foo():
    print('in the foo')
    bar()
foo()

#示范三：
def foo():
    print('in the foo')
    bar()
def bar():
    print('in the bar')
foo()

#示范四：
def foo():
    print('in the foo')
    bar()
foo()
def bar():
    print('in the bar')

有的函数可以不用起名字  比如lambda（匿名函数）

以下代码是高阶函数的a

import time

def bar():
    time.sleep(3)
    print('in the bar')
def test(name):
    start_time=time.time()
    name()#run bar
    stop_time=time.time()
    print('the name run time%s'%(stop_time -start_time ))

test(bar)

以下代码是高阶函数的b

import time
def bar():
    time.sleep(3)
    print('in the bar')
def test2(func):
    print(func)
    return func
#print(test2(bar))
bar=test2(bar)
bar()  #run bar 

import time
def  deco(func):
    start_time=time.time()
    func()#test1/test2传到这里然后去找def test1（）/test2（）
    stop_time=time.time()
    print('the time is %s'%(stop_time-start_time)  )#注意这里的%要用（）括起来 str
def test1():
    time.sleep(1)
    print('in the 1')
def test2():
    time.sleep(2)
    print('in the test2')
deco(test1)
deco(test2)

生成器：只有在调用的时候才会生成相应的数据  省内存空间   只记住当前位置   缺点 ：生成器只能按顺序依次进行运行  无法单独调用某一个值  所以什么切片啊 等等都无法使用   只能一个一个的向下取值  ._ _next_ _()取下一个的值     记住没法向上取值

斐波那契：0,1,1,2,3,5,8,13,21...

def flb(max):
    n,a,b=0,0,1
    while n<max:
        print(b)
        a,b=b,a+b#相当于a=b,b=a+b
        n=n+1
    return 0
flb(100)

以上是斐波那契  以下是用函数做的生成器表示的斐波那契（有yield就是生成器）

def flb(max):
    n,a,b=0,0,1
    while n<max:
        yield b#函数中要用yield 生成器 英文意思是产量
        a,b=b,a+b#相当于a=b,b=a+b
        n=n+1
    return 'hao'
f=(flb(10))
print(f.__next__() )
print(f.__next__() )
print(f.__next__() )
print(f.__next__() )#不能超过总量 否则会报错
print('=====!=====')
for i in f:
    print(i)

单线程下的并行效果：

import time
def consumer(name):#英文意思是消费者
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield
       print("包子[%s]来了,被[%s]吃了!" %(baozi,name))
c = consumer("ChenRonghua")
c.__next__()

# b1= "韭菜馅"
# c.send(b1)#新语法 发送 把b1发送进去 被yield接受 把b1（韭菜馅）传值
# c.__next__()

def producer(name):#英文意思是生产者
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("老子开始准备做包子啦!")
    for i in range(3):
        time.sleep(1)
        print("做了1个包子,分两半!")
        c.send(i)
        c2.send(i)
producer("hanbinlong")

迭代器：可以作用于for循环的对象称为可迭代对象

可以使用isinstance()判断一个对象是否是Iterator对象：

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

生成器一定是迭代器 但是反之不一定

>>> from collections import Iterator#导入Iterator

>>> isinstance((),Iterator#判断（）是不是迭代器

list,dict,str 等Iterable变成Iterator可以使用iter（）函数

inter（要变成迭代器）

小结

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

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

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

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

金角大王的博客！！！！这是一个链接