#如果需要将外层的函数的参数格式原封不动地转嫁给内部调用的函数，就需要用到下述方法：

 def index(name,age,sex):

     print('name:%s age:%s sex:%s' %(name,age,sex))

 def wrapper(*args,**kwargs): #args=(1,2,3),kwargs={'a': 10, 'b': 20, 'c': 30}

     print(args,kwargs)

     index(*args,**kwargs) #index(*(1,2,3),**{'a': 10, 'b': 20, 'c': 30}

 #我们虽然调用的是wrapper函数，但是我们遵循的其实是index函数的参数规则

 wrapper('andy',sex='male',age=18)

 #命名关键字参数（了解）：但凡在*后**之前定义的参数称之为命名关键字参数

 #注意点：

 #在调用函数时，传值的形式必须是key=value

 def foo(x,y,*,m=1,n):

     print(x,y,m,n)

 foo(1,2,n=3,m=4)

 #函数是第一类对象，意味着函数可以当作变量去使用

 #3.可以当作函数的返回值

 def bar():

     return foo

 f=bar()

 #4.可以当作容器类型的元素

 def f1():

     print('from f1')

 def f2():

     print('from f2')

 l=[f1,f2]

 print(l)

 l[1]()

 def pay():

     print('pay function')

 def withdraw():

     print('withdraw function')

 def auth():

     print('auth function')

 def shopping():

     print('shopping function')

 def transfer():

     print('transfer function')

 func_dic={

     '':pay,

     '':withdraw,

     '':auth,

     '':shopping,

     '':transfer

 }

 while True:

     print("""

     0 退出

     1 支付

     2 取款

     3 认证

     4 购物

     5 转账

     """)

     choice=input('请输入您要执行的操作：').strip() #choice='123'

     if choice == '':break

     if choice not in func_dic:

         print('输入错误的指令，请重新输入')

         continue

     func_dic[choice]() #

 #函数的嵌套调用：在调用一个函数时，其内部代码又调用其他函数

 def bar():

     print('from bar')

 def foo()：

     print('from foo')

     bar()

 foo()

 def mar2(x,y):

     if x>y:

         return x

     else:

         return y

 def max4(a,b,c,d):

     res1=max2(a,b)

     res2=max2(res1,c)

     res3=max2(res2,d)

     return res3

 print (max4(1,2,3,4))

 x=100

 y=200

 #强调，函数的形参名属于局部名称空间

 def foo(x,y):

     print(x,y)

 foo(1,2)

 def f1():

     x=1

     def f2():

         print('from f2')

 f1()

 x=11111

 def foo():

     y=2

 print(globals()) #返回的是全局作用域中的名字

 print(dir(globals)['__builtins__']) #返回的是全局作用域中的内置名称空间的名字

 print(locals() is globals())

 foo()

 #函数的作用域关系在函数定义阶段就已经固定，与函数的调用位置无关

 #即在调用函数时一定要跑到定义函数的位置寻找作用域关系

 x=222# 3.找全局函数

 def outter():

     x=111 #2.找外部函数

     def inner():

         x=0 #1.先找函数体内部

         print('from inner %s' %x)

     return inner

 x=333 #4.找全局函数

 f=outter() #f=指向outter.locals.inner

 print(f)

 def foo():

     x=444

     f()

 foo()#返回000,只看定义函数的位置找

 #global 名字声明时来自于全局的

 x=1

 def func():

     global x

     x=2

 func()

 print(x)

 #nonlocal 声明变量时来自于当前外层的，必须是在函数内

 x=222

 def f1():

     def f2()：

         nonlocal x

         x=0

     f2()

     print('f1-->',x)

 f1()

 print(x

 def outter():

     x=100

     def inner():

         print(x)

     return inner()

 f=outter()

 #x=200

 #f()

 def foo():

     x=300

     def bar():

         x=400

     bar()

 foo()

 x=1

 y=1

 def outer(x,y):

     def sum():

         res=x+y

         return res

     return sum

 f=outer(1,2)

 f()

 #闭包函数范例

 import requests

 def outter(url):

     def get():

         response=requests.get(url)

         print(len(response.text))

     return get

 jd=outter('https://www.jd.com')

 jd()

 baidu=outter('https://www.baidu.com')

 baidu()

 import time

 def index():

     time.sleep(3)

     print('welcome to index page')

 def home(name):

     time.sleep(3)

     print('welcome to index page %s' %name)

 def outer(func): #func=最原始的index

     def timer(*args,**kwargs):

         start=time.time()

         func(*args,**kwargs) #最原始的index()

         stop=time.time()

         print('run time is %s' %(stop-start))

     return timer

 #f=outer(index)

 #f()

 index=outer(index)

 home=outer(home)

 index()

 home('alex')

 #装饰器的语法糖：在被装饰对象正上方单独一行写上@装饰器名字

 import time

 def index():

     time.sleep(3)

     print('welcome to index page')

 def home(name):

     time.sleep(3)

     print('welcome to index page %s' %name)

 def timer(func): #func=最原始的index

     def wrapper(*args,**kwargs):

         start=time.time()

         res=func(*args,**kwargs) #最原始的index()

         stop=time.time()

         print('run time is %s' %(stop-start))

         return res

     return wrapper

 #f=outer(index)

 #f()

 res=index()

 print(res)