Für Schleifen und Verständnis in Elixir – Imperativcode transformieren

In diesem Artikel behandeln wir einige häufige Verwendungen von For-Schleifen und Comprehensions in Python, wie man eine vorhandene Schleife analysiert und wie man sie in Elixir in die entsprechenden Ausdrücke umwandelt. Verwendung der Funktionen im Modul Enum und comprehensions.

Wir konzentrieren uns auf:

• Umwandeln einer Datensammlung durch eine Funktion (Karte)
• Werte in oder aus einer Sammlung filtern (Filter)
• Erzeugen eines einzelnen Aggregatwerts oder einer einzelnen Struktur, z. B. eines Durchschnitts (reduzieren oder falten)

Wir schließen mit einem einfachen Beispiel ab, das alle drei kombiniert!

Python

Für Schleifen

In Python verfügen for-Schleifen typischerweise über eine verschachtelte Verarbeitung – die Schritte werden in derselben Klausel oder demselben Textkörper zusammengefasst. Hier ist ein Beispiel, das die ersten beiden geraden Zahlen quadriert:

result = 0
for num in [1, 2, 3, 4, 5]:
    if num % 2 == 0:
        result += num ** 2
print(result)  # Output: 20

Eine Herausforderung dieses verschachtelten Körpers besteht darin:

1. Identifizieren Sie jeden Schritt und...
2. Finden Sie heraus, um welche Art von Schritt es sich handelt.

Wenn Sie jeden Schritt aufschlüsseln, können Sie die stattfindenden Transformationen verstehen, unnötige eliminieren und diese Schritte in ein anderes Sprachkonstrukt oder eine Funktion auf höherer Ebene umschreiben.

Das Kommentieren der obigen Funktion führt zu:

result = 0
for num in [1, 2, 3, 4, 5]:
    ## Filter
    if num % 2 == 0:
        ## Reduce (result += ) and Map (num ** 2)
        result += num ** 2
print(result)  # Output: 20

Die Schritte

Als Ergebnis lautet die Reihenfolge der Schritte:

1. Filtern „out“ ungerade Zahlen/„in“ gerade Zahlen
2. OrdnenZahlen (z. B. 2) der entsprechenden Quadratzahl (z. B. 4) zu
3. Reduzierenauf eine Summe der quadrierten geraden Zahlen

Verständnis

Comprehensions in Python sind einfache Möglichkeiten, Sammlungen wie Listen und Wörterbücher zuzuordnen und zu filtern. Sie bieten keine Möglichkeit, das Ergebnis zu reduzieren, aber wir können integrierte Funktionen wie sum verwenden, um das Obige umzuwandeln und das Ergebnis des Verständnisses zu verarbeiten:

result = sum(num ** 2 for num in [1, 2, 3, 4, 5] if num % 2 == 0)
print(result)  # Output: 20

Mit Verständnis unterteilt der Ausdruck den Schritt Karte (Anzahl ** 2) und den Schritt Filter (bei Anzahl % 2). == 0) deutlich. Summe ist hier der Schritt Reduzieren.

Es ist einfach, diese Verständnisausdrücke in Python zu überfliegen, und es setzt eine sinnvolle Obergrenze für die Komplexität eines Verständnisses.

Mit diesem Hintergrund und einem besseren Verständnis der Struktur und Einschränkungen der Verarbeitungskonstrukte von Python fahren wir mit dem Umschreiben des obigen Python-Codes unter Verwendung der Verständnis- und Enum-Pipelines von Elixir fort!

Zuordnung: Enum.map und Generatoren

Wie können wir den Schritt zu Quadratzahlen schreiben? Bei Elixir ist es ganz einfach!

Verwenden von Enum.map:

result = 0
for num in [1, 2, 3, 4, 5]:
    if num % 2 == 0:
        result += num ** 2
print(result)  # Output: 20

und Verständnis verwenden (für):

result = 0
for num in [1, 2, 3, 4, 5]:
    ## Filter
    if num % 2 == 0:
        ## Reduce (result += ) and Map (num ** 2)
        result += num ** 2
print(result)  # Output: 20

Das <- stellt einen Generator-Ausdruck dar, der Werte generiert, die nach do:

Filterung: Enum.filter und Filter

Einfach mit Enum.filter (oder Enum.reject) zu machen:

result = sum(num ** 2 for num in [1, 2, 3, 4, 5] if num % 2 == 0)
print(result)  # Output: 20

Wir möchten ungerade Zahlen herausfiltern, bevor sie quadriert werden, also platzieren wir sie an der richtigen Stelle in der Pipeline – vor Enum.map.

Mithilfe von Verständnissen können wir dem Kopf des Verständnisses einen zweiten Ausdruck hinzufügen, einen Filter, der ein boolescher Test ist:

Enum.map([1, 2, 3, 4, 5], & &1 ** 2)

Der Ausdruck rem(n, 2) == 0 verwirft dann alle Elemente, die falsch (oder null) zurückgeben, und lässt [2, 4] als die Zahlen zurück, die tatsächlich an den Körper übergeben werden (do: n ** 2) des Verständnisses.

Reduzieren -> Enum.reduce und reduzieren:

Mit Enum.reduce/2 können wir eine Liste quadrierter Zahlen in ihre Summe umwandeln, indem wir sie zu einem Akkumulator addieren. Das erste Element wird als Anfangswert des Akkumulators verwendet, wenn wir keinen Anfangswert für den Akkumulator angeben (Enum.reduce/3), und das ist hier praktisch:

for n <- [1, 2, 3, 4, 5], do: n ** 2

Nach dem Login kopieren

Mit Comprehensions haben wir sogar noch mehr Leistung als das Python-Äquivalent. Wir können einen Reduzierungsschritt hinzufügen, indem wir dem Kopf eine weitere Klausel hinzufügen:

[1, 2, 3, 4, 5]
|> Enum.filter(& rem(&1, 2) == 0)
|> Enum.map(& &1 ** 2)

Nach dem Login kopieren

hier zwei Änderungen vornehmen:

1. Hinzufügen einer Reduce: 0-Klausel zum Kopf, um anzugeben, dass wir einen Wert akkumulieren, dessen Anfangswert 0 ist
2. Ändern des for-Körpers, um einen Acc-Wert (den Akkumulator) zu erfassen, zu dem wir den aktuellen quadrierten Wert addieren können.

Integrierte Funktionen: Enum.sum

Als allgemeine Regel sollten wir die Daten, die wir transformieren möchten, auf der höchstmöglichen Ebene ausdrücken. Es ist nützlich, sich Enum.reduce als die funktionale Transformation der niedrigsten Ebene vorzustellen, da alle anderen Datenverarbeitungsvorgänge in dieser Hinsicht neu geschrieben werden können.

Das Enum-Modul enthält viele übergeordnete Funktionen, die typischerweise das Reduzieren einer Liste von Werten auf einen einzigen Aggregatwert, wie eine Summe, ein Maximum oder ein Minimum, beinhalten. In diesem Fall möchten wir die Summe der Elemente.

Für Enum-Pipelines ist dies unkompliziert:

for n <- [1, 2, 3, 4, 5], rem(n, 2) == 0, do: n ** 2

Es gibt keine Möglichkeit, diese Aggregatfunktionen auf hoher Ebene in Comprehensions darzustellen, daher können wir die Ausgabe des Comprehensions wie folgt in einen Enum.sum-Aufruf weiterleiten, ähnlich wie wir es in Python gemacht haben:

[1, 2, 3, 4, 5]
|> Enum.filter(& rem(&1, 2) == 0)
|> Enum.map(& &1 ** 2)
|> Enum.reduce(& &1 + &2)

Das Mischen verschiedener Formen sollte generell vermieden werden, insbesondere wenn es sich um eine einfache Transformation handelt, da dies zu einer geringeren mentalen Belastung für den Leser führt – die obenstehende Reduce:-Form ist tatsächlich klarer zu lesen, obwohl sie auf einem niedrigeren Niveau liegt.

Welcher Elixir-Ausdruck ist besser?

Zusammenfassend haben wir am Ende zwei Formen gefunden, die man als idiomatisch bezeichnen könnte. Für Enum-Pipelines:

result = 0
for num in [1, 2, 3, 4, 5]:
    if num % 2 == 0:
        result += num ** 2
print(result)  # Output: 20

und Verständnis:

result = 0
for num in [1, 2, 3, 4, 5]:
    ## Filter
    if num % 2 == 0:
        ## Reduce (result += ) and Map (num ** 2)
        result += num ** 2
print(result)  # Output: 20

Leicht lesbarer Code sollte einfach zu durchsuchen sein, ohne Unklarheiten oder Stolpern über Ausdrücke. Ich denke, dass beide Formen dieses Kriterium erfüllen, als:

1. Sie folgen einer einzigen konsistenten Form – entweder Enum-Pipelines oder Comprehensions
2. Jeder Ausdruck entspricht einem einzelnen Verarbeitungsschritt
3. Es kann ohne Unterbrechung von oben nach unten oder von links nach rechts gelesen werden

Abschluss

Das Schreiben dieser Transformationen kann in Elixir auf verschiedene Arten erfolgen, und es ist für eine Codebasis leicht, Stile zu variieren, insbesondere wenn Code geändert wird und die Verarbeitung mit der Zeit komplizierter wird.

PureType kann Enum-Pipelines und -Verständnisse aufschlüsseln und analysieren, um sie in ihrer klarsten und idiomatischsten Form darzustellen, Ihre Vorlieben kennenzulernen und die Lesbarkeit und Klarheit Ihres Codes für andere im Team zu verbessern. Probieren Sie es noch heute aus!

Das obige ist der detaillierte Inhalt vonFür Schleifen und Verständnis in Elixir – Imperativcode transformieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!