Python函数一

1. 函数的两大分类

1.形式参数

在函数定义阶段，括号中填入的变量名，就是形式参数，简称：形参。

def my_func(a,b):
pass
# 此时a,b 就是函数my_func的形参。

2.实际参数

在函数调用阶段，括号中传入的数据值，就是实际参数，简称：实参

my_func(1,2)
# 此时，数据1,2就是函数my_func的实参

3.形参和实参的关系

实际参数以变量名 = 数据值的形式进行传递

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

4.形参和实参的表现形式

形参的表现形式只有一种，就是变量名

实参的表现形式有很多种...核心：都是数据值

2.位置参数

1.位置参数

在函数定义阶段，括号中填写的参数。

2.位置形参

在函数定义阶段，括号中从左往右填写的变量名就是位置形参

def index(a,b,c):
    pass

3.位置实参

在函数调用阶段，括号中从左往右传入的数据值就是位置实参

index(1,2,3)

定义一个函数，传入两个数字参数，功能是：返回大的

a = 10
b =20
if a>b:
    return a
else:
    return b

4.关键字实参

参数越简单，越靠前放

res = my_max(b=20, 111) # 错误 位置参数不能放在关键字参数后面

3.默认参数

1.默认形参

在函数定义阶段就可以给变量赋值了

1. 在调用节点如果你给了数据值，就使用你给的

2. 在调用阶段如果你不传数据值，那就使用默认的

小练习：定义一个函数功能是注册（name，age，gender）

def register(name, age, gender='male'):
    print("%s:%s:%s" % (name, age, gender))

register('kevin', 19)
register('kevin1', 19)
register('kevin2', 19, 'female')

注意：当有了默认参数，就可以传值和不传值了

练习题1-2：

参数的默认值如果给的是一个列表，那么，后续的数据都会指向同一个列表，(同一个内存空间)
# def my_func(name, age, hobby=[]):
#     hobby.append(age)
#     print("%s:%s:%s" % (name, age, hobby))
#
# my_func('kevin1', '20', [])
# my_func('kevin2', '18', [])
# my_func('kevin3', '39', [])


练习题二：


x = 100


def index(a, b, c=x):
    print(a, b, c)

x = 200

index(1,2)

4.可变长参数

1.位置参数（可变长参数）

不管传入多少个位置参数，函数都可以正常运行

def index(x,y,*a):
    print('x,y')
    print(a) 
index(1, 2, 3, 4, 5, 6)
* 在形参中的使用：接收多余的位置参数，并且组装成元素的形式一一返回

2.关键字参数（可变长参数）

不管传入多少个关键字参数，函数都可以正常运行

def func(**a):
    print(a)
func(age=20, name='kevin', salary=1000, gender='male')  # {'salary': 1000, 'gender': 'male'}
**在形参中得使用：接收对于的关键字参数，并且把关键字参数组织成字典的形式

不管传入多少个位置参数和关键字参数，函数都可以正常运行

def index(a, b, name, *c, **d):
    print(a, b)
    print(name)
    print(c)
    print(d)


index(1, 2, 3, 4, 5, name='kevin', age=20, gender='male')

"""
    *和**后面的变量名可以随意的起名字，只是一个变量名而已
    python中推荐使用
        *args   arguments
        **kw args  keyword arguments
        
    def index(*args, **kwargs):
        pass
"""

3.补充

*和**在实参中的使用

def index(a, b, *args ):
#     print(a, b, args)

# index(1, 2, 3)
# l = [11, 22, 33,44,55]
# t = (11, 22, 33,44,55)
# index(l[0], l[1], l[2])
"""
*在实参中得使用：把列表、元组内的各个元素打散，然后一一传值
"""
# index(*l) # index(11, 22, 33,44,55)
# index(*t) # index(11, 22, 33,44,55)
# print(*t)


def index(**kwargs):
    print(kwargs)  # {'username': 'kevin', 'age': '18', 'gender': 'male'}


# index(1, 2, name='kevin')

dict = {'username': 'kevin', 'age': '18', 'gender': 'male'}
# index(username='kevin', age='age', gender='male')
"""
**在实参中得使用：把字典内的元素打散，然后以关键字的形式一一传入
"""
index(**dict)
index(**{'username': 'kevin', 'age': '18', 'gender': 'male'}) # index(username='kevin', age='age', gender='male')

5.名称空间的概念

定义：存放变量名与变量值关系的地方

1.名称空间的分类

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

全局名称空间：在python文件中，顶格写的代码都在全局名称空间中

 name = 'kevin'

    if  True:
        a = 1

    while True:
        x = 10

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

存活周期：

内置的：伴随python解释器的启动/关闭而产生/回收

全局的：伴随python文件的开始执行/执行完毕而产生/回收

局部的：伴随函数的调用/结束而临时产生/回收

6.名字的查找顺序

1. 如果在局部中：

局部 >>> 全局 >>> 内置

2. 如果在全局中：

全局 >>> 内置

'''首先确定你所在的位置```

# index()

# x = 888
def index():
    # x = 666

    def index1():
        # x = 666

        def index2():
            # x = 666

            def index3():
                # x = 666

                def index4():
                    x = 666
                    print(x)
                index4()

            index3()

        index2()

    index1()


index()