Woher wissen Sie, ob Funktionsrückgabe- und Argumenttypen vorhanden sind?

Obwohl mir das Enten-Typisierungskonzept von Python bekannt ist, habe ich manchmal Probleme mit der Art der Argumente von Funktionen oder der Art des Rückgabewerts der Funktion.

Wenn ich die Funktion selbst geschrieben habe, kenne ich die Typen. Aber was ist, wenn jemand meine Funktionen nutzen und aufrufen möchte, wie soll er / sie die Typen kennen? Normalerweise füge ich Typinformationen in die Dokumentzeichenfolge der Funktion ein (wie: "...the id argument should be an integer..."und "... the function will return a (string, [integer]) tuple.")

Aber ist es wirklich so, wie es gemacht werden soll, die Informationen in der Dokumentenkette nachzuschlagen (und als Codierer dort abzulegen)?

Bearbeiten: Während die meisten Antworten auf "Ja, Dokument!" Ich denke, dass dies für 'komplexe' Typen nicht immer sehr einfach ist.
Zum Beispiel: wie beschreiben prägnant in einem docstring , dass eine Funktion , eine Liste von Tupeln zurückgibt, wobei jedes Tupel der Form (node_id, node_name, uptime_minutes) , und daß die Elemente jeweils ein String, String und Integer?
Die PEP-Dokumentation zu docstring enthält hierzu keine Richtlinien.
Ich denke, das Gegenargument wird sein, dass in diesem Fall Klassen verwendet werden sollten, aber ich finde Python sehr flexibel, weil es erlaubt, diese Dinge mit Listen und Tupeln herumzugeben, dh ohne Klassen.

Nun, seit 2011 haben sich die Dinge ein wenig geändert! Jetzt gibt es Typen Hinweise in Python 3.5 , die Sie annotate Argumente verwenden können , und die Art Ihrer Funktion zurückzukehren. Zum Beispiel dies:

def greeting(name):
  return 'Hello, {}'.format(name)

kann jetzt so geschrieben werden:

def greeting(name: str) -> str:
  return 'Hello, {}'.format(name)

Wie Sie jetzt sehen können, gibt es eine Art optionale statische Typprüfung, die Ihnen und Ihrer Typprüfung hilft, Ihren Code zu untersuchen.

Für weitere Erklärungen schlage ich vor, einen Blick in den Blog-Beitrag zu Typhinweisen im PyCharm-Blog zu werfen .

So funktionieren dynamische Sprachen. Es ist jedoch nicht immer gut, besonders wenn die Dokumentation schlecht ist - hat jemand versucht, ein schlecht dokumentiertes Python-Framework zu verwenden? Manchmal muss man zum Lesen der Quelle zurückkehren.

Hier sind einige Strategien, um Probleme beim Tippen von Enten zu vermeiden:

• Erstellen Sie eine Sprache für Ihre Problemdomäne
• Dies wird Ihnen helfen, Dinge richtig zu benennen
• Verwenden Sie Typen, um Konzepte in Ihrer Domänensprache darzustellen
• Benennen Sie Funktionsparameter mithilfe des Vokabulars der Domänensprache

Auch einer der wichtigsten Punkte:

• Halten Sie die Daten so lokal wie möglich!

Es sollten nur wenige gut definierte und dokumentierte Typen herumgereicht werden. Alles andere sollte beim Betrachten des Codes offensichtlich sein: Es gibt keine seltsamen Parametertypen aus der Ferne, die Sie nicht herausfinden können, wenn Sie in die Nähe des Codes schauen ...

Im Zusammenhang mit (und auch im Zusammenhang mit Docstrings) gibt es in Python eine Technik namens doctests. Verwenden Sie dies, um zu dokumentieren, wie Ihre Methoden voraussichtlich angewendet werden - und gleichzeitig eine gute Abdeckung durch Unit-Tests zu erzielen!

Ja, Sie sollten docstrings verwenden, um Ihre Klassen und Funktionen für andere Programmierer benutzerfreundlicher zu gestalten:

Mehr: http://www.python.org/dev/peps/pep-0257/#what-is-a-docstring

In einigen Editoren können Sie während der Eingabe Dokumentzeichenfolgen anzeigen, was die Arbeit erheblich erleichtert.

Ich besuchte einen Coursera-Kurs, es gab eine Lektion, in der wir über Designrezepte unterrichtet wurden.

Unterhalb des Docstring-Formats fand ich Preety nützlich.

def Bereich (Basis, Höhe):
    '' '(Nummer, Nummer) -> Nummer # ** TypeContract **
    Geben Sie den Bereich eines Trings mit der Bemaßungsbasis # ** Beschreibung ** zurück
    und Höhe

    >>> Bereich (10,5) # ** Beispiel **
    25.0
    >> Bereich (2,5,3)
    3,75
    '' '
    Rückgabe (Basis * Höhe) / 2 

Ich denke, wenn Docstrings auf diese Weise geschrieben werden, könnte dies Entwicklern sehr helfen.

Link zum Video [Sehen Sie sich das Video an] : https://www.youtube.com/watch?v=QAPg6Vb_LgI

Ja ist es.

In Python muss eine Funktion nicht immer eine Variable desselben Typs zurückgeben (obwohl Ihr Code besser lesbar ist, wenn Ihre Funktionen immer denselben Typ zurückgeben). Das bedeutet, dass Sie keinen einzigen Rückgabetyp für die Funktion angeben können.

Ebenso müssen die Parameter nicht immer vom gleichen Typ sein.

Beispiel: Wie kann in einer Dokumentzeichenfolge kurz beschrieben werden, dass eine Funktion eine Liste von Tupeln mit jedem Tupel des Formulars (Knoten-ID, Knotenname, Uptime-Minuten) zurückgibt und dass die Elemente jeweils eine Zeichenfolge, eine Zeichenfolge und eine Ganzzahl sind?

Ähm ... Es gibt keine "prägnante" Beschreibung dafür. Es ist komplex. Sie haben es so konzipiert, dass es komplex ist. Und es erfordert eine komplexe Dokumentation in der Dokumentzeichenfolge.

Entschuldigung, aber Komplexität ist - na ja - komplex.

Ja, da es sich um eine dynamisch typisierte Sprache handelt;)

Lesen Sie dies als Referenz: PEP 257

Docstrings (und Dokumentation im Allgemeinen). Python 3 führt (optionale) Funktionsanmerkungen ein, wie in PEP 3107 beschrieben (aber Docstrings nicht auslassen).