python基础day12 函数的参数

函数参数的两大分类

1. 形式参数

在函数定义阶段括号内一次写入的变量名就叫形式参数，简称“形参”

def index(a,b,c,d)
    pass
# a,b,c,d就称之为是函数的形参

2. 实际参数

在函数调用阶段括号内一次传入的变量值就叫实际参数，简称“实参”

index(1,2,3,4)
# 1,2,3,4就称之为是函数的实参

形式参数和实际参数之间的关系：

　　把实际参数传递给形式参数，以形参 = 实参的形式传入----->以变量名 = 变量值的形式传入

形参就相当于是变量名，实参就相当于是变量值

形参和实参在函数调用阶段临时绑定，当函数调用完毕，两者断开。

函数的形参形式只有一种，那就是变量名

函数的实参有很多种方式，但是抓住本质：就是数据值。

位置参数和关键字参数（核心）

位置参数：

　　在函数括号内依次写入的参数就是位置参数

位置形参：

　　在函数定义阶段括号内从左往右依次写入的变量名就是位置形参。

def index(a,b,c,d)
    pass
# a,b,c,d就是位置形参

位置实参：

在函数的调用阶段括号内从左往右依次写入的数据值就是位置实参。

index(1,2,3,4)
# 1，2，3，4就是位置实参

位置传参少一个或多一个都不行

关键字实参：

可以打破原来的顺序传递，就是传递参数不再按照顺序传递了。

register(age=18, name='kevin', gender='female')
register('kevin', age=18, 'female') # 不行，位置参数不能跟在关键字的后面
register('kevin', age=18, gender='female') # 行
register(age=18, 'kevin', gender='female') # 不行
register('kevin', name=18, gender='female') # 不行
'''位置参数不能写在关键字的后面，越简单的参数越靠前'''

默认参数

# 前提是默认的形参

在函数定义阶段就给参数赋值了

1. 如果你在函数调用阶段，没有给形参传值，那就是要默认的

2.如果你在函数调用阶段，给形参传值了，就是要你传的值。

# 练习：如果默认值是列表的话，比较特殊：以后所有调用该函数的时候，hobby用的都是一个
def register(name, age, hobby = []):
    hobby.append(age)
    print('%s:%s:%s' % (name, age, hobby))
register('kevin',18,)
register('kevin',19,)
register('kevin',20,)

# 练习2：
m = 200
def func(a, b, c=m)
    print(a,b,c)
m = 400
func(1,2)

'''
两个角度理解：
角度1：
  在函数定义阶段，参数的值就已经固定死了，不能修改
角度2：
  根据变量名和变量值在内存中关系来判断      
'''

可变长参数

# 1. 不管我在调用参数的时候，传入多少个位置参数，都能正常运行
def index(name, password, x, y, *a):
    print(name, password, a, x, y)
    print(a[0])  # 取出来的是元组，可以索引取值
# print(a, b, c, d)
'''*号在形参中的使用：会接收多余的位置参数'''
# index('kevin', 123, 1, 2, 3, 4, 5, 6)  # kevin 123 (1, 2, 3, 4, 5, 6)
# index('kevin', 123)  # kevin 123 ()
# index('kevin', 123, 3, 4, 5, 6, 7, y=2, x=1, )  # kevin 123 () 1 2
# index('kevin', 123, y=2, x=1, 3, 4, 5, 6, 7, )  # kevin 123 () 1 2

# 2. 不管我们在调用函数的时候，传入多少个关键字参数，都能正常运行
'''
**号在形参中的使用：
    接受多余的关键字参数
'''
def index(username, age, gender, hobby, **a):
    print(username, age, gender, a )# kevin 18 {'gender': 'male', 'hobby': 'read', 'a': 1, 'b': 2, 'c': 3}
    # {'hobby': 'read', 'a': 1, 'b': 2, 'c': 3}
# index(1, 2)
# index(a=1,b=2)
# 关键字传参就是指名道姓地传递
# index(b=1, a=1)

d = {'username':'kevin', 'age': 18}
# index(username = 'kevin', age = 18)  # 可行
# index(d.get('username'), d.get('age'))  # 可行
# index(username = d.get('username'), age=d.get('age'))  # 可行
# index(username=d.get('username'), age=d.get('age'),gender='male', hobby='read',a=1,b=2,c=3)
index(username=d.get('username'), age=d.get('age'),gender='male', hobby='read',a=1,b=2,c=3)
# 3. 不管我传入多少个位置参数和关键字参数，函数都能正常运行
def index(*a, **b):
    print(a, b)
# (1, 2, 3)  {'x': 1, 'y': 2, 'z': 3, 'm': 10, 'n': 20}
index(1, 2, 3, 4, k=10, x=1, y=2, z=3, m=10, n=20, )
"""
注意：
    *号和**号后面的变量可以任意起名，遵循变量的命名即可
    在python中，推荐使用
        *args: arguments  位置参数
        **kwargs: keyword arguments 关键字参数
    以后在定义函数的时候，如果我们不知道要传递多少个参数，我们就可以如下定义
        def index(*args, **kwargs):
            pass
"""

# *号和**号在实参中的使用

def index(*args):
    print(args)


# index(1,2,3,4,)

# l = [1, 2, 3, 4, 5, 6, 7, 8, 9, ]
t = (1, 2, 3, 4, 5, 6, 7, 8, 9, )
# index(l[0], l[1], l[2], l[4], l[4],)  # index(1,2,3,4,5)

'''
*在实参中的使用，就是把列表、元组中的一个一个元素打散，然后以位置参数的形式传递
'''
# 针对列表这种里面肯能存放多个元素的时候，我们利用*打散成一个个的元素
# *l 就把列表中的元素，挨个打散
# index(*l)  # (1, 2, 3, 4, 5, 6, 7, 8, 9)-----------> index(1,2,3,4,5,6,7,8,9)
index(*t)  # (1, 2, 3, 4, 5, 6, 7, 8, 9)-----------> index(1,2,3,4,5,6,7,8,9)



"""
**号在实参中的使用：把字典打散成关键字的形式进行传递
"""
def func(**kwargs):
    print(kwargs)  # {'username': 'kevin', 'age': 18, 'gender': 'male'}\
    # print(kwargs.get('username'))
    # print(kwargs.get('age'))
    # print(kwargs.get('gender'))


# func(username='kevin', age=18, gender='male')

d = {'a':1, 'b':2, 'c':3, 'd':4,'e':5}

# func(a=d.get('a'), b=d.get('b'))

# func(a=1,b=2,c=3,d=4,e=5)
func(**d)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

其他参数了解

def register(name,age,*,sex,height): #sex,height为命名关键字参数
    pass

register('lili',18,sex='male',height='1.8m') #正确使用
register('lili',18,'male','1.8m') # TypeError:未使用关键字的形式为sex和height传值
register('lili',18,height='1.8m') # TypeError没有为命名关键字参数height传值。

名称空间

什么是名称空间？

　　就是绑定变量名与变量值关系的地方

名称空间的分类：

　　1. 内置名称空间

　　　　# python内置的，可以拿来直接使用的，len, print

　　2. 全局名称空间

　　　　# 在py文件中，顶格写的变量都是在全局名称空间中

name ='jason' # name就是全局变量，它就在全局名称空间中存着

        if True:
            a = 123  # a也在全局变量，它也在全局名称空间中存储

        for i in range(10): # i 也是全局变量，它也在全局的名称空间中存储
            pass

        def func(): # func 也是全局的，它也在全局的名称空间中存储
            pass        

　　3. 局部名称空间

# 在函数中存在的都是局部的
    print(locals())  # {'a': 123, 'b': 'hello'}
    print(globals())

名字的查找顺序

 # len = 'helloworld'

# print(len) # helloworld

name = 'tank'

def index():
    # name = 'kevin'
    print(name)

index()
"""
名字的查找：
    先看你自己再哪个位置
        全局  >>>  内置
    先看你自己再哪个位置
        局部   >>>   全局    >>> 内置
"""

x = 111


def func():
    # x = 222

    def func1():
        # x = 333

        def func2():
            # x = 444

            def func3():
                # x = 555
                print(x)

            func3()

        func2()

    func1()


func()

"""验证变量的查找顺序：局部 >>> 全局 >>> 内置"""