1、使用 functools.partial 函数

functools.partial 函数可以用来创建一个新的函数，它固定了原函数中的某些参数

import functools

def power(x, n):
    return x ** n

square = functools.partial(power, n=2)
cube = functools.partial(power, n=3)

print(square(2)) #4
print(cube(2)) # 8

定义了一个 power() 函数，用于计算 x 的 n 次方。然后使用 functools.partial 函数固定了 n=2 和 n=3，得到了新的函数 square 和 cube。最后分别调用这两个函数，并传入 x=2，输出结果

2、使用 map() 函数：map() 函数可以对一个可迭代对象中的每个元素都执行相同的操作，返回一个新的可迭代对象

def square(x):
    return x ** 2

numbers = [1, 2, 3, 4, 5]
squared_numbers = map(square, numbers)
print(list(squared_numbers))

定义了一个函数 square()，然后使用 map() 函数将其应用到列表 numbers 中的每个元素上，返回一个新的列表 squared_numbers

3、使用类的方法：如果将一个函数定义为类的方法，那么就需要使用该类的实例来调用该函数

class Person:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f"Hello, my name is {self.name}.")

person = Person("Alice")
person.greet()

4、使用函数对象：在 Python 中，函数也是对象，因此可以将函数赋值给变量，然后通过该变量调用函数

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

hello = greet
hello("Alice")

定义了一个函数 greet()，然后将其赋值给变量 hello，最后通过 hello() 调用函数

5、使用 *args 和 **kwargs：当函数的参数个数不确定时，可以使用 *args 和 **kwargs 来传递不定数量的参数

#eg1
def multiply(*args):
    result = 1
    for arg in args:
        result *= arg
    return result

numbers = (2, 3, 5, 7)
print(multiply(*numbers))
#eg2
# 定义教授函数
def teach(subject):
    print(f"I am teaching {subject} now.")

# 使用 *args 和 **kwargs
def introduce(*args, **kwargs):
    print("I am a teacher.")
    print("My name is", kwargs.get("name"))
    for subject in args:
        teach(subject)

introduce("math", "English", name="Bob")

6、使用 lambda 函数：lambda 函数是一种匿名函数，可以在不定义函数名称的情况下定义简单的函数

# 使用 lambda 函数
teach2 = lambda subject: print(f"I am teaching {subject} now.")
teach2("history")

7、使用回调函数：回调函数是指传递给另一个函数的函数，当满足某个条件时，另一个函数将调用该函数

def is_even(x):
    return x % 2 == 0

def filter_numbers(numbers, callback):
    result = []
    for number in numbers:
        if callback(number):
            result.append(number)
    return result

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter_numbers(numbers, is_even)
print(even_numbers)

定义了一个 is_even() 函数，用于判断一个数是否为偶数。然后定义了一个 filter_numbers() 函数，用于筛选出满足某个条件的数字。最后将 is_even() 函数作为回调函数传递给 filter_numbers() 函数，并将数字列表 numbers 作为参数传递给它，得到所有偶数的列表 even_numbers

8、使用 exec() 或 eval() 函数：exec() 和 eval() 函数可以用来执行动态生成的 Python 代码

def create_function(code):
    namespace = {}
    exec(code, namespace)
    return namespace['add_numbers']

code = """
def add_numbers(x, y):
    return x + y
"""

add = create_function(code)
print(add(2, 3))

exec() 函数返回值为 None，因为它只是执行了一段代码，而没有返回任何值。

在上面的例子中，实际上是通过执行代码来定义了一个新的 add_numbers() 函数，并将它返回给了 create_function() 函数的调用者，将一个空字典传递给 exec() 函数，用来存储执行代码所定义的变量和函数。然后在返回值中使用这个字典来获取新定义的 add_numbers() 函数

9、使用装饰器（Decorator）。装饰器是一种特殊的语法，可以用来修改函数的行为或属性，同时不改变原函数的定义

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before function call")
        result = func(*args, **kwargs)
        print("After function call")
        return result
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

定义了一个装饰器 my_decorator()，它接受一个函数作为参数，并返回一个新的函数 wrapper()。wrapper() 函数可以在原函数被调用前后执行一些额外的代码，以修改原函数的行为。

然后，在 say_hello() 函数定义上方使用 @my_decorator 语法来应用装饰器。这相当于将 say_hello() 函数传递给 my_decorator() 函数，并将返回的新函数赋值给 say_hello()。因此，在调用 say_hello() 函数时，实际上是调用了经过装饰器修饰的新函数 wrapper()，从而实现了在函数调用前后执行一些额外的代码。

10、直接调用函数的 __call__() 方法

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

add = add_numbers  # 将函数对象赋值给变量 add
print(add(2, 3))   # 直接调用 add() 方法
print(add.__call__(2, 3))  # 使用 __call__() 方法调用函数

将函数对象 add_numbers 赋值给变量 add，然后可以直接使用 add() 方法来调用这个函数，也可以使用 add.__call__() 方法来调用

11、getattr() 函数调用方法。getattr() 函数用于获取对象的属性或方法，可以接受两个参数：第一个参数是对象，第二个参数是属性或方法的名称。如果对象有这个属性或方法，那么 getattr() 函数返回它的值或引用，否则抛出 AttributeError 异常。

import math

func_name = "sqrt"  # 函数名称
arg = 2             # 函数参数
func = getattr(math, func_name)  # 获取函数对象
result = func(arg)  # 调用函数并获取结果
print(result)       # 输出结果：1.4142135623730951

使用 getattr() 函数来获取 math 模块中的 sqrt 函数对象，并将其赋值给变量 func。然后，我们使用 func(arg) 的语法来调用这个函数，并获取结果。由于 math.sqrt() 函数用于计算平方根，因此在这个例子中，调用 func(2) 的结果应该是 1.4142135623730951。

需要注意的是，getattr() 函数只能用于获取属性或方法的值或引用，并不能修改它们。如果想要修改对象的属性或方法，可以使用 setattr() 函数或直接给属性赋值来实现

12、methodcaller() 用来返回一个函数，这个函数会调用指定对象的指定方法。methodcaller() 函数可以接受一个或多个参数，其中第一个参数是方法名称，后面的参数则是传递给方法的实际参数。

from operator import methodcaller

s = "hello world"
func = methodcaller("upper")
result = func(s)
print(result)  # 输出 "HELLO WORLD"

使用 methodcaller("upper") 创建了一个函数对象 func，它会调用字符串的 upper() 方法。然后，我们使用 func(s) 的语法来调用这个函数，并将字符串 s 作为参数传递进去。由于 upper() 方法会将字符串转换为大写形式，因此调用 func(s) 的结果应该是 "HELLO WORLD"。

需要注意的是，methodcaller() 函数返回的是一个函数对象，而不是实际的方法结果。如果需要获得方法的结果，必须使用返回的函数对象调用它。同时，由于 methodcaller() 函数返回的是一个函数对象，因此可以将其赋值给变量，并在需要的时候调用。