目录
函数的参数之位置参数
位置形参
在函数定义阶段括号内从左往右依次填写的变量名称之为位置形参
def func1(a, b, c):pass
ps:当子代码只有一行并且很简单的情况下，可以直接在冒号后编写，不用换行
位置实参
在函数调用阶段括号内从左往右依次填写的数据值称之为位置实参
func1(1, 2, 3)
注意：
实参可以是数据值也可以是绑定了数据值的变量名
给位置形参传值时必须个数一致，多一个少一个都不行
关键字参数
- 在函数调用阶段括号内以什么等于什么的形式传值称之为关键字实参
ps:1.指名道姓的给形参传值（打破了位置的限制）
2.位置实参必须在关键字实参的前面
小诀窍：无论是形参还是实参，都遵循短的（简单的）在长的（复杂的）前面
3.同一个形参在一次调用中只能传一次值
eg:
def func(a, b):
print(a, b)
func(1, 2) # 1,2
func(b=1, a=2) # 2 1 关键字传参(指名道姓的传)
func(b=1,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) # 实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名
默认参数
- 默认值参数：在函数定义阶段括号内以什么等于什么的形式填写的形参
- 注意：
1. 默认参数必须在位置参数之后
2. 在函数定义阶段就给形参绑定值，后续调用阶段就可以不传
3. 调用阶段不传值就使用默认的，传了就用传了的
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')
可变长参数
可变长形参：可以打破形参与实参的个数限制，随意传值
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
"""
*号在形参中
用于接收多余的位置参数 组织成元组赋值给*号后面的变量名
"""
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'}
"""
**号在形参中
用于接收多余的关键字参数 组织成字典的形式赋值给**号后面的变量名
"""
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 func5(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
"""
可变长实参
*在实参中作用 把*后面的值拆分成实参
"""
*在实参中
类似于for循环 将所有循环遍历出来的数据按照位置参数一次性传给函数
"""
eg:
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')
"""
**在实参中
将字典打散成关键字参数的形式传递给函数
"""
eg:
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)
命名关键字参数(冷门了解)
# def func(a,b,*args):
# pass
# func(1,2)
# func(a=1,b=2)
# func(1,b=222)
'''需要形参在传实参的时候 必须按照关键字参数才可以'''
# 在形参*args的后面
def func(a, b, *args, c):
print(a, b, args, c)
func(1,2,3,4,5,6,7) # 报错
func(1, 2, 3, 4, 5, 6, c=666) # 1 2 (3, 4, 5, 6) 666
# 如果形参中还有**kwargs 那必须在它的前面
def func(a, b, *args, c, **kwargs):
print(a, b, args, c, kwargs)
func(1, 2, 3, 4, 5, 6, c=123, name='jason') # 1 2 (3, 4, 5, 6) 123 {'name': 'jason'}
名称空间
定义
名称空间就是用来存储变量名与数据值绑定关系的地方(我们也可以简单的理解为就是存储变量名的地方)
name = 'jason'：在内存中申请一块内存空间存储jason，然后绑定变量名name
变量名name与值jason的绑定关系就会被存储到名称空间中，之后使用名字都是去名称空间中查找并锁定对应的数据值
del name
删除的不是数据值，而是变量名以及变量名与数据值之间的绑定关系
名称空间的分类
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.当我们在局部名称空间中的时候
局部名称空间 >>> 全局名称空间 >>> 内置名称空间
2.当我们在全局名称空间中的时候
全局名称空间 >>> 内置名称空间
名字的查找顺序默认情况下不能颠倒只能是 局部>>>:全局>>>:内置
ps:其实名字的查找顺序是可以打破的
查找顺序案例
1.相互独立的局部名称空间默认不能够互相访问
def func1():
name = 'jason'
print(age)
def func2():
age = 18
print(name)
2.局部空间嵌套
先从自己的局部名称空间查找 之后由内而外依次查找
x = '123'
def func1():
x = 1
def func2():
x = 2
def func3():
x = 3
print(x)#3
func3()
print(x)#2
func2()
print(x)#1
func1()
print(x)#123
作业：
2.判断下列money的值是多少并说明理由 思考如何修改而不是新增绑定关系
money = 100
def index():
money = 666
print(money) # 100 因为没有调用局部空间，直接打印
money = 100
def func1():
money = 666
def func2():
money = 888
func2()
print(money) # 100 因为它是全局名称空间没有调用变量