Python 内部函数：它们有什么用？

目录

内部函数，也被称为嵌套函数，是函数，你其他函数中定义。在 Python 中，这种函数可以直接访问在封闭函数中定义的变量和名称。内部函数有很多用途，最显着的是作为闭包工厂和装饰器函数。

在本教程中，您将学习如何：

• 提供封装并隐藏您的功能以防止外部访问
• 编写辅助函数以方便代码重用
• 创建在调用之间保留状态的闭包工厂函数
• 代码装饰器函数向现有函数添加行为

创建 Python 内部函数

在另一个函数内部定义的函数称为内部函数或嵌套函数。在 Python 中，这种函数可以访问封闭函数中的名称。以下是如何在 Python 中创建内部函数的示例：

>>> def outer_func():
...     def inner_func():
...         print("Hello, World!")
...     inner_func()
...

>>> outer_func()
Hello, World!

在此代码，可以定义inner_func()里面outer_func()，以打印的Hello, World!消息到屏幕上。要做到这一点，你叫inner_func()上的最后一行outer_func()。这是在 Python 中编写内部函数的最快方法。然而，内部函数提供了许多有趣的可能性，超出了您在本示例中看到的内容。

内部函数的核心特征是即使在该函数返回后，它们也能够从其封闭函数访问变量和对象。封闭函数提供了一个内部函数可以访问的命名空间：

>>> def outer_func(who):
...     def inner_func():
...         print(f"Hello, {who}")
...     inner_func()
...

>>> outer_func("World!")
Hello, World!

现在，您可以将字符串作为参数传递给outer_func()，并将inner_func()通过名称访问该参数who。但是，此名称是在 的本地范围内定义的outer_func()。您在外部函数的局部作用域中定义的名称称为非局部名称。从这个inner_func()角度来看，它们是非本地的。

以下是如何创建和使用更精细的内部函数的示例：

>>> def factorial(number):
...     # Validate input
...     if not isinstance(number, int):
...         raise TypeError("Sorry. 'number' must be an integer.")
...     if number < 0:
...         raise ValueError("Sorry. 'number' must be zero or positive.")
...     # Calculate the factorial of number
...     def inner_factorial(number):
...         if number <= 1:
...             return 1
...         return number * inner_factorial(number - 1)
...     return inner_factorial(number)
...

>>> factorial(4)
24

在 中factorial()，您首先验证输入数据以确保您的用户提供一个等于或大于零的整数。然后定义一个递归内部函数，调用inner_factorial()它执行阶乘计算并返回结果。最后一步是调用inner_factorial().

使用这种模式的主要优点是，通过在外部函数中执行所有参数检查，您可以安全地跳过内部函数中的错误检查并专注于手头的计算。

>>> def increment(number):
...     def inner_increment():
...         return number + 1
...     return inner_increment()
...

>>> increment(10)
11

>>> # Call inner_increment()
>>> inner_increment()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    inner_increment()
NameError: name 'inner_increment' is not defined

# hotspots.py

import csv
from collections import Counter

def process_hotspots(file):
    def most_common_provider(file_obj):
        hotspots = []
        with file_obj as csv_file:
            content = csv.DictReader(csv_file)

            for row in content:
                hotspots.append(row["Provider"])

        counter = Counter(hotspots)
        print(
            f"There are {len(hotspots)} Wi-Fi hotspots in NYC.\n"
            f"{counter.most_common(1)[0][0]} has the most with "
            f"{counter.most_common(1)[0][1]}."
        )

    if isinstance(file, str):
        # Got a string-based filepath
        file_obj = open(file, "r")
        most_common_provider(file_obj)
    else:
        # Got a file object
        most_common_provider(file)

>>> from hotspots import process_hotspots

>>> file_obj = open("./NYC_Wi-Fi_Hotspot_Locations.csv", "r")
>>> process_hotspots(file_obj)
There are 3319 Wi-Fi hotspots in NYC.
LinkNYC - Citybridge has the most with 1868.

>>> process_hotspots("./NYC_Wi-Fi_Hotspot_Locations.csv")
There are 3319 Wi-Fi hotspots in NYC.
LinkNYC - Citybridge has the most with 1868.

 1# powers.py
 2
 3def generate_power(exponent):
 4    def power(base):
 5        return base ** exponent
 6    return power

>>> from powers import generate_power

>>> raise_two = generate_power(2)
>>> raise_three = generate_power(3)

>>> raise_two(4)
16
>>> raise_two(5)
25

>>> raise_three(4)
64
>>> raise_three(5)
125

>>> def has_permission(page):
...     def permission(username):
...         if username.lower() == "admin":
...             return f"'{username}' has access to {page}."
...         else:
...             return f"'{username}' doesn't have access to {page}."
...     return permission
...

>>> check_admin_page_permision = has_permission("Admin Page")

>>> check_admin_page_permision("admin")
"'admin' has access to Admin Page."

>>> check_admin_page_permision("john")
"'john' doesn't have access to Admin Page."

>>> def mean():
...     sample = []
...     def inner_mean(number):
...         sample.append(number)
...         return sum(sample) / len(sample)
...     return inner_mean
...

>>> sample_mean = mean()
>>> sample_mean(100)
100.0
>>> sample_mean(105)
102.5
>>> sample_mean(101)
102.0
>>> sample_mean(98)
101.0

>>> def make_point(x, y):
...     def point():
...         print(f"Point({x}, {y})")
...     def get_x():
...         return x
...     def get_y():
...         return y
...     def set_x(value):
...         nonlocal x
...         x = value
...     def set_y(value):
...         nonlocal y
...         y = value
...     # Attach getters and setters
...     point.get_x = get_x
...     point.set_x = set_x
...     point.get_y = get_y
...     point.set_y = set_y
...     return point
...

>>> point = make_point(1, 2)
>>> point.get_x()
1
>>> point.get_y()
2
>>> point()
Point(1, 2)

>>> point.set_x(42)
>>> point.set_y(7)
>>> point()
Point(42, 7)

使用内部函数添加行为：装饰器

Python装饰器是另一个流行且方便的内部函数用例，尤其是闭包。装饰器是高阶函数，它接受一个可调用对象（函数、方法、类）作为参数并返回另一个可调用对象。

您可以使用装饰器函数为现有的可调用对象动态添加职责并透明地扩展其行为，而不会影响或修改原始可调用对象。

要创建装饰器，您只需要定义一个可调用对象（一个函数、方法或类），它接受一个函数对象作为参数，处理它，并返回另一个具有添加行为的函数对象。

一旦你的装饰器功能就位，你就可以将它应用到任何可调用的。为此，您需要@在装饰器名称前面使用 at 符号 ( )，然后将其放在自己的一行中，紧邻装饰后的可调用对象之前：

@decorator
def decorated_func():
    # Function body...
    pass

此语法decorator()自动将decorated_func()作为参数并在其正文中进行处理。此操作是以下赋值的简写：

decorated_func = decorator(decorated_func)

以下是如何构建装饰器函数以向现有函数添加新功能的示例：

>>> def add_messages(func):
...     def _add_messages():
...         print("This is my first decorator")
...         func()
...         print("Bye!")
...     return _add_messages
...

>>> @add_messages
... def greet():
...     print("Hello, World!")
...

>>> greet()
This is my first decorator
Hello, World!
Bye!

在这种情况下，您使用@add_messages来装饰greet()。这为装饰函数添加了新功能。现在，当您调用 时，您的函数将打印两条新消息greet()，而不仅仅是打印Hello, World!。

Python 装饰器的用例多种多样。这里是其中的一些：

• 调试
• 缓存
• 日志记录
• Timing

调试 Python 代码的常见做法是插入调用以print()检查变量的值、确认代码块被执行等。添加和删​​除对的调用print()可能很烦人，而且您可能会忘记其中的一些调用。为了防止这种情况，您可以编写如下装饰器：

>>> def debug(func):
...     def _debug(*args, **kwargs):
...         result = func(*args, **kwargs)
...         print(
...             f"{func.__name__}(args: {args}, kwargs: {kwargs}) -> {result}"
...         )
...         return result
...     return _debug
...

>>> @debug
... def add(a, b):
...     return a + b
...

>>> add(5, 6)
add(args: (5, 6), kwargs: {}) -> 11
11

这个例子提供了debug()，它是一个装饰器，它将一个函数作为参数，并用每个参数的当前值及其对应的返回值打印其签名。您可以使用此装饰器来调试您的函数。获得所需的结果后，您可以删除装饰器调用@debug，您的函数将为下一步做好准备。

这是如何创建装饰器的最后一个示例。这一次，您将重新实现generate_power()为装饰器函数：

>>> def generate_power(exponent):
...     def power(func):
...         def inner_power(*args):
...             base = func(*args)
...             return base ** exponent
...         return inner_power
...     return power
...

>>> @generate_power(2)
... def raise_two(n):
...     return n
...
>>> raise_two(7)
49

>>> @generate_power(3)
... def raise_three(n):
...     return n
...
>>> raise_three(5)
125

此版本generate_power()产生的结果与您在原始实现中得到的结果相同。在这种情况下，您使用闭包来记住exponent和装饰器返回输入函数的修改版本，func()。

在这里，装饰器需要接受一个参数 ( exponent)，因此您需要有两个嵌套级别的内部函数。第一级由 表示power()，它将装饰函数作为参数。第二级由 表示inner_power()，将参数打包在exponent中args，进行最后的幂计算，并返回结果。

结论

如果您在另一个函数内定义一个函数，那么您就是在创建一个内部函数，也称为嵌套函数。在 Python 中，内部函数可以直接访问您在封闭函数中定义的变量和名称。这为您提供了一种创建辅助函数、闭包和装饰器的机制。

在本教程中，您学习了如何：

• 通过在其他函数中嵌套函数来提供封装
• 编写辅助函数以重用代码片段
• 实现在调用之间保持状态的闭包工厂函数
• 构建装饰器函数以提供新功能

您现在已准备好在自己的代码中利用内部函数的多种用途。如果您有任何问题或意见，请务必在下面的评论部分分享。