形参与实参 和 名称空间

1.形参与实参的介绍

形参：在定义函数阶段定义的参数称之为形式参数（相当于变量名）
def func（x，y）： #x=1  y=2
    print（x,y）
实参：在调用函数阶段传入的值，（相当于变量名）
func（1,2）

形参与实参的关系：
1.在调用阶段，实参（变量值）会绑定给形参（变量名）
2.这种绑定关系只能在函数体内使用
3.实参与形参的绑定关系在函数调用时生效，函数调用结束后解除绑定关系

2.形参与实参的具体使用

2.1 位置参数：按照从左到右的顺序依次定义的参数称之为位置参数
位置形参：按照从左到右的顺序直接定义的‘变量名’
                特点：必须被传值，多一个不行少一个不行
def func（x,y）：
    print(x,y)
位置实参：按照从左到右的顺序依次传入的值
                特点：按照顺序与形参一一对应
func(1,2)  #x=1,y=2

2.2关键字参数
关键字实参：在函数调用阶段，按照key=value的形式传入值
        特点：指名道姓给某个形参传值，可完全不按照顺序
def func（x,y）:
    print(x,y)   #func(y=2,x=1)

混合使用，强调：
1.位置实参必须放在关键字实参前  #func（1，y=2）
2.不能为同一个形参重复传值  #func（1，y=2，x=3  报错

2.3默认参数
默认形参：在定义函数阶段，就已经被赋值的形参
       特点：在定义阶段就已经被赋值，意味着在调用阶段可以不用为其赋值
def func（x,y=3）:    #func(x=1)  x=1,y=3
        print(x,y)    #func(x=1,y=444)   x=1,y=444

位置形参与默认形参混用，强调：
1.位置形参必须在默认形参的左边
def func（y=2，x）：
             pass
2.默认参数的值是在函数定义阶段被赋值的，准确的说被赋予的是值的内存地址
示范1：
m =2
def func(x,y=m):  #y=2的内存地址
    print(x,y)
m=33333
func(1)   #1  2
示范2：
m =[11,]
def func(x,y=m):  #y指向列表m的内存地址，列表是可变类型
    print(x,y)            值变内存地址不变
m.append(33)
func(1)      #1,[11,33]
3.虽然默认值可以指定任意类型的数据类型，但是不推荐使用可变类型
#函数定义遵循：函数的调用只跟函数本身有关系，不受外界代码的影响  
def func(x,y,l=None):
        if l is None:
            l = []
        l.append(x)
        l.append(y)
    print(l)
new_l = [11,22]
func(1,2,new_l)   #[11,22,1,2]

2.4 可变长度的参数（*与**的用法）
可变长度指在调用函数时，传入的值（实参）的个数不固定
实参是用来为形参赋值的，所以对应着，针对溢出的实参必须有对应的形参来接收
2.4.1可变长度的位置参数
1，*形参名：用来接收溢出的位置实参，
溢出的位置实参会被*保存成元组的格式然后赋值紧跟其后的形参名
                       *后可以跟任意名字，但是约定俗称为args 
def func(x,y,*args):
        print(x,y,args)
func(1,2,3,4,5,6)   #1  2  (3,4,5,6)
2.*可以用在实参中，实参中带*(*后面能被for循环就可以)，先将*后的值打散成位置实参
def func(x,y,z):
    print(x,y,z)
func(*[11,22,33])  #func(11,22,33)
3.形参与实参中都在*
def func(x,y,*args):  
        print(x,y,args)
func(1,2,*[3,4,5])  # 1 2 (3,4,5)
2.4.2可变长度的关键字参数
1.**形参名：用来接收溢出的关键字实参，
**会将溢出的关键字实参保存成字典格式，然后赋值给紧跟其后的形参名
                **后可以跟任意名字，但是月额定俗称为kwargs
def func(x,y,**kwargs):
        print(x,y,kwargs)
func(1,y=2,a=3,b=4,)   #1  2  {a=3,b=4}
2.**可以用在实参中，实参中带**（**后跟着只能是字典），先将**后的值打散成位置实参
def func(x,y):
    print(x,y)
func(**{'x'=1,'y'=2})  #1  2
3.形参与实参中都在**
def func(x,y,**kwargs):
    print(x,y,kwargs)
func(**{'x'=1,'y'=2,'a'=3,'b'=4})  #1 2 {'a'=3,'b'=4}


混用*与**
*args必须在**kwargs之前

名称空间：

1.内置的名称空间： 在python解释器中存在的

2. 全局名称空间：在py文件中，定个写的代码都在全局名称空间中

name = 'kevin'
    if  True:
        a = 1
    while True:
        x = 10

3.局部名称空间： 只要在函数中出现都是局部的           #在函数体代码执行完产生的数据

存活周期
    # 内置的：伴随python解释器的启动/关闭而产生/回收
    # 全局的：伴随python文件的开始执行/执行完毕而产生/回收
    # 局部的：伴随函数的调用/结束而临时产生/回收

名字的查找顺序：

# 首先先确定你所在的位置
1. 如果在局部中：
    局部  >>>  全局 >>> 内置
2. 如果在全局中：
    全局 >>> 内置

函数的补充：

global与nonlocal 的使用

1. global:
   	局部修改全局的'不可变类型'的时候要使用global关键字声明
2. nonlocal
	内部的局部修改外部的局部的不可变类型的时候，需要使用nonlocal关键字声明 

函数对象（函数名）

1. 函数名可以当成变量赋值给别的变量
2. 函数名可以当成函数的实参
3. 函数名可以当成函数的返回值（如果全局想用局部的名字，return 出来）
4. 函数名可以做容器类型的元素值

def index():
    def func():
        pass
    return func
res=index() # func的内存地址
res()  # func()

'''函数名本质上就是函数的内存地址!!!!'''