【Python】函数进阶（推导式、全局作用域、多参数解析、装饰器）

妖狐艹你老母 2024-02-19 09:18 43阅读 0赞

## 一、推导式 ##

> 列表生成式是python内置的一种创建列表的方法，通过在**\[ \]**内部执行一行for循环语句，将for循环所遍 历到的元素添加到列表中。由于编译后的字节码更少， 因此比普通的采用append方法生成列表要快很 多，不仅如此，使用列表生成式编写的代码更加简洁，通过添加if else 语句，列表生成式也能对列表里 的元素进行限制。
> 
> 在Python编程语言中，**推导式（Comprehension）**是一种简洁的语法结构，用于快速创建序列对象（列表、集合、字典等）。推导式可以将循环和条件判断融合到一行代码中，使代码更加简洁和易读。

### 1、三种推导式 ###

> Python中有三种常见的推导式：列表推导式（List Comprehension）、集合推导式（Set Comprehension）和字典推导式（Dictionary Comprehension）。
> 
> 1.  列表推导式： 列表推导式用于快速创建一个列表。其基本语法为：\[expression for item in iterable if condition\]。 例如，我们可以使用列表推导式创建一个包含1到10的偶数的列表：
>     
>         evens = [x for x in range(1, 11) if x % 2 == 0] print(evens) # 输出: [2, 4, 6, 8, 10]
> 2.  集合推导式： 集合推导式用于快速创建一个集合。其基本语法为：\{expression for item in iterable if condition\}。 例如，我们可以使用集合推导式创建一个包含1到10的偶数的集合：
>     
>         evens = {x for x in range(1, 11) if x % 2 == 0} print(evens) # 输出: {2, 4, 6, 8, 10}
> 3.  字典推导式： 字典推导式用于快速创建一个字典。其基本语法为：\{key\_expression: value\_expression for item in iterable if condition\}。 例如，我们可以使用字典推导式创建一个包含1到10的偶数的字典，其中键是偶数，值是偶数的平方：
>     
>         evens_squared = {x: x**2 for x in range(1, 11) if x % 2 == 0} print(evens_squared) # 输出: {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}
> 
> 在使用推导式时需要注意代码的可读性和运行效率。虽然推导式能大大简化代码，但对于复杂的逻辑或数据处理过程，使用传统的循环结构可能更易理解和维护。

### 2、案例 ###

> 生成一个列表，列表里有10个元素，索引为奇数的元素值为1，索引为偶数的位置值为0

lst = [1 if item % 2 == 1 else 0 for item in range(1, 11)]

python的字典生成式通过在大括号\{\} 内执行一行for循环语句创建一个新的字典，大括号内的语句需要 指定键值对的key与value，这两项值都是for循环语句中变量。

class_dict = {
    'c++': 90,
    'python': 93,
    'java': 95,
    'javascript': 96,
    'node.js': 94
    }
    new_class_dict = {k: v for k, v in class_dict.items() if v >= 95}
    print(new_class_dict)

python集合生成式与列表生成式几乎是一模一样的，只需要将\[\]替换为\{\} 即可，在\{\}内执行一个for循环 语句，for循环所遍历的元素自动添加到集合之中。

lst = [
    {'name': 'python', 'price': 100},
    {'name': 'c++', 'price': 100},
    {'name': 'java', 'price': 80},
    {'name': 'java', 'price': 100},
    {'name': 'python', 'price': 85},
    {'name': 'node', 'price': 99},
    ]
    name_set = {item['name'] for item in lst}
    print(name_set)

## 二、全局作用域 ##

在Python中，全局作用域（Global Scope）是指在代码的最外层定义的变量和函数所拥有的作用域。在全局作用域中定义的变量和函数可以被程序的任何部分访问。

以下是关于全局作用域的几个重要点：

1.  全局变量： 在全局作用域中定义的变量即为全局变量。全局变量在程序的任何地方都可以被访问和修改。当你在一个函数中引用一个变量时，解释器首先会在局部作用域中查找该变量，如果找不到则继续在上一级的作用域中查找，直到找到或者查找到全局作用域。
2.  函数定义： 在全局作用域中定义的函数可以在代码的任何地方调用，无需考虑作用域的限制。
3.  使用global关键字： 如果你想在一个函数内改变全局变量的值，可以使用global关键字来声明全局变量。这样你就可以在函数内部通过变量名来访问和修改全局变量。

下面的示例演示了如何使用全局作用域：

# 全局作用域
    x = 10 
    
    def func():
        # 在函数内部访问全局变量
        print(x)
        
    def update_global():
        global x  # 使用global关键字声明将要修改的全局变量
        x = 20   # 修改全局变量的值
    
    # 调用函数
    func()  # 输出：10
    update_global()
    print(x)  # 输出：20

需要注意的是，在Python中，如果在函数内部对一个变量进行赋值操作，该变量默认为局部作用域的变量。如果你想在函数内部使用全局变量，并且不希望创建一个新的局部变量，可以通过global关键字来显式声明变量为全局变量。

## 三、多参数解析 ##

多参数解析是指通过一种机制，将多个参数传递给函数或方法，并在接收端进行解析。在Python中，常见的多参数解析方式主要有以下几种：

1.  位置参数（Positional Arguments）： 位置参数是最常见的参数解析方式，它根据参数传入的顺序来匹配和解析。当调用函数时，按照定义时的参数顺序依次传入实际参数值。
    
        def func(a, b, c): print(a, b, c) func(1, 2, 3) # 输出：1 2 3
2.  关键字参数（Keyword Arguments）： 关键字参数以键值对的形式传递给函数，通过参数的名称来进行匹配和解析。通过这种方式，可以明确指定参数的值。
    
        def func(a, b, c): print(a, b, c) func(a=1, b=2, c=3) # 输出：1 2 3
3.  默认参数（Default Arguments）： 默认参数是指在定义函数时，为参数设置一个默认值。这样，在函数调用时，如果没有对该参数进行赋值，将使用默认值。
    
        def func(a=1, b=2, c=3): print(a, b, c) func() # 输出：1 2 3
4.  可变数量的参数： 有时候，我们可能需要接收可变数量的参数，即在调用函数时不确定传入多少个参数。在Python中，可以使用特殊符号来实现这一功能。
    
     *  \***args**：用于接收任意数量的位置参数（非关键字参数）。
     *  \*\***kwargs**：用于接收任意数量的关键字参数。
    
        def func(*args, **kwargs):
            print("Positional arguments:", args)
            print("Keyword arguments:", kwargs)
        
        func(1, 2, 3, a=4, b=5) 
        # 输出：
        # Positional arguments: (1, 2, 3)
        # Keyword arguments: {'a': 4, 'b': 5}

> 如果你想在函数⾥同时使⽤所有这三种参数， 顺序是这样的：
> 
>     func(fargs, *args, **kwargs)

## 四、装饰器 ##

>  *  **闭包函数**：声明在一个函数中的函数，叫做闭包函数。
>  *  **闭包**：内部函数总是可以访问其所在的外部函数中声明的参数和变量，即使在其外部函数被返回了之 后。
> 
>     def outer(a):
>     def inner(b):
>     return a + b
>     return inner
> 
> 装饰器是闭包的一种应用。 装饰器就是用于拓展原来函数功能的一种函数，这个函数的特殊之处在于它的返回值也是一个函数，使 用装饰器的好处就是在不用更改原函数的代码前提下给函数增加新的功能。

装饰器（Decorator）是Python中一种特殊的语法，用于修改或扩展函数的功能。它可以在不修改原始函数代码的情况下，通过将函数作为参数传递给另一个函数来实现。装饰器通常用于在不修改已有函数代码的情况下，添加附加功能、验证输入、缓存数据等操作。

以下是装饰器的几个应用和作用案例：

**1. 计时器装饰器**：  
装饰器可以用来测量函数的执行时间。通过定义一个计时器装饰器，可以在调用函数前后记录时间并打印出函数执行时间。

import time
       
       def timer(func):
           def wrapper(*args, **kwargs):
               start_time = time.time()
               result = func(*args, **kwargs)
               end_time = time.time()
               execution_time = end_time - start_time
               print("Execution Time:", execution_time)
               return result
           return wrapper
       
       @timer
       def my_function():
           time.sleep(2)
           print("Function executed.")
           
       my_function()
       # 输出：
       # Function executed.
       # Execution Time: 2.0

**2. 认证装饰器：**  
装饰器可用于添加认证功能，用于验证用户是否具有访问函数的权限。这对于需要身份验证的Web应用程序特别有用。

def login_required(func):
           def wrapper(*args, **kwargs):
               if is_user_logged_in():
                   return func(*args, **kwargs)
               else:
                   return "You need to log in first."
           return wrapper
       
       @login_required
       def my_secure_function():
           return "Function executed."
       
       print(my_secure_function())  # 输出：You need to log in first.

**3. 缓存装饰器：**  
装饰器可以用于缓存函数的计算结果，以提高函数执行的效率。当再次调用函数时，如果输入参数和之前的相同，装饰器将直接返回缓存中的结果。 示例代码：

def cache(func):
           cached_results = {}
           def wrapper(*args):
               if args in cached_results:
                   return cached_results[args]
               else:
                   result = func(*args)
                   cached_results[args] = result
                   return result
           return wrapper
       
       @cache
       def factorial(n):
           if n == 0 or n == 1:
               return 1
           else:
              return n * factorial(n-1)
    
       print(factorial(5))  # 输出：120（第一次计算）
       print(factorial(5))  # 输出：120（直接从缓存中获取）

通过使用装饰器，我们可以非常方便地在函数的基础上添加附加功能，提高了代码的重用性、可读性和可维护性。装饰器是Python中强大而灵活的特性之一，可以满足不同场景下的各种需求。