day 012总结

昨日回顾

可变长参数

*

*形参：接收多余的位置实参

*实参（可迭代数据类型）：打散可迭代数据类型

**

**形参：接收多余的关键字实参

**实参：打散字典，当作关键字实参传参

def f1(*args,**kwargs)

函数对象

1. 引用
2. 作为容器类元素
3. 作为函数返回值
4. 作为函数参数

函数嵌套

def f1():
    def f2():
        pass

f2() # 报错

名称空间和作用域

1. 内置名称空间：内置方法
2. 全局名称空间：除了内置和局部就是全局
3. 局部名称空间：函数内部的变量和函数

执行顺序：内置 --》 全局 --》 局部

搜索顺序：从当前开始 局部 --》 全局 --》 内置

全局作用作用域和局部作用域没有半毛钱关系

局部作用域1和局部作用域2没有半毛钱关系

x = 10
def f1():
    x = 20
    def f2():
        x = 3
    
def f2():
    x = 5

f1()
print(x) # 10

今日内容

闭包函数

def f1(url):#f1就叫闭包函数
    def spider():
        print(url)
    rerurn spider# 函数对象
taoao=f1('www.taobao.com')
taobao()
baidu=f1('www.baidu.com')
baidu()

闭包函数：闭包函数 把闭包函数内部的变量+闭包函数内部的函数 这两者包裹在一起 然后通过返回值的形式返回出来

闭包函数至少要符合函数嵌套

装饰器

装饰器的本质就是一个 给函数增加功能的函数

装饰器给 函数 增加功能时需要注意一下两点：

1.不改变原函数的源代码

2.不改变原函数的调用方式

import time
def index():
    '''被装饰的函数'''
    print('index')
    time.sleep(1)
    
# time_count装饰器：对被装饰函数计时
def time_count(func):
    def wrapper():
        s=time.time
        func()
        e=time.time
        print(e-s)
     return wrapper

index=time_count(index)
index()

带返回值

import time
def index():
    '''被装饰的函数'''
    print('index')
    time.sleep(1)
    return 'index'
    
# time_count装饰器：对被装饰函数计时
def time_count(func):
    def wrapper():
        s=time.time
        res=func()
        e=time.time
        print(e-s)
        return res
     return wrapper

index=time_count(index)
res=index()
print(res)

加参数

import time
def index(x,y,z=10):
    '''被装饰的函数'''
    print('index')
    time.sleep(1)
    return 'index'
    
# time_count装饰器：对被装饰函数计时
def time_count(func):
    def wrapper(*args,**kwargs):
        s=time.time
        res=func(*args,**kwargs)
        e=time.time
        print(e-s)
        return res
     return wrapper

index=time_count(index)
res=index(10,20)
print(res)

装饰器模板

def deco(func):
    def wrapper(*args,**kwargs):
        '''加功能'''
        res=func(*args,**kwargs)
        return res
    return wrapper

语法糖

让代码变得更简单

import time

# time_count装饰器：对被装饰函数计时
def time_count(func):
    def wrapper(*args,**kwargs):
        s=time.time
        res=func(*args,**kwargs)
        e=time.time
        print(e-s)
        return res
     return wrapper
    
@time_count()
def index(x,y,z=10):
    '''被装饰的函数'''
    print('index')
    time.sleep(1)
    return 'index'

三层装饰器

由于两层的装饰器，参数必须得固定位func，但是三层的装饰器解除了这个限制。我们不仅仅可以使用上述单个参数的三层装饰器，多个参数的只需要在三层装饰器中多加入几个参数即可。也就是说装饰器三层即可，多加一层反倒无用

迭代器

可迭代对象：含有__item__方法的就叫做可迭代对象

迭代器：含有__item__和__next__方法的叫做迭代器

生成器：含有yield关键字的函数叫做生成器

转载于:https://www.cnblogs.com/zqfzqf/p/11575185.html