函数运用

Posted 2020-12-05 vxiaog

主要内容：

• 一 函数对象
• 二 函数嵌套
• 三 名称空间与作用域
• 四 闭包函数
• 五 装饰器

 

一 函数对象

　　函数是第一类对像（对象的概念后面会细讲），即函数可以当做数据传递

#1 可以被引用
#2 可以当作参数传递
#3 返回值可以是函数
#3 可以当作容器类型的元素
实际函数名就是一个变量名，函数也是变量，只不过赋值为一个函数体的内存地址而已

　　运用试列如下：

def foo():
    print(‘foo‘)

def bar():
    print(‘bar‘)

dic={
    ‘foo‘:foo,
    ‘bar‘:bar,
}
while True:
    choice=input(‘>>: ‘).strip()
    if choice in dic:
        dic[choice]()

　　二 函数嵌套

　　　函数嵌套，顾名思义从字面意思了解，就是在函数外面包裹一层东西，实际就是一个函数里面调用其他函数执行数据处理，

　　　这样可以减少我们的代码重复性，使程序结构更清晰。

#列如比较两个数的大写
def max(x,y):
    return x if x > y else y

#但比较多个数的大小，按照原始的方式，步骤太过繁琐，我们可以直接在这个函数中嵌套使用max函数，简化程序。

def max4(a,b,c,d):
    res1=max(a,b)
    res2=max(res1,c)
    res3=max(res2,d)
    return res3
print(max4(1,2,3,4))



#函数嵌套的定义方式：

def f1():
    def f2():
        def f3():
            print(‘from f3‘)
        f3()
    f2()

f1()

　　三 名称空间和作用域

　　　1. 什么是名称空间

名称空间是存放变量名和变量值内存地址映射关系的一个内存空间，比如x=1中，x实际在内存中与1的内存地址在名称空间里面以键值对的形式建立了映射关系。

名称空间分类：
内置名称空间：顾名思义，内置名称空间是为放置内置变量名跟变量值内存地址映射关系的内存空间。
全局名称空间：自己定义生效的，在程序全局范围内的变量名跟变量值内存地址映射关系的内存空间。
局部名称空间：在局部，比如函数体内等等定义的变量，而局部名称空间就是存放这些变量的变量名跟变量值内存地址映射关系的内存空间。

　　　　2. 名称空间的加载顺序：

python test.py
#1、python解释器先启动，因而首先加载的是：内置名称空间，在解释器启动后就一直存在，在解释器关闭之后才会释放掉空间
#2、执行test.py文件，然后以文件为基础，加载全局名称空间，在程序结束时就会被释放掉
#3、在执行文件的过程中如果调用函数，则临时产生局部名称空间，在函数调用结束时就会被释放掉

　　　　3. 名称的查看顺序：

当前位置局部名称空间--->全局名称空间--->内置名称空间

#需要注意的是：在全局无法查看局部的，在局部可以查看全局的，如下示例

# max=1
def f1():
    # max=2
    def f2():
        # max=3
        print(max)
    f2()
f1()
print(max)

　　　　4. 作用域

#1、作用域即范围
        - 全局范围（内置名称空间与全局名称空间属于该范围）：全局存活，全局有效
　     - 局部范围（局部名称空间属于该范围）：临时存活，局部有效
#2、作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关，如下
x=1
def f1():
    def f2():
        print(x)
    return f2
x=100
def f3(func):
    x=2
    func()
x=10000
f3(f1())

#3、查看作用域：globals(),locals()


LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__
locals 是函数内的名字空间，包括局部变量和形参
enclosing 外部嵌套函数的名字空间（闭包中常见）
globals 全局变量，函数定义所在模块的名字空间
builtins 内置模块的名字空间

　　　　5. global与nonlocal关键字

　　四 闭包函数

　　　　1. 什么是闭包

#内部函数包含对外部作用域而非全局作用域的引用

#提示：之前我们都是通过参数将外部的值传给函数，闭包提供了另外一种思路，用外部作用域将函数抱起来，函数可以引用外部作用域的变量等，可以达到传参的效果。

        def counter():
            n=0
            def incr():
                nonlocal n
                x=n
                n+=1
                return x
            return incr

        c=counter()
        print(c())
        print(c())
        print(c())
        print(c.__closure__[0].cell_contents) #查看闭包的元素

　　　　2.闭包的作用和意义

#闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
#应用领域：延迟计算（原来我们是传参，现在我们使用一个作用域将函数包起来）
    from urllib.request import urlopen

    def index(url):
        def get():
            return urlopen(url).read()
        return get

    baidu=index(‘http://www.baidu.com‘)
    print(baidu().decode(‘utf-8‘))

　　　五 装饰器

　　　　装饰器是闭包的一种高级用法

　　　　1.为什么要使用装饰器：

#开放封闭原则：对修改封闭，对扩展开放
既在不更改函数名称，函数体代码和函数调用方式的情况下，更改函数的功能或添加新的功能。

　　　　　2. 什么是装饰器

#字面意思理解就是用来装饰的，装饰函数，变更函数的作用或者添加新的功能。
装饰器他人的器具，本身可以是任意可调用对象，被装饰者也可以是任意可调用对象。
强调装饰器的原则：1 不修改被装饰对象的源代码 2 不修改被装饰对象的调用方式
装饰器的目标：在遵循1和2的前提下，为被装饰对象添加上新功能

　　　　3. 装饰器的语法

被装饰函数的正上方，单独一行
        @deco1
        @deco2
        @deco3
        def foo():
            pass

        foo=deco1(deco2(deco3(foo)))

　　　　4.装饰器的使用：

 1 import time
 2 def timmer(func):
 3     def wrapper(*args,**kwargs):
 4         start_time=time.time()
 5         res=func(*args,**kwargs)
 6         stop_time=time.time()
 7         print(‘run time is %s‘ %(stop_time-start_time))
 8         return res
 9     return wrapper
10 
11 @timmer
12 def foo():
13     time.sleep(3)
14     print(‘from foo‘)
15 foo()

无参装饰器

 1 def auth(driver=‘file‘):
 2     def auth2(func):
 3         def wrapper(*args,**kwargs):
 4             name=input("user: ")
 5             pwd=input("pwd: ")
 6 
 7             if driver == ‘file‘:
 8                 if name == ‘egon‘ and pwd == ‘123‘:
 9                     print(‘login successful‘)
10                     res=func(*args,**kwargs)
11                     return res
12             elif driver == ‘ldap‘:
13                 print(‘ldap‘)
14         return wrapper
15     return auth2
16 
17 @auth(driver=‘file‘)
18 def foo(name):
19     print(name)
20 
21 foo(‘egon‘)

有参装饰器

　　　　5. 装饰器的补充：wraps

from functools import wraps

def deco(func):
    @wraps(func) #加在最内层函数正上方
    def wrapper(*args,**kwargs):
        return func(*args,**kwargs)
    return wrapper

@deco
def index():
    ‘‘‘哈哈哈哈‘‘‘
    print(‘from index‘)

print(index.__doc__)