Python中的参数打包和解包

我们使用两个运算符 *（用于元组）和 **（用于字典）。

考虑这样一种情况：我们有一个函数接收四个参数。我们想调用这个函数，我们有一个大小为4的列表，其中包含该函数的所有参数。如果我们简单地传递一个列表给函数，调用就不起作用。

# A sample function that takes 4 arguments
# and prints them.
def fun(a, b, c, d):
    print(a, b, c, d)
 
# Driver Code
my_list = [1, 2, 3, 4]
 
# This doesn't work
fun(my_list)

输出

TypeError: fun() takes exactly 4 arguments (1 given)

解包

我们可以使用 * 来解包列表，这样它的所有元素都可以作为不同的参数传递。

# A sample function that takes 4 arguments
# and prints the,
def fun(a, b, c, d):
    print(a, b, c, d)
 
# Driver Code
my_list = [1, 2, 3, 4]
 
# Unpacking list into four arguments
fun(*my_list)

输出

(1, 2, 3, 4)

需要记住参数的长度必须与我们为参数解包的列表的长度相同。

# Error when len(args) != no of actual arguments
# required by the function
 
args = [0, 1, 4, 9]
 
 
def func(a, b, c):
    return a + b + c
 
 
# calling function with unpacking args
func(*args)

输出

Traceback (most recent call last):
  File "/home/592a8d2a568a0c12061950aa99d6dec3.py", line 10, in <module>
    func(*args)
TypeError: func() takes 3 positional arguments but 4 were given

再举一个例子，考虑内置的range（）函数，它需要单独的开始和停止参数。如果它们不能单独使用，请使用 *运算符编写函数调用，以将参数从列表或元组中解包：

>>>
>>> range(3, 6)  # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> range(*args)  # call with arguments unpacked from a list
[3, 4, 5]

打包

当我们不知道有多少参数需要传递给Python函数时，我们可以将所有参数打包到元组中。

# A Python program to demonstrate use
# of packing
 
# This function uses packing to sum
# unknown number of arguments
def mySum(*args):
    return sum(args)
 
# Driver code
print(mySum(1, 2, 3, 4, 5))
print(mySum(10, 20))

输出

15
30

上面的函数mySum（）进行“打包”，将该方法调用接收到的所有参数打包到一个变量中。一旦我们有了这个’packed’变量，我们就可以用它来做我们用普通元组做的事情。args[0]和args[1]将分别给予第一个和第二个参数。由于我们的元组是不可变的，所以可以将args元组转换为列表，这样就可以修改、删除和重新排列i中的项。

下面是一个展示打包和解包的示例。

# A Python program to demonstrate both packing and
# unpacking.
 
# A sample python function that takes three arguments
# and prints them
def fun1(a, b, c):
    print(a, b, c)
 
# Another sample function.
# This is an example of PACKING. All arguments passed
# to fun2 are packed into tuple *args.
def fun2(*args):
 
    # Convert args tuple to a list so we can modify it
    args = list(args)
 
    # Modifying args
    args[0] = 'python'
    args[1] = 'awesome'
 
    # UNPACKING args and calling fun1()
    fun1(*args)
 
# Driver code
fun2('Hello', 'beautiful', 'world!')

输出

(python, awesome, world!)

** 用于字典

# A sample program to demonstrate unpacking of
# dictionary items using **
def fun(a, b, c):
    print(a, b, c)
 
# A call with unpacking of dictionary
d = {'a':2, 'b':4, 'c':10}
fun(**d)

输出

2 4 10

这里 ** 解包了与它一起使用的字典，并将字典中的项作为关键字参数传递给函数。所以写“fun（1，**d）”相当于写“fun（1，b=4，c=10）”。

# A Python program to demonstrate packing of
# dictionary items using **
def fun(**kwargs):
 
    # kwargs is a dict
    print(type(kwargs))
 
    # Printing dictionary items
    for key in kwargs:
        print("%s = %s" % (key, kwargs[key]))
 
# Driver code
fun(name="geeks", ID="101", language="Python")

输出

<class 'dict'>
name = geeks
ID = 101
language = Python

应用和要点

1. 在套接字编程中用于向服务器发送大量请求。
2. 在Django框架中用于将变量参数发送到视图函数。
3. 有一些包装函数要求我们传入变量参数。
4. 参数的修改变得很容易，所以必须小心使用它们。