Day04:函数参数、对象、嵌套、闭包函数和装饰器

上节课复习：
    1.什么是函数
        函数就是具备某一功能的工具
    2.为何用函数
        1.程序的组织结构和可读性
        2.减少代码冗余
        3.扩展性强
    3.如何用函数
        函数分为两大类：
            内置函数：len
            自定义函数: 1.有参 2.无参 3.空函数
        语法：
            def函数名（arg1,arg2）
                '''
                注释
                '''
                code1
                code2
                return 返回值
        调用函数： 函数名（1，2，3）
        函数必须遵循：先定义，后调用
        定义阶段：只检测语法，与执行函数体代码
        调用阶段：通过函数名找到函数，然后执行函数整体代码
        函数名：用来访问函数的内存地址，加上括号用来执行函数
        函数参数：是外调用者为函数体传值的媒介
        函数体代码：是函数功能的具体实现
        函数返回值是函数体执行的成果，不写return默认返回None
            1.返回值没有类型限制
            2.返回值没有个数限制
                无return,默认返回None
                return值1：返回1
                return值1，2，3，：返回值（1，2，3）
            return注意点：是函数结束标志，函数体内可以有多个return,但是只要执行一次return,即代表函数结束

今日内容：
1.函数参数的使用
2.函数对象
3.函数嵌套
4.名称空间与作用域
5.闭包函数（2+3+4）
6.装饰器

一.函数参数的类型：
  1.形参与实参
    形参：定义函数时，括号内指定的参数，本质就是调用名
    实参：调用函数时，括号内传入的值
    只有在调用函数时才会在函数体内发生实参（值）与形参（变量名）的绑定关系
    该绑定关系只在调用函数时临时生效，在调用函数结束时解除绑定

 

def foo(x,y): #括号内x,y 为形参
    print(x)
    print(y)
foo(1,2) # 括号内1，2为实参

输出：

1
2

  2.位置参数：
    位置形参：在定义函数时，从左往右的顺序依次定义形参称之为位置形参
        注意：1.但凡是按照位置定义的形参，在调用函数时必须为其传值，多一个少一个都不行
    位置实参：在调用函数时，从左往右的顺序依次传入值称之为位置实参
        注意：1.在传值时按照顺序与形参一一对应

def foo(x,y,z): #括号内x,y,z 为形参
    print(x)
    print(y)
foo(1,2) # 括号内1，2为实参

输出：

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-3-b10bbf76aa4f> in <module>()
2     print(x)
3     print(y)
----> 4 foo(1,2) # 括号内1，2为实参

TypeError: foo() missing 1 required positional argument: 'z'

 3.关键字实参：
    在调用函数时，按照key=value的形式定义的实参，称之为关键字实参
    注意：1.在传值时可以完全打乱顺序，但仍然能指名道姓地指定参数的传值
         2.可以在调用函数时，混用位置实参与关键字实参，但是位置实参必须在关键字实参的左边，并且不能为某个形参重复性传值
       

def foo(x,y): #括号内x,y为形参
    print(x)
    print(y)
foo(y=3,x=2) # 指定关键字实参，可打乱顺序

输出：

2

3

4.默认参数：
        在定义函数时，就已经为某些参数绑定值，称之为默认参数
        注意：
            1.在定义阶段就已经有值，意味在调用阶段可以不用为其传值
            2.默认形参必须放到位置形参的后面
            3.默认形参的值只在定义阶段生效一次
            4.默认形参的值通常应该是不可变类型

def foo(x,y,z=3):
    print(x)
    print(y)
    print(z)
    
foo(1,2)

输出：

1

2

3

    归纳对比：默认形参vs位置形参：
        默认形参：大多数情况值不变
        位置形参：大多数情况值都是不一样的

m=10
def foo(x,y,z=m):
    print('x:%s' %x)
    print('y:%s' %y)
    print('z:%s' %z)
    
m=1111111
foo(1,2)

输出：

x:1
y:2
z:10

def foo(name,hobby,l=[]):
    l.append(hobby)
    print('%s 的爱好是 %s' % (name,l))
    
foo('andy','read')
foo('tom','run')
foo('alex','sing')

输出：

andy 的爱好是 ['read']
tom 的爱好是 ['read', 'run']
alex 的爱好是 ['read', 'run', 'sing']

def foo(name,hobby,l=None):
    if l is None:
        l=[]
    l.append(hobby)
    print('%s 的爱好是 %s' % (name,l))
l1=[]   
foo('andy','read',l1)
foo('andy','music',l1)
foo('andy','run',l1)
l2=[]
foo('lily','run',l2)
l3=[]
foo('alex','sing',l3)

输出：

andy 的爱好是 ['read']
andy 的爱好是 ['read', 'music']
andy 的爱好是 ['read', 'music', 'run']
lily 的爱好是 ['run']
alex 的爱好是 ['sing']

 5.可变长度的参数：
        可变长度指的是在调用函数时，函数参数的个数可以不固定
        然而实参终究是要为形参传值的，针对两种形式实参个数不固定，对应形参也必须要有两种解决方案来分别处理溢出位置实参（*）与溢出的关键字实参(**)

#*会将溢出的位置实参存成元组，然后赋值给紧跟其后的变量名
#1.1 形参中带*
def foo(x,y,*z): #*z=(3,4,5,6,7,8), 
    print(x)
    print(y)
    print(z)
foo(1,2,3,4,5,6,7,8)

输出：

1
2
(3, 4, 5, 6, 7, 8)
1
2
('h', 'e', 'l', 'l', 'o')
h
e
('l', 'l', 'o')

#1.3 实参中带*, 窍门：但凡碰到实参中带*，都先将其打散成位置实参，然后再考虑传值
def foo(x,y,z):  
    print(x,y,z)
l=['alex','tom','andy']
foo(*l)   #*后被打散

输出：

alex tom andy

#1.1 形参中带**
#**会将溢出的关键字实参存成字典，然后赋值给紧跟其后的变量名

def foo(x,y,m,n,**z): #**z={'a': 1, 'b': 2, 'c': 3}, 
    print(x)
    print(y)
    print(m)
    print(n)
    print(z)
foo(1,2,n=10,m=20,a=1,b=2,c=3)

输出：

1
2
20
10
{'a': 1, 'b': 2, 'c': 3}

#1.2 形参中带**，实参中带**
#**会将溢出的关键字实参存成字典，然后赋值给紧跟其后的变量名
#窍门：但凡在实参中带**，都将其打散称关键字实参，然后考虑传值

def foo(x,y,m,n,**z): #**z={'a': 1, 'b': 2, 'c': 3}, 
    print(x)
    print(y)
    print(m)
    print(n)
    print(z)
foo(1,2,n=10,m=20,**{'a':1,'b':2,'c':3})

输出：

1
2
20
10
{'a': 1, 'b': 2, 'c': 3}

def foo(x,y,m,n,**z): #**z={'a': 1, 'b': 2, 'c': 3}, 
    print(x)
    print(y)
    print(m)
    print(n)
    print(z)
foo(1,n=10,m=20,**{'a':1,'b':2,'c':3,'y':111})

输出：

1
111
20
10
{'a': 1, 'b': 2, 'c': 3}

#1.3 实参中带**
def foo(x,y,z): #**z={'a': 1, 'b': 2, 'c': 3}, 
    print(x)
    print(y)
    print(z)
foo(**{'x':1,'y':1,'z':2})

输出：

1
1
2

#如果需要将外层的函数的参数格式原封不动地转嫁给内部调用的函数，就需要用到下述方法：
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(1,2,3,a=10,b=20,c=30)

输出：

(1, 2, 3) {'a': 10, 'b': 20, 'c': 30}

 

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-31-02b3f05d6305> in <module>()
      5     print(args,kwargs)
      6     index(*args,**kwargs)
----> 7 wrapper(1,2,3,a=10,b=20,c=30)

<ipython-input-31-02b3f05d6305> in wrapper(*args, **kwargs)
      4 def wrapper(*args,**kwargs): #args=(1,2,3),kwargs={'a': 10, 'b': 20, 'c': 30}
      5     print(args,kwargs)
----> 6     index(*args,**kwargs)
      7 wrapper(1,2,3,a=10,b=20,c=30)

TypeError: index() got an unexpected keyword argument 'a'

#如果需要将外层的函数的参数格式原封不动地转嫁给内部调用的函数，就需要用到下述方法：
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)

输出：

('andy',) {'sex': 'male', 'age': 18}
name:andy age:18 sex:male

#命名关键字参数（了解）：但凡在*后**之前定义的参数称之为命名关键字参数
#注意点：
#在调用函数时，传值的形式必须是key=value
def foo(x,y,*,m=1,n):
    print(x,y,m,n)
foo(1,2,n=3,m=4)

输出：

1 2 4 3

#函数是第一类对象，意味着函数可以当作变量去使用
#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]()

输出：

[<function f1 at 0x000001ED436887B8>, <function f2 at 0x000001ED43688620>]
from f2

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={
    '1':pay,
    '2':withdraw,
    '3':auth,
    '4':shopping,
    '5':transfer
}
while True:
    print("""
    0 退出
    1 支付
    2 取款
    3 认证
    4 购物
    5 转账
    """)
    choice=input('请输入您要执行的操作：').strip() #choice='123'
    if choice == '0':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))

1.名称空间与作用域：namespaces
    名称空间是存放名字与值绑定关系的地方
    要取到值必须通过名字才能找，而名字又在名称空间中放着，所以在取值时需要先到名称空间中找到名字自然就拿到值的内存地址了
2.名称空间分为三种：
    a.内置名称空间：存放python解释器自带的名字，生命周期：在解释器启动时产生，关闭时回收
    b.全局名称空间：除了内置的与局部的之外的名字都属于全局名称空间，生命周期：在程序文件执行时就立刻产生，程序执行完毕后就回收
    c.局部名称空间：存放的时函数内部定义的名字，生命周期：在调用函数时临时生效，在调用函数结束时立刻回收
   
    加载顺序：内置名称空间--》全局名称空间--》局部名称空间
    加载名称空间的目的：为了将名字与值的绑定关系存放起来，而存的目的时为了取，也就是说，当我们在查找名字时，必然时在三者其一中查找
    查找顺序：局部名称空间--》全局名称空间--》内置名称空间
    基于当前所在位置往后查找

x=100
y=200
#强调，函数的形参名属于局部名称空间
def foo(x,y):
    print(x,y)
foo(1,2)

def f1():
    x=1
    def f2():
        print('from f2')
f1()

  4.作用域
       作用域指的是作用范围
       分为：
       全局作用范围：包含内置名称空间与全局名称空间中的名字
              特点：全局有效
       局部作用范围：包含的局部名称空间的名字
              特点：局部有效，临时存活

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

 

 

函数的作用域关系是在函数定义阶段就已经固定死的
#闭包函数
1.闭指的是-》定义在函数的内部函数
2.包指的是-》该内部函数包含对其外层作用域名字的引用
闭包函数通常需要结合函数对象的概念，将闭包函数返回到外部使用

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

装饰器：
    装饰指的是为被装饰对象添加新的功能
    器指的是工具
    装饰器本身可以任意可调用的对象，被装饰的对象也可以是任意可调用的对象
    目标：
        写一个函数用来为另一个函数添加新功能，需要遵循开放封闭原则（对修改时封闭的，对扩展时封闭的）
        1.不修改被装饰对象的源代码
        2.不修改被装饰对象的调用方式

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)