• 欢迎光临~

函数参数

开发技术 开发技术 2022-10-10 次浏览

目录
  • 前言
  • 函数参数
    • 位置参数
    • 关键字参数
    • 默认参数
    • 可变长形参
      • *args 接受多余的位置实参
      • **kwargs 接受多余的关键字实参
      • *args **kwargs 组合使用
      • 干点反人类的事!
      • 对传参的总结
    • 可变长实参
      • 命名关键字参数(了解)
    • 名称空间
      • 名称空间存活时间和作用域
      • 名字的查找顺序
      • 名称空间练习
    • 练习

前言

  • 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
	# nameagegenderindexMyClass 这些都是存在全局名称空间中啊!!
    
3.局部名称空间
	函数体代码运行类体代码运行 产生的空间

函数参数

参考:菜鸟教程 Python3 命名空间和作用域

名称空间存活时间和作用域

# 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
   
程序员灯塔
转载请注明原文链接:函数参数
喜欢 (0)
违法和不良信息举报电话:022-22558618 举报邮箱:dljd@tidljd.com