今日内容
1.位置参数
2.默认参数
3.可变长形参
4.可变长实参
5.命名关键字参数
6.名称空间
7.名称空间存活周期及作用范围
8.名称的查找顺序
9.查找顺序案例
1.位置参数
当子代码只有一行并且很简单的情况下，可以直接在冒号后编写，不用换行
位置形参 函数定义阶段括号内从左往右依次填写的变量名
def funcl(a,b,c):pass
位置实参 函数调用阶段括号内从左往右依次填写的数据值
funcl(1,2,3)
def funcl(a,b):
print(a,b)
func1(1, 2) # 按照位置一一对应传值
func1(1) # 少一个不行
func1(1, 2, 3) # 多一个也不行
func1(b=1, a=2) # 关键字传参(指名道姓的传)
func1(b=1, 2) # 关键字传参一定要跟在位置传参的后面 报错
func1(2, b=1) # 可以
func1(1, a=2, b=3) # 同一个形参在调用的时候不能多次赋值
name = 'jason'
pwd = 123
func1(name, pwd) # 实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名
func1(a=name, b=pwd) # 实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名
ps：越短的越简单的越靠前
越长的越复杂的越靠后
但是遇到下列的情况除外 同一个形参在调用的时候不能多次赋值
2.默认参数
本质就是关键字形参 提前就已经给了，用户可以不传，也可以传
默认参数的定义也遵循短的简单的靠前，长的复杂的靠后
def register(name, age, gender='male'):
print(f"""
--------学员信息----------
姓名:{name}
年龄:{age}
性别:{gender}
-------------------------
""")
register('jason', 18)
register('kevin', 28)
register('lili', 28, 'female')
register('lili', 28, gender='female')
register('jason', 18，'male')
register('tony', 28,'male')
register('kevin',38,'male')
3.可变长形参
def funcl(*a):
print(a)
funcl() #()
funcl(1) #(1,)
funcl(2) #(1,2)
def funcl2(b,*a):
print(a,b)
func2() #函数至少需要一个参数给到b
func2(1) () 1
func2(1，2，3，4) #(2,3,4) 1
*号在形参中，用于接收多余的位置参数，组织成元组赋值给*号后面的变量名
def funcl3(**k):
print(k)
func3() # {}
func3(a=1) #{'a':1}
func3(a=1,b=2,c=3)# {'a': 1, 'b': 2, 'c': 3}
def func4(a, **k):
print(a, k)
func4() # 函数至少需要一个参数给到a
func4(a=1) # 1 {}
func4(a=1, b=2, c=3) # 1 {'b': 2, 'c': 3}
func4(a=1, b=2, c=3, x='jason', y='kevin') # 1 {'b': 2, 'c': 3, 'x': 'jason', 'y': 'kevin'}
**号在形参中，用于接收多余的关键字参数，组成字典的形式赋值给**号后面的变量名
def func5(*a, **k):
print(a, k)
func5() # () {}
func5(1, 2, 3) # (1, 2, 3) {}
func5(a=1, b=2, c=3) # () {'a': 1, 'b': 2, 'c': 3}
func5(1, 2, 3, a=1, b=2, c=3) # (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}
def funcl5(n,*a,**k):
print(a,k)
func5() #函数至少需要一个参数给到n
func5(1,2,3) #(2,3) {}
func5(111,a=1,b=2,c=3) #(){'a':1,'b':2,'c':3}
func5(n=111,a=1, b=2, c=3) # () {'a': 1, 'b': 2, 'c': 3}
func5(a=1, b=2, c=3, n=111) # () {'a': 1, 'b': 2, 'c': 3}
func5(1, 2, 3, a=1, b=2, c=3) # (2, 3) {'a': 1, 'b': 2, 'c': 3}
由于*和**在函数的形参中使用频率很高，后面的变量名推荐使用
*args
**kwargs
def index(*args,**kwargs):pass
4.可变长实参
def index(a, b, c):
print(a, b, c)
l1 = [11, 22, 33]
t1 = (33, 22, 11)
s1 = 'tom'
se = {123, 321, 222}
d1 = {'username': 'jason', 'pwd': 123, 'age': 18}
将列表中三个数据值取出来传给函数的三个形参
index(l1[0], l1[1], l1[2])
index(*l1) # index(11, 22, 33)
index(*t1) # index(33, 22, 11)
index(*s1) # index('t','o','m')
index(*se) # index(321 123 222)
index(*d1) # index('username','pwd','age')
*在实参中，类似于for循环，将所有循环遍历出来的数据按照位置参数一次性传给函数
def index(username, pwd, age):
print(username, pwd, age)
d1 = {'username': 'jason', 'pwd': 123, 'age': 18}
index(username=d1.get('username'), pwd=d1.get('pwd'), age=d1.get('age'))
index(**d1) # index(username='jason',pwd=123,age=18)
**在实参中，将字典打散成关键字参数的形式传递给函数
def index(*args, **kwargs):
print(args) # (11, 22, 33, 44)
print(kwargs) # {}
index(*[11, 22, 33, 44]) # index(11, 22, 33, 44)
index(*(11, 22, 33, 44)) # index(11, 22, 33, 44)
5.命名关键字参数(了解)
形参必须按照关键字参数传值>>>:命名关键字参数
def index(name,*arges,gender='male',**kwarges):
print(name,argees,gender,kwarges)
index('jason',1,2,3,4,'female',b=2)
6.名称空间
name = 'jason'
1.申请内存空间存储jason
2.给jason绑定一个变量名name
3.后续通过变量名name就可以访问到jason
名称空间就是用来存储变量名与数据值绑定关系的地方(我们也可以简单的理解为就是存储变量名的地方)
1.内置名称空间
解释器运行自动产生，里面包含了很多名字
eg:len print input
2.全局名称空间
py文件运行产生，里面存放文件级别的名字
name = 'jason'
if name:
age = 18
while True:
gender = 'male'
def index():
pass
class MyClass(object):
pass
name\age\gender\index\MyClass
3.局部名称空间
函数体代码运行\类体代码运行，产生的空间
7.名称空间存活周期及作用范围(域)
存活周期
内置名称空间 python解释器启动则创建，关闭则销毁
全局名称空间 py文件执行则创建，运行则销毁
局部名称空间 函数体代码运行创建，结束销毁
作用域
内置名称空间 解释器级别的全局有效
全局名称空间 py文件级别的全局有效
局部名称空间 函数体代码内有效
8.名字的查找顺序
涉及到名字的查找，一定要先搞明白自己在哪个空间
1.当我们在局部名称空间中的时候
局部名称空间>>>全局名称空间>>>内置名称空间
2.当我们在全局名称空间中的时候
全局名称空间>>>内置名称空间
9.查找顺序案例
1.相互独立的局部名称空间默认不能互相访问
def funcl():
name = 'jason'
print(age)
def func2():
gae = 18
print(name)
2.局部名称空间嵌套
先从自己的局部名称空间查找，之后由内而外依次查找
函数体代码中名字的查找顺序在函数定义阶段就已经固定死了
x = '干饭了'
def func1():
x = 1
def func2():
x = 2
def func3():
print(x)
x = 3
func3()
func2()
func1()