### 选项：使用元组

def f(x):
y0 = x + 1
y1 = x * 3
y2 = y0 ** y3
return (y0, y1, y2)

### 选项：使用字典

def g(x):
y0 = x + 1
y1 = x * 3
y2 = y0 ** y3
return {'y0': y0, 'y1': y1 ,'y2': y2}

（编辑 - 要清楚，y0，y1和y2只是作为抽象标识符。正如所指出的，在实践中你会使用有意义的标识符）

result['y0']

### 选项：使用类

class ReturnValue:
def __init__(self, y0, y1, y2):
self.y0 = y0
self.y1 = y1
self.y2 = y2

def g(x):
y0 = x + 1
y1 = x * 3
y2 = y0 ** y3
return ReturnValue(y0, y1, y2)

Python提供了一个额外的功能，但是对于微小的对象__slots__属性。该课程可以表示为：

class ReturnValue(object):
__slots__ = ["y0", "y1", "y2"]
def __init__(self, y0, y1, y2):
self.y0 = y0
self.y1 = y1
self.y2 = y2

__slots__声明采用一系列实例变量，并在每个实例中保留足够的空间来保存每个变量的值。保存空间是因为没有为每个实例创建__dict__

### 选项：使用dataclass（python 3.7 +）

@dataclass
class Returnvalue:
y0: int
y1: float
y3: int

def total_cost(x):
y0 = x + 1
y1 = x * 3
y2 = y0 ** y3
return ReturnValue(y0, y1, y2)

### 选项：使用列表

def h(x):
result = [x + 1]
result.append(x * 3)
result.append(y0 ** y3)
return result

# 问题

#### 14 个答案:

Named tuples。另请参阅os.stat了解类似的内置示例。

>>> import collections
>>> Point = collections.namedtuple('Point', ['x', 'y'])
>>> p = Point(1, y=2)
>>> p.x, p.y
1 2
>>> p[0], p[1]
1 2

class Employee(NamedTuple):  # inherit from collections.NamedTuple
name: str
id: int = 3  # default value

employee = Employee('Guido')
assert employee.id == 3

def getImageData(filename):
[snip]
return size, (format, version, compression), (width,height)
size, type, dimensions = getImageData(x)

def f():
return True, False
x, y = f()
print(x)
print(y)

True
False

def g(x):
y0 = x + 1
y1 = x * 3
y2 = y0 ** y3
return {'y0':y0, 'y1':y1 ,'y2':y2 }

>>> def f(x):
y0 = x + 1
yield y0
yield x * 3
yield y0 ** 4

>>> a, b, c = f(5)
>>> a
6
>>> b
15
>>> c
1296

def g(x):
y0 = x + 1
y1 = x * 3
y2 = y0 ** y3
return {'y0':y0, 'y1':y1 ,'y2':y2 }

>>> def func():
...    return [1,2,3]
...
>>> a,b,c = func()
>>> a
1
>>> b
2
>>> c
3

class Some3SpaceThing(object):
def __init__(self,x):
self.g(x)
def g(self,x):
self.y0 = x + 1
self.y1 = x * 3
self.y2 = y0 ** y3

r = Some3SpaceThing( x )
r.y0
r.y1
r.y2

Python的元组，字符串和对象为程序员提供了在小型数据结构（“事物”）的形式和便利之间的平滑权衡。对我来说，如何表示事物的选择主要取决于我将如何使用该结构。在C ++中，对于具有方法的对象，使用struct和使用方法的对象class是常见的约定，即使您可以合法地将方法放在struct上;我的习惯在Python中很相似，dicttuple代替struct

for score,id,name in scoreAllTheThings():
if score > goodScoreThreshold:
print "%6.3f #%6d %s"%(score,id,name)

...因为对象版本更加杂乱无法阅读：

for entry in scoreAllTheThings():
if entry.score > goodScoreThreshold:
print "%6.3f #%6d %s"%(entry.score,entry.id,entry.name)

...更不用说dict

for entry in scoreAllTheThings():
if entry['score'] > goodScoreThreshold:
print "%6.3f #%6d %s"%(entry['score'],entry['id'],entry['name'])

+1 S.Lott对命名容器类的建议。

form = {
'level': 0,
'points': 0,
'game': {
'name': ''
}
}

def test(form):
form['game']['name'] = 'My game!'
form['level'] = 2

return form

>>> print(test(form))
{u'game': {u'name': u'My game!'}, u'points': 0, u'level': 2}

“最佳”是部分主观的决定。在可接受不可变的一般情况下，将元组用于小的收益集。当不需要可变性时，元组总是比列表更可取。