それをサポートする言語で複数の値を返すための標準的な方法は、しばしば混乱しています。

オプション：タプルの使用

次の簡単な例を考えてみます。

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

ただし、返される値の数が増えると、すぐに問題が発生します。4つまたは5つの値を返す場合はどうなりますか？もちろん、それらを繰り返し使用することはできますが、どの値がどこにあるのかを簡単に忘れてしまいます。また、受け取りたい場所をどこでも開梱するのは見苦しくなります。

オプション：辞書を使用する

次の論理的なステップは、ある種の「レコード表記」を導入することです。Pythonでは、これを行う明白な方法はを使用することですdict。

以下を検討してください。

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

（明確にするために、y0、y1、およびy2は単に抽象的な識別子として意図されています。指摘したように、実際には、意味のある識別子を使用します。）

これで、返されたオブジェクトの特定のメンバーを投影できるメカニズムができました。例えば、

result['y0']

オプション：クラスの使用

ただし、別のオプションがあります。代わりに、特殊な構造を返すことができます。私はこれをPythonのコンテキストで組み立てましたが、他の言語にも適用できると確信しています。確かに、もしあなたがCで働いていたなら、これが非常によくある唯一の選択肢かもしれません。ここに行く：

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では、前の2つはおそらく配管の点で非常に似{ y0, y1, y2 }ています-結局のところ、最終的__dict__にはの内部のエントリになりますReturnValue。

小さなオブジェクトである__slots__属性には、Pythonによって提供される追加機能が1つあります。クラスは次のように表現できます。

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

Pythonリファレンス・マニュアル：

__slots__宣言は、各変数の値を保持するために、各インスタンスにインスタンス変数と埋蔵量だけで十分なスペースのシーケンスを取り。は__dict__インスタンスごとに作成されないため、スペースが節約されます。

オプション：使用するデータクラスを（パイソン3.7+）

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)

オプション：リストを使用する

私が見逃していたもう1つの提案は、ビルザトカゲからのものです。

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

これは私の最も好きな方法ですが。私はHaskellへの暴露に汚染されていると思いますが、混合タイプのリストの考えは常に不快に感じてきました。この特定の例では、リストは混合タイプではありませんが、そうである可能性があります。

この方法で使用されるリストは、私が知る限り、タプルに関して実際には何も得ません。Pythonでのリストとタプルの唯一の本当の違いは、リストは変更可能であるのに対し、タプルは変更できないことです。

私は個人的に、関数型プログラミングの慣例を引き継ぐ傾向があります。同じタイプの要素をいくつでもリストに使用し、事前に定義されたタイプの要素をいくつでもタプルを使用します。

質問

長いプリアンブルの後に、避けられない質問が続きます。どちらの方法が良いと思いますか？

名前付きタプルは、この目的のために2.6で追加されました。同様の組み込み例については、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

最近のバージョンのPython 3（3.6以上、と思います）では、新しいtypingライブラリーにNamedTupleクラスが追加され、名前付きタプルの作成が簡単になり、より強力になりました。から継承typing.NamedTupleすると、docstring、デフォルト値、および型注釈を使用できます。

例（ドキュメントから）：

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

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

小規模なプロジェクトの場合、タプルを使用するのが最も簡単です。それを管理するのが非常に難しくなると（以前はそうではありません）、物事を論理構造にグループ化し始めますReturnValue。

キーを持つ辞書を返す"y0"、"y1"、"y2"、などのタプル上の任意の利点を提供していません。返すReturnValueプロパティを持つインスタンスを.y0、.y1、.y2、などのいずれかの組の上に任意の利点を提供していません。どこにでも行きたいなら、名前を付ける必要があります。とにかくタプルを使ってそれを行うことができます：

def get_image_data(filename):
    [snip]
    return size, (format, version, compression), (width,height)

size, type, dimensions = get_image_data(x)

IMHO、タプルを超える唯一の優れたテクニックは、re.match()またはから取得するような適切なメソッドとプロパティを持つ実際のオブジェクトを返すことですopen(file)。

答えの多くは、辞書やリストなど、ある種のコレクションを返す必要があることを示唆しています。追加の構文を省略して、戻り値をコンマ区切りで書き出すこともできます。注：これは技術的にはタプルを返します。

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

与える：

True
False

辞書に投票します。

2〜3個を超える変数を返す関数を作成すると、辞書に折りたたまれます。さもなければ、私が返すものの順序と内容を忘れがちです。

また、「特別な」構造を導入すると、コードの追跡が難しくなります。（他の誰かがコードを検索して、それが何かを見つける必要があります）

タイプの検索が気になる場合は、「x値リスト」などの説明的な辞書キーを使用してください。

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

返される値がクラスのカプセル化の候補である場合を除いて、通常はIMHOタプルが最適です。

タプルが「自然」であると感じるときはいつでもタプルを使用することを好みます。座標は典型的な例です。たとえば、1軸のみのスケーリング計算では、個別のオブジェクトが独立して立つことができ、順序が重要です。注：グループの意味に悪影響を与えずにアイテムを並べ替えたりシャッフルしたりできる場合は、タプルを使用しないでください。

グループ化されたオブジェクトが常に同じではない場合にのみ、辞書を戻り値として使用します。オプションのメールヘッダーを考えてみてください。

それ以外の場合、グループ化されたオブジェクトがグループ内で固有の意味を持つか、独自のメソッドを持つ完全なオブジェクトが必要な場合は、クラスを使用します。

私は好む：

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で類似しているdictとtupleの代わりに、struct。

座標セットのtuple場合は、点classまたはa ではなくdictを使用します（tupleaを辞書のキーとして使用できるため、dictsはスパースな多次元配列を作成します）。

物事のリストを繰り返し処理する場合はtuple、反復でsをアンパックすることをお勧めします。

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'])

モノが広く使用されており、コードの複数の場所で同様の重要な操作を行っている場合は、通常、適切なメソッドを持つクラスオブジェクトにすることをお勧めします。

最後に、Python以外のシステムコンポーネントとデータを交換する場合は、dictJSONシリアライゼーションに最適であるため、ほとんどの場合はそれらを保持します。

S.Lottの名前付きコンテナークラスの提案に対する+1。

Python 2.6以降の場合、名前付きタプルはこれらのコンテナクラスを簡単に作成するための便利な方法を提供し、結果は「軽量で通常のタプルよりも多くのメモリを必要としません」です。

Pythonのような言語では、新しいクラスを作成するよりもオーバーヘッドが少ないため、通常は辞書を使用します。

ただし、同じ変数のセットを常に返すことに気付いた場合は、おそらく、その中に新しいクラスが含まれています。

私はdictを使用して関数から値を渡したり返したりします：

で定義された変数のフォームを使用し、フォーム。

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}

これは私にとっても処理ユニットにとっても最も効率的な方法です。

ポインタを1つだけ渡して、1つだけポインタを返す必要があります。

コードを変更するたびに、関数の引数（数千）を変更する必要はありません。

「ベスト」は部分的に主観的な決定です。不変が許容される一般的なケースでは、小さな戻り値セットにタプルを使用します。可変性が要求されない場合、タプルは常にリストよりも望ましいです。

より複雑な戻り値の場合、または形式性が重要な場合（つまり、値の大きいコード）には、名前付きタプルの方が適しています。最も複雑なケースでは、通常オブジェクトが最適です。ただし、実際に重要なのは状況です。それが関数の最後に自然にあるのでオブジェクトを返すことが理にかなっている場合（例：Factoryパターン）、オブジェクトを返します。

賢者が言ったように：

時期尚早な最適化は、プログラミングにおけるすべての悪（または少なくともその大部分）の原因です。