Python中的*（星号）和**(双星号）完全详解

冷不防 2023-10-16 09:43 20阅读 0赞

![8f6e956b80594ad09f88fd9a453c3060.png][]

在Python中，\*和\*\*是两个重要的运算符，它们具有不同的用途。

\*（星号）用于解包序列或可迭代对象，将其元素分配给函数的参数或在列表、元组等数据结构中进行拼接。

\*\*（双星号）用于解包字典，将其键值对传递给函数的参数或在字典中进行拼接。

【示例代码】

下面是在实际接口自动化工作中常见的示例代码，演示了\*和\*\*的使用。

使用\*解包序列或可迭代对象

# 示例：传递可变数量的参数
    def sum_values(*args):
        total = 0
        for num in args:
            total += num
        return total
    result = sum_values(1, 2, 3, 4, 5)
    print(result)  # 输出：15
    # 示例：拼接列表
    numbers = [1, 2, 3, 4, 5]
    result = [*numbers, 6, 7, 8]
    print(result)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8]
    
    # 使用**解包字典
    # 示例1：传递可变数量的关键字参数
    def print_info(**kwargs):
        for key, value in kwargs.items():
            print(key, ":", value)
    print_info(name="Alice", age=25, city="New York")
    # 输出：
    # name : Alice
    # age : 25
    # city : New York
    
    # 示例：拼接字典
    defaults = {"color": "red", "size": "medium"}
    user_preferences = {"size": "large", "theme": "dark"}
    result = {**defaults, **user_preferences}
    print(result)
    # 输出：{'color': 'red', 'size': 'large', 'theme': 'dark'}

这些示例代码展示了\*和\*\*的基本用法。它们在接口自动化工作中可以用于传递可变数量的参数或关键字参数，以及在数据结构中进行拼接操作。

【\*（星号）的用途】

函数参数解包：当你有一个包含多个元素的列表或元组时，可以使用\*将其解包，并将每个元素作为单独的参数传递给函数。

# 示例代码：
    def multiply(a, b, c):
        return a * b * c
    numbers = [2, 3, 4]
    result = multiply(*numbers)
    print(result)  # 输出：24
    # 序列解包：使用*可以将一个序列解包到另一个序列中。
    
    # 示例代码：
    numbers = [1, 2, 3]
    new_numbers = [*numbers, 4, 5, 6]
    print(new_numbers)  # 输出：[1, 2, 3, 4, 5, 6]
    可变数量的参数：在函数定义时，*args可以接受可变数量的参数，这些参数被封装为一个元组。
    
    # 示例代码：
    def calculate_sum(*args):
        total = 0
        for num in args:
            total += num
        return total
    result = calculate_sum(1, 2, 3, 4, 5)
    print(result)  # 输出：15

【\*\*（双星号）的用途】

字典解包：使用\*\*可以将字典解包为关键字参数，将键值对传递给函数。

# 示例代码：
    def print_info(name, age, city):
        print("Name:", name)
        print("Age:", age)
        print("City:", city)
    user_info = {"name": "Alice", "age": 25, "city": "New York"}
    print_info(**user_info)
    # 输出：
    # Name: Alice
    # Age: 25
    # City: New York
    字典拼接：使用**可以将多个字典进行拼接。
    # 示例代码：
    defaults = {"color": "red", "size": "medium"}
    user_preferences = {"size": "large", "theme": "dark"}
    result = {**defaults, **user_preferences}
    print(result)
    # 输出：{'color': 'red', 'size': 'large', 'theme': 'dark'}

可变数量的关键字参数：在函数定义时，\*\*kwargs可以接受可变数量的关键字参数，这些参数被封装为一个字典。

# 示例代码：
    def print_info(**kwargs):
        for key, value in kwargs.items():
            print(key, ":", value)
    print_info(name="Alice", age=25, city="New York")
    # 输出：
    # name : Alice
    # age : 25
    # city : New York

【应用场景】

\*和\*\*在接口自动化工作中具有广泛的应用。它们可以帮助我们处理可变数量的参数、解包数据结构、动态构建函数调用等。

例如，在发送HTTP请求时，我们经常需要传递不同数量和类型的参数。使用\*和\*\*可以根据需要动态传递参数，而无需事先确定参数的数量。

# 示例代码：
    import requests
    def send_request(url, method="GET", **kwargs):
        response = requests.request(method, url, **kwargs)
        return response
    # 发送GET请求
    response1 = send_request("https://api.example.com/data")
    # 发送POST请求
    data = {"username": "Alice", "password": "123456"}
    response2 = send_request("https://api.example.com/login", method="POST", json=data)

在这个例子中，我们定义了一个send\_request函数，它可以根据需要传递不同的参数。通过使用\*\*kwargs，我们可以在函数调用时灵活地传递各种关键字参数，例如headers、params、json等。

请注意，和\*\*还可以用于其他更复杂的情况，例如在函数定义时使用args和kwargs来接受不定数量的参数，或者在函数调用时使用\*和来传递已经打包好的参数。此外，\*和\*\*还在迭代器和生成器中有其他的应用场景。

【\*在迭代器和生成器中的作用】

在迭代器和生成器中，\*用于展开可迭代对象并将其作为单独的元素进行处理。

# 示例代码：
    # 迭代器示例
    numbers = [1, 2, 3, 4, 5]
    iterator = iter(numbers)
    first, *rest = iterator
    print(first)  # 输出：1
    print(rest)  # 输出：[2, 3, 4, 5]
    # 生成器示例
    def generate_numbers():
        yield from range(1, 6)
    first, *rest = generate_numbers()
    print(first)  # 输出：1
    print(rest)  # 输出：[2, 3, 4, 5]

在这个例子中，我们使用\*将可迭代对象(numbers和generate\_numbers())中的元素展开，并将第一个元素赋值给变量first，将剩余的元素赋值给变量rest。

【\*\*在迭代器和生成器中的作用】

在迭代器和生成器中，\*\*用于接收和传递关键字参数。

# 示例代码：
    # 迭代器示例
    def iterate_dict():
        yield {"name": "Alice", "age": 25}
    data = next(iterate_dict())
    print(data)  # 输出：{'name': 'Alice', 'age': 25}
    # 生成器示例
    def generate_dict():
        yield {"name": "Bob", "age": 30}
    data = next(generate_dict())
    print(data)  # 输出：{'name': 'Bob', 'age': 30}

在这个例子中，我们使用\*\*将关键字参数作为字典进行传递，并在迭代器和生成器中生成包含关键字参数的字典对象。

【应用场景】

在实际的接口自动化工作中，我们经常需要处理迭代器和生成器来处理大量的数据或实现惰性计算。\*和\*\*在这些场景中非常有用，可以帮助我们处理迭代器和生成器中的元素和关键字参数。

例如，在处理API响应数据时，我们可以使用迭代器和生成器来逐个处理返回的结果。同时，使用\*可以将这些结果展开并进行进一步的处理，而使用\*\*可以将关键字参数传递给其他函数或方法。

# 示例代码：
    import requests
    def fetch_data(url):
        response = requests.get(url)
        yield from response.json()
    def process_data(*data):
        # 处理数据的逻辑
        pass
    url = "https://api.example.com/data"
    data_generator = fetch_data(url)
    first_data, *rest_data = data_generator
    # 处理第一个数据
    process_data(first_data)
    # 处理剩余的数据
    process_data(*rest_data)

在这个例子中，我们通过fetch\_data函数获取API的响应数据，并通过生成器逐个返回数据项。然后，我们使用\*将第一个数据项单独处理，将剩余的数据项作为参数列表传递给process\_data函数进行处理。

总结起来，\*和\*\*运算符在Python中具有广泛的应用，能够使我们的代码更加灵活和动态。它们可以用于解包序列和字典、处理可变数量的参数和关键字参数等。在实际的接口自动化工作中，我们可以利用它们来处理不确定的参数情况，提高代码的灵活性和可扩展性。

**最后：**下方这份完整的软件测试视频教程已经整理上传完成，需要的朋友们可以自行领取**【保证100%免费】**

![8b0171187dce405e878f274a8cdd9ec0.png][]

#### **软件测试面试文档** ####

我们学习必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有字节大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

![a3e4226c935c4242804cbdf26b571bc6.png][]

![58df6cd288094ad8874e814f2477620b.gif][]

[8f6e956b80594ad09f88fd9a453c3060.png]: https://img-blog.csdnimg.cn/8f6e956b80594ad09f88fd9a453c3060.png
[8b0171187dce405e878f274a8cdd9ec0.png]: https://img-blog.csdnimg.cn/8b0171187dce405e878f274a8cdd9ec0.png
[a3e4226c935c4242804cbdf26b571bc6.png]: https://img-blog.csdnimg.cn/a3e4226c935c4242804cbdf26b571bc6.png
[58df6cd288094ad8874e814f2477620b.gif]: https://img-blog.csdnimg.cn/58df6cd288094ad8874e814f2477620b.gif