Wie gebe ich mehrere Werte von einer Funktion?

Der übliche Weg, um mehrere Werte zurückgeben, die in Sprachen, die es unterstützen, ist oft tupling.

Option: Mit einem Tupel

Betrachten Sie dieses einfache Beispiel:

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

Jedoch, das wird schnell problematisch wird, da die Anzahl der zurückgegebenen Werte erhöht. Was, wenn Sie zurückkehren möchten, vier oder fünf Werte? Sicher, man könnte immer tupling, aber es wird leicht vergessen, welcher Wert wo. Es ist auch eher hässlich entpacken Sie Sie, wohin Sie wollen, Sie zu empfangen.

Option: eine Wörterbuch -

Der nächste logische Schritt zu sein scheint, die Einführung einer Art "record-notation'. In Python, die offensichtliche Weg, dies zu tun ist durch eine dict.

Folgendes:

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

(Nur um klar zu sein, y0, y1 und y2 dienen nur als abstrakte Bezeichner. Wie hingewiesen, in der Praxis würden Sie verwenden Sie sinnvolle Bezeichner.)

Nun, wir haben einen Mechanismus, durch den wir Projekt aus einem bestimmten Mitglied des zurückgegebenen Objekts. Zum Beispiel,

result['y0']

Option: Verwendung einer Klasse

Allerdings gibt es eine weitere option. Wir könnten stattdessen Rückkehr eine spezialisierte Struktur. Ich habe gerahmt, diese in den Kontext von Python, aber ich bin sicher, es gilt auch für andere Sprachen. In der Tat, wenn Sie arbeiten wurden in C das könnte sehr gut sein, 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 die beiden vorherigen sind vielleicht sehr ähnlich in Bezug auf Sanitär -, nachdem alle { y0, y1, y2 } nur am Ende als Einträge im internen __dict__ des ReturnValue.

Es ist eine zusätzliche Funktion, bereitgestellt durch Python-obwohl für winzige Objekte, die __slots__ Attribut. Die Klasse könnte wie folgt ausgedrückt werden:

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

Aus der Python-Referenz-Handbuch:

Den __slots__ Erklärung nimmt, eine Sequenz von Instanz-Variablen und behält sich nur genug Platz in jede Instanz einen Wert für jede variable. Speicherplatz wird gespart, weil __dict__ ist nicht geschaffen für jede Instanz.

Option: Mit einem dataclass (Python 3.7+)

Mit Python 3.7 neue dataclasses, zurückzukehren, eine Klasse, mit automatisch Hinzugefügt speziellen Methoden, schreib-und andere nützliche tools:

@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: Mit Hilfe einer Liste

Einen anderen Vorschlag, habe ich übersehen, kommt von Bill, die Eidechse:

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

Dies ist mein wenigsten bevorzugten Methode wenn. Ich glaube, ich bin verdorben durch die Einwirkung von Haskell, aber die Idee des mixed-Typ-Listen hat immer das Gefühl unbequem zu mir. In diesem speziellen Beispiel die Liste ist -nicht - gemischter Typ, aber es denkbar sein könnte.

Einer Liste, die in dieser Art und Weise wirklich nicht alles gewinnen mit Bezug auf die Tupel, so weit ich erzählen kann. Der einzige wirkliche Unterschied zwischen Listen und Tupel in Python ist, dass Listen sind veränderlich, in der Erwägung, dass Tupel nicht.

Ich persönlich tendiere zu führen über die Konventionen aus der funktionalen Programmierung: die Verwendung von Listen für beliebige Anzahl von Elementen des gleichen Typs, und Tupeln wird eine Feste Anzahl von Elementen, die bestimmte Arten.

Frage

Nach der langen Präambel, kommt die unvermeidliche Frage. Welche Methode (denken Sie) am besten ist?

Ich habe in der Regel gefunden, werde mich selbst das Wörterbuch route, denn es handelt sich weniger set-up-Arbeit. Von einem Typen Perspektive allerdings könnten Sie besser dran, wenn man die Klasse route, da dies kann Ihnen helfen, zu vermeiden, verwirrend, was ein Wörterbuch repräsentiert.

Auf der anderen Seite gibt es auch einige in der Python-Gemeinschaft, die das Gefühl haben implizite Schnittstellen sollten bevorzugt werden, um explizite Schnittstellen, an welchem Punkt der Typ des Objekts ist nicht wirklich relevant, da Sie im wesentlichen unter Berufung auf die Konvention, dass das gleiche Attribut haben stets die gleiche Bedeutung.

So, wie Sie es tun-Sie - return mehrere Werte in Python?

  • In Ihnen hervorragende Beispiele, die Sie verwenden variable y3, aber es sei denn, y3 ist global deklariert, dies würde die Ausbeute NameError: global name 'y3' is not defined vielleicht verwenden Sie einfach 3?
InformationsquelleAutor saffsd | 2008-12-10
  1. 604

    Benannte Tupel wurden in 2.6 für diesen Zweck. Siehe auch os.stat für eine ähnliche builtin 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 den letzten Versionen von Python 3 (3.6+, denke ich), die neue typing Bibliothek bekam die NamedTuple Klasse zu machen, benannten Tupel einfacher und mehr leistungsstarke. Erben von typing.NamedTuple ermöglicht Ihnen die Verwendung von docstrings, default-Werte, und geben Sie Anmerkungen ein.

    Beispiel (Aus der Dokumentation):

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

employee = Employee('Guido')
assert employee.id == 3
    • Dies ist die einzig richtige Antwort, denn es ist die einzige kanonische Struktur, die die OP nicht betrachten, und weil es behebt sein problem mit der Verwaltung von langen Tupeln. Sollte als angenommen markiert werden.
    • Gut, das design Begründung für die namedtuple ist mit einem kleineren Speicher-footprint für Masse Ergebnisse (lange Listen von Tupeln, wie die Ergebnisse der DB-Abfragen). Für einzelne Elemente (wenn die Funktion in Frage, die nicht oft aufgerufen) - Wörterbücher und-Klassen sind auch gut. Aber namedtuples sind eine schöne/schönere Lösung auch in diesem Fall.
    • Beste Antwort, denke ich. Eine Sache, die ich nicht wusste sofort - Sie brauchen nicht zu erklären, dass die namedtuple in den äußeren Umfang; Ihre Funktion selbst definieren können container und wieder zurück.
    • Tun Sie das nicht. Python macht keine Mühe, um uniquify namedtuple Definitionen (jeder Aufruf erzeugt eine neue), die Schaffung der namedtuple Klasse ist verhältnismäßig teuer, CPU und Arbeitsspeicher, und alle Klassendefinitionen intrinsisch umfassen zyklische Referenzen (also auf CPython, warten Sie für eine zyklische GC führen für Sie freigelassen). Es macht es auch unmöglich pickle die Klasse (und daher unmöglich zu nutzen, Instanzen mit multiprocessing in den meisten Fällen). Jede Kreation der Klasse, die auf meine 3.6.4 x64 verbraucht ~A. 0,337 ms, und belegt knapp 1 KB Speicher, töten jede Instanz Einsparungen.
    • Ich werde beachten Sie, Python 3.7 verbessert die Geschwindigkeit der Erstellung neuer namedtuple Klassen; die CPU-Kosten sinken um etwa einen Faktor 4x, aber Sie sind immer noch ungefähr 1000x höher als die Kosten für eine Instanz zu schaffen, und die Speicher-Kosten für jede Klasse bleibt hoch (ich war falsch in meinem letzten Kommentar über "unter 1 KB" für die Klasse _source selbst ist in der Regel 1,5 KB; _source entfernt 3.7, so ist es wahrscheinlich näher an der ursprünglichen Forderung von knapp unter 1 KB pro Klasse Kreation).
    • Schade dass dies nicht in der standard-Bibliothek. Man braucht, um import collections. Deshalb halte ich die Verwendung von Wörterbüchern.
    • Dies ist Teil der standard-Bibliothek, jedoch nicht vordefiniert. Sie brauchen keine sorgen zu machen, dass es vielleicht nicht auf einem anderen system installiert mit Python >= 2.6. Oder haben Sie nur Objekt der extra Zeile?

    InformationsquelleAutor A. Coady
  2. 199

    Für kleine Projekte finde ich es am einfachsten, mit zu arbeiten-Tupeln. Wenn das wird zu schwer zu verwalten (und nicht vor) ordne ich die Dinge in logische Strukturen, aber ich denke, dass Ihr vorgeschlagener Gebrauch von Wörterbüchern und ReturnValue Objekte ist falsch (oder zu simpel).

    Rückkehr ein dictionary mit den keys y0, y1, y2, etc. bietet keinen Vorteil über Tupel. Rückkehr ein ReturnValue-Instanz mit Eigenschaften .y0, .y1, .y2, etc. bietet keinen Vorteil gegenüber der Tupel entweder. Sie müssen zu Beginn der Benennung der Dinge, wenn Sie wollen, um überall zu bekommen, und Sie können tun, dass mit Tupeln sowieso:

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

    IMHO, die nur gute Technik jenseits von Tupeln ist die Rückkehr von realen Objekten mit geeigneten Methoden und Eigenschaften, wie Sie von re.match() oder open(file).

    • Frage - gibt es einen Unterschied zwischen size, type, dimensions = getImageData(x) und (size, type, dimensions) = getImageData(x)? I. e., nicht einwickeln Links-hand-Seite eine tupled Abtretung das einen Unterschied machen?
    • Es gibt keinen Unterschied. Tupel identifiziert wird, durch ein Komma und die Verwendung von Klammern ist nur die Gruppe gemeinsam etwas Unternehmen. Zum Beispiel(1) ist ein int bei (1,) oder 1, ist ein Tupel.
    • Re "die Rückkehr ein dictionary mit den keys y0, y1, y2 usw., bietet keinen Vorteil gegenüber tuples": Wörterbuch hat den Vorteil, dass können Sie Felder hinzufügen, die zurückgegeben Wörterbuch, ohne zu brechen vorhandenen code.
    InformationsquelleAutor too much php
  3. 185

    Viele der Antworten vorschlagen, die Sie brauchen, um wieder eine Sammlung irgendeiner Art, wie ein Wörterbuch oder eine Liste. Sie verlassen konnten aus der zusätzlichen syntax und schreiben Sie einfach die return-Werte werden durch Kommas getrennt. Hinweis: diese technisch gibt ein Tupel.

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

    gibt:

    True
False
    • Sie sind immer noch die Rückkehr einer Sammlung. Es ist ein Tupel. Ich bevorzuge die Klammer, um es deutlicher. Versuchen Sie dies:type(f()) zurück <class 'tuple'>.
    • Es gibt keinen Grund, um die tuple Aspekt explizit; es ist nicht wirklich wichtig, dass Sie zurückgeben, eine tuple dies ist das idiom für die Rückgabe mehrere Werte Zeitraum. Gleichen Grund, warum Sie das weglassen der Klammern mit der swap-idiom, x, y = y, x mehrere Initialisierung x, y = 0, 1, etc.; sicher, es macht tuples unter der Haube, aber es gibt keinen Grund für die explizite, da die tuples nicht der Punkt, an alle. Das Python-tutorial stellt mehrfache Zuordnung lange, bevor es selbst berührt tuples.
    • jegliche Sequenz von Werten, getrennt durch ein Komma, in der rechten Seite des = ist ein Tupel in Python mit oder ohne Klammer um Sie herum. Also gibt es eigentlich keine expliziten oder impliziten hier. a,b,c ist, wie sehr ein Tupel (a,b,c). Auch gibt es kein making of tuple "unter der Haube", wenn Sie wieder solche Werte, da es nur ein schlichter Tupel. Die OP bereits erwähnt Tupel, so gibt es eigentlich keinen Unterschied zwischen dem, was er erwähnt und was diese Antwort zeigt. Keiner
    • Ja, die Sprache, die definition, behandelt Sie als gleichwertig. Das heißt, die tatsächliche Programmierer neigen zu behandeln Klammern als Hinweis auf eine Sequenz-Daten-Struktur, während ohne Sie, es ist nur "mehrere Dinge". Ich Stimme gibt es keinen Unterschied im Verhalten, aber die zusätzlichen Klammern ändern die Weise, die meisten Leute die ich kenne denken über es. Stimmte es unterscheidet sich nicht von den OP ' s Beispiel, in der das Verhalten (mit den gleichen Einschränkungen, die OP nicht mögen).
    InformationsquelleAutor Joseph Hansen
  4. 69

    Vote ich für das Wörterbuch.

    Ich finde, dass wenn ich eine Funktion zurückgibt, die etwas mehr als 2-3 Variablen werde ich Falten Sie Sie in einem Wörterbuch nach. Ansonsten Neige ich dazu, zu vergessen, die Reihenfolge und der Inhalt von dem, was ich fahre.

    Auch, die Einführung einer "besonderen" Struktur macht den code schwerer zu Folgen. (Jemand anderes suchen, durch den code, um herauszufinden, was es ist)

    Wenn Ihr besorgt über Aussehen, verwenden Sie beschreibende Wörterbuch Schlüssel, Beispiel: 'x-Werte-Liste".

    def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return {'y0':y0, 'y1':y1 ,'y2':y2 }
    • nach vielen Jahren der Programmierung habe ich eher auf was auch immer die Struktur der Daten und die Funktion erforderlich ist. Zuerst die Funktion, kann man immer gestalten wie es nötig ist.
    • Wie würden wir die Werte in das Wörterbuch, ohne den Aufruf der Funktion mehrere Male? Zum Beispiel, wenn ich verwenden möchten, y1 und y3 in eine andere Funktion?
    • ordnen Sie die Ergebnisse in eine separate variable. result = g(x); other_function(result)
    • ja. Dieser Weg ermöglicht auch die pass-Ergebnis, um mehrere Funktionen, die die verschiedenen Argumente aus dem Ergebnis, ohne ausdrücklich auf bestimmte Teile das Ergebnis jedes mal.
    InformationsquelleAutor monkut
  5. 36

    Eine andere Möglichkeit 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 sind in der Regel am besten, außer in Fällen, in denen die Werte, die zurückgegeben werden, sind Kandidaten für die Verkapselung in eine Klasse.

    • Das ist wohl die sauberste Lösung, und hat eine saubere syntax. Gibt es irgendwelche Nachteile dadurch? Wenn Sie nicht alle gibt, gibt es 'unverbrauchten' ergibt warten, Sie zu verletzen?
    • Dies kann "sauber", aber es scheint nicht intuitiv überhaupt. Wie würde jemand, der nie begegnet dieses Muster, bevor Sie wissen, dass Sie eine automatische Tupel Auspacken auslösen würde jedes yield?
    • Generatoren sind nur, dass... - Generatoren. Es gibt keine äußere Unterschied zwischen def f(x): …; yield b; yield a; yield r vs. (g for g in [b, a, r]), und beide leicht konvertieren zu Listen oder Tupeln, und als solche unterstützt tuple unpacking. Die Tupel von generator-form folgt einem funktionalen Ansatz, während die Funktion Formular ist zwingend notwendig und erlauben flow control und variable Zuordnung.
    InformationsquelleAutor rlms
  6. 28

    Ich lieber mit Tupeln, wenn ein Tupel fühlt sich "natürlicher"; Koordinaten sind ein typisches Beispiel, wo die Objekte trennen zu können, stehen auf Ihren eigenen, zum Beispiel in einem-Achse Skalierung Berechnungen, und die Reihenfolge ist wichtig. Hinweis: wenn kann ich Sortieren oder mischen die Elemente ohne einen nachteiligen Effekt auf die Bedeutung der Gruppe, dann habe ich wohl nicht verwenden ein Tupel.

    Benutze ich Wörterbücher als return-Wert nur, wenn die gruppierten Objekte nicht immer das gleiche. Denken Sie optionale E-Mail-Header.

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

    InformationsquelleAutor tzot
  7. 26

    Ich bevorzuge:

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

    Es scheint, alles andere ist nur zusätzlicher code, das gleiche zu tun.

    • Tupel sind einfacher zu entpacken: y0, y1, y2 = g() mit einem dict haben Sie zu tun: Ergebnis = g() y0, y1, y2 = Ergebnis.get('y0'), das Ergebnis.get('y1'), das Ergebnis.get('y2'), das ist ein bisschen hässlich. Jede Lösung hat seine "Pluspunkte" und die 'Nachteile'.
    InformationsquelleAutor UnkwnTech
  8. 25
    >>> def func():
...    return [1,2,3]
...
>>> a,b,c = func()
>>> a
1
>>> b
2
>>> c
3
    • Nein ist es nicht, es gibt ein Tupel nicht eine Liste.
    • destructuring ist die - argument für die Rückgabe von Listen meiner Meinung nach
    InformationsquelleAutor WebQube
  9. 18

    In der Regel, die "spezielle Struktur" IST eigentlich eine sinnvolle aktuelle Zustand eines Objekts, mit seinen 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 mag, um Namen zu finden, die für den anonymen Strukturen, wo möglich. Sinnvolle Namen machen die Dinge mehr klar.

    InformationsquelleAutor S.Lott
  10. 18

    Python-tuples, dicts und Objekte bieten dem Programmierer einen reibungslosen Kompromiss zwischen Formalität und Komfort für die kleinen Daten-Strukturen ("Dinge"). Für mich, die Entscheidung, wie Sie repräsentieren eine Sache wird bestimmt vor allem, wie werde ich die Struktur. In C++, es ist eine gängige Konvention zu verwenden struct für Daten-only-items und class für Objekte mit Methoden, auch wenn Sie rechtlich Methoden auf eine struct; meine Gewohnheit ist ähnlich wie in Python, mit dict und tuple im Ort struct.

    Für Koordinaten-sets, verwende ich ein tuple eher als einen Punkt class oder eine dict (und beachten Sie, dass Sie eine tuple als dictionary-Schlüssel, so dicts machen große sparse multidimensional arrays).

    Wenn ich werde sein, der Iteration über eine Liste der Dinge, die ich lieber Auspacken tuples auf die iteration:

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

    ...wie die Objekt-version ist übersichtlicher zu Lesen:

    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 die Sache ist weit verbreitet, und Sie finden sich dabei ähnliche nicht-triviale Operationen auf es an mehreren stellen im code, dann ist es meist lohnend zu machen, ein Klasse-Objekt mit den entsprechenden Methoden.

    Schließlich, wenn ich bin gehen, um den Austausch von Daten mit nicht-Python-system-Komponenten, ich werde sehr oft halten Sie Sie in einem dict weil das ist am besten geeignet, um JSON-Serialisierung.

    InformationsquelleAutor Russell Borogove
  11. 16

    +1 auf S. Lott ' s Vorschlag eines namens container-Klasse.

    Für Python 2.6 und höher, eine benannte Tupel bietet eine nützliche Möglichkeit, einfach die Erstellung dieser container-Klassen, und die Ergebnisse sind "leicht und erfordern nicht mehr Speicher als der reguläre Tupel".

    InformationsquelleAutor John Fouhy
  12. 4

    In Sprachen wie Python, ich würde in der Regel verwenden Sie ein Wörterbuch, wie es erfordert weniger Aufwand als eine neue Klasse zu erstellen.

    Allerdings, wenn ich ständig die Rückgabe der gleichen Menge von Variablen, dann wahrscheinlich beinhaltet eine neue Klasse, die werde ich Faktor aus.

    InformationsquelleAutor fluffels
  13. 3

    Ich mit einem dict übergeben und zurückgeben von Werten aus einer Funktion:

    Verwendung variabler form gemäß der Definition in 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 processing unit.

    Übergibt man nur einen Zeiger an und kehren nur einem Zeiger aus.

    Du nicht ändern-Funktionen " (Tausende davon) Argumente, Wann immer Sie eine änderung in Ihrem code.

    • Dicts sind veränderlich. Wenn Sie eine dict an eine Funktion und diese Funktion bearbeitet die dict, änderungen werden außerhalb des Geltungsbereichs der Funktion. Mit der Funktion zurück, die dict-am Ende könnte bedeuten, dass die Funktion hat keine Nebenwirkungen, deshalb sollte der Wert nicht zurückgegeben werden, so dass es klar, dass test direkt den Wert verändern. Vergleichen Sie dies mit dict.update, die nicht einen Wert zurückgeben.
    • die Funktion der dict-am Ende könnte bedeuten, dass die Funktion hat keine Nebenwirkungen". Es bedeutet nicht, dass, weil ,wie Sie sagten, dict ist veränderlich. Allerdings, Rückgabe form verletzt Lesbarkeit noch die Leistung. In den Fällen, wo Sie brauchen, um neu zu formatieren form, die Rückgabe [der form] bedeutet stellen Sie sicher, dass die letzten form zurückgegeben wird, weil Sie nicht halten Spur von form Veränderungen überall.
    InformationsquelleAutor Elis Byberi
  14. 1

    "Beste" ist eine teilweise subjektive Entscheidung. Verwenden Tupel für kleine Rückkehr setzt im Allgemeinen Fall, wo eine unveränderliche ist akzeptabel. Ein Tupel ist immer besser, eine Liste, wenn Veränderlichkeit ist nicht Voraussetzung.

    Weitere komplexe, die Werte zurückgeben, oder für den Fall, wo Formalität ist wertvoll (d.h. hoher Wert, code) ein benanntes Tupel ist besser. Für die meisten komplexen Fall ein Objekt in der Regel am besten. Jedoch, es ist wirklich die situation, dass Fragen. Wenn es Sinn macht, ein Objekt zurückgeben, weil das ist, was Sie natürlich haben, am Ende der Funktion (z.B. Factory pattern), dann das Objekt zurückgeben.

    Als weiser Mann sagte:

    Vorzeitige Optimierung ist die Wurzel allen übels (oder zumindest die meisten
    es) in der Programmierung.

    InformationsquelleAutor joel3000
Schreibe einen Kommentar