Direkt zum Hauptbereich

Wald oder Bäume

Wann soll man Details einer Funktion in Unterfunktionen extrahieren, weil man ansonsten "den Wald vor lauter Bäumen nicht sieht"?

Und wann soll man lieber die Details sichtbar lassen?

Welches sind die Vor- und Nachteile ​​der folgenden Beispiele und welches favorisiert ihr?

1. Alle Details


import sys

def main():
    numbers = [int(argument) for argument in sys.argv[1:] if str.isnumeric(argument)]

    for i in range(0, len(numbers)):
        for j in range(1, len(numbers) - i):
            if numbers[j] < numbers[j - 1]:
                numbers[j-1:j+1] = [numbers[j], numbers[j - 1]]

    print(', '.join([str(number) for number in numbers]))

if __name__ == '__main__':
    main()

2. Alle Details mit Kommentaren


import sys

def main():
    #Read numbers from command line
    numbers = [int(argument) for argument in sys.argv[1:] if str.isnumeric(argument)]

    #Sort numbers
    for i in range(0, len(numbers)):
        for j in range(1, len(numbers) - i):
            if numbers[j] < numbers[j - 1]:
                numbers[j-1:j+1] = [numbers[j], numbers[j - 1]]

    #Write numbers to console
    print(', '.join([str(number) for number in numbers]))

if __name__ == '__main__':
    main()

3. Drei Unterfunktionen mit konkreten Namen


import sys

def main():
    numbers = readNumbersFromCommandLine()
    sort(numbers)
    writeNumbersToConsole(numbers)

def readNumbersFromCommandLine():
    return [int(argument) for argument in sys.argv[1:] if str.isnumeric(argument)]

def sort(numbers):
    for i in range(0, len(numbers)):
        for j in range(1, len(numbers) - i):
            if numbers[j] < numbers[j - 1]:
                numbers[j-1:j+1] = [numbers[j], numbers[j - 1]]

def writeNumbersToConsole(numbers):
    print(', '.join([str(number) for number in numbers]))

if __name__ == '__main__':
    main()

4. Drei Unterfunktionen mit allgemeinen Namen


import sys

def main():
    numbers = getNumbers()
    sort(numbers)
    setNumbers(numbers)

def getNumbers():
    return [int(argument) for argument in sys.argv[1:] if str.isnumeric(argument)]

def sort(numbers):
    for i in range(0, len(numbers)):
        for j in range(1, len(numbers) - i):
            if numbers[j] < numbers[j - 1]:
                numbers[j-1:j+1] = [numbers[j], numbers[j - 1]]

def setNumbers(numbers):
    print(', '.join([str(number) for number in numbers]))

if __name__ == '__main__':
    main()

Kommentare

  1. Kommentare sollten beschreiben, warum etwas passiert und nicht was passiert. Was passiert sollte aus dem Code ersichtlich sein.

    Zur Gruppierung eignen sich die Funktionen dann auch besser und geben dem Abschnitt einen Namen, genau wie deine Kommentare.

    Das die Funktion dann nur an einer einzigen Stelle verwendet wird ist dann nicht so schlimm.

    Wenn es sich mit der Funktion dann doch komisch überdimensioniert an, ist es dann doch besser Inline zu schreiben.

    Ich denke an Code smells. Müsste ich Mal lesen.

    AntwortenLöschen
    Antworten
    1. Als ob ich Dir die Antwort diktiert hätte :-).

      Allerdings stoße ich bei manchen Entwicklern auch auf das Argument, dass Unterfunktionen nerven, da man dann immer im Code hin und her springen muss, um zu erfahren was der Code denn nun eigentlich machen würde. Es sei doch viel besser wenn alles in einer Funktion an einer stelle wäre, weil der Code dann viel besser zu verstehen sei.

      Löschen

Kommentar veröffentlichen

Beliebte Posts aus diesem Blog

Utopie gesucht

In den 90er Jahren gab es meiner Meinung nach eine positive Zukunftssicht. Das sah man u.a. in der Serie Star Trek The next generation. Heute dagegen scheint es nur noch pessimistische Blicke auf die Zukunft zu geben. Auch die aktuellen Star Trek Serien stellen eine düsterere Welt dar. Dies könnte zu einer selbst erfüllenden Prophezeiung werden. Gibt es in der aktuellen Popkultur noch Utopien?

Umlagen und Produktivität

Genug prokastiniert. Hier jetzt also der Folgeartikel zum letzten Rentenbeitrag (also dem Artikel, nicht die Zahlung :-)). Zuerst möchte ich den Umstand hervorheben, dass unsere deutsche Rentenversicherung, wie bekannt sein dürfte, ein Umlagesystem ist. Das bei diesem System eingezahlte Geld wird nicht in einem Tresor bis zur Rente verwahrt und fließt auch nicht in Investitionen, wie Staats- oder Unternehmensanleihen, die später dann eine Rendite abwerfen würden; sondern es wird sofort wieder an die aktuellen Rentner ausgezahlt. Das hat große Vorteile, weil es gerade auch die Schwachen absichert (oder zumindest sollte), die während ihrer Erwerbstätigkeit nicht die Mittel haben, um privat vorzusorgen, und vor großen volkswirtschaftlichen Katastrophen absichert, wie Finanzkrisen oder Kriegen, die angespartes Kapital binnen kürzester Zeit vernichten können. Deswegen ist ein Umlageverfahren gerade nach solchen Katastrophen eine gute Lösung, um schnell die Bedürftigen zu unterstützen, da s...

Bevölkerungsstatistikspielereien

Beim statistischen Bundesamt kann man sich Daten der Fortschreibung des Bevölkerungsstandes seit 1970 herunterladen. Da bekommt man dann eine Tabelle, in der für jedes Jahr die Anzahl der Menschen in Deutschland des jeweiligen Alters aufgeführt sind.  Ich habe mir einmal immer die Zehnerjahre geben lassen und die Anzahl der Personen unter 18 Jahren aufsummiert (Jugend), zwischen 18 und 64 (Erwerbstätige) und alle ab 65 (Rentner) und habe dann das Verhältnis der Erwerbstätigen zu den Rentnern ermittelt.  (Hier als Bild, da ich in Blogger keine vernünftige Tabellendarstellung hinbekomme). Man sieht, dass 1970 auf einen Rentner noch 4 Erwerbstätige kamen, also - bildlich gesprochen - jeder Arbeiter etwa ein Viertel der Rente eines Rentners beisteuerte. Heute kommen nur noch ganz knapp drei Erwerbstätige auf einen Rentner, was bedeuten kann, dass entweder jeder Erwerbstätige jetzt ein Drittel der Rente schultern muss oder der Rentner nur nur drei Viertel der ursprünglichen Rente ...