理解一流的功能

Question

我试图理解第一类函数，以及如何在实际例子中使用它们。我举的例子是在为登录用户调用特定函数之前进行身份验证。例如：

def authenticate(user_id):
    if user_id != 1: return None
    def call_func(func_name):
        print(f"{user_id} is logged in! ==> Calling function '{func_name}'")
    return call_func

user0 = authenticate(user_id=0)
if user0: user0(func_name='xyz')
user1 = authenticate(user_id=1)
if user1: user1(func_name='xyz')

打印内容：

1 is logged in! ==> Calling function 'xyz'

这是对一级函数的正确理解吗？以上看起来更像是wrapper或decorator的概念。这些基本上是同一件事，还是这三个概念有什么区别？你知道吗

Answer 1

第一类仅仅意味着它可以独立存在。不需要无人陪同。你知道吗

方法

在Java和C#等语言中，可以创建类来将方法推入其中。你知道吗

class Logger {
    public Logger(string name) {
        this.name = name;
    }

    public void Log(string msg) {
        System.out.print(name + msg);
    }
}

然后使用这些类的实例来调用这些方法。你知道吗

Logger logger = new Logger("a name");
logger.Log("a message");

函数只能作为类的方法存在。这个阶级是一等公民。

功能

在像python这样的语言中，您可以只使用一个函数。你知道吗

def log(name, msg):
    print(name, msg)

调用这个函数。你知道吗

log('a name', 'a message')

函数可以简单地存在。

Python注释

Python有很多类。因此，如果您仍然希望避免一直键入'a name'，您可以使用它们。你知道吗

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

    def log(self, msg):
        print(self.name, msg)

logger = Logger('a name')
logger.log('a message')

由于函数是一等公民，闭包也是一种东西，同样，只要函数就可以实现。你知道吗

def logger(name):
    def log(msg):
        print(name, msg)
    return log

log = logger('a name')
log('a message')

装饰师

decorator只是使用其他函数的函数功能。拿着例如，前面的log函数。如果我们有一个fuzz修饰符，并用它来装饰log函数，它实际上用它自己的函数替换了我们的日志函数（这恰好调用了我们的函数）。你知道吗

def fuzz(func):
    def fuzzed_func(*args, **kwargs):
        print('fuzz')
        func(*args, **kwargs)
        print('fuzz')
    return fuzzed_func

@fuzz
def log(name, msg):
    print(name, msg)

fuzz

a name a message

fuzz

---

注1。在这里给出的所有示例中，数据类型也是一等公民。string本身就是Java语言。因为在Python中，'a name'本身也是一个str。因此，不仅函数和类适用于第一个类。

注2。另外，在类的情况下，可以有不作用于self或this的方法，它们被引用为静态方法。本质上是类中的函数。

额外费用

关于这一点，有一个非常棒的讽刺，你可能想在某个时候读一下。你知道吗

Execution in the Kingdom of Nouns by Steve Yegge

David Beazley最近在PyCon 2019上做了一次出色的演讲，大致是关于这个主题的，它非常出色地展示了函数的威力。你知道吗

Lambda Calculus from the Ground Up