Die kanonische Methode, mehrere Werte in Sprachen zurückzugeben, die dies unterstützen, ist häufig ein Tupeln .

Option: Verwenden eines Tupels

Betrachten Sie dieses triviale Beispiel:

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

Dies wird jedoch schnell problematisch, wenn die Anzahl der zurückgegebenen Werte zunimmt. Was ist, wenn Sie vier oder fünf Werte zurückgeben möchten? Sicher, Sie könnten sie weiter tupeln, aber es wird leicht zu vergessen, welcher Wert wo ist. Es ist auch ziemlich hässlich, sie auszupacken, wo immer Sie sie erhalten möchten.

Option: Verwenden eines Wörterbuchs

Der nächste logische Schritt scheint darin zu bestehen, eine Art "Datensatznotation" einzuführen. In Python ist der offensichtliche Weg, dies zu tun, mittels a dict.

Folgendes berücksichtigen:

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

(Um ganz klar zu sein, y0, y1 und y2 sind nur als abstrakte Bezeichner gedacht. Wie bereits erwähnt, würden Sie in der Praxis aussagekräftige Bezeichner verwenden.)

Jetzt haben wir einen Mechanismus, mit dem wir ein bestimmtes Mitglied des zurückgegebenen Objekts projizieren können. Zum Beispiel,

result['y0']

Option: Verwenden einer Klasse

Es gibt jedoch eine andere Option. Wir könnten stattdessen eine spezialisierte Struktur zurückgeben. Ich habe dies im Kontext von Python gerahmt, aber ich bin sicher, dass es auch für andere Sprachen gilt. Wenn Sie in C arbeiten, ist dies möglicherweise Ihre einzige Option. Hier geht:

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)

In Python sind sich die beiden vorherigen in Bezug auf die Installation vielleicht sehr ähnlich - schließlich handelt es sich { y0, y1, y2 }nur um Einträge im internen Bereich __dict__des ReturnValue.

Es gibt eine zusätzliche Funktion, die Python für winzige Objekte bereitstellt, das __slots__Attribut. Die Klasse könnte ausgedrückt werden als:

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

Aus dem Python-Referenzhandbuch :

Die __slots__Deklaration verwendet eine Folge von Instanzvariablen und reserviert in jeder Instanz gerade genug Speicherplatz, um einen Wert für jede Variable aufzunehmen. Speicherplatz wird gespart, da __dict__nicht für jede Instanz erstellt wird.

Option: Verwenden einer Datenklasse (Python 3.7+)

Geben Sie mit den neuen Datenklassen von Python 3.7 eine Klasse mit automatisch hinzugefügten speziellen Methoden, Eingaben und anderen nützlichen Tools zurück:

@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)

Option: Verwenden einer Liste

Ein weiterer Vorschlag, den ich übersehen hatte, stammt von Bill the Lizard:

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

Dies ist jedoch meine am wenigsten bevorzugte Methode. Ich glaube, ich bin durch die Begegnung mit Haskell in Mitleidenschaft gezogen, aber die Idee von Listen mit gemischten Typen hat sich für mich immer unangenehm angefühlt. In diesem speziellen Beispiel ist die Liste kein gemischter Typ, aber es könnte denkbar sein.

Eine Liste, die auf diese Weise verwendet wird, hat, soweit ich das beurteilen kann, wirklich nichts mit dem Tupel zu tun. Der einzige wirkliche Unterschied zwischen Listen und Tupeln in Python besteht darin, dass Listen veränderlich sind , Tupel jedoch nicht.

Ich persönlich neige dazu, die Konventionen aus der funktionalen Programmierung zu übernehmen: Verwenden Sie Listen für eine beliebige Anzahl von Elementen desselben Typs und Tupel für eine feste Anzahl von Elementen eines vorgegebenen Typs.

Frage

Nach der langen Präambel kommt die unvermeidliche Frage. Welche Methode (denkst du) ist die beste?

Zu diesem Zweck wurden in 2.6 benannte Tupel hinzugefügt. Siehe auch os.stat für ein ähnliches eingebautes Beispiel.

>>> 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

In neueren Versionen von Python 3 (3.6+, glaube ich) hat die neue typingBibliothek die NamedTupleKlasse erhalten, um benannte Tupel einfacher zu erstellen und leistungsfähiger zu machen. Beim Erben von typing.NamedTuplekönnen Sie Dokumentzeichenfolgen, Standardwerte und Typanmerkungen verwenden.

Beispiel (aus den Dokumenten):

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

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

Für kleine Projekte finde ich es am einfachsten, mit Tupeln zu arbeiten. Wenn das zu schwierig wird (und nicht vorher), fange ich an, Dinge in logische Strukturen zu gruppieren. Ich denke jedoch, dass Ihre vorgeschlagene Verwendung von Wörterbüchern und ReturnValueObjekten falsch (oder zu simpel) ist.

Wiederkehrende ein Wörterbuch mit den Tasten "y0", "y1", "y2"etc. bietet keinen Vorteil gegenüber Tupel. Zurückgeben einer ReturnValueInstanz mit Eigenschaften .y0, .y1, .y2etc. bietet keinen Vorteil gegenüber Tupeln entweder. Sie müssen anfangen, Dinge zu benennen, wenn Sie irgendwohin wollen, und Sie können dies trotzdem mit Tupeln tun:

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

size, type, dimensions = get_image_data(x)

IMHO ist die einzig gute Technik jenseits von Tupeln die Rückgabe realer Objekte mit geeigneten Methoden und Eigenschaften, wie Sie sie von re.match()oder erhalten open(file).

Viele der Antworten deuten darauf hin, dass Sie eine Sammlung wie ein Wörterbuch oder eine Liste zurückgeben müssen. Sie können die zusätzliche Syntax weglassen und die durch Kommas getrennten Rückgabewerte einfach ausschreiben. Hinweis: Dies gibt technisch ein Tupel zurück.

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

gibt:

True
False

Ich stimme für das Wörterbuch.

Ich finde, wenn ich eine Funktion erstelle, die mehr als 2-3 Variablen zurückgibt, falte ich sie in einem Wörterbuch zusammen. Ansonsten neige ich dazu, die Reihenfolge und den Inhalt meiner Rücksendung zu vergessen.

Durch die Einführung einer speziellen Struktur wird es außerdem schwieriger, Ihrem Code zu folgen. (Jemand anderes muss den Code durchsuchen, um herauszufinden, was er ist.)

Wenn Sie Bedenken hinsichtlich der Typensuche haben, verwenden Sie beschreibende Wörterbuchschlüssel, z. B. "Liste der x-Werte".

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

Eine andere Option wäre die Verwendung von Generatoren:

>>> 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

Obwohl IMHO-Tupel normalerweise am besten sind, außer in Fällen, in denen die zurückgegebenen Werte Kandidaten für die Kapselung in einer Klasse sind.

Ich bevorzuge es, Tupel zu verwenden, wenn sich ein Tupel "natürlich" anfühlt. Koordinaten sind ein typisches Beispiel, bei dem die einzelnen Objekte für sich allein stehen können, z. B. bei nur einachsigen Skalierungsberechnungen, und die Reihenfolge ist wichtig. Hinweis: Wenn ich die Elemente sortieren oder mischen kann, ohne die Bedeutung der Gruppe zu beeinträchtigen, sollte ich wahrscheinlich kein Tupel verwenden.

Ich verwende Wörterbücher nur dann als Rückgabewert, wenn die gruppierten Objekte nicht immer gleich sind. Denken Sie an optionale E-Mail-Header.

Für den Rest der Fälle, in denen die gruppierten Objekte innerhalb der Gruppe eine inhärente Bedeutung haben oder ein vollwertiges Objekt mit eigenen Methoden benötigt wird, verwende ich eine Klasse.

Ich bevorzuge:

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

Es scheint, dass alles andere nur zusätzlicher Code ist, um dasselbe zu tun.

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

Im Allgemeinen ist die "spezialisierte Struktur" tatsächlich ein vernünftiger aktueller Zustand eines Objekts mit eigenen Methoden.

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

Ich finde gerne Namen für anonyme Strukturen, wo dies möglich ist. Bedeutungsvolle Namen machen die Dinge klarer.

Pythons Tupel, Diktate und Objekte bieten dem Programmierer einen reibungslosen Kompromiss zwischen Formalität und Komfort für kleine Datenstrukturen ("Dinge"). Für mich hängt die Wahl, wie eine Sache dargestellt werden soll, hauptsächlich davon ab, wie ich die Struktur verwenden werde. In C ++ ist es eine übliche Konvention, structnur für Datenelemente und classfür Objekte mit Methoden zu verwenden, obwohl Sie Methoden legal auf a setzen können struct. Meine Gewohnheit ist in Python ähnlich, mit dictund tupleanstelle vonstruct .

Für Koordinatensätze verwende ich tupleeher einen als einen Punkt classoder einen dict(und beachte, dass Sie einen tupleals Wörterbuchschlüssel verwenden können, dictum großartige, spärliche mehrdimensionale Arrays zu erstellen).

Wenn ich eine Liste von Dingen durchlaufen möchte, entpacke ich lieber tuples in der Iteration:

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

... da die Objektversion unübersichtlicher zu lesen ist:

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

... geschweige denn die dict.

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

Wenn das Ding weit verbreitet ist und Sie an mehreren Stellen im Code ähnliche, nicht triviale Operationen ausführen, lohnt es sich normalerweise, es zu einem Klassenobjekt mit geeigneten Methoden zu machen.

Wenn ich Daten mit Nicht-Python-Systemkomponenten austauschen möchte, behalte ich sie meistens in einem, dictda dies für die JSON-Serialisierung am besten geeignet ist.

+1 auf S.Lotts Vorschlag einer benannten Containerklasse.

Ab Python 2.6 bietet ein benanntes Tupel eine nützliche Möglichkeit, diese Containerklassen einfach zu erstellen. Die Ergebnisse sind "leichtgewichtig und erfordern nicht mehr Speicher als normale Tupel".

In Sprachen wie Python würde ich normalerweise ein Wörterbuch verwenden, da es weniger Aufwand erfordert als das Erstellen einer neuen Klasse.

Wenn ich jedoch ständig denselben Satz von Variablen zurückgebe, handelt es sich wahrscheinlich um eine neue Klasse, die ich herausrechnen werde.

Ich würde ein Diktat verwenden, um Werte von einer Funktion zu übergeben und zurückzugeben:

Verwenden Sie die im Formular definierte variable Form .

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}

Dies ist der effizienteste Weg für mich und für die Verarbeitungseinheit.

Sie müssen nur einen Zeiger übergeben und nur einen Zeiger zurückgeben.

Sie müssen die Argumente von Funktionen (Tausende von ihnen) nicht ändern, wenn Sie Änderungen an Ihrem Code vornehmen.

"Best" ist eine teilweise subjektive Entscheidung. Verwenden Sie Tupel für kleine Rückgabesätze im allgemeinen Fall, wenn eine unveränderliche Menge akzeptabel ist. Ein Tupel ist einer Liste immer vorzuziehen, wenn keine Veränderlichkeit erforderlich ist.

Für komplexere Rückgabewerte oder für den Fall, dass Formalität wertvoll ist (dh Code mit hohem Wert), ist ein benanntes Tupel besser. Für den komplexesten Fall ist ein Objekt normalerweise am besten. Es ist jedoch wirklich die Situation, die zählt. Wenn es sinnvoll ist, ein Objekt zurückzugeben, weil Sie dies natürlich am Ende der Funktion haben (z. B. Factory-Muster), geben Sie das Objekt zurück.

Wie der Weise sagte:

Vorzeitige Optimierung ist die Wurzel allen Übels (oder zumindest des größten Teils davon) in der Programmierung.