退货声明的目的是什么？

Question

返回语句是什么的简单基本解释是什么，如何在Python中使用它？

它和print语句有什么区别？

Answer 1

print()函数在控制台中写入一个字符串，即“prints”。 return语句会导致函数退出并将值传回其调用者。功能一般来说就是接受输入并返回一些东西。当函数准备好向其调用者返回值时，将使用return语句。

例如，这是一个同时使用print()和return的函数：

def foo():
    print("hello from inside of foo")
    return 1

现在你可以运行调用foo的代码，如下所示：

if __name__ == '__main__':
    print("going to call foo")
    x = foo()
    print("called foo")
    print("foo returned " + str(x))

如果您将此作为脚本（例如.py文件）而不是Python解释器运行，您将获得以下输出：

going to call foo
hello from inside foo
called foo   
foo returned 1

我希望这更清楚。解释器将返回值写入控制台，这样我就可以看出为什么有人会感到困惑。

这是解释器的另一个例子，它证明：

>>> def foo():
...     print("hello from within foo")
...     return 1
...
>>> foo()
hello from within foo
1
>>> def bar():
...   return 10 * foo()
...
>>> bar()
hello from within foo
10

您可以看到从foo()调用bar()时，1未写入控制台。相反，它用于计算从bar()返回的值。

print()是一个导致副作用的函数（它在控制台中写入一个字符串），但执行将继续执行下一个语句。 return导致函数停止执行并将值传递回任何调用它。

Answer 2

我认为词典是您最好的参考资料

Return和Print

简而言之：

返回 向该函数的调用者提供或回复，而打印 生成文本

Answer 3

将print语句视为导致 副作用 ，它会让您的函数向用户写出一些文本，但它不能由另一个函数使用。

我将尝试通过一些示例和维基百科的几个定义来更好地解释这一点。

以下是维基百科的功能定义

一个函数，在数学中，将一个数量，函数的参数（也称为输入）与另一个数量，函数的值（也称为输出）相关联。 < / p>

想一想。当你说这个函数有一个值是什么意思？

这意味着您实际上可以用正常值替换函数的值！ （假设两个值是相同类型的值）

你为什么要这么问？

可以接受与输入相同类型的值的其他函数呢？

def square(n):
    return n * n

def add_one(n):
    return n + 1

print square(12)

# square(12) is the same as writing 144

print add_one(square(12))
print add_one(144)
#These both have the same output

对于只依赖于输入来产生输出的函数，有一个奇特的数学术语：参考透明度。同样，来自维基百科的定义。

参照透明度和参照不透明度是计算机程序部分的属性。如果表达式可以替换为其值而不改变程序的行为，则表示该表达式是引用透明的

如果你刚接触编程，可能有点难以理解这意味着什么，但我认为你会在经过一些实验后得到它。 一般来说，你可以做一些事情，比如在函数中打印，最后你也可以有一个return语句。

请记住，当你使用return时，你基本上是说“对这个函数的调用与写入返回的值相同”

如果您拒绝放入自己的Python，它实际上会为您插入一个返回值，它被称为“无”，它是一种特殊类型，只是没有任何意义，或者为null。

Answer 4

在python中，我们开始用＆＃34; def＆＃34;定义一个函数。通常，但不一定，用＆＃34; return＆＃34;结束功能。

变量x的函数表示为f（x）。这个功能有什么作用？假设，此函数将x加2。所以，f（x）= x + 2

现在，这个函数的代码将是：

public class User {

    @Id
    private String id;
    @NotNull
    private String name;
    private int age;
    private String username;
    private String password;
    private String role;




    public User() {
        super();        
    }



    public User(String name,String username,
            String password, String role) {
        super();
        this.name = name;
        this.username = username;
        this.password = password;
        this.role = role;
    }



    public String getId() {
        return id;
    }



    public void setId(String id) {
        this.id = id;
    }



    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }


    public void setAge(int age) {
        this.age = age;
    }


    public String getUsername() {
        return username;
    }


    public void setUsername(String username) {
        this.username = username;
    }


    public String getPassword() {
        return password;
    }


    public void setPassword(String password) {
        this.password = password;
    }



    public String getRole() {
        return role;
    }



    public void setRole(String role) {
        this.role = role;
    }

}

定义函数后，可以将其用于任何变量并获取结果。如：

def A_function (x):
    return x + 2

我们可以稍微改写代码，例如：

print A_function (2)
>>> 4

这也会给＃34; 4＆＃34;。

现在，我们甚至可以使用此代码：

def A_function (x):
    y = x + 2
    return y
print A_function (2)

那也会给4.看，＆＃34; x＆＃34;旁边返回实际上意味着（x + 2），而不是＆＃34; A_function（x）＆＃34;。

我想从这个简单的例子中，你会理解return命令的含义。

Answer 5

return表示“从此函数输出此值”。

print表示“将此值发送到（通常）stdout”

在Python REPL中，默认情况下会将函数返回输出到屏幕（这与打印不完全相同）。

这是印刷的一个例子：

>>> n = "foo\nbar" #just assigning a variable. No output
>>> n #the value is output, but it is in a "raw form"
'foo\nbar'
>>> print n #the \n is now a newline
foo
bar
>>>

这是返回的一个例子：

>>> def getN():
...    return "foo\nbar"
...
>>> getN() #When this isn't assigned to something, it is just output
'foo\nbar'
>>> n = getN() # assigning a variable to the return value. No output
>>> n #the value is output, but it is in a "raw form"
'foo\nbar'
>>> print n #the \n is now a newline
foo
bar
>>>

Answer 6

以上未讨论过的案例 return 语句允许您在到达结束之前终止函数的执行。执行流程立即返回给调用者。

第9行：

def ret(n):
    if n > 9:
         temp = "two digits"
         return temp     #Line 4        
    else :
         temp = "one digit"
         return temp     #Line 8
    return     #Line 9
    print ("return statement")
ret(10)

执行条件语句后，由于 return （第9行），函数 ret（）终止。 因此， print（＆＃34; return语句＆＃34;）不会被执行。

 output : two digits   

返回语句后出现的代码或未达到控制流的位置是死代码。

返回值
在第4行和第8行中，return语句用于在条件执行后返回临时变量的值。

显示打印和返回之间的区别：

 def ret(n):
     if n > 9:
         print("two digits")
         return "two digits"           
     else :
         print("one digit")
         return "one digit"    
     return       
ret(25)


output : two digits
        'two digits'

Answer 7

只是为了增加@Nathan Hughes的优秀答案：

return语句可以用作一种控制流程。通过在函数中间放置一个（或多个）return语句，我们可以说：“停止执行此函数。我们要么得到了我们想要的东西，要么出错了！”

以下是一个例子：

>>> def make_3_characters_long(some_string):
...     if len(some_string) == 3:
...         return False
...     if str(some_string) != some_string:
...         return "Not a string!"
...     if len(some_string) < 3:
...         return ''.join(some_string,'x')[:,3]
...     return some_string[:,3]
... 
>>> threechars = make_3_characters_long('xyz')    
>>> if threechars:
...     print threechars
... else:
...     print "threechars is already 3 characters long!"
... 
threechars is already 3 characters long!

有关使用return的这种方式的更多建议，请参阅Python指南的Code Style section。

Answer 8

＆＃34;返回＆＃34;之间的区别和＆＃34;打印＆＃34;也可以在以下示例中找到：

RETURN：

def bigger(a, b):
    if a > b:
        return a
    elif a <b:
        return b
    else:
        return a

上述代码将为所有输入提供正确的结果。

PRINT：

def bigger(a, b):
    if a > b:
        print a
    elif a <b:
        print b
    else:
        print a

注意：对于许多测试用例，这将失败。

ERROR：

----  

FAILURE : Test case input: 3, 8.

            Expected result: 8  

FAILURE : Test case input: 4, 3.

            Expected result: 4  

FAILURE : Test case input: 3, 3.

            Expected result: 3  

---

You passed 0 out of 3 test cases

Answer 9

这是我的理解。 （希望它会帮助某人，而且它是正确的）。

def count_number_of(x):
    count = 0
    for item in x:
        if item == "what_you_look_for":
        count = count + 1
    return count

因此，这段简单的代码会计算某些事件的出现次数。回报的位置很重要。它告诉您的程序您需要哪个值。因此，当您打印时，您将输出发送到屏幕。当你回来时，你告诉价值去某个地方。在这种情况下，您可以看到count = 0缩进并返回 - 我们希望值（count + 1）替换为0。 如果在缩进return命令时尝试遵循代码的逻辑，则输出将始终为1，因为我们永远不会告诉初始计数要更改。 我希望我做对了。 哦，返回总是在函数内部。

Answer 10

return是函数定义的一部分，而print将文本输出到标准输出（通常是控制台）。

函数是接受参数并返回值的过程。 return用于后者，而前者用def完成。

示例：

def timestwo(x):
    return x*2

Answer 11

return应该用于递归函数/方法，或者您希望将返回的值用于算法中的后续应用程序。

当您想要向用户显示有意义和所需的输出时，应该使用

print，并且您不希望屏幕上出现用户不感兴趣的中间结果，尽管它们对调试你的代码。

以下代码说明了如何正确使用return和print：

def fact(x):
    if x < 2:
        return 1
    return x * fact(x - 1)

print(fact(5))

这种解释适用于所有编程语言，而不仅仅是 python 。

Answer 12

关于return函数的最好的事情是你可以从函数返回一个值，但你可以对print做同样的事情，那么差异是什么？ 基本上return而不仅仅是返回它会以对象形式给出输出，这样我们就可以将函数的返回值保存到任何变量，但我们不能使用print，因为它与{{1}相同在stdout/cout。

请按照以下代码更好地理解

CODE

C Programming

我们现在正在为def add(a, b): print "ADDING %d + %d" % (a, b) return a + b def subtract(a, b): print "SUBTRACTING %d - %d" % (a, b) return a - b def multiply(a, b): print "MULTIPLYING %d * %d" % (a, b) return a * b def divide(a, b): print "DIVIDING %d / %d" % (a, b) return a / b print "Let's do some math with just functions!" age = add(30, 5) height = subtract(78, 4) weight = multiply(90, 2) iq = divide(100, 2) print "Age: %d, Height: %d, Weight: %d, IQ: %d" % (age, height, weight, iq) # A puzzle for the extra credit, type it in anyway. print "Here is a puzzle." what = add(age, subtract(height, multiply(weight, divide(iq, 2)))) print "That becomes: ", what, "Can you do it by hand?" 和add, subtract, multiply,执行自己的数学函数。需要注意的重要一点是我们说返回divide的最后一行（在a + b中）。这样做有以下几点：

1. 我们的函数使用两个参数调用：add和a。
2. 我们打印出我们的功能正在做什么，在这种情况下＆＃34;添加。＆＃34;
3. 然后我们告诉Python做一些落后的事情：我们返回b的添加内容。您可以这样说，＆＃34;我添加a + b和a然后返回它们。＆＃34;
4. Python添加了两个数字。然后当函数结束时，运行它的任何行都能够将此b结果赋给变量。

Answer 13

我认为一个非常简单的答案可能在这里有用：

return使值（通常是变量）可供调用者使用（例如，由使用return的函数位于其中的函数存储）。没有return，您的值或变量将无法供调用者存储/重用。

print打印到屏幕上，但不会使值或变量可供调用者使用。

（完全承认，更彻底的答案更准确。）