Gemeinsame Refaktoren in Python für Anfänger

Refactoring trägt dazu bei, Ihren Code sauberer und effizienter zu machen. Hier sind fünf gängige Refaktoren für Anfänger in Python.

Ich. Boolesche Ausdrücke vereinfachen

Ein gängiges Muster ist die Verwendung eines if-else-Blocks, nur um „True“ oder „False“ zurückzugeben. Zum Beispiel:

if condition:
    return True
else:
    return False

Umgestalten in:

return condition

Die Bedingung selbst ist bereits ein boolescher Ausdruck, daher ist der if-else-Block unnötig. Durch die direkte Rückgabe der Bedingung wird der Code kürzer und besser lesbar. Dies ist eine einfache, aber effektive Möglichkeit, die Übersichtlichkeit zu verbessern, ohne die Funktionalität zu ändern.

II. List Comprehensions statt for / if

Anfänger verwenden häufig for-Schleifen mit if-Anweisungen, um Listen zu erstellen. Zum Beispiel:

result = []
for item in items:
    if condition(item):
        result.append(item)

Refaktorieren Sie es in ein Listenverständnis:

result = [item for item in items if condition(item)]

Listenverständnisse bieten eine prägnantere Möglichkeit, Listen zu erstellen. Sie sind in der Regel auch schneller als gleichwertige for-Schleifen, da sie intern von Python optimiert werden. Dieser Ansatz ist auch einfacher zu lesen, insbesondere für einfache Listenerstellungsaufgaben.

III. Vermeiden Sie wiederholte Berechnungen

Wenn Sie dieselbe Funktion mehrmals in einer Schleife aufrufen, speichern Sie das Ergebnis in einer Variablen. Zum Beispiel:

for item in items:
    if len(item) > 5:
        result.append(item)
...

Umgestalten in:

for item in items:
    len = len(item)
    if len > 5:
        result.append(item)
...

Stellen Sie sich vor, dass diese Bedingung in mehreren elif- oder verschachtelten if-Anweisungen enthalten wäre. Hier wird len(item) bei jeder Iteration zweimal aufgerufen, was insbesondere bei großen Listen ineffizient sein kann. Durch das Speichern des Ergebnisses von len(item) in einer Variablen (len) entfällt die wiederholte Berechnung, wodurch die Leistung verbessert und der Code sauberer wird. Dies ist ein einfaches Beispiel.

IV. Ersetzen Sie Schleifen durch Karte und Filter

Anstatt explizite Schleifen zu schreiben, verwenden Sie die in Python integrierten Funktionen wie map() und filter(), die effizienter und prägnanter sein können. Um beispielsweise jedes Element in einer Liste zu verdoppeln:

result = []
for item in items:
    result.append(item * 2)

Umgestalten in:

result = list(map(lambda x: x * 2, items))

Oder um Elemente größer als 5 zu filtern:

result = []
for item in items:
    if item > 5:
        result.append(item)

Umgestalten in:

result = list(filter(lambda x: x > 5, items))

Sowohl map() als auch filter() akzeptieren Funktionen als Argumente, sodass wir Lambda verwenden können, um kleine anonyme Funktionen zu definieren. Die Lambda-Funktion ist eine prägnante Möglichkeit, einfache Operationen zu definieren. Lambda x: x * 2 erstellt beispielsweise eine Funktion, die x mit 2 multipliziert. Der Vorteil von map() und filter() besteht darin, dass sie häufig effizienter sind als die Verwendung einer for-Schleife und in der Regel besser lesbar sind. Man könnte auch Listenverständnisse verwenden (siehe oben).

V Kombinieren Sie mehrere if-Anweisungen

Wenn Sie mehrere Bedingungen prüfen, kann die Kombination mit logischen Operatoren (und, oder) Ihren Code vereinfachen. Zum Beispiel:

if a > 0:
    if b > 0:
        result = a + b

Umgestalten in:

if condition:
    return True
else:
    return False

Dies reduziert unnötige Verschachtelungen und erleichtert das Lesen und Warten des Codes. Die Kombination von Bedingungen in einer if-Anweisung macht den Logikfluss klarer und eliminiert Redundanz.

Fazit

Beim Refactoring geht es darum, Ihren Code kürzer, klarer und effizienter zu machen, ohne seine Funktionsweise zu ändern. Indem Sie boolesche Ausdrücke vereinfachen, Listenverständnisse verwenden, wiederholte Berechnungen vermeiden, integrierte Funktionen wie map() und filter() nutzen und Bedingungen zusammenführen, können Sie Ihren Code trocken machen. Mit Lambda können Sie kleine Funktionen in einer einzigen Zeile definieren und so den Code sauber und schnell halten. Diese Vorgehensweisen verbessern nicht nur die Leistung, sondern verbessern auch die Lesbarkeit, was für die langfristige Aufrechterhaltung des Codes von entscheidender Bedeutung ist.

Weiterführende Literatur:

https://www.w3schools.com/python/python_lambda.asp

https://www.w3schools.com/python/ref_func_filter.asp

https://www.w3schools.com/python/ref_func_map.asp

Das obige ist der detaillierte Inhalt vonGemeinsame Refaktoren in Python für Anfänger. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!