什么是函数？

Python中的函数是执行特定任务或一组任务的命名代码块。函数可以接受输入（称为参数或参数）并返回输出（一个值或一组值）。它们允许将复杂的任务分解为更小的、可管理的部分。在Python中，有几种类型的函数，每种都有自己的用途和特点。以下是函数的主要类型：

• >内置函数：

这些函数内置于 Python 中并且始终可供使用。示例包括print()、len()、range()和input()。

• > 用户定义函数：

> 这些是由用户定义的功能。可以创建自己的函数来执行特定任务并在整个代码中重用它们。

• > 匿名函数（Lambda 函数）：

这些是没有名称定义的小型单行函数。它们通常用于需要快速、一次性功能的情况。

定义用户定义函数

以下是定义函数的基本语法：

def  function_name ( parameters ): 
    # 函数的代码块
    # ... 
    return result   # 可选

• def：该关键字用于定义函数。
• function_name：这是函数的名称。它应该描述函数执行的任务。
• parameters：这些是函数可以接受的输入值。它们是可选的。
• return：该关键字用于指定函数应返回的值。这是可选的；函数不能返回任何内容。

函数定义

这是一个简单函数的示例：

defgreet ( ): 
    print ( “你好！” )

在这里，定义了一个简单的函数，名为 greet 。

调用函数

一旦定义了一个函数，就可以通过使用它的名字后跟包含参数的圆括号来调用它。

greet()   # Output: Hello

当被调用时，它会打印“Hello！“.

函数参数

函数可以接受参数，参数是调用函数时传递给函数的值。

def  gret ( name ): 
    print ( f"Hello, {name} !" ) 

# 使用参数调用函数
greet( "Alice" )   # 输出：你好，Alice！

Return语句

Python中的 return 语句用于指定函数应该返回什么值。它结束函数的执行并将指定的值发送回调用方。

def  add ( x, y ): 
    return x + y 

result = add( 3 , 5 ) 
print (result)   # 输出：8

一个函数可以有多个 return 语句，但只有一个会被执行。该函数将在遇到 return 语句时立即退出。

def is_positive(num):
    if num > 0:
        return True
    else:
        return False

函数可以返回多个值，方法是将它们打包到一个数据结构中，如元组。这允许从函数返回更复杂的数据。

def calculate_stats(numbers):
    total = sum(numbers)
    average = total / len(numbers)
    return total, average

result = calculate_stats([1, 2, 3, 4, 5])  # result will be (15, 3.0)
    

一旦一个函数返回一个值，可以用各种方式使用它：

• 将其分配给一个变量以供以后使用。
• 直接在表达式中使用。
• 将其作为参数传递给另一个函数。

def  square ( x ): 
    return x ** 2

 result = square( 4 )   # 结果将为 16

默认参数

可以为函数参数提供默认值。如果在调用函数时没有为该参数传递值，则将使用默认值。

def greet(name="User"):
    return f"Hello, {name}!"

greeting = greet()
print(greeting)  # Output: Hello, User!

关键字参数

也可以通过关键字传递参数。

defgreet  ( first_name ,last_name ): 
    print ( f"Hello, {first_name}  {last_name} !" ) 

greet(last_name= "Doe" ,first_name= "John" )   #输出:你好,John Doe!

变长参数列表

可变长度参数列表（Variable-Length Argument Lists），在Python中通常被称为 *args和 **kwargs，允许函数接受任意数量的参数。当您需要创建可以处理不同数量参数的灵活函数时，它们非常有用。它们通常用于库和框架中，为用户提供灵活的API。

args（Arbitrary Positional Arguments）：

*args 语法允许函数接收任意数量的位置参数。这些参数作为元组传递，可以在函数中使用循环或索引访问。

def  sum_numbers ( *args ):
    总计 = 0 
    for num in args:
        总计 += num
    返回总计

结果 = sum_numbers( 1 , 2 , 3 , 4 ) 
print (result)   # 输出: 10

在这个例子中， *args 收集传递给 sum_numbers 的所有参数，并将它们视为一个元组（在本例中为 (1, 2, 3, 4) ）。

*kwargs（任意关键字参数）：

**kwargs 语法允许函数接收任意数量的关键字参数。这些参数作为字典传递，其中键是参数名称，值是相应的值。

def  print_info ( **kwargs ):
    对于kwargs.items()中的键、值： 
        print ( f" {key} : {value} " ) 

print_info(name= "Alice" ,age= 30 , city= "New York"）

在本例中， **kwargs 收集关键字参数并将其视为字典（本例中为 {'name': 'Alice', 'age': 30, 'city': 'New York'} ）。

组合 *args和 **kwargs：

可以在同一个函数定义中同时使用 *args 和 **kwargs 。

def  example_function ( *args, **kwargs ): 
    print ( "位置参数 (*args):" , args) 
    print ( "关键字参数 (**kwargs):" , kwargs) 

example_function( 1 , 2 , 3 , name= “爱丽丝”，年龄= 30）

在本例中， *args 收集位置参数 (1, 2, 3) ， **kwargs 收集关键字参数 {'name': 'Alice', 'age': 30} 。

使用 *args和 **kwargs与普通参数：

可以将 *args和 **kwargs沿着与普通参数一起使用，但请记住，它们必须位于普通参数之后。

def example_function (normal_arg, *args, **kwargs): 
    print ( "普通参数:" , normal_arg) 
    print ( "位置参数 (*args):" , args) 
    print ( "关键字参数 (**kwargs):" , kwargs) 

example_function ( "Hello" , 1 , 2 , 3 , name= "Alice" , 年龄= 30 )

在这个例子中， normal_arg 将接收值 "Hello" ， *args 将接收值 (1, 2, 3) ，而 **kwargs 将接收值 {'name': 'Alice', 'age': 30} 。

变量作用域

函数中变量的作用域是指程序中可以访问或引用变量的区域。在Python中，变量作用域主要有两种类型：全局和局部。

1.全局作用域：

• 在任何函数之外定义的变量都有全局作用域。
• 它们可以从程序中的任何地方访问，包括内部函数。
• 范例：

x = 10   # 全局变量

def  func (): 
    print (x)   # 可在函数内部访问

func()   # 输出: 10 
print (x)   # 输出: 10

2.本地作用域：

• 在函数内部定义的变量具有局部作用域。
• 它们只能在定义它们的函数中访问。
• 范例：

def  func (): 
    y = 20   # 局部变量
    print (y) 

func()   # 输出：20 

# 尝试在函数外部访问 y 将导致错误
# print(y) # 这将引发 NameError

3. 作用域覆盖：

• 如果全局变量和局部变量都存在同名变量，则局部变量在函数的作用域内隐藏全局变量。
• 范例：

x = 10   # 全局变量

def  func (): 
    x = 20   # 与全局变量同名的局部变量
    print (x)   # 这将打印局部变量 x

 func()   # 输出：20 
print (x)   # 输出： 10（全局x保持不变）

4.全局变量本地化：

• 如果想在函数中修改一个全局变量，需要使用 global 关键字来表明你引用的是全局变量，而不是创建一个新的局部变量。
• 范例：

x = 10   # 全局变量

def  func (): 
    global x   # 表示x为全局变量
    x = 20     # 修改全局x 
    print (x) 

func()   # 输出: 20 
print (x)   # 输出: 20 (Global) x 已修改）

5.非局部关键字（嵌套函数）：

• 当有嵌套函数（一个函数在另一个函数中）时，可能会遇到需要修改外部作用域中的变量的情况。
• nonlocal 关键字允许这样做。
• 范例：

def  external (): 
    x = 10   # 外部函数中的局部变量

    def  inner (): 
        nonlocal x   # 表示x在外部作用域中
        x = 20       # 修改外部作用域中的变量
        print (x) 

    inner()   # 输出: 20 
    print (x)   # 输出：20

外层()

递归函数

递归函数是一个调用自身的函数。这是一种强大的技术，用于解决可以分解为更小，类似子问题的问题。

def  Factorial ( n ): 
    if n == 0 : 
        return  1 
    else : 
        return n * Factorial(n- 1 ) 

result = Factorial( 5 ) 
print (result)   # 输出：120

Lambda函数

Lambda 函数，也称为匿名函数或lambda 表达式，是一种在 Python 中定义小型、简单函数的简洁方法。它们通常用于需要函数的操作，但定义一个成熟的命名函数是多余的。Lambda 函数对于短期、一次性操作特别方便。但是，它们不适合复杂或多步骤操作，在这些操作中您可能希望使用命名函数来提高清晰度和可重用性。

以下是 lambda 函数的基本语法：

lambda参数：表达式

• lambda：这是表明您正在创建 lambda 函数的关键字。
• arguments：这些是函数的输入参数。您可以有任意数量的参数，以逗号分隔。
• expression：这是函数执行的计算。该表达式的结果是隐式返回的。

这是一个例子：

双精度= lambda x: x * 2

在此示例中，我们创建了一个 lambda 函数，该函数接受一个参数x并返回x * 2。

Lambda 函数通常用于需要将一个简单函数作为参数传递给另一个函数的场景，例如 in map、filter或sorted。

示例：将 Lambda 与map()

该map()函数将给定函数应用于列表中的所有项目并返回一个迭代器。

Numbers = [ 1 , 2 , 3 , 4 , 5 ] 
squared = map ( lambda x: x** 2 , Numbers) 
print ( list (squared))   # 输出：[1, 4, 9, 16, 25]

在此示例中，lambda 函数lambda x: x**2应用于numbers列表中的每个元素。

示例：将 Lambda 与filter()

该filter()函数根据函数返回 true 的可迭代对象的元素创建迭代器。

Numbers = [ 1 , 2 , 3 , 4 , 5 ] 
Even_numbers = filter ( lambda x: x % 2 == 0 , Numbers) 
print ( list (even_numbers))   # 输出：[2, 4]

在此示例中，lambda 函数lambda x: x % 2 == 0从列表中过滤掉偶数numbers。

示例：将 Lambda 与sorted()

该sorted()函数对可迭代对象进行排序并返回一个新的排序列表。

名称 = [ 'Alice' , 'Bob' , '查理' , '大卫' ] 
Sorted_names = Sorted(names, key=lambda x: len (x)) 
print (sorted_names) # 输出: [ 'Bob' , 'Alice'、“大卫”、“查理” ]

在此示例中，我们使用 lambda 函数根据名称列表的长度对名称列表进行排序lambda x: len(x)。