PEP 8 Code-Stil in Python

Einführung

In diesem Lab lernen Sie, wie Sie den PEP 8 Style Guide auf Ihren Python-Code anwenden. PEP 8 ist der offizielle Style Guide für Python und bietet eine Reihe von Empfehlungen für das Schreiben von lesbarem und konsistentem Code. Die Einhaltung dieser Richtlinien erleichtert es Ihnen und anderen, Ihren Code zu lesen.

Sie werden üben, wichtige PEP 8 Regeln für Einrückung (Indentation), Zeilenlänge (Line Length), Leerzeichen (Spacing) und Namenskonventionen (Naming Conventions) umzusetzen. Sie lernen auch, wie Sie das Tool autopep8 verwenden, um Ihren Code automatisch zu formatieren, was Ihnen Zeit spart und die Einhaltung von Community-Standards gewährleistet.

PEP 8 Einrückung und Zeilenlänge verstehen

Korrekte Einrückung und Zeilenlänge sind grundlegend für lesbaren Python-Code. In diesem Schritt lernen Sie die PEP 8 Richtlinien für diese beiden Aspekte kennen und wenden sie an.

Einrückung (Indentation): PEP 8 empfiehlt die Verwendung von 4 Leerzeichen pro Einrückungsebene. Dies ist eine starke Konvention in der Python-Community.

Zeilenlänge (Line Length): PEP 8 schlägt vor, alle Zeilen auf maximal 79 Zeichen zu begrenzen. Für Docstrings und Kommentare beträgt das Limit 72 Zeichen. Dies verbessert die Lesbarkeit, insbesondere auf kleineren Bildschirmen oder beim seitenweisen Vergleichen von Code.

Lassen Sie uns dies in die Praxis umsetzen. Finden Sie im Dateiexplorer auf der linken Seite die Datei indentation_example.py und öffnen Sie sie. Der darin enthaltene Code demonstriert die korrekte Einrückung für Funktionsdefinitionen und mehrzeilige Anweisungen.

## Korrekte Einrückung mit 4 Leerzeichen.
def long_function_name(
        var_one, var_two, var_three,
        var_four):
    print(var_one)

## Definition einiger Variablen zur Demonstration.
var_one = "first"
var_two = "second"
var_three = "third"
var_four = "fourth"

## Ausrichtung am öffnenden Trennzeichen.
foo = long_function_name(var_one, var_two,
                         var_three, var_four)

## Verwendung einer hängenden Einrückung (hanging indent). Die erste Zeile hat keine Argumente,
## und nachfolgende Zeilen sind eingerückt, um sie zu unterscheiden.
bar = long_function_name(
    var_one, var_two,
    var_three, var_four)

## Eine mehrzeilige Liste.
my_list = [
    1, 2, 3,
    4, 5, 6,
]

## Aufrufen der Funktionen zur Erzeugung der Ausgabe.
long_function_name("first call", "second", "third", "fourth")
foo = long_function_name("second call", "second", "third", "fourth")
bar = long_function_name("third call", "second", "third", "fourth")

Nachdem Sie den Code überprüft haben, führen Sie das Skript aus, um seine Ausgabe zu sehen. Öffnen Sie das Terminal am unteren Rand der WebIDE und führen Sie den folgenden Befehl aus:

python ~/project/indentation_example.py

Das Skript wird ausgeführt und gibt das erste Argument jedes Funktionsaufrufs aus. Die Ausgabe wird sein:

first call
second call
third call

Diese Übung demonstriert, wie konsistente Einrückung komplexe Funktionsaufrufe und Datenstrukturen wesentlich einfacher lesbar macht.

Übung zu Leerzeichen und Namenskonventionen

Konsistente Leerzeichen (Spacing) und klare Namenskonventionen (Naming Conventions) sind ebenfalls entscheidend für die Lesbarkeit des Codes. Dieser Schritt behandelt die PEP 8 Regeln für beides.

Leerzeichen:

• Verwenden Sie ein einzelnes Leerzeichen um die meisten Operatoren (=, +=, ==, <, >).
• Verwenden Sie ein Leerzeichen nach Kommas in Listen, Tupeln und Funktionsargumenten.
• Vermeiden Sie zusätzliche Leerzeichen unmittelbar innerhalb von Klammern, eckigen Klammern oder geschweiften Klammern.

Namenskonventionen:

• snake_case: Verwenden für Funktionen und Variablen (z.B. my_function, user_name).
• PascalCase: Verwenden für Klassennamen (z.B. MyClass).
• UPPERCASE_SNAKE_CASE: Verwenden für Konstanten (z.B. MAX_CONNECTIONS).

Sehen wir uns diese Regeln in Aktion an. Öffnen Sie im Dateiexplorer die Datei style_guide_example.py. Der Code enthält Beispiele für korrekte Leerzeichensetzung und Benennung, wobei inkommentierte falsche Versionen zum Vergleich bereitgestellt werden.

## A constant
MAX_OVERFLOW = 100

## A class name in PascalCase
class MySampleClass:
    def __init__(self, name):
        ## A variable name in snake_case
        self.instance_name = name

    ## A function name in snake_case
    def sample_method(self, var_one, var_two):
        ## Correct spacing around operators and after comma
        result = var_one + var_two
        print(self.instance_name, result)

## --- Incorrect examples for comparison ---
## class mySampleClass:
##     def SampleMethod(self, varOne, varTwo):
##         result=varOne+varTwo
##         print(self.instance_name,result)

## Create an object and call the method
my_object = MySampleClass("TestObject")
my_object.sample_method(10, 5)

Speichern Sie die Datei, falls Sie Änderungen vorgenommen haben, und führen Sie sie im Terminal aus:

python ~/project/style_guide_example.py

Die Ausgabe zeigt den Namen des Objekts und das Ergebnis der Berechnung:

TestObject 15

Durch die Einhaltung dieser Regeln für Leerzeichen und Benennung wird die Struktur und der Zweck Ihres Codes für jeden Leser sofort klarer.

Verwendung von autopep8 zur automatischen Formatierung

Die manuelle Formatierung von Code kann mühsam sein. Glücklicherweise gibt es Tools, die diesen Prozess automatisieren. In diesem Schritt installieren und verwenden Sie autopep8, ein beliebtes Tool, das Python-Code automatisch neu formatiert, um ihn an den PEP 8 Style Guide anzupassen.

Zuerst müssen Sie das Paket autopep8 installieren. Öffnen Sie das Terminal und führen Sie den folgenden Befehl aus. sudo wird verwendet, um es systemweit zu installieren.

sudo pip3 install autopep8

Der Installationsprozess wird beginnen, und Sie sollten eine Ausgabe sehen, die die erfolgreiche Installation bestätigt:

Collecting autopep8
...
Successfully installed autopep8-X.Y.Z

Als Nächstes arbeiten wir mit einer Python-Datei, die absichtlich schlecht formatiert ist. Öffnen Sie im Dateiexplorer unformatted_code.py und untersuchen Sie deren Inhalt:

a=1
b=2;
def  my_function ( arg1 , arg2 = 0 ):
    result = arg1+arg2
    print( result)

Dieser Code weist mehrere Stilprobleme auf: inkonsistente Leerzeichen, ein überflüssiges Semikolon und zusätzliche Leerzeichen in der Funktionsdefinition.

Nun verwenden wir autopep8, um dies zu beheben. Das Flag --in-place weist das Tool an, die Datei direkt zu ändern. Führen Sie diesen Befehl in Ihrem Terminal aus:

autopep8 --in-place ~/project/unformatted_code.py

Nachdem der Befehl abgeschlossen ist, öffnen Sie unformatted_code.py erneut im Editor. Sie werden sehen, dass der Code automatisch bereinigt wurde:

a = 1
b = 2


def my_function(arg1, arg2=0):
    result = arg1 + arg2
    print(result)

Beachten Sie, wie autopep8 die Leerzeichen korrigiert, das Semikolon entfernt und zwei Leerzeilen vor der Funktionsdefinition hinzugefügt hat, wie von PEP 8 empfohlen. Die Verwendung eines Auto-Formatierers wie autopep8 ist eine äußerst effiziente Methode, um einen konsistenten Code-Stil über Ihre Projekte hinweg beizubehalten.

Alles zusammenfügen: Refactoring eines Skripts

Nun ist es Zeit, alles Gelernte anzuwenden. In diesem Schritt werden Sie ein Skript manuell refaktorisieren (refactor), das gegen mehrere PEP 8 Richtlinien verstößt. Diese Übung testet Ihr Verständnis von Einrückung (Indentation), Leerzeichen und Namenskonventionen.

Öffnen Sie zuerst refactor_challenge.py im Dateiexplorer. Es enthält den folgenden Code, der die Fläche eines Rechtecks berechnet, aber mit schlechtem Stil geschrieben ist.

## This script calculates the area of a rectangle and prints it.
def CalculateArea(width,height):
    Area = width*height ## calculate area
    return Area

w = 10
h = 5
rectangle_area=CalculateArea(w,h)
print("The area of the rectangle is:",rectangle_area)

Ihre Aufgabe ist es, diesen Code im Editor manuell zu bearbeiten, um ihn PEP 8-konform zu machen. Achten Sie auf folgende Probleme:

1. Funktionsbenennung: Funktionsnamen sollten im snake_case sein.
2. Variablennamen: Variablennamen sollten ebenfalls im snake_case sein.
3. Leerzeichen: Überprüfen Sie die korrekte Leerzeichensetzung um Operatoren und nach Kommas.
4. Kommentare: Inline-Kommentare sollten nach dem # ein Leerzeichen aufweisen.

Nehmen Sie sich einen Moment Zeit, um den Code selbst zu refaktorisieren. Sobald Sie fertig sind, sollte Ihr Code in etwa so aussehen:

## This script calculates the area of a rectangle and prints it.
def calculate_area(width, height):
    """Calculate and return the area of a rectangle."""
    area = width * height  ## calculate area
    return area


w = 10
h = 5
rectangle_area = calculate_area(w, h)
print("The area of the rectangle is:", rectangle_area)

Beachten Sie die Änderungen: CalculateArea wurde zu calculate_area, Area wurde zu area, und die Leerzeichensetzung wurde korrigiert. Wir haben der Funktion auch einen Docstring hinzugefügt, was eine Best Practice ist, um zu erklären, was eine Funktion tut.

Speichern Sie Ihre Änderungen und führen Sie das Skript aus, um sicherzustellen, dass es weiterhin korrekt funktioniert:

python ~/project/refactor_challenge.py

Die Ausgabe sollte sein:

The area of the rectangle is: 50

Diese Übung zeigt, dass das Refactoring für den Stil nicht ändert, was der Code tut, aber es verbessert seine Lesbarkeit und Wartbarkeit dramatisch.

Zusammenfassung

In diesem Lab haben Sie die Grundlagen des PEP 8 Style Guides für Python gelernt. Sie haben geübt, Regeln für Einrückung (Indentation), Zeilenlänge, Leerzeichensetzung und Namenskonventionen anzuwenden. Sie haben auch die Leistungsfähigkeit von autopep8 entdeckt, um Ihren Code automatisch zu formatieren und diese Standards zu erfüllen. Durch den Abschluss einer abschließenden Refactoring-Herausforderung haben Sie all diese Konzepte zusammengeführt, um ein schlecht gestyltes Skript in sauberen, lesbaren und wartbaren Python-Code umzuwandeln. Die Einhaltung von PEP 8 ist eine Schlüsselpraxis für jeden professionellen Python-Entwickler, da sie die Zusammenarbeit fördert und die Codequalität verbessert.