python函数参数,序列解包

最新推荐文章于 2024-05-17 13:34:14 发布

元丷

最新推荐文章于 2024-05-17 13:34:14 发布

阅读量3.4k

点赞数 3

分类专栏： Python python 文章标签： python 函数参数序列解包

本文链接：https://blog.csdn.net/qq_39603089/article/details/89929431

版权

Python 同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

python

8 篇文章 0 订阅

订阅专栏

函数参数

在这里插入图片描述

函数的定义与使用
```
def 函数名([参数列表])：
	'''注释'''
	函数体
```
- 函数形参不需要声明起类型，也不需要制定函数的返回值类型。
- 及时改函数不需要接受任何参数，也必须保留一对空的括号。
- 括号后面的冒号必不可少。
- 函数体相对于def关键字必须保持一定的空格缩进。
- Python允许嵌套定义函数
函数参数

在Python中，函数参数有很多种：可以为普通参数、默认值参数、关键参数、可变长度参数等等。

Python在定义函数时不需要指定形参的类型，完全由调用者传递的实参类型以及Python解释器的理解和推断来决定，类似于重载和泛型。
- 位置参数
  
  调用函数时实参和形参的顺序严格一致，比起实参和形参的数量必须相同
```
def demo(a,b,c):    #所有形参都是位置参数
    print(a,b,c)
    
>>>demo(2,3,4)
2,3,4

>>>demo(2,3,4,5)    #实参与形参的数量必须相同
demo() takes 3 positional arguments but 4 were given
```
- 默认值参数
  
  调用带有默认值参数的函数时，可以不对默认值参数进行赋值，也可以为其赋值，具有很大的灵活性。
```
def say(message,times = 1,sx = 2):
    函数体
>>> say(1,2)
1 2 2
>>> say.__defaults__
(1, 2)
```
  函数名.__ defaults__ 可以查看函数所有默认值参数的当前值，返回胃一个元组，元素依次表示每个默认值的当前值。
  
  注意：默认值参数必须出现在函数参数列表的最右端，任何一个默认值参数右边不能有非默认值参数。
- 关键参数
  
  关键字参数主要只调用函数时的参数传递方式，通过关键参数，实参顺序可以和形参顺序不一致，但不影响传递结果，避免了用户需要牢记位置参数顺序的麻烦。
```
>>> say(2,sx=3)
2 1 3
```
- 可变长度参数
  - 可变长度参数主要有两种形式：在参数名前加1个*或2个**
  - *parameter用来接受多个实参并将其放在一个元组中
  - **parameter接受多个关键参数并存放到字典中
    
    *parameter的用法
    
    无论调用该函数时传递了多少实参，一律将其放入元组中
```
>>> def demo(*p):
    print(p)
>>> demo(1,2,3)
(1, 2, 3)
>>> demo(1,2)
(1, 2)
>>> demo(1,2,3,4,5,6,7)
(1, 2, 3, 4, 5, 6, 7)
```
    **parameter的用法
    
    调用该函数时自动将接受的参数转换为字典
```
>>> def demo(**p):
    for item in p.items():
        print(item)
>>> demo(x=1,y=2,z=3)
('y', 2)
('x', 1)
('z', 3)
```
    在函数定义中增加一些外围的检查代码，可以防止用户调用函数时传入无效参数。
```
def demo(a,b,**kwargs):
	for para in kwargs.keys():
		if para not in ('x','y','z')
			raise Exception('{0}is not a valid parameter'.format(para))
	print(a+b+sum(kwargs.values()))
	# 只能接收'x','y','z',这三个参数
```
    定义函数时可以同时使用位置参数，关键参数，默认参数和可变长度参数。一般不要这样做
    
    降低可读性，查错困难，函数设计不好，不满足模块高内聚的要求。
- 强制函数的某些参数必须以关键参数形式进行传值
  
  在函数定义是，位于*parameter活单独一个星号 *之后的所有参数都只能以关键参数的形式进行传值，不接收其他任何形式的传值。
  
  如果需要强制所有参数都必须以关键参数形式进行传值，可以在定义函数时把单独以个星号*作为函数第一个参数。
```
>>> def demo(a, b, *, c):
...     print(a+b+c)
...
>>> demo(1,2,c=2)
5
>>> def demo(a, b, *p, c):
...     print(a+b+c+sum(p))
...
>>> demo(1,2,3,4,5,c=6)
21
```
- 传递参数是的序列解包
  
  序列解包是非常重要且常用的一个功能。
```
>>> lt = [1,2,3]
>>> a, b, c = lt
>>> print(a,b,c)
1 2 3
>>> x, y, z = 1, 2, 3
>>> print(x,y,z)
1 2 3
>>> a_tuple=tuple(range(3))
>>> x,y,z = a_tuple
>>> print(x,y,z)
0 1 2
>>> x, y, z = map(str, range(3))
```
  在Python列表、元组、集合、字典以及其他可迭代对象，对字典使用时，默认是对字典“键”进行操作，Python解释器将自动进行解包。对“键：值” 对进行操作使用字典的items()方法，对“值”进行操作应使用 values() 方法进行指定。
```
>>> s = {'a':1,'b':2}
>>> a,b = s
>>> a
'a'
>>> a,b = s.items()
>>> b
('b', 2)
>>> a,b = s.values()
>>> a
1
>>> a,b,c='ABC'
>>> a
'A'
```
  特殊用法：
```
>>> print(*[1,2,3],4,*(5,6))
1 2 3 4 5 6
>>> *range(3),3
(0, 1, 2, 3)
>>> {*range(3),3,4}
{0, 1, 2, 3, 4}
>>> {'a':1,**{'b':2}}
{'a': 1, 'b': 2}
```
  序列解包逆运算
```
>>> a, *b, c = 1,2,3,4,5
>>> a,b,c
(1, [2, 3, 4], 5)
>>> a,*b,c=tuple(range(20))
>>> b
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
```
  传递参数是的序列解包
```
>>> def demo(a,b,c):
...     print(a,b,c)
...
>>> seq = [1,2,3]
>>> demo(*seq)
1 2 3
>>> seq = {1:'a',2:'b',3:'c'}
>>> demo(*seq)
1 2 3
>>> demo(*seq.values())
a b c
```
  如果实参是字典可以使用两个星号 ** 进行解包，会把字典转换成类似于关键字参数的形式进行参数传递。要求实参字典中的所有键都必须是函数的形参名称，或者于函数中两个星号的可变长度参数相对应。
```
>>> p = {'a':1,'b':2,'c':3}
>>> def f(a,b,c=5):
...     print(a,b,c)
...
>>> f(**p)
1 2 3
>>> def demo(**p):
...     for item in p.items():
...             print(item)
...
>>> demo(**p)
('a', 1)
('b', 2)
('c', 3)
```
  一个函数需要以多种新式来接收参数，定义时一般把位置参数放在最前面，然后是默认值参数，接下来是一个星号的可变长度参数，最后两个星号的可变长度参数；调用函数是，一般也按照这个顺序进行参数传递。调用函数时如果对实参使用一个星号* 进行序列解包，那么这些解包后的实参将会被当做普通位置参数对待，并且会在关键参数和使用两个星号** 进行解包的参数之前进行处理。

元丷

关注

3
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
python函数参数,序列解包

函数参数函数的定义与使用def 函数名([参数列表])： '''注释''' 函数体函数形参不需要声明起类型，也不需要制定函数的返回值类型。及时改函数不需要接受任何参数，也必须保留一对空的括号。括号后面的冒号必不可少。函数体相对于def关键字必须保持一定的空格缩进。Python允许嵌套定义函数函数参数在Python中，函数参数有很多种：可以为普通参数、默认值参...
复制链接

扫一扫

专栏目录