函数的参数
形式参数
什么是形式参数：
在'函数定义阶段'括号内依次写入的变量名就叫形式参数，简称"形参"
def index(a,b,c,d,e):
pass
# a,b就称之为是函数的形参
1、位置形参
位置形参
在函数'定义阶段'括号内从'左往右依次'写入的'变量名'就是位置形参
def index(a,b,c,d):
pass
# a,b,c,d就是位置形参
2、默认形参
# 前提是默认的形参
在函数定义阶段就给参数赋值了
1. 如果你在函数调用阶段，没有给形参传值，那就是要默认的
a = 1
b = 2
def index(a,b)：
print(a,b) #1,2
index()
'''这时候就不用在实参位置为a,b赋值了'''
2. 如果你在函数调用阶段，给形参传值了，就是要你传的值
a = 1
b = 2
def index(a,b):
print(a,b) #3,4
index(3,4)
'''这时候实参位置的的值就会覆盖原本的值'''
3、笔试题：
m = 200
def func(a, b, c=m):
print(a, b, c)
m = 400
func(1, 2)
"""
两个角度理解
角度1：
在函数定义阶段，参数的值就已经固定死了，不能修改
角度2：
根据变量名和变量值在内存中关系来判断
"""
3、形参注意点
'''
位置形参必须要在默认形参前面
默认形参应该为不可变类型
默认形参的值应该是在定义阶段被定义的
'''
实际参数
在'函数调用阶段'括号内依次传入的变量值就叫实际参数，简称"实参"
index(1, 2, 3)
# 1,2,3就称之为是函数的实参
"""
形式参数和实际参数之间的关系
把实际参数传递给形式参数，以形参=实参的形式传入----->以变量名=变量值的形式传入
形参就相当于是变量名，实参相当于是变量值
形参和实参在函数调用阶段临时绑定，当函数调用完毕，两者断开
"""
函数的形参形式其实只有一种，那就是变量名
函数的实参有很多中方式，但是抓住本质：就是数据值
1、位置实参
位置实参
在函数的'调用阶段'括号内从'左往右依次'写入的'数据值'就是
位置实参
index(1,2,3,4)
# 1,2,3,4就是位置实参
2、关键字实参
按照关键字进行传参
例：
def 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') # 不行
'''位置参数不能写在关键字的后面，越简单的参数越靠前'''
3、可变长实参
作用：
传入的实参个数不固定，对应的就必须要有一个特殊的形参来接受溢出的值
'''
溢出的位置实参使用*号接收，赋值为元组
溢出来的关键字实参使用**接收，赋值为字典
'''
1. 不管我在调用函数的时候，传入多少个位置参数，都能正常运行
def index(name, password, x, y, *a):
print(name, password, a, x, y)
# print(a[0])
# print(a[1])
# print(a[2])
# 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}
名称空间
什么是名称空间?
就是绑定变量名与变量值关系的地方
名称空间的分类：
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()
"""验证变量的查找顺序：局部 >>> 全局 >>> 内置"""