我写了以下代码:
class FigureOut:
def setName(self, name):
fullname = name.split()
self.first_name = fullname[0]
self.last_name = fullname[1]
def getName(self):
return self.first_name, self.last_name
f = FigureOut()
f.setName("Allen Solly")
name = f.getName()
print (name)
我得到以下输出:
('Allen', 'Solly')
当python中的函数返回多个值时，是否总是将多个值转换为多个值的列表，然后从函数中返回?
Whenever multiple values are returned from a function in python, does it always convert the multiple values to a list of multiple values and then returns it from the function?
整个过程是否与将多个值显式转换为 list 然后返回列表相同，例如在 JAVA 中，因为在 JAVA 中的函数只能返回一个对象?
Is the whole process same as converting the multiple values to a list explicitly and then returning the list, for example in JAVA, as one can return only one object from a function in JAVA?
由于getName中的return语句指定了多个元素:
Since the return statement in getName specifies multiple elements:
def getName(self):
return self.first_name, self.last_name
Python 将返回一个基本上包含它们的容器对象.
Python will return a container object that basically contains them.
在这种情况下，返回一个逗号分隔的元素集会创建一个元组.多个值只能在容器内返回.
In this case, returning a comma separated set of elements creates a tuple. Multiple values can only be returned inside containers.
让我们使用一个返回多个值的更简单的函数:
Let's use a simpler function that returns multiple values:
def foo(a, b):
return a, b
您可以查看使用 dis 生成的字节码.dis，一个 Python 字节码的反汇编器.对于没有任何括号的逗号分隔值，它看起来像这样:
You can look at the byte code generated by using dis.dis, a disassembler for Python bytecode. For comma separated values w/o any brackets, it looks like this:
>>> import dis
>>> def foo(a, b):
... return a,b
>>> dis.dis(foo)
2 0 LOAD_FAST 0 (a)
3 LOAD_FAST 1 (b)
6 BUILD_TUPLE 2
9 RETURN_VALUE
如您所见，这些值首先使用 LOAD_FAST 加载到内部堆栈，然后是 BUILD_TUPLE(抓取之前放置在堆栈上的2 个元素).由于存在逗号，Python 知道创建一个元组.
As you can see the values are first loaded on the internal stack with LOAD_FAST and then a BUILD_TUPLE (grabbing the previous 2 elements placed on the stack) is generated. Python knows to create a tuple due to the commas being present.
您也可以使用 [] 指定另一种返回类型，例如列表.对于这种情况，一个 BUILD_LIST将按照与其等效的元组相同的语义发出:
You could alternatively specify another return type, for example a list, by using []. For this case, a BUILD_LIST is going to be issued following the same semantics as it's tuple equivalent:
>>> def foo_list(a, b):
... return [a, b]
>>> dis.dis(foo_list)
2 0 LOAD_FAST 0 (a)
3 LOAD_FAST 1 (b)
6 BUILD_LIST 2
9 RETURN_VALUE
返回的对象类型实际上取决于括号的存在(对于元组，() 如果至少有一个逗号，则可以省略).[] 创建列表和 {} 集.字典需要 key:val 对.
The type of object returned really depends on the presence of brackets (for tuples () can be omitted if there's at least one comma). [] creates lists and {} sets. Dictionaries need key:val pairs.
总而言之，返回一个实际对象.如果该对象是容器类型，它可以包含多个值，给人以返回多个结果的印象.然后通常的方法是直接解包:
To summarize, one actual object is returned. If that object is of a container type, it can contain multiple values giving the impression of multiple results returned. The usual method then is to unpack them directly:
>>> first_name, last_name = f.getName()
>>> print (first_name, last_name)
<小时>
除此之外，您的 Java 方法正在泄漏到 Python 中:-)
As an aside to all this, your Java ways are leaking into Python :-)
在 Python 中编写类时不要使用 getter，使用 properties.属性是管理属性的惯用方式，有关这些的更多信息，请参阅一个不错的答案 这里.
Don't use getters when writing classes in Python, use properties. Properties are the idiomatic way to manage attributes, for more on these, see a nice answer here.
这篇关于Python如何从一个函数返回多个值?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持跟版网！