Python内部函数

在Python中，函数被视为第一类对象。语言中的第一类对象在整个过程中被统一处理。它们可以存储在数据结构中，作为参数传递，或者在控制结构中使用。如果一种编程语言将函数视为一等对象，则称其支持一等函数。 Python支持 First Class 函数的概念。

一等函数的性质：

函数是 Object 类型的实例。
您可以将函数存储在变量中。
您可以将函数作为参数传递给另一个函数。
您可以从函数。
您可以将它们存储在数据结构中，例如哈希表、列表……

注意：要了解有关头等对象的更多信息，请单击此处。

内部函数

在另一个函数内部定义的函数称为inner function或nested functio 。嵌套函数能够访问封闭范围的变量。使用内部函数是为了保护它们免受函数外部发生的任何事情的影响。这个过程也称为Encapsulation 。要了解有关封装的更多信息，请单击此处。

例子：

# Python program to illustrate 
# nested functions 
def outerFunction(text): 
    text = text 
    
    def innerFunction(): 
        print(text) 
    
    innerFunction() 
    
if __name__ == '__main__': 
    outerFunction('Hey !')

输出：

Hey!

在上面的示例中，innerFunction() 已在 outerFunction() 内部定义，使其成为内部函数。要调用innerFunction()，我们必须先调用outerFunction()。然后，outerFunction() 将继续调用 innerFunction()，因为它已在其中定义。

重要的是必须调用外部函数，以便内部函数可以执行。为了证明这一点，请考虑以下示例：
例子：

# Python program to illustrate 
# nested functions 
def outerFunction(text): 
    text = text 
    
    def innerFunction(): 
        print(text) 
    
    innerFunction()

输出：

This code will return nothing when executed.

嵌套函数中的变量范围

我们可以找到变量并在需要时访问它的位置称为变量的范围。
已知如何访问函数内部的全局变量，但是，如何访问外部函数的变量呢？让我们看一个例子：

# Python program to 
# demonstrate accessing of
# variables of nested functions
  
def f1():
    s = 'I love GeeksforGeeks'
      
    def f2():
        print(s)
          
    f2()
  
# Driver's code
f1()

输出：

I love GeeksforGeeks

在上面的例子中，可以看出它类似于从函数中访问全局变量。现在假设您要更改外部函数的变量。

# Python program to 
# demonstrate accessing of
# variables of nested functions
  
def f1():
    s = 'I love GeeksforGeeks'
      
    def f2():
        s = 'Me too'
        print(s)
          
    f2()
    print(s)
  
# Driver's code
f1()

输出：

Me too
I love GeeksforGeeks

可以看出外层函数的变量值没有改变。但是，外部函数的变量值是可以改变的。有不同的方法可以改变外部函数的变量值。

使用可迭代 -

# Python program to 
# demonstrate accessing of
# variables of nested functions
  
def f1():
    s = ['I love GeeksforGeeks']
      
    def f2():
        s[0] = 'Me too'
        print(s)
          
    f2()
    print(s)
  
# Driver's code
f1()

输出：

['Me too']
['Me too']

使用 nonlocal 关键字 –

# Python program to 
# demonstrate accessing of
# variables of nested functions
  
def f1():
    s = 'I love GeeksforGeeks'
      
    def f2():
        nonlocal s
        s = 'Me too'
        print(s)
          
    f2()
    print(s)
  
# Driver's code
f1()

输出：

Me too
Me too

也可以更改值，如下例所示。

# Python program to 
# demonstrate accessing of
# variables of nested functions
  
def f1():
    f1.s = 'I love GeeksforGeeks'
      
    def f2():
        f1.s = 'Me too'
        print(f1.s)
          
    f2()
    print(f1.s)
  
# Driver's code
f1()

输出：

Me too
Me too

Python闭包

闭包是一个函数对象，它记住封闭范围内的值，即使它们不存在于内存中。

它是将函数与环境一起存储的记录：将函数的每个自由变量（在本地使用但在封闭范围内定义的变量）与闭包时绑定名称的值或引用相关联的映射被创建。
闭包——与普通函数不同——允许函数通过闭包的值或引用的副本访问那些捕获的变量，即使在函数在其范围之外调用时也是如此。
过滤器无。

# Python program to illustrate 
# closures 
def outerFunction(text): 
    text = text 
    
    def innerFunction(): 
        print(text) 
    
    return innerFunction # Note we are returning function WITHOUT parenthesis 
    
if __name__ == '__main__': 
    myFunction = outerFunction('Hey !') 
    myFunction()

输出：

Hey!

从上面的代码中可以看出，闭包有助于在其范围之外调用函数。
函数innerFunction 的作用域仅在outerFunction 内部。但是通过使用闭包，我们可以轻松地扩展其范围以调用其范围之外的函数。

# Python program to illustrate 
# closures 
import logging 
logging.basicConfig(filename ='example.log', level = logging.INFO) 
    
    
def logger(func): 
    def log_func(*args): 
        logging.info( 
            'Running "{}" with arguments {}'.format(func.__name__, args)) 
        print(func(*args)) 
    # Necessary for closure to work (returning WITHOUT parenthesis) 
    return log_func               
    
def add(x, y): 
    return x + y 
    
def sub(x, y): 
    return x-y 
    
add_logger = logger(add) 
sub_logger = logger(sub) 
    
add_logger(3, 3) 
add_logger(4, 5) 
    
sub_logger(10, 5) 
sub_logger(20, 10)

输出：