目录
今日内容概要
- 函数参数的位置参数
- 默认参数
- 可变长形参
- 可变长实参
- 命名关键字参数
- 名称空间
- 名称空间存活周期及作用域
- 名字的查找顺序
- 查找顺序的案
今日内容详情
函数参数之位置参数
1.位置形参：
函数定义阶段括号内从左往右依次填写的变量名
def func1 (a, b, c):pass
# 当子代码只有一行并且很简单的情况下 可以直接在冒号后编写 不用换行
2.位置实参
函数调用阶段括号内从左到右依次填写的数据值
func(1,2,3)
3.代码实例：
def func1(a,b):
print(a,b)
1.按位置传值
# func1(1,2) # 按照位置一一对应传值
# func1(1) # 少了是不行的 报错
# func1(1, 2, 3) # 多了也不行 报错
2.按关键字传值（关键字实参）
# 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) # 实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名
4.规范口诀
"""
越短的，越简单的越靠前
越长的，越复杂的越靠后
但是遇到下列情况除外：
同一个形参在调用的时候不能多次赋值
"""
默认参数
本质其实就是关键字形参，函数在定义阶段括号内以什么等于什么填写的形参
别名叫默认参数：就是提前就已经给了 用户可以不传 也可以传
默认参数的定义也遵循短的简单的靠前 长的复杂的靠后
代码实例如下：
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'）
可变长形参
1.形参中的*会将溢出的位置实参全部接受，然后以元组的形式存储，然后把元组赋值给*后的参数，需要注意的是*后的参数名约定成俗成为args
代码如下：
1.当没有位置参数时
# def sum_sef(*args):
# print(args)
#
# sum_sef() # ()
# sum_sef(1, 2, 3, 4, 5, 6) # (1, 2, 3, 4, 5, 6)
# sum_sef(1) # (1,)
2.当有位置参数时
# def sum_sef(b, *args):
# print(b, args)
# sum_sef() # 当形参有一个位置参数时 函数至少给b一个数据值
# sum_sef(1) # 1 ()
# sum_sef(1, 2, 3, 4) # 1 (2, 3, 4)
2.形参中的**会将溢出的关键字实参全部接收，然后存储字典的形式，然后把字典赋值给**后的参数，需要注意的是**后的参数名约定成俗为kwargs
代码如下：
1.没有位置参数时
# def func1 (**kwargs):
# print(kwargs)
#
#
# func1() # {}
# func1(a=1) # {'a': 1}
# func1(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
#
2.有位置参数时
# def func2 (a, **kwargs):
# print(a,kwargs)
#
#
# func2() # 当有位置参数时，函数至少要给a一个数据值
# func2(a=1)
# func2(a=1, b=2, c=3)
# func2(a=1, b=2, c=3, x='hello', y='jamer')
3.** kwargs和*args的结合应用
1.没有位置参数时
# def func5(*args, **kwargs):
# print(args, kwargs)
#
#
# 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}
2.有位置参数时
# def func5(n,*args, **kwargs):
# print(n, args, kwargs)
#
#
# func5() # 当有位置参数时，函数至少要给n一个数据值
# func5(1, 2, 3) # 1 (2, 3) {}
# func5(111, a=1, b=2, c=3) # 111 () {'a': 1, 'b': 2, 'c': 3}
# func5(n=111, a=1, b=2, c=3) # 111 () {'a': 1, 'b': 2, 'c': 3}
# func5(a=1, b=2, c=3, n=111) # 111 () {'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}
可变长实参
1.*在实参中 类似于for循环 实参中 *会将*后参数的值循环取出按照位置参数一次性传给函数
代码如下：
# def index(a, b, c):
# print(a, b, c)
# l1 = [11, 22, 33]
# t1 = (33, 22, 11)
# s1 = 'son'
# se = {123, 321, 123467}
# d1 = {'username':'jason', 'pwd':123, 'age':18}
#
#
#
# index(*l1) # index(11, 22, 33)
# index(*t1) # index(33, 22, 11)
# index(*s1) # index('s', 'o', 'n')
# index(*se) # index(321, 123467, 123)
# index(*d1) # index('username', 'pwd', 'age')
2.**在实参中 将字典打散成关键字参数的形式传递给函数
代码如下：
#def index(username, pwd, age):
# print(username, pwd, age)
#d1 = {'username':'lwx', 'pwd':123, 'age':18}
#index(**d1) #等同于 index(username=d1.get('username'), pwd=d1.get('pwd'), age=d1.get('age'))
3.可变长参数之实参实际案例
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)
命名关键字参数
形参必须按照关键字参数传值>>>:命名关键字参数
def index(name, *args, gender='male', **kwargs):
print(name, args, gender, kwargs)
# index('jason',1,2,3,4,a=1,b=2)
index('jason', 1, 2, 3, 4, 'female', b=2)
名称空间
名称空间就是用来存储变量名与数据值绑定关系的地方
简单的理解就是存储变量名的地方
回顾：变量名绑定数据值的底层原理
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.局部名称空间
函数体代码运行\类体代码运行 产生的空间
名称空间存活周期及作用域
1.存或周期
1.内置名称空间
python解释器启动则创建 关闭则销毁
2.全局名称空间
py文件执行则创建 运行结束则销毁
3.局部名称空间
函数体代码运行创建 函数体代码结束则销毁（类暂不考虑）
2.作用域
1.内置名称空间
解释器级别的全局有效
2.全局名称空间
py文件级别的全局有效
3.局部名称空间
函数体代码内有效
名字的查找顺序
涉及到名字的查找一定要搞清楚自己在哪个空间
1.当我们在局部名称空间中的时候
局部名称空间>>>全局名称空间>>>内置名称空间
2.当我们在全局名称空间中的时候
全局名称空间>>>内置名称空间
ps：其实名字的查找顺序是可以打破的
查找顺序案例
1.相互独立的局部名称空间默认不能够相互访问
def func1():
name = 'jason'
print(age)
def func2():
age = 18
print(name)
2.局部名称空间嵌套
先从自己的局部名称空间查找 之后由内而外依次查找
"""
函数体代码中名字的查找顺序在函数定义阶段就已经固定死了
x = '干饭了'
def func1():
x = 1
def func2():
x = 2
def func3():
print(x)
x = 3
func3()
func2()
func1()
"""