函数二

1、函数的参数分为形参与实参。

　　1).形参指的是在定义函数时，括号内定义的参数。

　　def foo（x，y）#x，y就是形参   相当于定义变量名。

　　　　if  x>y:

　　　　print(x)

　　　　else:

　　　　print(y)　　

2).实参指的是在调用函数是括号内传入的值。

def foo(10,1)  #10，1就是实参。相当于变量的值。

另外：实参值与形参的绑定关系在函数调用时生效，运行结束后关系立刻解除。

2、位置参数：就是指从左到右依次定义的函数参数。

       1）位置形参：再定义函数按位置定义的形参，在调用函数时必须为其传值，而且多一个不行，少一个也不行。：

def foo(x,y,z):

　　print(x,y,z)

　　2)位置实参：在调用函数时按照位置传入的实参，位置实参会与形参 一 一对应。

foo(1,3,2)

3、关键字参数：

　　定义：在调用函数时按照 key=value的形式定义的参数，相当与指名道姓为形参绑定位置，意味着即使不按照顺序定义仍然能为指定的参数传值。

　　def foo（x，y）

       foo（x=0，y=1）

需要注意的是在调用函数时位置实参可以与关键字实参可以同时使用，但是要遵循形参的规则。

不能为同一个参数重复传值。

位置参数必须放在关键字参数前面。

4、默认参数

　　定义：在定义参数时已经为某个形参赋值，意味着调用阶段可以不用传值。

ef register(name,age,sex='male'):
print(name,age,sex)


register('egon',18,)
register('alex',73,'female')
register('wxx',84,)
register('xxx',84)
register('yy',84)

　　位置形参必须在默认参数前面。

　　默认参数的值只在定义阶段赋值一次,也就是说默认参数的值再定义阶段就固定死了

　   默认参数的值应该设置为不可变类型

应用

对于经常需要变化的值,需要将对应的形参定义成位置形参

对于大多数情况值都一样的情况,需要将对应的形参定义成默认形参

5、可变长度参数

　　什么是可变长度参数：

　　（可变长度指的参数的个数可以不固定,实参有按位置定义的实参和按关键字定义的实参,

　　所以可变长的实参指的就是按照这两种形式定义的实参个数可以不固定,

　　然而实参终究是要给形参传值的

　　所以形参必须有两种对应的解决方案来分别处理以上两种形式可变长度的实参）

　　形参:

*
**

*会将实参溢出的位置实参全部接收，然后保存成元组然后赋值给args（可以用彼得名字但是这是约定成俗的）

　　       ** 会将益处的关键字参数全部接收，然后保存成字典的形式赋值给kwags

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　示例：：

==========================形参里包含*与**

#*会将溢出的位置实参全部接收,然后保存成元组的形式赋值给args
# def foo(x,y,z,*args): #args=(4,5,6,7,8)
# print(x,y,z)
# print(args)
#
# foo(1,2,3,4,5,6,7,8,)


#**会将溢出的关键字实参全部接收,然后保存成字典的形式赋值给kwargs
# def foo(x,y,z,**kwargs): # kwargs={'c':3,'a':1,'b':2}
# print(x,y,z)
# print(kwargs)
#
# foo(x=1,y=2,z=3,a=1,b=2,c=3)
#





#==========================实参里包含*与**
# 一旦碰到实参加*,就把该实参的值打散
# def foo(x,y,z,*args): #args=([4,5,6,7,8],)
# print(x,y,z)
# print(args)
#
# foo(1,2,3,*[4,5,6,7,8]) #foo(1,2,3,4,5,6,7,8)
# foo(1,2,3,*(4,5,6,7,8)) #foo(1,2,3,4,5,6,7,8)
# foo(1,2,3,*'hello') #foo(1,2,3,'h','e','l','l','o')
#

#
# def foo(x,y,z):
# print(x,y,z)

# foo(*[1,2,3]) #foo(1,2,3)
# foo(*[1,2,3,4]) #foo(1,2,3,4) #报错
# foo(*[1,2,]) #foo(1,2,) #报错


# 一旦碰到实参加**,就把该实参的值打散
# def foo(x,y,z,**kwargs):
# print(x,y,z)
# print(kwargs)
#
# foo(1,2,3,**{'a':1,'b':2}) #foo(1,2,3,b=2,a=1)


# def foo(x,y,z):
# print(x,y,z)

# foo(1,**{'z':3,'y':2}) #foo(1,z=3,y=2)
# foo(1,**{'z':3,'y':2,'x':111}) #foo(1,z=3,y=2,x=111)




# 组合使用
def index(name,age,gender):
print('welcome %s %s %s' %(name,age,gender))

def wrapper(*args,**kwargs): #args=(1,2,3),kwargs={'x':1,'y':2,'z':3}
# print(args)
# print(kwargs)
index(*args,**kwargs) # index(*(1,2,3),**{'x':1,'y':2,'z':3}) # index(1,2,3,z=3,y=2,x=2)

# wrapper(1,2,3,x=1,y=2,z=3)

# wrapper(name='egon',age=18,gender='male')
wrapper('egon',age=18,gender='male')
wrapper('egon',18,gender='male')
wrapper('egon',18,'male')

命名关键字参数：

什么是命名关键字参数？

格式：在*后面参数都是命名关键字参数
特点：
1 必须被传值
1 约束函数的调用者必须按照key=value的形式传值
#2 约束函数的调用者必须用我们指定的key名

函数嵌套：在函数中调出了其他函数。

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

# def foo(y=1,x):
#     pass

def auth(*args,name,pwd):
    print(name,pwd)

#
# auth(pwd='213',name='egon'
函数的嵌套：
1、函数嵌套调用，在函数中调出了其他函数。

def max2(x,y):
    if x > y:
        return x
    else:
        return y

def max3(x,y,z):
    res1=max2(x,y)
    res2=max2(res1,z)
    return res2

print(max3(11,199,2))

函数嵌套定义：在函数内又调用其他函数。

def func1():
    print('from func1')
    def func2(): #func2=内存地址
         print('from func2')

    print(func2) #<function func1.<locals>.func2 at 0x0000024907A098C8>
    func2()
    func2()
    func2()
    func1()

名称空间：存放名字与值绑定关系的地方。
名称空间分类：
1、内置名称空间
存放在python解释器自带的名字，在解释器程序启动时生效，关闭时则失效。
2、全局名称空间
文件级别的名字在执行文件时生效，在文件结束时或在文件运行期间被删除则失效。
3、局部名称空间：
存放函数内定义的名字，（函数的参数与函数内地名字都存放在局部名称空间，只在函数调用时生效。
加载顺序：内置名称--全局---局部
查找顺序：局部---全局--内置。
作用域：
1、全局作用域
包含内置空间名称，全局空间名称，在任何位置都能够访问到。该范围的名字会伴随程序整个生命周期
1、局部作用域：
包含的是局部名称空间的名字。
特点：只能在函数内使用，在调用函数时生效，调用结束失效。
函数对象：
可以被引用；

# def bar():
#     print('from bar')
#
# f=bar
# f()

可以当作参数传入

# x=1
# def func(a):
#     print(a)
#
# func(x)

# def bar():
#     print('from bar')
#
# def wrapper(func): #func=bar
#     func() #bar()
#
# wrapper(bar)

可以当作函数的返回值

# x=1
# def foo():
#     return x
#
# res=foo()
# print(res)



# def bar():
#     print('from bar')
#
# def foo(func): #func=<function bar at 0x00000225AF631E18>
#     return func #return <function bar at 0x00000225AF631E18>
#
#
# # print(bar)
# f=foo(bar) #f=<function bar at 0x00000225AF631E18>
# # print(f)
# f()

可以当作容器

# x=1
# l=[x,]
#
# print(l)

# def get():
#     print('from get')
#
# def put():
#     print('from put')
#
# l=[get,put]
#
# # print(l)
# l[0]()

# def auth():
#     print("登陆")
# def reigster():
#     print('注册')
# def transfer():
#     print('转账')
# dic={'1':auth,
#      '2':reigster,
#      '3':transfer}
# def interactive():
#     while True:
#
#         print('''
#         1 登陆
#         2 注册
#         3 转账''')
#         choice=input('>>')
#         if choice in dic:
#             dic[choice]()
#         else:
#             print('非法输入')
# interactive()

闭包函数：
是指定义在函数内部的函数，并且该函数包含对外部函数作用域中的名字引用。
作用域关系在函数定义阶段就定义死了，与位置无关。

def  outter():
#     x=2
#     def inner():
#         print('from, inner',x)
#     return inner
# f=outter()
# #
# def foo():
#     print('我是全世界最帅的人！！！！')
#     x=12321312312
#     f()
# foo()