Python 为什么在下面的代码中使用return语句末尾的括号，如果我不使用'；是否使用圆括号表示返回地址？

示例：为什么dictuse1返回值而dictuse2返回地址如下所示

def dictuse1(operator,x,y):
    return{
    'add':lambda:x + y,
    'sub':lambda:x - y,
    'mul':lambda:x * y,
    'div':lambda:x / y,
    }.get(operator,lambda:None)()
def dictuse2(operator,x,y):
    return{
    'add':lambda:x + y,
    'sub':lambda:x - y,
    'mul':lambda:x * y,
    'div':lambda:x / y,
    }.get(operator,lambda:None)     #No parentheses here compared to previous function
d = dictuse1('add',8,9)
print(d)      #return 17
a = dictuse2('a',5,4)
print(a)      #returns:<function dictuse.<locals>.<lambda> at 0x7f30d23f3ea0>

def指令1（操作员，x，y）：
返回{
“添加”：lambda:x+y，
“sub”：lambda:x-y，
“mul”：lambda:x*y，
“div”：lambda:x/y，
}.get（运算符，lambda:None）（）
def指令2（操作员，x，y）：
返回{
“添加”：lambda:x+y，
“sub”：lambda:x-y，
“mul”：lambda:x*y，
“div”：lambda:x/y，
}.get（运算符，lambda:None）#与前面的函数相比，此处没有括号
d=格言1（'add'，8,9）
打印（d）#返回17
a=口述2（'a'，5,4）
打印（a）#返回：

因为在Python中，一切都是对象。这包括整数、浮点数、字符串、其他类的实例、类本身和函数

第一个函数从字典中检索一个函数，或者使用默认值并调用它，返回调用结果（在您的例子中是一个数字）

第二个函数返回函数本身

---

括号是函数调用的符号：

（lambda x，y:x+y）（1，2）

，例如，调用函数并返回

1+2==3

。如果删除括号，将得到一个函数对象。

因为如果要查找的键不在字典中，字典上的

get

方法将返回一个默认值，当您传递字典中没有的

a

时，它返回了

lambda:None

，这是一个匿名函数，要执行这个函数，您必须用paradensis调用它

括号与

返回无关；它们是用来调用函数的，就像你调用函数一样

让我们将其分解为更具可读性的形式：

function_table = {
    'add': lambda: x + y,
    'sub': lambda: x - y,
    'mul': lambda: x * y,
    'div': lambda: x / y,
}

到目前为止，还不错：这只是一个将字符串映射到函数的字典，因此您可以按名称查找函数

default_function = lambda: None

这只是一个可以调用并返回
None
的函数

function = function_table.get(operator, default_function)

这只是在dict中查找一个值。
d.get（key，default）
提供
d[key]
如果该键有值，或者
default
如果没有值

因此，现在的
函数
是
添加
函数

lambda:x+y，或者默认的

lambda:None

，或者其他三个函数中的任何一个，但无论是哪一个，它都是不带参数的函数。所以我们可以称之为。这就是括号的含义：

value = function()

现在我们只返回该值：

return value

---

如果不使用括号，就不会调用函数并返回它给您的值，而是返回它。因此，您不会返回

5

或

None

，而是返回一个函数对象。如果你试着把它打印出来，也许它会说一些类似于

，但它说什么并不重要；它告诉你的是，你正在打印的东西是一些函数，它没有名字，因为你用

lambda

而不是

def

来定义它，试着在一些有意义的部分上拆分这样一行

def dictuse1(operator, x, y):
    # Stores mapping from operator names (strings) 
    # to op implementations (functions == lambdas)
    optable = {
        'add': lambda: x + y,
        'sub': lambda: x - y,
        'mul': lambda: x * y,
        'div': lambda: x / y,
    }

    # Define a default op
    noop = lambda: None

    # Take the function by op name
    op = optable.get(operator, noop)

    # Exectute it and return a returning value of that function.
    return op()  # remove () and you have a dictuse2 here.

---

dictuse1

和

dictuse2

之间唯一的区别是最后一个函数返回函数，而不是调用该函数的结果。

顺便说一句，使用

操作符作为变量名不是一个好主意，因为它是标准模块的名称。顺便说一句，该模块在这段代码中会很有用，因为它定义了您用lambdas定义的函数。@PM2Ring我不确定
操作符
是否真的有用，因为这些函数都是
x
和
y
参数上的空闭包，因此，您必须编写类似于
functools.partial（operator.add，x，y）
的代码，这并不像您通常从模块中获得的好处那么多。不过，总的来说，这绝对是个好建议。@abarnert啊，说得对。