One place for hosting & domains

      Vier Methoden zum Durchsuchen von Arrays in JavaScript


      In JavaScript gibt es viele nützliche Möglichkeiten, Elemente in Arrays zu finden. Sie könnten jederzeit auf die Basisschleife zurückgreifen, aber mit ES6+ gibt es eine Vielzahl von Methoden, um das Array in einer Schleife zu durchlaufen und das Gewünschte mit Leichtigkeit zu finden.

      Welche Methode wenden Sie bei so vielen verschiedenen Methoden an und in welchem Fall?  Wenn Sie zum Beispiel ein Array durchsuchen, möchten Sie wissen, ob das Element überhaupt in dem Array enthalten ist?  Benötigen Sie den Index des Elements oder das Element selbst?

      Bei jeder der verschiedenen Methoden, die wir behandeln werden, ist es wichtig zu verstehen, dass es sich bei allen um integrierte Methoden auf dem Array.Prototyp handelt. Das bedeutet, dass Sie sie einfach auf ein beliebiges Array mit Punktnotation verketten müssen.  Das bedeutet auch, dass diese Methoden nicht für Objekte oder etwas anderes als Arrays verfügbar sind (obwohl es Überschneidungen mit Strings gibt).

      Wir sehen uns die folgenden Array-Methoden an:

      beinhaltet

      const alligator = ["thick scales", 80, "4 foot tail", "rounded snout"];
      
      alligator.includes("thick scales"); // returns true
      

      Die .beinhaltet-Methode gibt einen booleschen Wert zurück und ist ideal, um Ihnen mitzuteilen, ob ein Element in einem Array existiert oder nicht.  Sie gibt eine einfache wahre oder falsche Antwort. Dies ist die grundlegende Syntax:

      arr.includes(valueToFind, [fromIndex]);
      

      Wie Sie in unserem Beispiel sehen, hatten wir nun nur einen Parameter – den valueToFind. Dies ist der Wert, der im Array übereinstimmt. Der optionale fromIndex ist eine Zahl, die anzeigt, welchen Index Sie mit der Suche beginnen möchten, (Standardwert ist 0, das gesamte Array wird durchsucht). Da das Element „thick scales“ also bei dem Index 0 liegt, wäre das folgende falsch: alligator.includes('thick scales', 1); , da es bei Index 1 und weiter mit der Suche beginnt.

      Jetzt gibt es einige wichtige Dinge zu beachten. Diese .beinhaltet() -Methode verwendet einen strengen Vergleich. Das bedeutet, dass aus dem obigen Beispiel Folgendes falsch zurückgegeben werden würde: alligator.includes('80'); das liegt daran, dass, obwohl 80 == '80' wahr ist, 80 === ‘80’ falsch ist – verschiedene Typen werden einem strengen Vergleich nicht standhalten.“

      find

      Wie unterscheidet sich .find() von der beinhaltet() Methode? Wenn wir in unserem Beispiel nur den Text „beinhaltet“ in „finden“ geändert haben, würden wir diesen Fehler erhalten:

      Uncaught TypeError: thick scales is not a function
      

      Das liegt daran, dass bei der Find-Methode eine Funktion übergeben werden muss.  Das liegt daran, dass die Suchmethode nicht einfach den einfachen Vergleichsoperator wie “beinhaltet()” verwenden wird. Stattdessen übergibt es jedes Element an Ihre Funktion und prüft, ob es wahr oder falsch zurückgibt.  Obwohl dies also funktioniert: alligator.find(() => 'thick scales'); würden Sie wahrscheinlich Ihren eigenen Vergleichsoperator in die Funktion setzen wollen, damit er alles Relevante zurückgibt.

      const alligator = ["thick scales", 80, "4 foot tail", "rounded snout"];
      
      alligator.find(el => el.length < 12); // returns '4 foot tail'
      

      Diese einfache Funktion in unserer Finden-Methode betrachtet jedes Element des Arrays mit dem Alias ‘el’, den wir ihm zugewiesen haben, und hält an, wenn das erste gefunden wurde, das wahr ist.  In unserem Fall hat wahr eine Längeneigenschaft von weniger als 12 (Zahlen haben keine Längeneigenschaft). Sie könnten diese Funktion natürlich so komplex gestalten wie Sie sie benötigen, so dass Ihr wahrer Zustand Ihren Anforderungen entspricht.

      Beachten Sie auch, dass dies nicht wahr zurückgegeben wurde. Die Finden-Methode gibt keinen Booleschen Wert zurück, sondern das erste übereinstimmende Element. Wenn es kein übereinstimmendes Element gibt, da es nichts gibt, das die in Ihrer Funktion definierten Kriterien erfüllt, wird es als undefined zurückgegeben. Beachten Sie auch, dass es das erste zurückgibt, wenn also mehr als ein Element im Array vorhanden ist, das den Kriterien entspricht, wird es nur die erste Instanz erhalten. Wenn es in unserem Beispiel eine weitere Zeichenfolge von Länge unter 12 nach „4 Fuß hoch“ gab, würde dies unser Ergebnis nicht ändern.

      In unserem Beispiel haben wir den Rückruf nur mit einem Parameter verwendet.  Sie können auch Parameter hinzufügen, um auf den Index des aktuellen Elements zu verweisen.  Ein weiterer Parameter kann das gesamte Array selbst sein, aber ich finde, dass dies selten verwendet wird. Hier ist ein Beispiel der Verwendung mit dem Index:

      alligator.find((el, idx) => typeof el === "string" && idx === 2); // returns '4 foot tall'
      

      Wir wissen, dass es in unserem Array 3 verschiedene Elemente gibt, die der ersten Bedingung entsprechen (typeof el === „string“). Wenn dies unsere Bedingung war, würde sie die erste zurückgeben, „thick scales“ . Der Unterschied ist jedoch, dass nur eine den Index von 2 hat und das ist „4 Fuß hoch“.

      Apropos Indizes, eine ähnliche Array-Methode ist .findIndex(). Diese Methode empfängt auch eine Funktion, aber wie Sie sich denken können, gibt sie den Index des übereinstimmenden Elements anstelle des Elements selbst zurück.

      indexOf

      const alligator = ["thick scales", 80, "4 foot tail", "rounded snout"];
      
      alligator.indexOf("rounded snout"); // returns 3
      

      Wie die .includes() Methode, verwendet .indexOf() einen strengen Vergleich , keine Funktion, wie wir bei der Methode .finden() gesehen haben. Aber im Gegensatz zu .includes() gibt es den Index des Elements zurück, anstatt einen Booleschen Wert. Sie können auch angeben, bei welchem Index im Array die Suche beginnen soll.

      Ich finde indexOf() sehr nützlich. Es ist schnell und einfach und kann Ihnen sagen, wo sich das Element im Array befindet und ob es existiert.  Wie wird Ihnen mitgeteilt, ob das Element existiert? Grundsätzlich können wir wissen, dass das Element existiert, wenn es eine positive Zahl zurückgibt, und wenn es -1 zurückgibt, wissen wir, dass das Element nicht existiert.

      alligator.indexOf("soft and fluffy"); // returns -1
      alligator.indexOf(80); // returns 1
      alligator.indexOf(80, 2); // returns -1
      

      Und wie Sie sehen können, obwohl wir die Methoden find() oder findIndex() erhalten können, um uns die gleichen Informationen zu geben, ist dies viel weniger zu schreiben. Wir brauchen keine Vergleichsfunktion zu schreiben, da sie bereits innerhalb der Methode indexOf liegt.

      Genau wie die anderen gibt indexOf() jetzt auch den Index des ersten gefundenen übereinstimmenden Elements zurück.  JavaScript gibt uns eine alternative Array-Methode .lastIndexOf(). Wie Sie sich denken können, macht dies dasselbe wie indexOf() aber ausgehend vom letzten Index des Arrays und in umgekehrter Reihenfolge. Sie können auch einen zweiten Parameter angeben, aber denken Sie daran, dass sich die Indexes nicht ändern, nur weil Sie eine andere Methode verwenden.

      const alligator = ["thick scales", 80, "4 foot tail", "rounded snout", 80];
      
      alligator.indexOf(80); // returns 1
      alligator.lastIndexOf(80); // returns 4
      alligator.indexOf(80, 2); // returns 4
      alligator.lastIndexOf(80, 4); // returns 4
      alligator.lastIndexOf(80, 3); // returns 1
      

      Bonus: filter

      const alligator = ["thick scales", 80, "4 foot tail", "rounded snout", 80];
      
      alligator.filter(el => el === 80); //returns [80, 80]
      

      Die filter()-Methode ist wie die find()-Methode, d. h. sie erfordert eine übermittelte Funktion und eine Bedingung für das, was zurückgegeben wird.  Der Hauptunterschied ist, dass filter() immer ein Array zurückgibt, auch wenn es nur ein übereinstimmendes Element gibt.  Aber sie gibt alle übereinstimmenden Elemente zurück, während find() nur die erste Übereinstimmung zurückgibt.

      Das Wichtige am Filter ist, dass er alle Elemente zurückgibt, die Ihren Kriterien entsprechen.  Es kann auch nur ich sein, aber ich kann mich täuschen, wenn ich denke: „Das sind die Elemente, die ich herausfiltern möchte”, wenn Sie in Wahrheit die Elemente angeben, die Sie hineinfiltern möchten.

      Zusammenfassung

      Die einfachste Methode, die ich verwende, wenn ich etwas suche, ist die find()-Methode, aber wie Sie sehen können, hängt das wirklich von Ihrem Fall ab.

      • Müssen Sie nur wissen, ob sie existiert?  Verwenden Sie .includes().
      • Müssen Sie das Element selbst besorgen?  Verwenden Sie .find() oder .filter() für mehrere Elemente.
      • Müssen Sie den Index des Elements finden? Verwenden Sie .indexOf() oder findIndex() für eine komplexere Suche.

      Die Arrays in den Beispielen waren hier sehr einfach. Sie können sich mit einem Array von Objekten konfrontiert sehen. Im Folgenden finden Sie einige sehr einfache Beispiele, um durch den Dschungel vernetzter Objekte zu navigieren:

      const jungle = [
        { name: "frog", threat: 0 },
        { name: "monkey", threat: 5 },
        { name: "gorilla", threat: 8 },
        { name: "lion", threat: 10 }
      ];
      
      // break the object down in order to use .includes() or .indexOf()
      const names = jungle.map(el => el.name); // returns ['frog', 'monkey', 'gorilla', 'lion']
      console.log(names.includes("gorilla")); // returns true
      console.log(names.indexOf("lion")); // returns 3 - which corresponds correctly assuming no sorting was done
      
      // methods we can do on the array of objects
      console.log(jungle.find(el => el.threat == 5)); // returns object - {name: "monkey", threat: 5}
      console.log(jungle.filter(el => el.threat > 5)); // returns array - [{name: "gorilla", threat: 8}, {name: 'lion', threat: 10}]
      



      Source link

      Verwenden eines Unterprozesses zum Ausführen externer Programme in Python 3


      Der Autor hat den COVID-19 Relief Fund dazu ausgewählt, eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Python 3 beinhaltet das subprocess-Modul zum Ausführen externer Programme und Lesen ihrer Ausgaben in Ihrem Python-Code.

      Möglicherweise finden Sie subprocess nützlich, wenn Sie in Ihrem Python-Code auf Ihrem Computer ein anderes Programm verwenden möchten. Beispielsweise möchten Sie vielleicht git aus Ihrem Python-Code aufrufen, um Dateien in Ihrem Projekt abzurufen, die in der git-Versionskontrolle verfolgt werden. Da sich jedes Programm, das Sie auf Ihrem Computer aufrufen können, über subprocess steuern lässt, gelten die hier angegebenen Beispiele für externe Programme, die Sie ggf. über Ihren Python-Code aufrufen möchten.

      subprocess enthält verschiedene Klassen und Funktionen; wir werden in diesem Tutorial jedoch eine der nützlichsten Funktionen von subprocess abdecken: subprocess.run. Wir werden uns die verschiedenen Einsatzmöglichkeiten und wichtigsten Schlüsselwortargumente ansehen.

      Voraussetzungen

      Um das Beste aus diesem Tutorial herauszuholen, empfiehlt es sich, eine gewisse Vertrautheit mit Programmierung in Python 3 aufzuweisen. Sie können sich für die erforderlichen Hintergrundinformationen folgende Tutorials ansehen:

      Ausführen eines externen Programms

      Sie können mit der Funktion subprocess.run ein externes Programm über Ihren Python-Code ausführen. Zuerst müssen Sie jedoch die Module subprocess und sys in Ihr Programm importieren:

      import subprocess
      import sys
      
      result = subprocess.run([sys.executable, "-c", "print('ocean')"])
      

      Wenn Sie dies ausführen, erhalten Sie eine Ausgabe wie die folgende:

      Output

      ocean

      Sehen wir uns dieses Beispiel an:

      • sys.executable ist der absolute Pfad zur ausführbaren Python-Datei, mit der Ihr Programm ursprünglich aufgerufen wurde. Beispielsweise kann sys.executable ein Pfad wie /usr/local/bin/python sein.
      • An subprocess.run wird eine Liste mit Zeichenfolgen übergeben, die aus den Komponenten des Befehls besteht, den wir ausführen möchten. Da die erste Zeichenfolge, die wir übergeben, sys.executable ist, weisen wir subprocess.run an, ein neues Python-Programm auszuführen.
      • Die Komponente -c ist eine python-Befehlszeilenoption, mit der Sie eine Zeichenfolge mit einem gesamten Python-Programm zur Ausführung übergeben können. In unserem Fall übergeben wir ein Programm, das die Zeichenkette ocean ausgibt.

      Sie können sich jeden Eintrag in der Liste, den wir an subprocess.run übergeben, als durch ein Leerzeichen getrennt vorstellen. Beispielsweise wird [sys.executable, "-c", "print('ocean')"] in etwa zu /usr/local/bin/python -c "print('ocean')". Beachten Sie, dass subprocess automatisch die Komponenten des Befehls angibt, bevor versucht wird, sie im zugrunde liegenden Betriebssystem auszuführen. So können Sie beispielsweise einen Dateinamen übergeben, der Leerzeichen enthält.

      Warnung: Übergeben Sie nie unvertrauenswürdige Eingaben an subprocess.run. Da subprocess.run die Fähigkeit hat, beliebige Befehle auf Ihrem Computer auszuführen, können bösartige Akteure damit Ihren Computer auf unerwartete Weise manipulieren.

      Erfassen von Ausgaben aus einem externen Programm

      Nachdem wir mit subprocess.run ein externes Programm aufrufen können, sehen wir uns nun an, wie wir Ausgaben von diesem Programm erfassen können. Beispielsweise kann dieser Prozess nützlich sein, wenn wir git ls-files verwenden möchten, um alle aktuell in der Versionskontrolle gespeicherten Dateien auszugeben.

      Anmerkung: Die in diesem Abschnitt angegebenen Beispiele benötigen Python 3.7 oder höher. Insbesondere wurden die Schlüsselwortargumente capture_output und text in Python 3.7 hinzugefügt, als es im Juni 2018 veröffentlicht wurde.

      Ergänzen wir unser vorheriges Beispiel:

      import subprocess
      import sys
      
      result = subprocess.run(
          [sys.executable, "-c", "print('ocean')"], capture_output=True, text=True
      )
      print("stdout:", result.stdout)
      print("stderr:", result.stderr)
      

      Wenn wir diesen Code ausführen, erhalten wir eine Ausgabe wie die folgende:

      Output

      stdout: ocean stderr:

      Dieses Beispiel ist weitgehend das gleiche wie das im ersten Abschnitt eingeführte: Wir führen noch immer einen Unterprozess zum Ausdrucken von ocean aus. Wichtig:Wir übergeben jedoch die Schlüsselwortargumente capture_output=True und text=True an subprocess.run.

      subprocess.run gibt ein subprocess.CompletedProcess-Objekt zurück, das an result gebunden ist. Das Objekt subprocess.CompletedProcess enthält Details zum Exitcode des externen Programms und seiner Ausgabe. capture_output=True sorgt dafür, dass result.stdout und result.stderr mit der entsprechenden Ausgabe aus dem externen Programm gefüllt werden. Standardmäßig sind result.stdout und result.stderr als Bytes gebunden; das Schlüsselwortargument text=True weist Python an, die Bytes in Zeichenfolgen zu decodieren.

      Im Ausgabebereich lautet stdout ocean (plus der nachfolgenden neuen Zeile, die print implizit hinzufügt); wir verfügen über kein stderr.

      Versuchen wir es mit einem Beispiel, das für stderr einen nicht leeren Wert erstellt:

      import subprocess
      import sys
      
      result = subprocess.run(
          [sys.executable, "-c", "raise ValueError('oops')"], capture_output=True, text=True
      )
      print("stdout:", result.stdout)
      print("stderr:", result.stderr)
      

      Wenn wir diesen Code ausführen, erhalten wir eine Ausgabe wie die folgende:

      Output

      stdout: stderr: Traceback (most recent call last): File "<string>", line 1, in <module> ValueError: oops

      Dieser Code führt einen Python-Unterprozess aus, der sofort einen ValueError auslöst. Wenn wir das endgültige Ergebnis prüfen, sehen wir in stdout nichts und ein Traceback unseres ValueError in stderr. Das liegt daran, dass Python das Traceback der nicht behandelten Ausnahme in stderr schreibt.

      Auslösen einer Ausnahme bei einem fehlerhaften Exitcode

      Manchmal ist es nützlich, eine Ausnahme auszulösen, wenn ein ausgeführtes Programm mit einem fehlerhaften Exitcode beendet wird. Programme, die mit einem Nullcode beendet werden, werden als erfolgreich betrachtet; Programme, die mit einem Nicht-Nullcode beendet werden, werden hingegen als fehlerhaft betrachtet. Als Beispiel kann dieses Muster nützlich sein, wenn wir eine Ausnahme auslösen möchten für den Fall, dass wir git ls-files in einem Verzeichnis ausführen, das in Wahrheit kein git-Repository ist.

      Wir können das Schlüsselwortargument check=True nutzen, damit für subprocess.run eine Ausnahme ausgelöst wird, wenn das externe Programm einen Nicht-Null-Exitcode zurückgibt:

      import subprocess
      import sys
      
      result = subprocess.run([sys.executable, "-c", "raise ValueError('oops')"], check=True)
      

      Wenn wir diesen Code ausführen, erhalten wir eine Ausgabe wie die folgende:

      Output

      Traceback (most recent call last): File "<string>", line 1, in <module> ValueError: oops Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/usr/local/lib/python3.8/subprocess.py", line 512, in run raise CalledProcessError(retcode, process.args, subprocess.CalledProcessError: Command '['/usr/local/bin/python', '-c', "raise ValueError('oops')"]' returned non-zero exit status 1.

      Diese Ausgabe zeigt, dass wir einen Unterprozess ausgeführt haben, der einen Fehler ausgelöst hat, der in unserem Terminal in stderr ausgegeben wird. Dann hat subprocess.run in unserem Namen in unserem zentralen Python-Programm ordnungsgemäß einen subprocess.CalledProcessError ausgelöst.

      Alternativ enthält das subprocess-Modul auch die Methode subprocess.CompletedProcess.check_returncode, die wir mit ähnlicher Wirkung aufrufen können:

      import subprocess
      import sys
      
      result = subprocess.run([sys.executable, "-c", "raise ValueError('oops')"])
      result.check_returncode()
      

      Wenn wir diesen Code ausführen, erhalten wir:

      Output

      Traceback (most recent call last): File "<string>", line 1, in <module> ValueError: oops Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/usr/local/lib/python3.8/subprocess.py", line 444, in check_returncode raise CalledProcessError(self.returncode, self.args, self.stdout, subprocess.CalledProcessError: Command '['/usr/local/bin/python', '-c', "raise ValueError('oops')"]' returned non-zero exit status 1.

      Da wir check=True nicht an subprocess.run übergeben haben, haben wir eine subprocess.CompletedProcess-Instanz erfolgreich an result gebunden, obwohl unser Programm mit einem Nicht-Nullcode beendet wurde. Ein Aufruf von result.check_returncode() löst jedoch einen subprocess.CalledProcessError aus, da erkannt wird, dass der abgeschlossene Prozess mit einem fehlerhaften Code beendet wurde.

      Verwenden von Timeouts zum frühzeitigen Beenden von Programmen

      subprocess.run enthält das timeout-Argument, sodass Sie ein externes Programm anhalten können, wenn dessen Ausführung zu lange dauert:

      import subprocess
      import sys
      
      result = subprocess.run([sys.executable, "-c", "import time; time.sleep(2)"], timeout=1)
      

      Wenn wir diesen Code ausführen, erhalten wir eine Ausgabe wie die folgende:

      Output

      Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/usr/local/lib/python3.8/subprocess.py", line 491, in run stdout, stderr = process.communicate(input, timeout=timeout) File "/usr/local/lib/python3.8/subprocess.py", line 1024, in communicate stdout, stderr = self._communicate(input, endtime, timeout) File "/usr/local/lib/python3.8/subprocess.py", line 1892, in _communicate self.wait(timeout=self._remaining_time(endtime)) File "/usr/local/lib/python3.8/subprocess.py", line 1079, in wait return self._wait(timeout=timeout) File "/usr/local/lib/python3.8/subprocess.py", line 1796, in _wait raise TimeoutExpired(self.args, timeout) subprocess.TimeoutExpired: Command '['/usr/local/bin/python', '-c', 'import time; time.sleep(2)']' timed out after 0.9997982999999522 seconds

      Der Unterprozess, den wir ausführen wollten, verwendet die Funktion time.sleep, um für 2 Sekunden zu schlafen. Wir haben jedoch das Schlüsselwortargument timeout=1 an subprocess.run übergeben, um bei unserem Unterprozess nach 1 Sekunde für ein Timeout zu sorgen. Das erklärt, warum unser Aufruf an subprocess.run letztlich eine subprocess.TimeoutExpired-Ausnahme ausgelöst hat.

      Beachten Sie, dass das Schlüsselwortargument timeout für subprocess.run ungefähr ist. Python wird sich bemühen, den Unterprozess nach der timeout-Zahl von Sekunden zu beenden; der Vorgang wird jedoch nicht unbedingt genau sein.

      Übergeben von Eingaben an Programme

      Manchmal erwarten Programme, dass Eingaben über stdin an sie übergeben werden.

      Das Schlüsselwortargument input an subprocess.run ermöglicht Ihnen, Daten an stdin des Unterprozesses zu übergeben. Beispiel:

      import subprocess
      import sys
      
      result = subprocess.run(
          [sys.executable, "-c", "import sys; print(sys.stdin.read())"], input=b"underwater"
      )
      

      Nach Ausführung dieses Codes erhalten wir eine Ausgabe wie die folgende:

      Output

      underwater

      In diesem Fall haben wir die Bytes underwater an input übergeben. Unser Zielunterprozess hat sys.stdin verwendet, um das übergebene stdin (underwater) zu lesen und in unserer Ausgabe auszugeben.

      Das Schlüsselwortargument input kann nützlich sein, wenn Sie mehrere subprocess.run-Aufrufe verketten möchten, um die Ausgabe eines Programms als Eingabe an ein anderes zu übergeben.

      Zusammenfassung

      Das subprocess-Modul ist ein leistungsfähiger Bestandeil der Python-Standardbibliothek, mit dem Sie externe Programme ausführen und deren Ausgaben bequem überprüfen können. In diesem Tutorial haben Sie gelernt, wie Sie subprocess.run verwenden können, um externe Programme zu steuern, Eingaben an sie zu übergeben, ihre Ausgabe zu analysieren und ihre Rückgabecodes zu überprüfen.

      Das subprocess-Modul macht zusätzliche Klassen und Dienstprogramme verfügbar, auf die wir in diesem Tutorial nicht eingegangen sind. Nachdem Sie nun über Grundkenntnisse verfügen, können Sie die Dokumentation des subprocess-Moduls nutzen, um mehr über andere verfügbare Klassen und Dienstprogramme zu erfahren.



      Source link

      Verwenden des pathlib-Moduls zum Bearbeiten von Dateisystempfaden in Python 3


      Der Autor hat den COVID-19 Relief Fund dazu ausgewählt, eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Python 3 enthält das pathlib-Modul zur betriebssystemunabhängigen Bearbeitung von Dateisystempfaden. pathlib ähnelt dem os.path-Modul; pathlib bietet jedoch eine übergeordnete – und oft bequemere – Oberfläche als os.path.

      Wir können Dateien auf einem Computer mit hierarchischen Pfaden identifizieren. Beispielsweise können wir die Datei wave.txt auf einem Computer mit diesem Pfad identifizieren: /Users/sammy/ocean/wave.txt. Betriebssysteme stellen Pfade etwas anders dar. Windows kann den Pfad zur Datei wave.txt folgendermaßen darstellen: C:Userssammyoceanwave.txt.

      Sie finden das pathlib-Modul ggf. nützlich, wenn Sie in Ihrem Python-Programm Dateien im Dateisystem erstellen oder verschieben, Dateien im Dateisystem auflisten, die alle einer bestimmten Erweiterung oder einem Muster entsprechen, oder basierend auf Sammlungen roher Zeichenfolgen dem jeweiligen Betriebssystem entsprechende Dateipfade erstellen. Zwar ließen sich auch andere Tools (wie das Modul os.path) zur Erledigung vieler dieser Aufgaben verwenden, doch können Sie mit dem pathlib-Modul solche Operationen mit hoher Lesbarkeit und einer minimalen Codemenge ausführen.

      In diesem Tutorial sehen wir uns einige der Wege an, um das Modul pathlib zum Darstellen und Bearbeiten von Dateisystempfaden zu verwenden.

      Voraussetzungen

      Um das Beste aus diesem Tutorial herauszuholen, empfiehlt es sich, eine gewisse Vertrautheit mit Programmierung in Python 3 aufzuweisen. Sie können sich für die erforderlichen Hintergrundinformationen folgende Tutorials ansehen:

      Erstellen von Path-Instanzen

      Das pathlib-Modul bietet mehrere Klassen; eine der wichtigsten ist jedoch die Path-Klasse. Instanzen der Path-Klasse stellen einen Pfad zu einer Datei oder einem Verzeichnis im Dateisystem unseres Computers dar.

      Beispielsweise instanziiert der folgende Code eine Path-Instanz, die einen Teil des Pfads zu einer Datei wave.txt darstellt:

      from pathlib import Path
      
      wave = Path("ocean", "wave.txt")
      print(wave)
      

      Wenn wir diesen Code ausführen, erhalten wir eine Ausgabe wie die folgende:

      Output

      ocean/wave.txt

      from pathlib import Path macht die Path-Klasse für unser Programm verfügbar. Dann instanziiert Path("ocean", "wave.txt") eine neue Path-Instanz. Ein Drucken der Ausgabe zeigt, dass Python das entsprechende Betriebssystemtrennzeichen / zwischen den beiden Pfadkomponenten hinzugefügt hat, die wir angegeben haben: "ocean" und "wave.txt".

      Anmerkung: Je nach Betriebssystem kann Ihre Ausgabe von den Beispielausgaben in diesem Tutorial leicht abweichen. Wenn Sie Windows ausführen, könnte Ihre Ausgabe für dieses erste Beispiel so aussehen: oceanwave.txt.

      Aktuell enthält das Path-Objekt, das der Variable wave zugeordnet ist, einen relative path (relativen Pfad). Anders gesagt kann ocean/wave.txt an mehreren Stellen in unserem Dateisystem vorkommen. Beispielsweise kann die Datei in /Users/user_1/ocean/wave.txt oder /Users/user_2/research/ocean/wave.txt vorhanden sein; wir haben jedoch noch nicht genau angegeben, worauf wir uns beziehen. Ein absoluter Pfad dagegen verweist eindeutig auf einen Speicherort im Dateisystem.

      Mit Path.home() können Sie den absoluten Pfad zum Stammverzeichnis des aktuellen Benutzers abrufen:

      home = Path.home()
      wave_absolute = Path(home, "ocean", "wave.txt")
      print(home)
      print(wave_absolute)
      

      Wenn wir diesen Code ausführen, erhalten wir eine Ausgabe, die der folgenden ähnelt:

      Output

      /Users/sammy /Users/sammy/ocean/wave.txt

      Anmerkung: Wie zuvor erwähnt, wird Ihre Ausgabe je nach Betriebssystem variieren. Auch Ihr Stammverzeichnis wird sich natürlich von /Users/sammy unterscheiden.

      Path.home() gibt eine Path-Instanz mit einem absoluten Pfad zum Stammverzeichnis des aktuellen Benutzers zurück. Dann übergeben wir diese Path-Instanz und die Zeichenfolgen "ocean" und "wave.txt" in einen anderen Path-Konstruktor, um einen absoluten Pfad zur Datei wave.txt zu erstellen. Die Ausgabe zeigt, dass die erste Zeile das Stammverzeichnis ist und die zweite Zeile das Stammverzeichnis plus ocean/wave.txt ist.

      Dieses Beispiel veranschaulicht auch ein wichtiges Merkmal der Path-Klasse: Der Path-Konstruktor akzeptiert sowohl Zeichenfolgen als auch bereits vorhandene Path-Objekte.

      Sehen wir uns die Unterstützung für beide Zeichenfolgen und Path-Objekte im Path-Konstruktor etwas genauer an:

      shark = Path(Path.home(), "ocean", "animals", Path("fish", "shark.txt"))
      print(shark)
      

      Wenn wir diesen Python-Code ausführen, erhalten wir eine Ausgabe wie die folgende:

      Output

      /Users/sammy/ocean/animals/fish/shark.txt

      shark ist ein Path (Pfad) zu einer Datei, die wir sowohl mit beiden Path-Objekten (Path.home() und Path("fish", "shark.txt")) als auch Zeichenfolgen ("ocean" und "animals") erstellt haben. Der Path-Konstruktor behandelt beide Arten von Objekten auf intelligente Weise und verknüpft sie sauber mit dem entsprechenden Betriebssystemtrennzeichen, in dem Fall /.

      Zugriff auf Dateiattribute

      Nachdem wir die Path-Instanzen erstellt haben, erfahren Sie nun, wie Sie diese Instanzen zum Zugriff auf Informationen über eine Datei verwenden können.

      Wir können die Attribute name und suffix zum Zugreifen auf Dateinamen und Dateiendungen nutzen:

      wave = Path("ocean", "wave.txt")
      print(wave)
      print(wave.name)
      print(wave.suffix)
      

      Wenn wir diesen Code ausführen, erhalten wir eine Ausgabe wie die folgende:

      Output

      /Users/sammy/ocean/wave.txt wave.txt .txt

      Diese Ausgabe zeigt, dass der Name der Datei am Ende unseres Pfades wave.txt ist und das Suffix dieser Datei .txt lautet.

      Path-Instanzen bieten außerdem die Funktion with_name, mit der Sie nahtlos ein neues Path-Objekt mit einem anderen Namen erstellen können:

      wave = Path("ocean", "wave.txt")
      tides = wave.with_name("tides.txt")
      print(wave)
      print(tides)
      

      Wenn wir dies ausführen, erhalten wir eine Ausgabe wie die folgende:

      ocean/wave.txt
      ocean/tides.txt
      

      Der Code erstellt zunächst eine Path-Instanz, die auf eine Datei namens wave.txt verweist. Dann rufen wir die Methode with_name für wave auf, um eine zweite Path-Instanz zurückzugeben, die auf eine neue Datei namens tides.txt verweist. Der Verzeichnisteil ocean/ des Pfads bleibt unverändert, sodass der endgültige Pfad ocean/tides.txt lautet.

      Zugriff auf Vorgänger

      Manchmal ist es nützlich, Verzeichnisse aufzurufen, die einen bestimmten Pfad enthalten. Betrachten wir ein Beispiel:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      print(shark)
      print(shark.parent)
      

      Wenn wir diesen Code ausführen, erhalten wir eine Ausgabe, die der folgenden ähnelt:

      Output

      ocean/animals/fish/shark.txt ocean/animals/fish

      Das Attribut parent bei einer Path-Instanz gibt den unmittelbarsten Vorgänger eines bestimmten Dateipfads zurück. In diesem Fall wird das Verzeichnis zurückgegeben, das die Datei shark.txt enthält: ocean/animals/fish.

      Wir können auf das Attribut parent mehrmals hintereinander zugreifen, um die Vorgängerstruktur einer bestimmten Datei nach oben zu durchlaufen:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      print(shark)
      print(shark.parent.parent)
      

      Wenn wir diesen Code ausführen, erhalten wir die folgende Ausgabe:

      Output

      ocean/animals/fish/shark.txt ocean/animals

      Die Ausgabe ähnelt der früheren Ausgabe, doch befinden wir uns nun noch eine Stufe höher, da wir .parent ein zweites Mal aufgerufen haben. Zwei Verzeichnisse nach oben von shark.txt befindet sich das Verzeichnis ocean/animals.

      Verwenden von Glob zum Auflisten von Dateien

      Es ist auch möglich, die Path-Klasse zum Auflisten von Dateien mit der Methode glob zu verwenden.

      Gehen wir davon aus, wir haben eine Verzeichnisstruktur, die so aussieht:

      └── ocean
          ├── animals
          │   └── fish
          │       └── shark.txt
          ├── tides.txt
          └── wave.txt
      

      Ein Verzeichnis ocean enthält die Dateien tides.txt und wave.txt. Wir haben eine Datei namens shark.txt, die unter dem Verzeichnis ocean, einem Verzeichnis animals und einem Verzeichnis fish geschachtelt ist: ocean/animals/fish.

      Um alle .txt-Dateien im Verzeichnis ocean aufzulisten, können wir sagen:

      for txt_path in Path("ocean").glob("*.txt"):
          print(txt_path)
      

      Dieser Code würde eine Ausgabe ergeben wie:

      Output

      ocean/wave.txt ocean/tides.txt

      Das glob-Muster __"*.txt" findet alle Dateien, die auf .txt enden. Da das Codebeispiel dieses Glob im Verzeichnis ocean ausführt, werden die beiden .txt-Dateien im Verzeichnis ocean zurückgegeben: wave.txt und tides.txt.

      Anmerkung: Wenn Sie die in diesem Beispiel angegebenen Ausgaben replizieren möchten, müssen Sie die hier dargestellte Verzeichnisstruktur auf Ihrem Computer nachahmen.

      Wir können die glob-Methode auch rekursiv verwenden. Um alle .txt-Dateien im Verzeichnis ocean und allen seinen Unterverzeichnissen aufzulisten, können wir sagen:

      for txt_path in Path("ocean").glob("**/*.txt"):
          print(txt_path)
      

      Wenn wir diesen Code ausführen, erhalten wir eine Ausgabe wie die folgende:

      Output

      ocean/wave.txt ocean/tides.txt ocean/animals/fish/shark.txt

      Der **-Teil des glob-Musters wird dieses Verzeichnis und alle Verzeichnisse darunter rekursiv abgleichen. Wir erhalten also nicht nur die Dateien wave.txt und tides.txt in der Ausgabe, sondern auch die Datei shark.txt, die unter ocean/animals/fish geschachtelt war.

      Berechnung relativer Pfade

      Wir können die Methode Path.relative_to verwenden, um Pfade in Relation zueinander zu berechnen. Die relative_to-Methode ist zum Beispiel nützlich, wenn Sie einen Teil eines langen Dateipfads abrufen möchten.

      Erwägen Sie folgenden Code:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      below_ocean = shark.relative_to(Path("ocean"))
      below_animals = shark.relative_to(Path("ocean", "animals"))
      print(shark)
      print(below_ocean)
      print(below_animals)
      

      Wenn wir dies ausführen, erhalten wir eine Ausgabe wie die folgende:

      Output

      ocean/animals/fish/shark.txt animals/fish/shark.txt fish/shark.txt

      Die relative_to-Methode gibt ein neues Path-Objekt in Relation zum angegebenen Argument zurück. In unserem Beispiel berechnen wir den Pfad zu shark.txt in Relation zum Verzeichnis ocean und dann in Relation zu den Verzeichnissen ocean und animals.

      Wenn relative_to keine Antwort berechnen kann, da wir ihm einen nicht zugeordneten Pfad geben, wird ein ValueError ausgelöst:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      shark.relative_to(Path("unrelated", "path"))
      

      Wir erhalten eine ValueError-Ausnahme, die von dem Code ausgelöst wurde und ungefähr so aussehen wird:

      Output

      Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/usr/local/lib/Python3.8/pathlib.py", line 899, in relative_to raise ValueError("{!r} does not start with {!r}" ValueError: 'ocean/animals/fish/shark.txt' does not start with 'unrelated/path'

      unrelated/path ist kein Teil von ocean/animals/fish/shark.txt, sodass Python keinen relativen Pfad für uns berechnen kann.

      Zusammenfassung

      Das pathlib-Modul ist eine leistungsfähige Komponente der Python-Standardbibliothek, mit der wir Dateisystempfade bei jedem Betriebssystem schnell bearbeiten können. In diesem Tutorial haben wir gelernt, einige der wichtigsten Dienstprogramme von pathlib zum Aufrufen von Dateiattributen, zum Auflisten von Dateien mit glob-Mustern und Durchlaufen von übergeordneten Dateien und Verzeichnissen zu verwenden.

      Das pathlib-Modul macht zusätzliche Klassen und Dienstprogramme verfügbar, die wir in diesem Tutorial nicht abgedeckt haben. Nachdem Sie nun über Grundkenntnisse verfügen, können Sie die Dokumentation des pathlib-Moduls nutzen, um mehr über andere verfügbare Klassen und Dienstprogramme zu erfahren.

      Wenn Sie daran interessiert sind, andere Python-Bibliotheken zu verwenden, sehen Sie sich die folgenden Tutorials an:



      Source link