One place for hosting & domains

      Verwenden der Git-Integration in Visual Studio Code


      Einführung

      Visual Studio Code (VS-Code) hat sich zu einem der beliebtesten Editoren für die Webentwicklung entwickelt. Dank seiner vielen integrierten Funktionen wie der Integration der Quellcodeverwaltung, insbesondere mit Git, hat er eine solche Popularität erlangt. Die Nutzung der Leistungsfähigkeit von Git innerhalb von VS-Code kann Ihren Workflow effizienter und robuster machen.

      In diesem Tutorial erkunden Sie die Verwendung der Quellcodeverwaltungs-Integration in VS-Code mit Git.

      Voraussetzungen

      Um dieses Tutorial zu absolvieren, benötigen Sie Folgendes:

      Schritt 1 — Vertrautmachen mit der Registerkarte Quellcodeverwaltung

      Was Sie zuerst tun müssen, um die Vorteile der Quellcodeverwaltung-Integration zu nutzen, ist die Initialisierung eines Projekts als Git-Repository.

      Öffnen Sie Visual Studio Code und greifen Sie auf das integrierte Terminal zu. Sie können dies durch Verwendung der Tastenkombination STRG+` unter Linux, macOS oder Windows öffnen.

      Erstellen Sie in Ihrem Terminal ein Verzeichnis für ein neues Projekt und wechseln Sie in dieses Verzeichnis:

      • mkdir git_test
      • cd git_test

      Erstellen Sie dann Git-Repository:

      Eine weitere Möglichkeit, dies mit Visual Studio Code zu bewerkstelligen, ist das Öffnen der Registerkarte Quellcodeverwaltung (das Symbol sieht aus wie eine Straßenverzweigung) im linken Bereich:

      Symbol für Quellcodeverwaltung

      Wählen Sie als Nächstes Open Folder (Ordner öffnen):

      Screenshot mit der Schaltfläche „Ordner öffnen“

      Dadurch wird Ihr Datei-Explorer für das aktuelle Verzeichnis geöffnet. Wählen Sie das bevorzugte Projektverzeichnis und klicken Sie auf Open (Öffnen).

      Wählen Sie dann Initialize Repository (Repository initialisieren):

      Screenshot, der die Schaltfläche „Repository initialisieren“ zeigt

      Wenn Sie nun Ihr Dateisystem überprüfen, sehen Sie, dass es ein Verzeichnis .git enthält. Verwenden Sie dazu das Terminal, um zu Ihrem Projektverzeichnis zu navigieren und alle Inhalte aufzulisten:

      Sie sehen das erstellte Verzeichnis .git:

      Output

      Nachdem das Repository nun initialisiert wurde, fügen Sie eine Datei namens index.html hinzu.

      Nachdem Sie dies getan haben, sehen Sie im Fenster Source Control (Quellcodeverwaltung), dass Ihre neue Datei mit dem Buchstaben U daneben angezeigt wird. U steht für unverfolgte Datei, d. h. eine Datei, die neu ist oder geändert wurde, aber dem Repository noch nicht hinzugefügt wurde:

      Screenshot einer unverfolgten Datei mit dem Buchstaben U-Indikator

      Sie können jetzt auf das Plus-Symbol (+) neben der Auflistung der Datei index.html klicken, um die Datei nach dem Repository zu verfolgen.

      Sobald die Datei hinzugefügt wurde, ändert sich der Buchstabe neben der Datei an eine A. A steht für eine neue Datei, die dem Repository hinzugefügt wurde.

      Um Ihre Änderungen zu übergeben, geben Sie eine Übergabe-Nachricht in das Eingabefeld oben im Fenster Source Control (Quellcodeverwaltung) ein. Klicken Sie dann auf das Prüfsymbol, um die Übergabe auszuführen.

      Screenshot einer hinzugefügten Datei mit dem Buchstabe-A-Indikator und der Übergabenachricht

      Danach werden Sie feststellen, dass keine Änderungen ausstehen.

      Fügen Sie als Nächstes Ihrer Datei index.html etwas Inhalt hinzu.

      Sie können eine Emmet-Verknüpfung verwenden, um ein HTML5-Skelett in VS-Code zu generieren, indem Sie die Taste ! drücken, gefolgt von der Taste Tab. Fahren Sie fort und fügen Sie dem <body> etwas wie eine Überschrift <h1> hinzu, und speichern Sie anschließend.

      Im Fenster Quellcodeverwaltung sehen Sie, dass Ihre Datei geändert wurde. Daneben wird der Buchstabe M angezeigt, der für eine modifizierte Datei steht:

      Screenshot der geänderten Datei mit dem Buchstabe-M-Indikator

      Zur Übung sollten Sie auch diese Änderung übergeben.

      Nachdem Sie nun mit der Bedienung des Quellcodeverwaltungsfensters vertraut sind, fahren Sie mit der Interpretation der „Gutter“-Indikatoren fort.

      Schritt 2 — Interpretation der Gutter-Indikatoren

      In diesem Schritt werfen Sie einen Blick auf das sogenannte „Gutter“ in VS-Code. Das Gutter ist der schmale Bereich rechts neben der Zeilennummer.

      Wenn Sie zuvor Code-Folding verwendet haben, befinden sich die Symbole für Maximieren und Minimieren im Gutter.

      Beginnen wir damit, eine kleine an Ihrer Datei index.html vorzunehmen, beispielsweise eine Änderung des Inhalts innerhalb des Tags <h1>. Danach werden Sie eine blaue vertikale Markierung im Gutter der Zeile, die Sie geändert haben, bemerken. Die vertikale blaue Markierung bedeutet, dass die entsprechende Codezeile geändert wurde.

      Versuchen Sie nun, eine Codezeile zu löschen. Sie können eine der Zeilen im Abschnitt <body> Ihrer Datei index.html löschen. Beachten Sie, dass im Gutter nun ein rotes Dreieck vorhanden ist. Das rote Dreieck kennzeichnet eine Zeile oder eine Gruppe von Zeilen, die gelöscht.

      Fügen Sie schließlich am Ende Ihres Abschnitts <body> eine neue Codezeile hinzu und beachten Sie den grünen Balken. Der vertikale grüne Balken steht für eine hinzugefügte Codezeile.

      Dieses Beispiel zeigt Gutter-Indikatoren für eine geänderte Zeile, eine entfernte Zeile und eine neue Zeile:

      Screenshot mit Beispielen der drei Arten von Gutter-Indikatoren

      Schritt 3 — Vergleichen von Dateien

      VS-Code bietet auch die Möglichkeit, einen Vergleich mit einer Datei auszuführen. Normalerweise müssten Sie dafür ein separates Diff-Tool herunterladen, sodass diese integrierte Funktion Ihnen dabei helfen kann, effizienter zu arbeiten.

      Um einen Vergleich anzuzeigen, öffnen Sie das Quellcodeverwaltungsfenster und doppelklicken Sie auf eine geänderte Datei. Doppelklicken Sie in diesem Fall auf die Datei index.html. Sie werden zu einer typischen Diff-Ansicht mit der aktuellen Version der Datei auf der linken und der zuvor übergebenen Version der Datei auf der rechten Seite gebracht.

      Dieses Beispiel zeigt, dass in der aktuellen Version eine Zeile hinzugefügt wurde:

      Screenshot mit einem Beispiel einer geteilten Bildschirmanzeige eines Vergleichs

      Schritt 4 — Arbeiten mit Zweigen

      In der unteren Leiste haben Sie die Möglichkeit, Zweige zu erstellen und zu wechseln. Wenn Sie einen Blick auf die unterste linke Ecke des Editors werfen, sollten Sie das Quellcodeverwaltungs-Symbol sehen (dasjenige, das wie eine Weggabelung aussieht), gefolgt höchstwahrscheinlich von master oder dem Namen des aktuellen Arbeitszweigs.

      Zweigindikator in der unteren Leiste von VS-Code mit der Anzeige „master“

      Um einen Zweig zu erstellen, klicken Sie auf diesen Zweignamen. Es sollte sich ein Menü öffnen, das Ihnen die Möglichkeit gibt, einen neuen Zweig zu erstellen:

      Eingabeaufforderung zur Erstellung eines neuen Zweigs

      Fahren Sie fort und erstellen Sie einen neuen Zweig namens test.

      Nehmen Sie nun eine Änderung an Ihrer Datei index.html vor, die anzeigt, dass Sie sich in dem neuen Zweig test befinden, indem Sie beispielsweise den Text „this is the new test branch“ (Dies ist der neue Testzweig) hinzufügen.

      Übergeben Sie diese Änderungen an den Zweig test. Klicken Sie dann erneut auf den Zweignamen unten links, um wieder zu dem Zweig master zu wechseln.

      Nach dem Wechsel zum Zweig master werden Sie feststellen, dass der Text this is the new test branch (Dies ist der neue Testzweig), der dem Zeig test übergeben wurde, nicht mehr vorhanden ist.

      Schritt 5 — Arbeiten mit Remote-Repositorys

      In diesem Tutorial wird nicht im Detail darauf eingegangen, aber über das Quellcodeverwaltungsfenster haben Sie Zugriff auf die Arbeit mit Remote-Repositorys. Wenn Sie schon mit einem Remote-Repository gearbeitet haben, werden Ihnen vertraute Befehle wie pull, sync, publish, stash usw. auffallen.

      Schritt 6 — Installieren nützlicher Erweiterungen

      VS-Code enthält nicht nur viele integrierte Funktionen für Git, es gibt auch einige sehr beliebte Erweiterungen, um zusätzliche Funktionalität hinzuzufügen.

      Git Blame

      Diese Erweiterung bietet die Möglichkeit, Git Blame-Informationen in der Statusleiste für die aktuell ausgewählte Zeile anzuzeigen.

      Dies kann einschüchternd klingen, aber keine Sorge, bei der Erweiterung „Git Blame“ geht es viel mehr um Praktikabilität als darum, jemandem ein schlechtes Gewissen einzureden. Bei der Idee, jemandem „ein schlechtes Gewissen“ für eine Code-Änderung einzureden geht es weniger darum, diese Person zu beschämen, als vielmehr darum, die richtige Person zu finden, der man Fragen zu bestimmten Teilen des Codes stellen kann.

      Wie Sie auf dem Screenshot sehen können, bietet diese Erweiterung in der unteren Symbolleiste eine subtile, auf die aktuelle Codezeile, die Sie gerade bearbeiten, bezogene Nachricht, die erklärt, wer die Änderung vorgenommen hat und wann sie vorgenommen wurde.

      Git Blame in der unteren Symbolleiste

      Git History

      Obwohl Sie mit den integrierten Funktionen in VS-Code aktuelle Änderungen anzeigen, Vergleiche durchführen und Zweige verwalten können, bietet es keinen detaillierten Einblick in Ihren Git-Verlauf. Die Erweiterung Git History löst dieses Problem.

      Wie Sie in der nachstehenden Abbildung sehen können, ermöglicht diese Erweiterung Ihnen, den Verlauf einer Datei, eines bestimmten Autors, eines Zweigs usw. sorgfältig zu untersuchen. Um das nachstehende Fenster „Git History“ zu aktivieren, klicken Sie mit der rechten Maustaste auf eine Datei und wählen Sie Git: View File History:

      Ergebnisse der Erweiterung „Git History“

      Zusätzlich können Sie Zweige und Übergaben vergleichen, Zweige aus Übergaben erstellen und vieles mehr.

      Git Lens

      Git Lens erweitert die in Visual Studio Code integrierten Git-Funktionen. Es hilft Ihnen, die Code-Autorenschaft auf einen Blick mittels Git Blame-Annotationen und Code Lens zu visualisieren, nahtlos durch Git-Repositorys zu navigieren und diese zu erkunden, wertvolle Erkenntnisse über leistungsstarke Vergleichsbefehle zu gewinnen und vieles mehr.

      Die Erweiterung „Git Lens“ ist eine der beliebtesten in der Gemeinschaft und ist auch die leistungsstärkste. In den meisten Fällen kann sie mit ihrer Funktionalität jede der beiden vorherigen Erweiterungen ersetzen.

      Für „Blame“-Informationen erscheint rechts neben der Zeile, an der Sie gerade arbeiten, eine subtile Nachricht, die Sie darüber informiert, werde die Änderung vorgenommen hat, wann sie vorgenommen wurde und die zugehörige Übergabemeldung. Es gibt einige zusätzliche Informationen, die angezeigt werden, wenn Sie mit der Maus über diese Nachricht fahren, wie die Code-Änderung selbst, der Zeitstempel und mehr.

      Git Blame-Funktionalität in Git Lens

      Für Git-Verlaufsinformationen bietet diese Erweiterung eine Vielzahl von Funktionen. Sie haben einfachen Zugriff auf zahlreiche Optionen, darunter die Anzeige des Dateiverlaufs, die Durchführung von Vergleichen mit vorherigen Versionen, das Öffnen einer bestimmten Revision und vieles mehr. Um diese Optionen zu öffnen, können Sie auf den Text in der unteren Statusleiste klicken, der den Autor enthält, der die Codezeile bearbeitet hat und wie lange es her ist, dass sie bearbeitet wurde.

      Dadurch wird das folgende Fenster geöffnet:

      Git History-Funktionalität in Git Lens

      Diese Erweiterung ist vollgepackt mit Funktionalität und es wird eine Weile dauern, bis Sie alles, was sie zu bieten hat, aufgenommen haben.

      Zusammenfassung

      In diesem Tutorial haben Sie erkundet, wie die Integration der Quellcodeverwaltung mit VS-Code verwendet wird. VS-Code kann mit vielen Funktionen umgehen, für die zuvor ein separates Tool heruntergeladen werden musste.



      Source link

      Verwenden der Python-Map-Funktion


      Einführung

      Wir können die integrierte Python-Funktion map() verwenden, um für jedes Element in einer Iterablen (wie einer Liste oder einem Wörterbuch) eine Funktion anzuwenden und einen neuen Iterator zum Abrufen der Ergebnisse zurückgeben. map() gibt ein map-Objekt (einen Iterator) zurück, das wir in anderen Teilen unseres Programms nutzen können. Außerdem können wir das map-Objekt an die Funktion list() oder einen anderen Sequenztyp übergeben, um eine Iterable zu erstellen.

      Die Syntax für die Funktion map() lautet folgendermaßen:

      map(function, iterable, [iterable 2, iterable 3, ...])
      

      Anstatt eine for-Schleife zu verwenden, bietet die Funktion map() die Möglichkeit, für jedes Element in einer Iterablen eine Funktion anzugeben. Daher kann dies oft effektiver sein, da die Funktion nur auf ein Element auf einmal angewendet wird, anstatt Kopien der Elemente in einer anderen Iterablen zu erstellen. Dies ist besonders nützlich, wenn Sie Programme verwenden, die große Datenmengen verarbeiten. map() kann zudem mehrere Iterablen als Argumente an die Funktion übergeben, indem ein Element aus jeder Iterablen an die Funktion gesendet wird.

      In diesem Tutorial werden wir uns drei verschiedene Möglichkeiten der Verwendung von map() ansehen: mit einer lambda-Funktion, mit einer benutzerdefinierten Funktion und schließlich mit einer integrierten Funktion unter Verwendung mehrerer Iterablenargumente.

      Verwenden einer Lambda-Funktion

      Das erste Argument für map() ist eine Funktion, die wir auf die einzelnen Elemente anwenden. Python ruft die Funktion für jedes Element in der Iterablen, das wir an map() übergeben, einmal auf und gibt das bearbeitete Element innerhalb eines map-Objekts zurück. Für das erste Funktionsargument können wir entweder eine benutzerdefinierte Funktion übergeben oder lambda-Funktionen nutzen (insbesondere wenn der Ausdruck nicht sehr komplex ist).

      Die Syntax von map() mit einer lambda-Funktion lautet wie folgt:

      map(lambda item: item[] expression, iterable)
      

      Mit einer Liste wie der folgenden können wir eine lambda-Funktion mit einem Ausdruck implementieren, den wir auf jedes Element in unserer Liste anwenden möchten:

      numbers = [10, 15, 21, 33, 42, 55]
      

      Um einen Ausdruck auf jede unserer Zahlen anzuwenden, können wir map() und lambda nutzen:

      mapped_numbers = list(map(lambda x: x * 2 + 3, numbers))
      

      Hier deklarieren wir in unserer Liste ein Element als x. Dann fügen wir unseren Ausdruck hinzu. Wir übergeben unsere Liste mit Zahlen als Iterable für map().

      Um die Ergebnisse davon sofort zu erhalten, drucken wir eine Liste des map-Objekts aus:

      print(mapped_numbers)
      

      Output

      [23, 33, 45, 69, 87, 113]

      Wir haben list() verwendet, damit das map-Objekt als Liste zurückgegeben wird und nicht als schlechter menschenlesbares Objekt wie: <map object at 0x7fc250003a58>. Das map-Objekt ist ein Iterator über unsere Ergebnisse; daher können wir mit for eine Schleife darüber legen oder list() verwenden, um es in eine Liste umzuwandeln. Wir tun dies hier, da es eine gute Möglichkeit zur Prüfung der Ergebnisse darstellt.

      Letztlich ist map() am nützlichsten bei der Arbeit mit großen Datensätzen; daher würden wir mit dem map-Objekt wahrscheinlich weiter arbeiten und in der Regel keinen Konstruktor wie list() anwenden.

      Für kleinere Datensätze eignet sich die Erfassung in Listen ggf. besser; für die Zwecke dieses Tutorials verwenden wir jedoch einen kleinen Datensatz zum Demonstrieren von map().

      Implementieren einer benutzerdefinierten Funktion

      Ähnlich wie bei lambda können wir eine Funktion verwenden, die wir zur Anwendung auf eine Iterable definiert haben. Zwar sind lambda-Funktionen nützlicher für die Implementierung, wenn Sie mit einem einzeiligen Ausdruck arbeiten, doch sind benutzerdefinierte Funktionen besser geeignet, wenn der Ausdruck komplexer wird. Wenn wir weitere Daten an die Funktion übergeben müssen, die Sie auf Ihre Iterable anwenden möchten, können benutzerdefinierte Funktionen außerdem besser lesbar sein.

      Beispielsweise ist jedes Element in der folgenden Iterable ein Wörterbuch, das verschiedene Details zu den einzelnen Aquariumgeschöpfen enthält:

      aquarium_creatures = [
          {"name": "sammy", "species": "shark", "tank number": 11, "type": "fish"},
          {"name": "ashley", "species": "crab", "tank number": 25, "type": "shellfish"},
          {"name": "jo", "species": "guppy", "tank number": 18, "type": "fish"},
          {"name": "jackie", "species": "lobster", "tank number": 21, "type": "shellfish"},
          {"name": "charlie", "species": "clownfish", "tank number": 12, "type": "fish"},
          {"name": "olly", "species": "green turtle", "tank number": 34, "type": "turtle"}
      ]
      

      Wir haben beschlossen, dass alle Aquariumgeschöpfe tatsächlich in den gleichen Tank kommen sollen. Wir müssen unsere Datensätze aktualisieren, um widerzuspiegeln, dass alle unsere Geschöpfe in Tank 42 kommen werden. Um map()-Zugriff auf alle Wörterbücher und Schlüsselwertpaare in den Wörterbüchern zu erhalten, erstellen wir eine geschachtelte Funktion:

      def assign_to_tank(aquarium_creatures, new_tank_number):
          def apply(x):
              x["tank number"] = new_tank_number
              return x
          return map(apply, aquarium_creatures)
      

      Wir definieren eine assign_to_tank()-Funktion, die aquarium_creatures und new_tank_number als Parameter verwendet. In assign_to_tank() übergeben wir in der letzten Zeile apply() als Funktion an map(). Die Funktion assign_to_tank gibt den Iterator zurück, der sich aus map() ergibt.

      apply() nimmt x als Argument, das einen Eintrag in unserer Liste darstellt (ein einzelnes Wörterbuch).

      Als Nächstes definieren wir, dass x der Schlüssel "tank number" von aquarium_creatures sein und die übergebene new_tank_number speichern soll. Wir geben jedes Element nach Anwenden der neuen Tanknummer zurück.

      Wir rufen assign_to_tank() mit unserer Liste von Wörterbüchern und der neuen Tanknummer auf, die wir für die einzelnen Geschöpfe ersetzen möchten:

      assigned_tanks = assign_to_tank(aquarium_creatures, 42)
      

      Nach Abschluss der Funktion ist unser map-Objekt in der Variable assigned_tanks gespeichert, die wir in eine Liste verwandeln und drucken:

      print(list(assigned_tanks))
      

      Wir erhalten die folgende Ausgabe aus diesem Programm:

      Output

      [{'name': 'sammy', 'species': 'shark', 'tank number': 42, 'type': 'fish'}, {'name': 'ashley', 'species': 'crab', 'tank number': 42, 'type': 'shellfish'}, {'name': 'jo', 'species': 'guppy', 'tank number': 42, 'type': 'fish'}, {'name': 'jackie', 'species': 'lobster', 'tank number': 42, 'type': 'shellfish'}, {'name': 'charlie', 'species': 'clownfish', 'tank number': 42, 'type': 'fish'}, {'name': 'olly', 'species': 'green turtle', 'tank number': 42, 'type': 'turtle'}]

      Wir haben die neue Tanknummer unserer Liste von Wörterbüchern zugeordnet. Mithilfe einer von uns definierten Funktion können wir map() integrieren, um die Funktion effizient auf jedes Element der Liste anzuwenden.

      Verwenden einer integrierten Funktion mit mehreren Iterablen

      Genauso wie bei lambda-Funktionen oder unseren selbst definierten Funktionen können wir integrierte Python-Funktionen mit map() verwenden. Um eine Funktion mit mehreren Iterablen anzuwenden, übergeben wir nach dem ersten einen weiteren Iterablennamen. Verwenden Sie beispielsweise die Funktion pow(), die in zwei Zahlen nimmt, um die Potenz der Basisnummer für den bereitgestellten Exponenten zu finden.

      Hier sehen wir unsere Listen mit Integerzahlen, die wir mit pow() verwenden möchten:

      base_numbers = [2, 4, 6, 8, 10]
      powers = [1, 2, 3, 4, 5]
      

      Als Nächstes übergeben wir pow() als unsere Funktion an map() und stellen die beiden Listen als unsere Iterablen bereit:

      numbers_powers = list(map(pow, base_numbers, powers))
      
      print(numbers_powers)
      

      map() wendet die Funktion pow() in jeder Liste auf das gleiche Element an, um die Potenz anzugeben. Daher werden unsere Ergebnisse 2**1, 4**2, 6**3 usw. anzeigen:

      Output

      [2, 16, 216, 4096, 100000]

      Wenn wir map() eine Iterable zur Verfügung stellen würden, die länger als die andere ist, würde map() die Berechnung stoppen, sobald das Ende der kürzesten Iterable erreicht ist. Im folgenden Programm ergänzen wir base_numbers um drei zusätzliche Zahlen:

      base_numbers = [2, 4, 6, 8, 10, 12, 14, 16]
      powers = [1, 2, 3, 4, 5]
      
      numbers_powers = list(map(pow, base_numbers, powers))
      
      print(numbers_powers)
      

      Als Folge ändert sich innerhalb der Berechnung dieses Programms nichts und bleibt das Ergebnis somit gleich:

      Output

      [2, 16, 216, 4096, 100000]

      Wir haben die Funktion map() mit einer integrierten Python-Funktion verwendet und gesehen, dass sie mehrere Iterablen handhaben kann. Außerdem haben wir überprüft, ob map() weitere Iterablen verarbeitet, bis das Ende der Iterablen mit den wenigsten Elementen erreicht wurde.

      Zusammenfassung

      In diesem Tutorial haben wir die verschiedenen Möglichkeiten zur Verwendung der Funktion map() in Python kennengelernt. Jetzt können Sie map() mit Ihrer eigenen Funktion, einer lambda-Funktion und anderen integrierten Funktionen verwenden. Zudem können Sie map() mit Funktionen implementieren, die mehrere Iterablen erfordern.

      In diesem Tutorial haben wir die Ergebnisse von map() für Demonstrationszwecke sofort in einem Listenformat ausgegeben. In unseren Programmen würden wir normalerweise das zurückgegebene map-Objekt verwenden, um die Daten weiter zu bearbeiten.

      Wenn Sie mehr über Python erfahren möchten, lesen Sie unsere Reihe Codieren in Python 3 und unsere Python Themenseite. Wenn Sie mehr über die Arbeit mit Datensätzen in funktionaler Programmierung erfahren möchten, lesen Sie unseren Artikel zur Funktion filter().



      Source link

      Verwenden der Python-Filterfunktion


      Einführung

      Die in Python integrierte filter()-Funktion kann dazu dienen, aus einem vorhandenen iterable (wie einer Liste oder einem Wörterbuch) einen neuen iterator zu erstellen, der Elemente mithilfe einer von uns bereitgestellten Funktion effizient filtern kann. Ein iterable ist ein Python-Objekt, bei dem „iterated over“ möglich ist, d. h. Elemente werden in einer Reihenfolge zurückgegeben, die wir in einer for-Schleife verwenden können.

      Die grundlegende Syntax für die Funktion filter() lautet:

      filter(function, iterable)
      

      Dadurch wird ein Filterobjekt zurückgegeben, das ein iterable ist. Wir können eine Funktion wie list() verwenden, um eine Liste aller in einem Filterobjekt zurückgegebenen Elemente zu erstellen.

      Die Funktion filter() bietet eine Möglichkeit, Werte zu filtern, die oft effizienter ist als eine Listen-Abstraktion, insbesondere wenn wir mit größeren Datensätzen arbeiten. Beispielsweise erstellt eine Listen-Abstraktion eine neue Liste, was die Laufzeit dieser Verarbeitung erhöht. So verfügen wir, nachdem unsere Listen-Abstraktion ihren Ausdruck abgeschlossen hat, über zwei Listen im Arbeitsspeicher. Allerdings wird filter() ein einfaches Objekt erstellen, das einen Verweis auf die Originalliste, die bereitgestellte Funktion und einen Index enthält, wo in der Originalliste gesucht werden soll. Dafür wird weniger Arbeitsspeicher benötigt.

      In diesem Tutorial werden wir uns vier verschiedene Methoden zur Verwendung von filter() ansehen: mit zwei verschiedenen iterable-Strukturen, mit einer lambda-Funktion und ohne definierte Funktion.

      Verwenden von filter() mit einer Funktion

      Das erste Argument für filter() ist eine Funktion, mit der wir entscheiden, ob die einzelnen Elemente enthalten sein oder herausgefiltert werden sollen. Die Funktion wird für jedes Element im iterable, das als zweites Argument übergeben wird, einmal aufgerufen, und bei jeder Rückgabe von False wird der Wert gelöscht. Da dieses Argument eine Funktion ist, können wir entweder eine normale Funktion übergeben oder lambda-Funktionen nutzen, insbesondere wenn der Ausdruck weniger komplex ist.

      Im Folgenden wird die Syntax einer lambda-Funktion mit filter() dargestellt:

      filter(lambda item: item[] expression, iterable)
      

      Mit einer Liste wie dieser können wir eine lambda-Funktion mit einem Ausdruck integrieren, gegen den wir die einzelnen Elemente aus der Liste bewerten möchten:

      creature_names = ['Sammy', 'Ashley', 'Jo', 'Olly', 'Jackie', 'Charlie']
      

      Um die Liste zu filtern und die Namen unserer Aquariumbewohner zu finden, die mit einem Vokal beginnen, können wir die folgende lambda-Funktion ausführen:

      print(list(filter(lambda x: x[0].lower() in 'aeiou', creature_names)))
      

      Hier deklarieren wir einen Punkt in unserer Liste als x. Dann legen wir unseren Ausdruck so fest, dass er auf das erste Zeichen der jeweiligen Zeichenfolge (oder Zeichen „zero“) zugreift, also x[0]. Durch Kleinschreibung aller Namen wird sichergestellt, dass Buchstaben mit der Zeichenfolge in unserem Ausdruck (aeiou) abgeglichen werden.

      Abschließend übergeben wir das iterable creature_names. Wie im vorherigen Abschnitt wenden wir list() auf das Ergebnis an, um eine Liste aus den iterator filter()-Ergebnissen zu erstellen.

      Die Ausgabe wird wie folgt aussehen:

      Output

      ['Ashley', 'Olly']

      Das gleiche Ergebnis kann mit einer selbst definierten Funktion erzielt werden:

      creature_names = ['Sammy', 'Ashley', 'Jo', 'Olly', 'Jackie', 'Charlie']
      
      def names_vowels(x):
        return x[0].lower() in 'aeiou'
      
      filtered_names = filter(names_vowels, creature_names)
      
      print(list(filtered_names))
      

      Unsere Funktion names_vowels definiert den Ausdruck, den wir implementieren werden, um creature_names zu filtern.

      Die Ausgabe würde erneut wie folgt aussehen:

      Output

      ['Ashley', 'Olly']

      Im Allgemeinen erzielen lambda-Funktionen mit filter() das gleiche Ergebnis, wie wenn wir eine reguläre Funktion verwenden würden. Die Notwendigkeit zur Definition einer regulären Funktion wächst mit der Komplexität der Ausdrücke zum Filtern unserer Daten. Dadurch lässt sich in unserem Code wahrscheinlich auch eine bessere Lesbarkeit erzielen.

      Verwenden von None mit filter()

      Wir können None als erstes Argument an filter() übergeben, damit der zurückgegebene iterator alle Werte ausgibt, die Python als „falsy“ erachtet. Im Allgemeinen betrachtet Python alles mit einer Länge von 0 (wie eine leere Liste oder eine leere Zeichenfolge) und alles, was 0 numerisch entspricht, als „false“, daher die Verwendung des Begriffs „falsy“.

      Im folgenden Fall möchten wir unsere Liste so filtern, dass nur die Tanknummern unseres Aquariums angezeigt werden:

      aquarium_tanks = [11, False, 18, 21, "", 12, 34, 0, [], {}]
      

      In diesem Code haben wir eine Liste, die Integer, leere Sequenzen und einen booleschen Wert enthält.

      filtered_tanks = filter(None, aquarium_tanks)
      

      Wir verwenden die Funktion filter() mit None und übergeben die Liste aquarium_tanks als unser iterable. Da wir None als erstes Argument übergeben haben, prüfen wir, ob die Elemente in unserer Liste als false angesehen werden.

      print(list(filtered_tanks))
      

      Dann schließen wir filtered_tanks in eine list()-Funktion ein, damit sie beim Drucken eine Liste für filtered_tanks zurückgibt.

      Hier sehen wir, dass die Ausgabe nur die Integerwerte enthält. Alle Elemente, die zu False ausgewertet wurden oder der Länge 0 entsprechen, wurden durch filter() entfernt:

      Output

      [11, 25, 18, 21, 12, 34]

      Anmerkung: Wenn wir list() nicht verwenden und filtered_tanks drucken, erhalten wir ein Filterobjekt, das etwa so aussieht: <Filter object at 0x7fafd5903240>. Das Filterobjekt ist ein iterable, sodass wir ein loop over mit for vornehmen können; alternativ können wir list() verwenden, um es in eine Liste umzuwandeln. Dies tun wir hier, da es eine gute Möglichkeit ist, die Ergebnisse zu prüfen.

      Bei None haben wir filter() verwendet, um Elemente aus unserer Liste schnell zu entfernen, die als false betrachtet wurden.

      Verwenden von filter() mit einer Liste von Wörterbüchern

      Wenn wir eine komplexere Datenstruktur aufweisen, können wir filter() dennoch verwenden, um die einzelnen Elemente zu bewerten. Wenn wir beispielsweise über eine Liste von Wörterbüchern verfügen, wollen wir nicht nur über jedes einzelne Element in der Liste – einem der Wörterbücher – iterieren, sondern wollen ggf. auch über jedes key:value-Paar in einem Wörterbuch iterieren, um alle Daten auszuwerten.

      Als Beispiel gehen wir davon aus, dass wir eine Liste jedes einzelnen Tiers in unserem Aquarium sowie verschiedene Details zu ihnen haben:

      aquarium_creatures = [
        {"name": "sammy", "species": "shark", "tank number": "11", "type": "fish"},
        {"name": "ashley", "species": "crab", "tank number": "25", "type": "shellfish"},
        {"name": "jo", "species": "guppy", "tank number": "18", "type": "fish"},
        {"name": "jackie", "species": "lobster", "tank number": "21", "type": "shellfish"},
        {"name": "charlie", "species": "clownfish", "tank number": "12", "type": "fish"},
        {"name": "olly", "species": "green turtle", "tank number": "34", "type": "turtle"}
      ]
      

      Wir möchten diese Daten mit einer Suchzeichenfolge filtern, die wir der Funktion übergeben. Damit filter() auf jedes Wörterbuch und jedes Element in den Wörterbüchern zugreift, richten wir eine geschachtelte Funktion ein, die wie folgt aussieht:

      def filter_set(aquarium_creatures, search_string):
          def iterator_func(x):
              for v in x.values():
                  if search_string in v:
                      return True
              return False
          return filter(iterator_func, aquarium_creatures)
      

      Wir definieren eine filter_set()-Funktion, die aquarium_creatures und search_string als Parameter verwendet. In filter_set() übergeben wir unsere iterator_func() als Funktion an filter(). Die Funktion filter_set() gibt den iterator zurück, der aus filter() resultiert.

      Die iterator_func() nimmt x als Argument, was ein Element in unserer Liste (d. h. einem einzelnen Wörterbuch) darstellt.

      Als Nächstes greift die for-Schleife auf die Werte in den einzelnen key:value-Paaren in unseren Wörterbüchern zu und nutzt dann eine bedingte Anweisung, um zu prüfen, ob die search_string in v ist, was einen Wert darstellt.

      Wie in unseren vorherigen Beispielen: Wenn der Ausdruck zu True auswertet, fügt die Funktion das Element dem Filterobjekt hinzu. Dieses wird zurückgegeben, sobald die Funktion filter_set() abgeschlossen ist. Wir positionieren return False außerhalb unserer Schleife, damit jedes Element in jedem Wörterbuch geprüft wird, anstatt nach der Überprüfung des ersten Wörterbuchs zurückzukehren.

      Wir rufen filter_set() mit unserer Liste der Wörterbücher und der Suchzeichenfolge auf, für die wir Übereinstimmungen finden möchten:

      filtered_records = filter_set(aquarium_creatures, "2")    
      

      Nach Abschluss der Funktion ist unser Filterobjekt in der Variable filtered_records gespeichert, die wir in eine Liste verwandeln und drucken:

      print(list(filtered_records))      
      

      Wir sehen die folgende Ausgabe aus diesem Programm:

      Output

      [{'name': 'ashley', 'species': 'crab', 'tank number': '25', 'type': 'shellfish'}, {'name': 'jackie', 'species': 'lobster', 'tank number': '21', 'type': 'shellfish'}, {'name': 'charlie', 'species': 'clownfish', 'tank number': '12', 'type': 'fish'}]

      Wir haben die Liste der Wörterbücher mit der Suchzeichenfolge 2 gefiltert. Wir können sehen, dass die drei Wörterbücher zurückgegeben wurden, die eine Tanknummer mit 2 enthielten. Mit unserer eigenen geschachtelten Funktion können wir auf jedes einzelne Element zugreifen und effizient mit der Suchzeichenfolge abgleichen.

      Zusammenfassung

      In diesem Tutorial haben wir die verschiedenen Möglichkeiten zur Verwendung der Funktion filter() in Python kennengelernt. Jetzt können Sie filter() mit Ihrer eigenen Funktion, einer lambda-Funktion oder mit None verwenden, um in Datenstrukturen unterschiedlicher Komplexität nach Elementen zu filtern.

      Zwar haben wir in diesem Tutorial die Ergebnisse von filter() sofort im Listenformat gedruckt, doch ist es wahrscheinlich, dass wir das zurückgegebene filter()-Objekt in unseren Programmen verwenden und die Daten weiter bearbeiten werden.

      Wenn Sie mehr über Python erfahren möchten, lesen Sie unsere Reihe Codieren in Python 3 und unsere Python Themenseite.



      Source link