今日内容概要
- 函数参数
- 名称空间与作用域
- 名字的查找顺序
今日内容详细
函数参数
位置参数及关键字参数
位置形参
函数定义阶段括号内从左往右依次填写的变量名
def func(a, b, c):pass # 括号内a b c 都是位置形参
'''当子代码只有一行并且很简单的情况下 可以直接在冒号后编写 不用换行'''
位置实参
函数调用阶段括号内从左往右依次填写的数据值
func(1, 2, 3) # 按照位置传参 一一对应传值
关键字实参
func(b=2, a=1, c=3) # 传参数的时候指名道姓的传
'''传参注意事项'''
有多少个形参就要传多少个实参
def func1(a, b):
print(a, b)
func(1) # 少一个参数 会报错
func(1, 2, 3) # 多一个参数 会报错
func(b=1, 2) # 关键字传参一定要跟在位置传参后面 会报错
func(2, b=1) # 关键字传参和位置传参正确写法
func(1, a=2, b=3) # 同一个形参在调用的时候不能多次赋值 会报错
'''实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名'''
name = 'cxk'
pwd = 123
func(name, pwd) # 位置传参
func(a=name, b=pwd) #关键字传参
'''
越短的越简单的越靠前
越长的越复杂的越靠后
但是遇到下列的情况除外
同一个形参在调用的时候不能多次赋值
'''
默认参数
本质其实就是关键字形参别名叫默认参数:提前就已经给了 用户可以不传也可以传
'''默认参数的定义也遵循短的简单的靠前 长的复杂的靠后'''
def register(name, age, gender='male'):
print(f'''
======信息======
姓名:{name}
年龄:{age}
性别:{gender}
================
''')
register('cxk', 18) # 因为有默认参数 所以可以不传gender参数
# register('cxk', 18, 'male')
register('lili', 18, 'female') # 也可以传gender参数 传新参数覆盖默认参数
register('lili', 18, gender='female') # 通过关键字传参
可变长参数
可变长形参
*变量名 表示
'''*号在形参中用于接收多余的位置参数 组织成元祖赋值给*号后的变量名'''
def func(*a):
print(a)
func() # () 没有传参也可以运行
func(1) # (1,)
func(1, 2) # (1, 2)
def func1(a, *b):
print(a, b)
func1() # 会报错 至少要传一个参数给到a
func1(1) # 1, ()
func1(1, 2, 3) # 1, (2, 3)
'''不建议的写法'''
def func2(*a, b):
print(a, b)
func(1, 2) # 会报错 所有参数都被a接收 b接收不到参数
func(b=1, 2) # 会报错 位置参数必须在关键字参数前
func(1, b=2) # (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(1) # 1 {}
func4(a=1) # 1 {}
func4(a=1, b=2, c=3) # 1 {'b': 2, 'c': 3}
*和**结合使用
def func5(*a, **b):
print(a, b)
func5() # () {}
func5(1) # (1,) {}
func5(a=1, b=2) # () {'a':1, 'b': 2}
fucn5(1, 2, 3, a=4, b=5) # (1, 2, 3) {'a':4, 'b': 5}
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
'''
可变长实参
'''*在实参中类似于for循环 将所有循环遍历出来的数据按照位置参数一次性传给函数'''
def fucn(a, b, c):
print(a, b, c)
'''将列表中的三个数据值取出来传给函数的三个形参'''
l1 = [1, 2, 3] # 列表中的数据值个数要和形参的个数相同不然报错
func(l1[0], l1[1], l1[2]) # 通过索引取值后传参 比较麻烦
func(*l1) # 等同于func(1, 2, 3) 1 2 3
'''将元组中的三个数据值取出来传给函数的三个形参'''
t1 = (1, 2, 3) # 元祖中的数据值个数要和形参的个数相同不然报错
func(t1[0], t1[1], t1[2]) # 通过索引取值后传参 比较麻烦
func(*t1) # 等同于func(1, 2, 3) 1 2 3
'''将字符串中的三个数据值取出来传给函数的三个形参'''
s1 = 'cxk' # 字符串中的字符个数要和形参的个数相同不然报错
func(*s1) # 等同于func('c', 'x', 'k') c x k
'''将集合中的三个数据值取出来传给函数的三个形参'''
se = {1, 2, 3}
func(*se) # 集合是无序的 所以是不按顺序传参的
'''将字典中的三个数据值取出来传给函数的三个形参'''
d1 = {'num': 1, 'num1': 2, 'num2': 3} # 通过*只会将key值传过去
func(*d1) # 等同于func('num','num1', 'num2')
'''**在实参中是将字典打散成关键字参数的形式传递给函数'''
def func1(name, age):
print(name, age)
d2 = {'name': 'cxk', 'age': 18}
func1(**d2) # 等同于func1('name'='cxk', 'age'=18)
'''可变长形参和实参结合使用'''
def func2(*args, **kwargs):
print(args)
print(kwargs)
func2(*(1, 2, 3)) # (1, 2, 3)
# {}
命名关键字参数
'''形参必须按照关键字参数传值'''
def index(name, *args, gender='male', **kwargs):
print(name, args, gender, kwargs)
index('jason',1,2,3,4,a=1,b=2)
# jason (1, 2, 3, 4) male {'a': 1, 'b': 2}
index('jason', 1, 2, 3, 4, 'female', b=2)
# jason (1, 2, 3, 4, 'female') male {'b': 2}
index('jason', 1, 2, 3, 4, a=1, gender='female', b=2)
# jason (1, 2, 3, 4) female {'a': 1, 'b': 2}
名称空间及它的存活周期和作用范围(域)
名称空间就是用来存储变量名与数据值绑定关系的地方(可以理解为就是存储变量名的地方)
内置名称空间
解释器运行自动产生 里面包含了很多名字
如: len print input
存活周期
python解释器启动则创建 关闭则销毁
作用域
解释器级别的全局有效
全局名称空间
py文件运行产生 里面存放文件级别的名字
name = 'cxk'
if name:
age = 18
while True:
gender = 'male'
def func():
pass
class MyClass(object):
pass
其中的name\age\gender\func\MyClass都存放在全局名称空间中
存活周期
py文件执行则创建 运行结束则销毁
作用域
py文件级别的全局有效
局部名称空间
函数体代码内运行\类体代码内运行产生的空间
def func():
name = 'cxk'
class MyClass(object):
name = 'jack'
其中各自的name都存放在函数体代码内运行\类体代码内运行产生的空间中
存活周期
函数体代码运行创建 结束则销毁
作用域
函数体代码内有效
名字的查找顺序
涉及到名字的查找 一定要先搞明白自己在哪个空间
1.当我们在局部名称空间中的时候
局部名称空间 >>> 全局名称空间 >>> 内置名称空间
2.当我们在全局名称空间中的时候
全局名称空间 >>> 内置名称空间
'''其实名字的查找顺序是可以打破的'''
查找顺序案例
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()
"""