目录
一.函数参数
1.位置参数
位置即顺序，位置参数指的是按顺序定义的参数依次定义形参，称之为位置形参，需要从两个角度去看：
1.位置形参：
在定义函数时，按照从左到右的顺序依次定义形参，称之为位置形参，凡是按照这种形式定义的形参都必须被传值
def func1(a, b, c):pass
2.位置实参：
在调用函数时，按照从左到右的顺序依次定义实参，称之为位置实参，凡是按照这种形式定义的实参会按照从左到右的顺序与形参一一对应
func1(1, 2, 3)
实操：
def func1(a, b):
print(a, b)
func1(1, 2) # 按照位置一一对应传值
func1(1) # 少一个都不行
func1(1, 2, 3) # 多一个也不行
func1(b=1, a=2) # 关键字传参(指名道姓的传)
func1(b=1, 2) # 关键字传参一定要跟在位置传参的后面 报错
func1(1, a=2, b=3) # 同一个形参在调用的时候不能多次赋值 报错
name = 'daniel'
age = 18
func1(name, age) # 实参没有固定的定义可以传数据值 也可以传绑定了数据值的变量名
func1(a=name, b=age) # 实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名
"""
参数要遵循
越短的越简单的越靠前
越长的越复杂的越靠后
但是遇到下列的情况除外
同一个形参在调用的时候不能多次赋值
"""
2.默认参数
本质其实是就是关键字形参(关键字实参上述内容已经介绍)
别名叫默认参数：提前就已经给了 用户可以传也可以不传
'''默认参数的定义也遵循越短的越简单的越靠前 越长的越复杂的考后'''
def register(name, age, gender='male'):
print(name, age, gender)
register('jason', 18) # jason 18 male
register('kevin', 28) # kevin 28 male
register('lili', 28, 'female') # lili 28 female
register('lili', 28, gender='female') # lili 28 female
register('jason', 18, 'male') # jason 18 male
3.可变长形参
1、可变长形参之‘ * ’：
函数可以接收任意个数的参数，只需要在形参前面加一个*(星号)，一个星号形参的函数会把多个位置参数值当成元祖的形式传入，也就是传入的多个参数值可以在函数内部进行元祖遍历
def func1(*a):
print(a)
func1() # ()
func1(1) # (1,)
func1(1, 2) # (1, 2)
—————————————————————————————————————————————————————
def func2(b, *a):
print(a, b)
func2() # 函数至少需要一个参数给到b
func2(1) # () 1
func2(1, 2, 3, 4) # (2, 3, 4) 1
"""
*号在形参中
用于接收多余的位置参数 组织成元组赋值给*号后面吗的变量名
"""
2、可变长形参之‘ ** ’:
形参前面加两个*(星号)，注意是两个星号哦，两个星号形参的函数会把关键字参数值当成字典的形式传入，在函数内部会把关键字参数当成字典在函数内部进行遍历
def func3(**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'}
"""
**号在形参中
用于接收多余的关键字参数 组织成字典的形式赋值给**号后面的变量名
"""
3、‘ * ’和‘ ** ’混合使用
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 func6(n, *a, **k):
print(n, a, k)
func6() # 函数至少需要一个参数给到n
func6(1, 2, 3) #1 (2, 3) {}
func6(111, a=1, b=2, c=3) # 111 () {'a': 1, 'b': 2, 'c': 3}
func6(n=111, a=1, b=2, c=3) # 111 () {'a': 1, 'b': 2, 'c': 3}
func6(a=1, b=2, c=3, n=111) # 111 () {'a': 1, 'b': 2, 'c': 3}
func6(1, 2, 3, a=1, b=2, c=3) # 1 (2, 3) {'a': 1, 'b': 2, 'c': 3}
"""
由于*和**在函数的形式中使用频率很高 后面跟的变量名推荐使用
*args
**kwargs
def index(*args, **kwargs):pass
"""
4.可变长实参
1.可变长实参之‘ * ’
实参中的‘ * ’，‘ * ’会将‘ * ’后参数的值循环取出，打散成位置实参。以后但凡碰到实参中带‘ * ’的，它就是位置实参，应该马上打散成位置实参去看。
def index(x, y, z):
print(x, y, z)
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) 11 22 33
index(*t1) # index(33, 22, 11) 33 22 11
index(*s1) # index('t', 'o', 'm') t o m
index(*se) # index(321 123 222) 321 123 222
index(*d1) # index('username', 'pwd', 'age') username pwd age
"""
*在实参中
类似于for循环 将所有循环遍历出来的数据按照位置参数一次性穿个函数
"""
2.可变长实参之‘ ** ’
实参中的‘ ** ’，‘ ** ’会将‘ ** ‘后参数的值循环取出，打散成关键字实参。以后但凡碰到实参中带的‘ ** ’，它就是关键字实参，应该马上打散成关键字实参去看。
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, *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)
二.名称空间
1.什么是名称空间
名称空间就是用来储存变量名与数据值绑定关系的地方（我们也可以简单的理解为就是储存变量名的地方），名称空间可以分为三类：内置名称空间、全局名称空间、局部名称空间
1.内置名称空间
解释器运行自动产生 ，里面包含很多名字（比如：len、print、input）
2.全局名称空间
py文件运行产生，里面存放文件级别的名字
eg：
name = 'jason'
if name:
age = 18
while Ture:
gender = 'male'
def index():
pass
class MyClass(object):
pass
name\age\gender\index\MyClass
3.局部名称空间
函数体代码运行，产生的空间
2.名称空间存活周期 及作用范围(域)
-
存活周期
-
内置名称空间
python解释器启动则创建，关闭则销毁
-
全局名称空间
py文件执行则创建，运行结束则销毁
-
局部名称空间
函数体代码运行创建，函数体代码结束则销毁
-
-
作用域
- 内置名称空间
解释器级别的全局有效 - 全局名称空间
py文件级别的全局有效 - 局部名称空间
函数体代码内有效
- 内置名称空间
3.名字的查找顺序
涉及到名字的查找，一定要先搞明白自己在哪个空间
1.当我们在全局名称空间中的时候
局部名称空间 >>> 全局名称空间 >>> 内置名称空间
2.当我们在全局名称空间中的时候
全局名称空间 >>> 内置名称空间
ps：名字的查找顺序是可以打破的
4.查找顺序案例
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():
x = 3
func3()
func2()
func1()
'''函数体代码中名字的查找顺序在函数定义阶段就已经固定死了'''
