python入门之函数调用第二关_Python入门之函数对象、函数嵌套、名称空间与作用域、装饰器...

一 函数对象

1. 函数是第一类对象，即函数可以当作数据传递

1 可以被引用

2 可以当作参数传递

3 返回值可以是函数

3 可以当作容器类型的元素

2.利用该特性，优雅的取代多分支的if

def foo():

print('foo')

def bar():

print('bar')

dic={

'foo':foo,

'bar':bar,

}

while True:

choice=input('>>: ').strip()

if choice in dic:

dic[choice]()

二 函数嵌套

1.函数的嵌套调用

def max(x,y):

return x if x > y else y

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))

2. 函数的嵌套定义

def f1():

def f2():

def f3():

print('from f3')

f3()

f2()

f1()

f3() #报错，为何？请看下一小节

三 名称空间与作用域

1.什么是名称空间？

名称空间：存放名字的地方，三种名称空间，（之前遗留的问题x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字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.装饰器的使用

无参数装饰器：

import time

def timmer(func):

def wrapper(*args,**kwargs):

start_time=time.time()

res=func(*args,**kwargs)

stop_time=time.time()

print('run time is %s' %(stop_time-start_time))

return res

return wrapper

@timmer

def foo():

time.sleep(3)

print('from foo')

foo()

有参数装饰器：

def auth(driver='file'):

def auth2(func):

def wrapper(*args,**kwargs):

name=input("user: ")

pwd=input("pwd: ")

if driver == 'file':

if name == 'egon' and pwd == '123':

print('login successful')

res=func(*args,**kwargs)

return res

elif driver == 'ldap':

print('ldap')

return wrapper

return auth2

@auth(driver='file')

def foo(name):

print(name)

foo('egon')

4. 装饰器语法

被装饰函数的正上方，单独一行

@deco1

@deco2

@deco3

def foo():

pass

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

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__)

6.叠加多个装饰器

叠加多个装饰器

1. 加载顺序(outter函数的调用顺序):自下而上

2. 执行顺序(wrapper函数的执行顺序):自上而下

示范代码：

def outter1(func1): #func1=wrapper2的内存地址

print('加载了outter1')

def wrapper1(*args,**kwargs):

print('执行了wrapper1')

res1=func1(*args,**kwargs)

return res1

return wrapper1

def outter2(func2): #func2=wrapper3的内存地址

print('加载了outter2')

def wrapper2(*args,**kwargs):

print('执行了wrapper2')

res2=func2(*args,**kwargs)

return res2

return wrapper2

def outter3(func3): # func3=最原始的那个index的内存地址

print('加载了outter3')

def wrapper3(*args,**kwargs):

print('执行了wrapper3')

res3=func3(*args,**kwargs)

return res3

return wrapper3

@outter1 # outter1(wrapper2的内存地址)======>index=wrapper1的内存地址

@outter2 # outter2(wrapper3的内存地址)======>wrapper2的内存地址

@outter3 # outter3(最原始的那个index的内存地址)===>wrapper3的内存地址

def index():

print('from index')