Python Code Lesbarkeit

Question

Ich habe eine Programmiererfahrung mit statisch typisierten Sprachen. Jetzt schreibe ich Code in Python. Ich habe Schwierigkeiten mit seiner Lesbarkeit. Können sagen, ich Host- eine Klasse:

class Host(object): 
    def __init__(self, name, network_interface): 
    self.name = name 
    self.network_interface = network_interface 

ich nicht von dieser Definition verstehen, was "network_interface" sein sollte. Ist es ein String, wie "eth0" oder ist es eine Instanz einer Klasse NetworkInterface? Die einzige Möglichkeit, dies zu lösen, ist eine Dokumentation des Codes mit einem "Docstring". So etwas wie dieses:

class Host(object): 
    ''' Attributes: 
     @name: a string 
     @network_interface: an instance of class NetworkInterface''' 

Oder vielleicht gibt es Namenskonventionen für solche Dinge?

Answer 1

Mit dynamischen Sprachen lernen Sie etwas über statische Sprachen: all die Hilfe, die Sie von der statischen Sprache haben, die Sie jetzt in der dynamischen Sprache vermissen, war nicht sehr hilfreich.

Um Ihr Beispiel in einer statischen Sprache zu verwenden, würden Sie wissen, dass der Parameter eine Zeichenfolge ist, und in Python nicht. In Python schreibst du also einen Docstring.Und während du es schreibst, erkennst du, dass du mehr darüber zu sagen hast als "es ist eine Schnur". Sie müssen angeben, welche Daten in der Zeichenfolge enthalten sind und welches Format sie haben soll und was die Standardeinstellung ist, und etwas über Fehlerbedingungen.

Und dann merkt man, dass Sie das auch für Ihre statische Sprache geschrieben haben sollten. Sicher, Java würde Sie zwingen, zu wissen, dass es eine Zeichenkette ist, aber es müssen alle diese anderen Details spezifiziert werden, und Sie müssen diese Arbeit manuell in jeder Sprache erledigen.

Answer 2

Die Docstring-Konventionen sind unter PEP 257.

Das Beispiel gibt dieses Format für die Angabe Argumente folgt, können Sie die Typen hinzufügen, wenn sie Materie:

def complex(real=0.0, imag=0.0): 
    """Form a complex number. 

    Keyword arguments: 
    real -- the real part (default 0.0) 
    imag -- the imaginary part (default 0.0) 

    """ 
    if imag == 0.0 and real == 0.0: return complex_zero 
    ... 

Es gab auch ein abgelehnter PEP für Docstrings für Attribute (statt Konstruktorargumente).

Answer 3

Die pythischste Lösung ist mit Beispielen zu dokumentieren. Geben Sie nach Möglichkeit an, welche Vorgänge ein Objekt unterstützen muss, um akzeptabel zu sein, und nicht einen bestimmten Typ.

class Host(object): 
    def __init__(self, name, network_interface) 
    """Initialise host with given name and network_interface. 

    network_interface -- must support the same operations as NetworkInterface 

    >>> network_interface = NetworkInterface() 
    >>> host = Host("my_host", network_interface) 

    """ 
    ... 

An dieser Stelle Ihre Quelle doctest hook up, um sicherzustellen, Ihre doc Beispiele auch in Zukunft arbeiten.

Answer 4

Ich persönlich fand sehr nützlich, pylint zu verwenden, um meinen Code zu validieren.

Wenn Sie pylint Vorschlag fast automatisch folgen, wird Ihr Code besser lesbar, Sie verbessern Ihre Python Schreibfähigkeiten, beachten Sie Namenskonventionen. Sie können auch eigene Namenskonventionen definieren. Es ist besonders nützlich für einen Python Anfänger.

Ich schlage vor, Sie zu verwenden.

Answer 5

Python, obwohl nicht so offen wie C oder Java getippt, wird immer noch getippt und löst Ausnahmen aus, wenn Sie Dinge mit Typen machen, die einfach nicht gut zusammenspielen.

Zu diesem Zweck, wenn Sie besorgt sind über Ihren Code richtig verwendet, richtig gepflegt, etc. einfach Docstrings, Kommentare oder noch expliziter Variablennamen, um anzugeben, was der Typ sein sollte.

Noch besser noch, Code enthalten, der es ermöglicht, den Typ zu verarbeiten, der übergeben wird, solange es ein brauchbares Ergebnis liefert.

Answer 6

Ein Vorteil der statischen Typisierung ist, dass Typen eine Form der Dokumentation darstellen. Bei der Programmierung in Python können Sie flexibler und flüssiger dokumentieren. Natürlich möchten Sie in Ihrem Beispiel sagen, dass network_interface NetworkInterface implementieren sollte, aber in vielen Fällen ist der Typ offensichtlich aus dem Kontext, Variablennamen oder Konvention, und in diesen Fällen können Sie durch das Weglassen des offensichtlichen Codes lesbareren Code erzeugen. Allgemein ist es, die Bedeutung eines Parameters zu beschreiben und implizit den Typ anzugeben.

Zum Beispiel:

def Bar(foo, count): 
    """Bar the foo the given number of times.""" 
    ... 

Dies beschreibt die Funktion lapidar und präzise. Was foo und bar bedeuten, wird aus dem Kontext offensichtlich, und diese Zählung ist eine implizite (positive) Ganzzahl.

Für Ihr Beispiel, würde ich in dem Dokument String den Typen nur erwähnen:

"""Create a named host on the given NetworkInterface.""" 

Dies ist kürzer, besser lesbar und enthält mehr Informationen als eine Auflistung der Arten.