目录
前言
- 1.明确函数的 调用阶段 和 定义阶段
- 2.调用阶段的是实参 定义阶段是形参
函数参数
位置参数
# 1.用位置实参传参
def func1(a, b): # 定义位置形参a，b
print(a, b)
func1(1, 2) # 按照位置一一对应传值 # 这里的1，2是位置实参
func1(1) # 少一个不行 # TypeError: func1() missing 1 required positional argument: 'b'
func1(1, 2, 3) # 多一个也不行 # TypeError: func1() takes 2 positional arguments but 3 were
关键字参数
# 2.用关键字实参传参
def func1(a, b):
print(a, b)
func1(b=1, a=2) # 2 1 # 指名道姓的传参
func1(b=1, 2) # 这样写会报错 # 这是一条规则 关键字实参必须跟在位置实参后面
# 报错如下： SyntaxError: positional argument follows keyword argument
func1(2, b=1) # 2 1 # 这样写可以 这是位置实参和关键字实参的混合使用
func1(1, a=2, b=3) # 报错 相当于给a传了2个实参
# 报错如下： TypeError: func1() got multiple values for argument 'a'
# 3.实参可以是变量名
name = 'alice'
age = 18
def func1(a, b):
print(a, b)
func1(name, age) # alice 18
func1(a=name, b=age) # alice 18
# 实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名
'''
口诀：(对于形参、实参都适用)
越短的越简单的越靠前
越长的越复杂的越靠后
同一个形参在调用的时候不能多次赋值
'''
默认参数
默认参数其实就是关键字形参，别名叫默认参数。
他的作用是：在函数定义阶段就已经给了 用户可以不传 也可以传
# 1.基本使用
def func2(a='miku'):
print(a)
func2() # miku # 不传实参 输出默认值
func2('tifa') # tifa # 传位置实参
func2(a='alice') # alice # 传关键字实参
# 2.默认形参不能在位置形参后面
def func2(a='miku',b): # 会报错 = =！
print(a)
# 定义阶段就会报错
# SyntaxError: non-default argument follows default argument
'''
越短的越简单的越靠前
越长的越复杂的越靠后'''
# 3.位置形参与关键字形参组合使用
def func2(a, b, c='miku'):
print(a, b, c)
func2('tifa', 'alice') # tifa alice miku # 至少要传2个
func2('tifa', 'alice', 'cloud') # tifa alice cloud # 传3个也行=。=
可变长形参
*args 接受多余的位置实参
# 首先申明：这里的*args是一种新的形参 跟以前不一样！！
# 之前的形参都只能对应一个实参 这个*args可以接受多个位置实参 将其存入一个元祖 然后可以通过变量名args
# 在函数内调用这个元祖= =
# 1.基本使用
def func1(*a):
print(a)
func1() # () # 不放实参 结果是个空元祖
func1(1) # (1,)
func1(1,2) # (1, 2)
# 2.位置形参 + *args
def func2(a, *b): # 星号后面只是一个变量名
print(a, b)
# func2() # 函数至少需要一个参数给到a
func2(1) # 1 ()
func2(1, 2, 3, 4) # 1 (2, 3, 4)
**kwargs 接受多余的关键字实参
# 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}
# 2.位置形参 + **kwargs
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} # 关键词实参给位置形参a传参 # 剩余的被**k全收
func4(a=1, b=2, c=3, x='miku', y='tifa') # 1 {'b': 2, 'c': 3, 'x': 'miku', 'y': 'tifa'}
*args **kwargs 组合使用
# 1.基本使用
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}
# 2. *args **kwargs 位置形参 组合使用
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}
干点反人类的事！
# 1.给*arg传关键字实参
def func(*a):
print(a)
func(a=1) # TypeError: func() got an unexpected keyword argument 'a
# 函数获得了意料之外的关键字参数a # 恭喜恭喜
# 2.给*kwargs传位置实参
def func(**k):
print(k)
func(1) # 报错 # TypeError: func() takes 0 positional arguments but 1 was given
# 3.反着用
def func(**k,*a):
print(k,a)
# 在定义阶段就会报错 # SyntaxError: invalid syntax
# 折磨python解释器
对传参的总结
可变长实参
# 1.使用单星号传参
def index(a, b, c):
print(a, b, c)
# 这些哥们等待传参
l1 = [11, 22, 33]
t1 = (33, 22, 11)
s1 = 'miku'
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('m','o','m')
index(*se) # index(321 123 222)
index(*d1) # index('username','pwd','age')
# 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)
命名关键字参数(了解)
# 1.基本使用
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)
# 2.更多规则
def f(pos1, pos2, /, pos_or_kwd, *args, kwd1, kwd2, **kwargs):
print(pos1, pos2, pos_or_kwd, args, kwd1, kwd2, kwargs)
# / 用于在逻辑上分割仅限位置形参与其它形参 / 左边仅限位置参数
f(1, 2, 3, 4, 5, 6, 7, kwd1=1, kwd2=2, miku='cute') # 1 2 3 (4, 5, 6, 7) 1 2 {'miku': 'cute'}
# 最少需要传这些实参
f(1, 2, 3, kwd1=4, kwd2=5) # 1 2 3 () 4 5 {}
# 前面两个形参就必须传位置实参
f(pos1=1, pos2=2, pos_or_kwd=3, kwd1=4, kwd2=5) # 报错 # TypeError: f() missing 2 required positional arguments: 'pos1' and 'pos2'
# 第三个形参 可以传位置实参 也可以传关键字实参
f(1, 2, pos_or_kwd=3, kwd1=4, kwd2=5) # 1 2 3 () 4 5 {}
# 3.形参规则总结
# 位置形参 / 1个形参 n个位置形参 关键字形参 n个关键字形参
- 想了解更多可以看python官方文档
名称空间
"""
name = 'miku'
1.申请内存空间存储miku
2.给miku绑定一个变量名name
3.后续通过变量名name就可以访问到miku
"""
名称空间就是用来存储变量名与数据值绑定关系的地方(我们也可以简单的理解为就是存储变量名的地方)
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.存活周期
内置名称空间
python解释器启动则创建 关闭则销毁
全局名称空间
py文件执行则创建 运行结束则销毁
局部名称空间
函数体代码运行创建 函数体代码结束则销毁(类暂且不考虑)
# 2.作用域
内置名称空间
解释器级别的全局有效
全局名称空间
py文件级别的全局有效
局部名称空间
函数体代码内有效
名字的查找顺序
涉及到名字的查找 一定要先搞明白自己在哪个空间
1.当我们在局部名称空间中的时候
局部名称空间 >>> 全局名称空间 >>> 内置名称空间
2.当我们在全局名称空间中的时候
全局名称空间 >>> 内置名称空间
ps:其实名字的查找顺序是可以打破的
名称空间练习
看再多理论，不如多做几道题！
# 1.相互独立的局部名称空间默认不能够互相访问
def func1():
name = 'jason'
print(age)
def func2():
age = 18
print(name)
func1() # 报错 # NameError: name 'age' is not defined
# 2.局部名称空间嵌套
# 先从自己的局部名称空间查找 之后由内而外依次查找
# 函数体代码中名字的查找顺序在函数定义阶段就已经固定死了
x = 0
def func1():
x = 1
def func2():
x = 2
def func3():
x = 'miku'
print(x)
func3()
func2()
func1() # miku
函数体给框起来了:
# 3.定义阶段做的事儿
def fool():
x = 'tifa'
def fool2(): # 函数体代码中名字的查找顺序在函数定义阶段就已经固定死了
print(x) # 在定义阶段 这个x 它知道自己要去 fool2的局部命名空间取值'miku' 他不会去外层取'tifa'
x = 'miku'
fool2() # 在调用阶段会报错 # UnboundLocalError: local variable 'x' referenced before assignment
fool()
练习
# 判断下列money的值是多少并说明理由 思考如何修改而不是新增绑定关系
money = 100
def index():
money = 666
print(money)
# 调用index函数 会先在局部里面找money 所以应该输出666
money = 100
def func1():
money = 666
def func2():
money = 888
func2()
print(money)
# 调用func2函数 什么也没发生 函数定义阶段时 func1中 新增money=666 func2中 新增money==888 这两个不是一个东西 它们在不同的局部命名空间
# print(money) 这段代码在全局空间 所以他先去全局空间找 啊 找到一个money=100 所以输出一个100