python函数（1）— 函数分类

笃行之.kiss

已于 2023-06-29 10:28:17 修改

阅读量476

点赞数

分类专栏： Python基础文章标签： python 高阶函数匿名函数递归函数偏函数

于 2023-04-26 15:28:42 首次发布

本文链接：https://blog.csdn.net/panc_guizaijianchi/article/details/130386940

版权

Python基础专栏收录该内容

32 篇文章 38 订阅

订阅专栏

1、内置函数

Python 解释器自带的函数叫做内置函数，这些函数可以直接使用，不需要导入某个模块。

可以使用命令 dir('__builtins__') 查看内置函数列表：

C:\Users\057776>python
Python 3.8.8 (tags/v3.8.8:024d805, Feb 19 2021, 13:18:16) [MSC v.1928 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
>>>

附上官网内置函数大全：内置函数 — Python 3.8.16 文档

2、嵌套函数

在Python中，我们可以在一个函数内定义另外一个函数，这就是嵌套函数（Nested Functions）。

嵌套函数的基本语法如下：

def outer_function():
    # 外部函数中的代码

    def inner_function():
        # 内部函数中的代码

    # 外部函数返回内部函数
    return inner_function

在上面的代码中，定义了一个嵌套函数`inner_function`，并将其作为外部函数`outer_function`的返回值。这意味着我们可以通过调用`outer_function()`来访问`inner_function`。

嵌套函数的一个常见使用场景是实现闭包（Closure）。闭包是指一个函数对象可以访问其定义域之外的变量。例如：

def outer_function(x):
    def inner_function(y):
        return x + y

    return inner_function

closure = outer_function(10)
print(closure(5))  # 输出15

在上面的例子中，我们定义了一个嵌套函数`inner_function`，并将外部函数`outer_function`的参数`x`捕获到`inner_function`的作用域中。这样，我们就创建了一个闭包`closure`，它可以将`x`的值保留下来，并且在之后的调用中继续使用。

这样，我们就可以通过调用`closure(y)`来访问`x`和`y`，并且每次返回的结果都基于之前的调用。

3、闭包函数

Python闭包函数指的是在一个函数内部定义另一个函数，并且返回这个函数，使得这个函数可以访问外部函数的局部变量，形成一个封闭的环境，这个封闭的环境就是闭包。闭包中的函数可以被保存下来，甚至可以在函数外被调用。

举一个例子：

def outer(a):
    def inner(b):
        return a + b
    return inner

在这个例子中，`outer` 函数定义了一个内部函数 `inner` ，它接受一个参数 `b` ，并且返回 `a + b` 的结果。`outer` 函数返回 `inner` 函数本身，从而使得 `inner` 函数可以在外部被调用。

我们可以这样使用闭包：

add5 = outer(5)
add10 = outer(10)
print(add5(3))  # 输出 8
print(add10(3))  # 输出 13

在这个例子中，我们调用了 `outer(5)` 和 `outer(10)`，得到了两个函数 `add5` 和 `add10`。这两个函数在被定义时访问了外部函数 `outer` 的局部变量 `a`，并且将这个局部变量封闭在了闭包中。在使用时，我们分别传入参数 3，得到了 8 和 13 的结果。

4、装饰器函数

装饰器函数是一种高级函数，它可以获取一个函数，对这个函数进行修改，然后返回一个新的函数，从而达到增加函数功能的目的。在Python中，使用@符号可以很方便地应用装饰器函数。

下面是一个简单的装饰器函数示例：

def my_decorator(func):
    def wrapper():
        print("Before the function is called.")
        func()
        print("After the function is called.")
    return wrapper
 
@my_decorator
def say_hello():
    print("Hello!")
 
say_hello()

输出结果如下：

Before the function is called.
Hello!
After the function is called.

在这个示例中，我们定义了一个名为`my_decorator`的装饰器函数，它获取一个函数作为参数`func`，返回一个新的函数`wrapper`，在这个函数中，我们可以添加一些额外的代码，比如在函数执行前后打印一些信息。然后，我们使用@符号将装饰器函数应用到一个示例函数`say_hello`上，调用`say_hello`函数时，就会先执行`my_decorator`函数里定义的一些代码，再执行`say_hello`函数的正常逻辑。

5、匿名函数

匿名函数，也称为 lambda 表达式，是一种简化函数定义的方法，主要用于一些简单的场景，不需要定义函数，给函数起名等，使我们的程序更加简洁。

（1）语法格式

lambda [parameters] ：expression

说明：

“ lambda”一词不是名称，而是关键字。此关键字指定后面的函数是匿名的。
参数可以有多个，多个参数之间用","分隔，表达式只能是一个。
输入是 parameters，输出是expression。

参数：

parameters，非必输项，可以没有参数，一个参数，多个参数。没有参数的情况实际是使用了外部参数而已。
expression，表达式

返回值：

表达式的结果就是lambda函数的输出值。

（2）使用匿名函数的优缺点

可以减少代码量，使代码更简洁，更Python范！
lambda表达式没有函数名，不用纠结函数起名了
避免滥用lambda表达式

（3）用法实例

一个参数

lambda x: x ** 2

多个参数

lambda x, y: x + y

无参数，没有参数的情况，表达式实际是使用了外部参数。

def func(x):
    return lambda: x ** 2

和高阶函数一起使用

from functools import reduce


# 将lambda函数作为参数传递给map函数
print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])))

# 将lambda函数作为参数传递给reduce函数
print(reduce(lambda x, y: x + y, [1, 2, 3, 4, 5]))

# 将lambda函数作为参数传递给filter函数
print(list(filter(lambda x: x % 2 == 1, [1, 2, 3, 4, 5])))

6、高阶函数

Python中，高阶函数是指可以接收其它函数作为参数，或者将函数作为返回值的一类函数。

具体来说，高阶函数可以具有以下特点：

接收一个或多个函数作为参数传入；
将一个函数作为返回值返回。

下面是一个使用高阶函数的简单例子：

def add(a, b):
    return a + b

def sub(a, b):
    return a - b

def apply_operation(func, a, b):
    return func(a, b)

print(apply_operation(add, 1, 2))  # 输出 3
print(apply_operation(sub, 4, 2))  # 输出 2

在上面的例子中，我们定义了一个 `apply_operation` 函数，它接收一个函数和两个参数，然后将这个函数应用到两个参数上。其中，`add` 和 `sub` 函数就是传递给 `apply_operation` 函数的操作函数。

Python中有很多内置的高阶函数，如`map()`、`filter()`、`reduce()`等。

举例来说，`map()`函数就是一种高阶函数，它可以接收一个函数和一个迭代器作为参数，对迭代器中的每个元素应用函数，返回一个新的可迭代对象。示例代码如下：

def square(x):
    return x * x

lst = [1, 2, 3, 4, 5]
squares = map(square, lst)
print(list(squares))    # [1, 4, 9, 16, 25]

另外，Python中也支持通过lambda表达式来创建匿名函数，从而方便地进行函数式编程。例如，使用lambda表达式对列表中的元素进行平方操作，可以这样写：

lst = [1, 2, 3, 4, 5]
squares = map(lambda x: x * x, lst)
print(list(squares))    # [1, 4, 9, 16, 25]

详见：Python函数 — 高阶函数

7、回调函数

Python中，回调函数是指将一个函数作为参数传递给另一个函数，在另一个函数中调用该参数函数实现特定的功能。回调函数常用于异步编程、事件处理和GUI编程等场景，以在特定条件下执行特定操作。

下面是一个简单的示例，展示如何在Python中使用回调函数：

def calculate(x, y, callback):
    result = x + y
    callback(result)
    
def print_result(res):
    print("计算结果为：", res)

calculate(2, 3, print_result)   # 将print_result作为回调函数传递给calculate函数

以上代码中，我们定义了一个`calculate`函数，该函数接受三个参数：x、y和一个回调函数`callback`。在函数内部，我们将`x + y`的结果传递给`callback`函数，以实现特定的功能。然后，我们定义了一个`print_result`函数作为回调函数，以在调用`calculate`函数时打印计算结果。最后，我们调用`calculate`函数，并将`print_result`函数作为回调函数传递给它。这将在计算结果返回后自动触发回调函数，实现特定的操作。

需要注意的是，回调函数必须在参数列表的最后一个位置，并被封装在`callable()`中，以确保它是可以被调用的函数。同时，回调函数通常应该是异步执行的，以避免在主程序中使用时出现阻塞问题。

8、返回函数

Python中，返回函数指的是一个函数可以返回另一个函数。

下面是一个简单的示例：

def make_adder(n):
    def adder(x):
        return x + n
    return adder

add_5 = make_adder(5)
print(add_5(10))  # 输出 15

在这个示例中，make_adder是一个函数，它接受一个参数n并返回一个新的函数adder。adder的作用是将其输入值x与n相加并返回结果。make_adder函数返回adder，因此我们可以将make_adder看作是一个工厂函数，用于生成特定的adder函数。我们可以使用make_adder函数创建多个adder函数，每个函数都添加特定的值。

Python的返回函数使用常见场景包括：

（1）嵌套函数时，内层函数可以作为返回函数返回给外层函数，用于实现闭包，保护变量不被其他函数访问和修改。

（2）返回函数可以用于装饰器、装饰器工厂等高级用法中。

（3）返回函数可以用于实现延迟计算，即先返回一个求值函数，等到需要使用结果时再执行。

（4）在函数式编程中，返回函数常用于实现柯里化和偏函数等高级技巧。

总之，返回函数是Python中一个非常有用的特性，可以让我们编写更加灵活、模块化和高效的代码。

9、递归函数

Python中递归函数是一种特殊的函数，它在函数定义中调用自身函数，用于解决重复子问题的问题，递归函数可以通过把复杂问题拆分成简单的子问题来简化问题的解决方式，例如计算阶乘或斐波那契数列等问题。递归函数包括两部分，一部分是基本情况，即没有递归调用的情况，另一部分是递归情况，即调用函数本身的情况。在使用递归函数时要注意防止无限递归，要在适当的时候设置跳出递归的条件。

下面是使用递归函数来计算阶乘和斐波那契数列问题实例：

计算阶乘

# 计算n的阶乘
def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

计算斐波那契数列

# 计算斐波那契数列第n项的值
def fib(n):
    if n <= 1:
        return n
    else:
        return fib(n - 1) + fib(n - 2)

递归函数的优缺点：

优点：

递归函数实现简单，易于理解；
适合解决相对简单、结构严谨的问题；
代码相对紧凑、优美。

缺点：

递归函数调用过程中会多次压栈、弹栈，对内存和运行效率的损耗较大；
当递归层数过多时会导致栈溢出；
递归实现，根据递归的方式不同，时间复杂度和空间复杂度有可能会变得非常高，不太适合处理大规模的数据。

Python中编写递归函数，可以按照以下步骤进行：

（1）确定终止条件，递归函数必须有终止条件，否则递归将永远不会结束。

（2）拆分问题，把原问题拆分成多个相同的子问题，每个子问题的计算方式与原问题相同，只是规模或参数有所不同。

（3）调用自身，递归函数在自身内部调用自身来解决每个子问题。

（4）合并结果，将子问题的结果合并起来得到原问题的解。

10、偏函数

Python中的偏函数是指固定原函数中某些参数后生成一个新的函数，新函数可以忽略掉被固定的参数，只需要传入其他的参数即可。使用functools模块的partial()函数来创建偏函数，partial()函数的第一个参数是原函数，后面的参数为需要固定的参数。

语法格式：

functools.partial(func, /, *args, **keywords)

参数说明：

func：一个可调用对象或函数。
*args：被调用对象需要固定的位置参数。
**keywords：被调用对象需要固定的关键字参数。

偏函数实例：

from functools import partial


def power(base, exponent):
    return base ** exponent


square = partial(power, exponent=2)

print(square(5))  # 输出5^2 = 25

上面的例子中，我们先定义了一个power函数，然后使用partial()函数来创建了一个新的square函数，将exponent参数固定为2，这样每次调用square函数时只需要传入base参数即可。

reference：

函数(1) - 《零基础学python》（第二版）

Python函数大全及9种函数类型详解 - Python自学网