One place for hosting & domains

      und

      So sichern, wiederherstellen und migrieren Sie eine MongoDB-Datenbank unter Ubuntu 20.04


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

      Einführung

      MongoDB ist eine der beliebtesten NoSQL-Datenbank-Engines. Es ist bekannt für seine Skalierbarkeit, Robustheit, Zuverlässigkeit und Benutzerfreundlichkeit. In diesem Artikel werden Sie eine Beispiel-MongoDB-Datenbank sichern, wiederherstellen und migrieren.

      Beim Importieren und Exportieren einer Datenbank werden Daten in einem für Menschen lesbaren Format verarbeitet, das mit anderen Softwareprodukten kompatibel ist. Im Gegensatz dazu erstellen oder verwenden die Sicherungs- und Wiederherstellungsvorgänge von MongoDB MongoDB-spezifische Binärdaten, wodurch nicht nur die Konsistenz und Integrität Ihrer Daten, sondern auch die spezifischen MongoDB-Attribute erhalten bleiben. Daher ist es für die Migration normalerweise vorzuziehen, Backup und Wiederherstellung zu verwenden, solange das Quell- und das Zielsystem kompatibel sind.

      Voraussetzungen

      Bevor Sie diesem Tutorial folgen, stellen Sie bitte sicher, dass Sie die folgenden Voraussetzungen erfüllen:

      Sofern nicht anders angegeben, sollten alle Befehle, für die in diesem Tutorial-Root-Berechtigungen erforderlich sind, als Nicht-Root-Benutzer mit Sudo-Berechtigungen ausgeführt werden.

      Schritt 1 — Verwenden von JSON und BSON in MongoDB

      Bevor Sie mit diesem Artikel fortfahren, ist ein grundlegendes Verständnis der Angelegenheit erforderlich. Wenn Sie Erfahrung mit anderen NoSQL-Datenbanksystemen wie Redis haben, können Sie bei der Arbeit mit MongoDB einige Ähnlichkeiten feststellen.

      MongoDB verwendet die Formate JSON und BSON (binäres JSON) zum Speichern seiner Informationen. JSON ist das für Menschen lesbare Format, das sich perfekt zum Exportieren und eventuell zum Importieren Ihrer Daten eignet. Sie können Ihre exportierten Daten mit jedem Tool, das JSON unterstützt, einschließlich eines einfachen Texteditors, weiter verwalten.

      Ein Beispiel-JSON-Dokument sieht folgendermaßen aus:

      Example of JSON Format

      {"address":[
          {"building":"1007", "street":"Park Ave"},
          {"building":"1008", "street":"New Ave"},
      ]}
      

      JSON ist zum Arbeiten praktisch, unterstützt jedoch nicht alle in BSON verfügbaren Datentypen. Dies bedeutet, dass es bei Verwendung von JSON zu einem sogenannten „Verlust der Wiedergabetreue“ der Informationen kommt. Zum Sichern und Wiederherstellen ist es besser, das binäre BSON zu verwenden.

      Zweitens müssen Sie sich nicht um die explizite Erstellung einer MongoDB-Datenbank kümmern. Wenn die für den Import angegebene Datenbank noch nicht vorhanden ist, wird sie automatisch erstellt. Noch besser ist die Struktur der Sammlungen (Datenbanktabellen). Im Gegensatz zu anderen Datenbank-Engines wird in MongoDB die Struktur beim Einfügen des ersten Dokuments (Datenbankzeile) automatisch neu erstellt.

      Drittens kann das Lesen oder Einfügen großer Datenmengen, wie z. B. die Aufgaben dieses Artikels, in MongoDB ressourcenintensiv sein und einen Großteil Ihrer CPU, Ihres Arbeitsspeichers und Ihres Speicherplatzes beanspruchen. Dies ist entscheidend, da MongoDB häufig für große Datenbanken und Big Data verwendet wird. Die einfachste Lösung für dieses Problem besteht darin, die Exporte und Sicherungen während der Nacht oder außerhalb der Stoßzeiten auszuführen.

      Viertens kann die Informationskonsistenz problematisch sein, wenn Sie einen ausgelasteten MongoDB-Server haben, auf dem sich die Informationen während des Datenbankexports oder -sicherungsprozesses ändern. Eine mögliche Lösung für dieses Problem ist die Replikation, die Sie möglicherweise in Betracht ziehen, wenn Sie mit dem Thema MongoDB fortfahren.

      Während Sie die Import- und Exportfunktionen zum Sichern und Wiederherstellen Ihrer Daten verwenden können, gibt es bessere Möglichkeiten, um die vollständige Integrität Ihrer MongoDB-Datenbanken sicherzustellen. Um Ihre Daten zu sichern, sollten Sie den Befehl mongodump verwenden. Zum Wiederherstellen verwenden Sie mongorestore. Sehen wir uns an, wie sie funktionieren.

      Schritt 2 – Verwenden von mongodump zum Sichern einer MongoDB-Datenbank

      Lassen Sie uns zuerst das Sichern Ihrer MongoDB-Datenbank behandeln.

      Ein wesentliches Argument für mongodump ist --db, das den Namen der Datenbank angibt, die Sie sichern möchten. Wenn Sie keinen Datenbanknamen angeben, sichert mongodump alle Ihre Datenbanken. Das zweite wichtige Argument ist --out, das das Verzeichnis definiert, in das die Daten gespeichert werden. Lassen Sie uns beispielsweise die newdb-Datenbank sichern und im Verzeichnis /var/backups/mongobackups speichern. Im Idealfall haben wir jedes unserer Backups in einem Verzeichnis mit dem aktuellen Datum wie /var/backups/mongobackups/10-29-20.

      Erstellen Sie zuerst dieses Verzeichnis /var/backups/mongobackups:

      • sudo mkdir /var/backups/mongobackups

      Führen Sie dann mongodump aus:

      • sudo mongodump --db newdb --out /var/backups/mongobackups/`date +"%m-%d-%y"`

      Sie werden eine Ausgabe wie diese sehen:

      Output

      2020-10-29T19:22:36.886+0000 writing newdb.restaurants to 2020-10-29T19:22:36.969+0000 done dumping newdb.restaurants (25359 documents)

      Beachten Sie, dass wir im obigen Verzeichnispfad das Datum + „%m-%d-%y“ verwendet haben, das automatisch das aktuelle Datum abruft. Auf diese Weise können wir Backups im Verzeichnis wie /var/backups/10-29-20/ erstellen. Dies ist besonders praktisch, wenn wir die Backups automatisieren.

      An diesem Punkt verfügen Sie über eine vollständige Sicherung der newdb-Datenbank im Verzeichnis /var/backups/mongobackups/10-29-20/newdb/. Dieses Backup verfügt über alles, um newdb richtig zu restaurieren und ihre sogenannte „Treue“ zu erhalten.

      In der Regel sollten Sie regelmäßige Sicherungen durchführen, vorzugsweise wenn der Server am wenigsten ausgelastet ist. Auf diese Weise können Sie den Befehl mongodump als Cron-Job festlegen, sodass er regelmäßig ausgeführt wird, z. B. jeden Tag um 03:03 Uhr.

      Um dies zu erreichen, öffnen Sie Crontab, Cron’s Editor:

      Beachten Sie, dass Sie beim Ausführen von sudo crontab die Cron-Jobs für den Root-Benutzer bearbeiten. Dies wird empfohlen, da die Crons für Ihren Benutzer möglicherweise nicht ordnungsgemäß ausgeführt werden, insbesondere wenn für Ihr Sudo-Profil eine Passwortüberprüfung erforderlich ist.

      Fügen Sie in die Crontab-Eingabeaufforderung den folgenden mongodump-Befehl ein:

      crontab

      3 3 * * * mongodump --out /var/backups/mongobackups/`date +"%m-%d-%y"`
      

      Im obigen Befehl lassen wir das Argument --db absichtlich weg, da Sie typischerweise alle Ihre Datenbanken gesichert werden möchten.

      Abhängig von Ihrer MongoDB-Datenbankgröße wird Ihnen möglicherweise bald der Speicherplatz mit zu vielen Backups ausgehen. Aus diesem Grund wird auch empfohlen, die alten Backups regelmäßig zu bereinigen oder zu komprimieren.

      Um beispielsweise alle Backups zu löschen, die älter als sieben Tage sind, können Sie den folgenden Bash-Befehl verwenden:

      • find /var/backups/mongobackups/ -mtime +7 -exec rm -rf {} ;

      Ähnlich wie beim vorherigen mongodump-Befehl können Sie diesen auch als Cron-Job hinzufügen. Er sollte kurz vor dem Start des nächsten Backups ausgeführt werden, z. B. um 03:01 Uhr. Öffnen Sie zu diesem Zweck crontab erneut:

      Fügen Sie danach die folgende Zeile ein:

      crontab

      1 3 * * * find /var/backups/mongobackups/ -mtime +7 -exec rm -rf {} ;
      

      Speichern und schließen Sie die Datei.

      Wenn Sie alle Aufgaben in diesem Schritt ausführen, wird eine ordnungsgemäße Backup-Lösung für Ihre MongoDB-Datenbanken sichergestellt.

      Schritt 3 – Verwenden von mongorestore zum Wiederherstellen und Migrieren einer MongoDB-Datenbank

      Wenn Sie Ihre MongoDB-Datenbank aus einem früheren Backup wiederherstellen, wird die genaue Kopie Ihrer MongoDB-Informationen zu einem bestimmten Zeitpunkt erstellt, einschließlich aller Indizes und Datentypen. Dies ist besonders nützlich, wenn Sie Ihre MongoDB-Datenbanken migrieren möchten. Zum Wiederherstellen von MongoDB verwenden wir den Befehl mongorestore, der mit den binären Backups funktioniert, die mongodump produziert.

      Lassen Sie uns unsere Beispiele mit der newdb-Datenbank fortsetzen und sehen, wie wir sie aus dem zuvor erstellten Backup wiederherstellen können. Wir geben zuerst den Namen der Datenbank mit dem Argument --nsInclude an. Wir verwenden newdb.* zum Wiederherstellen aller Sammlungen. Um eine einzelne Sammlung wie Restaurants wiederherzustellen, verwenden Sie stattdessen newdb.restaurants.

      Wenn wir dann --drop verwenden, stellen wir sicher, dass die Zieldatenbank zuerst weggelassen wird, sodass das Backup in einer sauberen Datenbank wiederhergestellt wird. Als letztes Argument geben wir das Verzeichnis des letzten Backups an, das in etwa so aussieht: /var/backups/mongobackups/10-29-20/newdb/.

      Sobald Sie ein zeitgestempeltes Backup haben, können Sie dieses mit folgendem Befehl wiederherstellen:

      • sudo mongorestore --db newdb --drop /var/backups/mongobackups/10-29-20/newdb/

      Sie werden eine Ausgabe wie diese sehen:

      Output

      2020-10-29T19:25:45.825+0000 the --db and --collection args should only be used when restoring from a BSON file. Other uses are deprecated and will not exist in the future; use --nsInclude instead 2020-10-29T19:25:45.826+0000 building a list of collections to restore from /var/backups/mongobackups/10-29-20/newdb dir 2020-10-29T19:25:45.829+0000 reading metadata for newdb.restaurants from /var/backups/mongobackups/10-29-20/newdb/restaurants.metadata.json 2020-10-29T19:25:45.834+0000 restoring newdb.restaurants from /var/backups/mongobackups/10-29-20/newdb/restaurants.bson 2020-10-29T19:25:46.130+0000 no indexes to restore 2020-10-29T19:25:46.130+0000 finished restoring newdb.restaurants (25359 documents) 2020-10-29T19:25:46.130+0000 done

      Im obigen Fall stellen wir die Daten auf demselben Server wieder her, auf dem wir das Backup erstellt haben. Wenn Sie die Daten auf einen anderen Server migrieren und dieselbe Technik verwenden möchten, sollten Sie das Backup-Verzeichnis, in unserem Fall /var/backups/mongobackups/10-29-20/newdb/, auf den anderen Server kopieren.

      Zusammenfassung

      Sie haben jetzt einige wichtige Aufgaben im Zusammenhang mit dem Sichern, Wiederherstellen und Migrieren Ihrer MongoDB-Datenbanken ausgeführt. Kein Produktions-MongoDB-Server sollte jemals ohne eine zuverlässige Backup-Strategie wie die hier beschriebene ausgeführt werden.



      Source link

      So importieren und exportieren Sie eine MongoDB-Datenbank unter Ubuntu 20.04


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

      Einführung

      MongoDB ist eine der beliebtesten NoSQL-Datenbank-Engines. Es ist berühmt für seine Skalierbarkeit, Leistung, Zuverlässigkeit und Benutzerfreundlichkeit. In diesem Artikel zeigen wir Ihnen, wie Sie Ihre MongoDB-Datenbanken importieren und exportieren.

      Wir sollten klarstellen, dass unter Import und Export diejenigen Vorgänge zu verstehen sind, die Daten in einem für Menschen lesbaren Format verarbeiten, das mit anderen Softwareprodukten kompatibel ist. Im Gegensatz dazu erstellen oder verwenden die Sicherungs- und Wiederherstellungsvorgänge MongoDB-spezifische Binärdaten, wodurch die Konsistenz und Integrität Ihrer Daten sowie deren spezifische MongoDB-Attribute erhalten bleiben. Daher ist es für die Migration normalerweise vorzuziehen, Backup und Wiederherstellung zu verwenden, solange das Quell- und das Zielsystem kompatibel sind.

      Backup-, Wiederherstellungs- und Migrationsaufgaben gehen über den Rahmen dieses Artikels hinaus. Weitere Informationen finden Sie unter So sichern Sie eine MongoDB-Datenbank unter Ubuntu 20.04.

      Voraussetzungen

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

      Schritt 1 — Importieren von Informationen in MongoDB

      Um zu erfahren, wie Informationen in MongoDB importiert werden, verwenden wir eine beliebte Beispiel-MongoDB-Datenbank über Restaurants. Sie ist im .json-Format und kann mit wget wie folgt heruntergeladen werden:

      • wget https://raw.githubusercontent.com/mongodb/docs-assets/primer-dataset/primer-dataset.json

      Sobald der Download abgeschlossen ist, sollten Sie eine Datei mit dem Namen primer-dataset.json (12 MB Größe) im aktuellen Verzeichnis haben. Importieren wir die Daten aus dieser Datei in eine neue Datenbank namens newdb und in eine Sammlung mit dem Namen Restaurants.

      Verwenden Sie den Befehl mongoimport wie folgt:

      • sudo mongoimport --db newdb --collection restaurants --file primer-dataset.json

      Das Ergebnis sieht folgendermaßen aus:

      Output

      2020-11-11T19:37:55.607+0000 connected to: mongodb://localhost/ 2020-11-11T19:37:57.841+0000 25359 document(s) imported successfully. 0 document(s) failed to import

      Wie der obige Befehl zeigt, wurden 25359 Dokumente importiert. Da wir keine Datenbank mit dem Namen newdb haben, hat MongoDB sie automatisch erstellt.

      Überprüfen wir den Import.

      Stellen Sie eine Verbindung mit der neu erstellten newdb-Datenbank her:

      Sie sind nun mit der newdb-Datenbankinstanz verbunden. Beachten Sie, dass sich Ihre Eingabeaufforderung geändert hat, was anzeigt, dass Sie mit der Datenbank verbunden sind.

      Zählen Sie die Dokumente in der Sammlung Restaurants mit dem Befehl:

      Das Ergebnis zeigt 25359, was die Anzahl importierter Dokumente ist. Für eine noch bessere Überprüfung können Sie das erste Dokument aus der Sammlung Restaurants wie folgt auswählen:

      Das Ergebnis sieht folgendermaßen aus:

      [secondary label Output]
      {
          "_id" : ObjectId("5fac3d937f12c471b3f26733"),
          "address" : {
              "building" : "1007",
              "coord" : [
                  -73.856077,
                  40.848447
              ],
              "street" : "Morris Park Ave",
              "zipcode" : "10462"
          },
          "borough" : "Bronx",
          "cuisine" : "Bakery",
          "grades" : [
              {
                  "date" : ISODate("2014-03-03T00:00:00Z"),
                  "grade" : "A",
                  "score" : 2
              },
      ...
          ],
          "name" : "Morris Park Bake Shop",
          "restaurant_id" : "30075445"
      }
      

      Eine solche detaillierte Überprüfung kann Probleme mit den Dokumenten wie ihrem Inhalt, der Codierung usw. enthüllen. Das Format json verwendet UTF-8-Codierung und Ihre Exporte und Importe sollten in dieser Codierung vorhanden sein. Denken Sie daran, wenn Sie die json-Dateien manuell bearbeiten. Andernfalls verarbeitet MongoDB dies automatisch für Sie.

      Um die MongoDB-Eingabeaufforderung zu beenden, geben Sie exit an die Eingabeaufforderung ein:

      Sie werden als non-root user zur normalen Befehlszeilenaufforderung zurückgegeben.

      Schritt 2 — Exportieren von Informationen aus MongoDB

      Wie bereits erwähnt, können Sie durch den Export von MongoDB-Informationen eine für Menschen lesbare Textdatei mit Ihren Daten abrufen. Standardmäßig werden Informationen im JSON-Format exportiert. Sie können sie jedoch auch nach CSV exportieren (durch Kommas getrennter Wert).

      Um Informationen aus MongoDB zu exportieren, verwenden Sie den Befehl mongoexport. Es ermöglicht Ihnen, einen sehr feinkörnigen Export zu exportieren, sodass Sie eine Datenbank, eine Sammlung, ein Feld und sogar eine Abfrage für den Export angeben können.

      Ein einfaches mongoexport-Beispiel wäre die Sammlung Restaurants aus der newdb-Datenbank, die wir zuvor importiert haben. Dies kann wie folgt erfolgen:

      • sudo mongoexport --db newdb -c restaurants --out newdbexport.json

      Im obigen Befehl verwenden wir --db, um die Datenbank -c für die Sammlung und --out für die Datei zu spezifizieren, in der die Daten gespeichert werden.

      Die Ausgabe eines erfolgreichen mongoexport sollte folgendermaßen aussehen:

      Output

      2020-11-11T19:39:57.595+0000 connected to: mongodb://localhost/ 2020-11-11T19:39:58.619+0000 [###############.........] newdb.restaurants 16000/25359 (63.1%) 2020-11-11T19:39:58.871+0000 [########################] newdb.restaurants 25359/25359 (100.0%) 2020-11-11T19:39:58.871+0000 exported 25359 records

      Die obige Ausgabe zeigt, dass 25359 Dokumente importiert wurden, die gleiche Anzahl wie die importierten sind.

      In einigen Fällen müssen Sie möglicherweise nur einen Teil Ihrer Sammlung exportieren. Angesichts der Struktur und den Inhalt der Restaurants-json-Datei exportieren wir alle Restaurants, die die Kriterien erfüllen, die sich in der Bronx befinden und chinesische Küche anbieten. Wenn wir diese Informationen direkt während der Verbindung mit MongoDB erhalten möchten, stellen Sie erneut eine Verbindung zur Datenbank her:

      Verwenden Sie dann diese Abfrage:

      • db.restaurants.find( { "borough": "Bronx", "cuisine": "Chinese" } )

      Die Ergebnisse werden dem Terminal angezeigt:

      Output

      • 2020-12-03T01:35:25.366+0000 connected to: mongodb://localhost/
      • 2020-12-03T01:35:25.410+0000 exported 323 records

      Um die MongoDB-Eingabeaufforderung zu beenden, geben Sie exit ein:

      Wenn Sie die Daten von einer sudo-Befehlszeile exportieren möchten, anstatt mit der Datenbank verbunden zu sein, machen Sie die vorherige Abfrage zu einem Teil des mongoexport-Befehls, indem Sie sie für das Argument -q wie folgt angeben:

      • sudo mongoexport --db newdb -c restaurants -q "{"borough": "Bronx", "cuisine": "Chinese"}" --out Bronx_Chinese_retaurants.json

      Beachten Sie, dass wir die doppelten Anführungszeichen mit Backslash () in der Abfrage umgehen. Ähnlich müssen Sie alle anderen Sonderzeichen in der Abfrage umgehen.

      Wenn der Export erfolgreich war, sollte das Ergebnis folgendermaßen aussehen:

      Output

      2020-11-11T19:49:21.727+0000 connected to: mongodb://localhost/ 2020-11-11T19:49:21.765+0000 exported 323 records

      Das obige Beispiel zeigt, dass 323 Datensätze exportiert wurden, und Sie können sie in der von uns angegebenen Datei Bronx_Chinese_retaurants.json finden.

      Verwenden Sie cat und less, um die Daten zu durchsuchen:

      • cat Bronx_Chinese_retaurants.json | less

      Verwenden Sie SPACE, um die Daten zu übermitteln:

      Output

      • date":{"$date":"2015-01-14T00:00:00Z"},"grade":"Z","score":36}],"na{"_id":{"$oid":"5fc8402d141f5e54f9054f8d"},"address":{"building":"1236","coord":[-73.8893654,40.81376179999999],"street":"238 Spofford Ave","zipcode":"10474"},"borough":"Bronx","cuisine":"Chinese","grades":[{"date":{"$date":"2013-12-30T00:00:00Z"},"grade":"A","score":8},{"date":{"$date":"2013-01-08T00:00:00Z"},"grade":"A","score":10},{"date":{"$date":"2012-06-12T00:00:00Z"},"grade":"B","score":15}],
      • . . .

      Drücken Sie q, um zu beenden. Sie können nun eine MongoDB-Datenbank importieren und exportieren.

      Zusammenfassung

      Dieser Artikel hat Sie in die Grundlagen zum Importieren und Exportieren von Informationen zu und aus einer MongoDB-Datenbank eingeführt. Sie können weitere Informationen über So sichern Sie eine MongoDB-Datenbank unter Ubuntu 20.04 lesen.

      Sie können auch die Replikation berücksichtigen. Durch die Replikation können Sie Ihren MongoDB-Dienst ohne Unterbrechung von einem Slave-MongoDB-Server aus fortsetzen, während Sie den Master-Dienst nach einem Fehler wiederherstellen. Teil der Replikation ist das Betriebsprotokoll (oplog), das alle Operationen aufzeichnet, die Ihre Daten ändern. Sie können dieses Protokoll genauso verwenden wie das Binärprotokoll in MySQL, um Ihre Daten nach dem letzten Backup wiederherzustellen. Denken Sie daran, dass Backups normalerweise nachts stattfinden. Wenn Sie sich entscheiden, abends einen Backup wiederherzustellen, fehlen Ihnen alle Aktualisierungen seit dem letzten Backup.



      Source link

      So indexieren und trennen Sie Zeichenfolgen in Python 3


      Einführung

      Der Python-Zeichenfolgen-Datentyp ist eine Sequenz, die aus einem oder mehreren einzelnen Zeichen besteht, die aus Buchstaben, Zahlen, Leerzeichen oder Symbolen bestehen können. Da es sich bei einer Zeichenfolge um eine Sequenz handelt, kann durch Indizieren und Schneiden auf dieselbe Weise wie bei anderen sequenzbasierten Datentypen auf sie zugegriffen werden.

      Dieses Tutorial führt Sie durch den Zugriff auf Zeichenfolgen durch Indizieren, sie durch ihre Zeichenfolgen schneiden und einige Zähl- und Zeichenortungsmethoden durchgehen.

      Wie Zeichenfolgen indiziert sind

      Wie der Listendatentyp mit Elementen, die einer Indexnummer entsprechen, entspricht auch jedes Zeichen einer Zeichenfolge einer Indexnummer, beginnend mit der Indexnummer 0.

      Für die Zeichenfolge Sammy Shark! die Indexaufschlüsselung sieht folgendermaßen aus:

      S a m m y S h a r k !
      0 1 2 3 4 5 6 7 8 9 10 11

      Wie Sie sehen können, beginnt das erste S bei Index 0 und die Zeichenfolge endet bei Index 11 mit dem ! -Symbol.

      Wir bemerken auch, dass das Leerzeichen zwischen Sammy und Shark auch seiner eigenen Indexnummer entspricht. In diesem Fall beträgt die dem Leerzeichen zugeordnete Indexnummer 5.

      Das Ausrufezeichen (!) hat auch eine Indexnummer zugeordnet. Alle anderen Symbole oder Satzzeichen wie *#$&. ;?, ist ebenfalls ein Zeichen und würde mit einer eigenen Indexnummer verknüpft.

      Die Tatsache, dass jedes Zeichen in einer Python-Zeichenfolge eine entsprechende Indexnummer hat, ermöglicht es uns, auf Zeichenfolgen auf dieselbe Weise wie bei anderen sequentiellen Datentypen zuzugreifen und diese zu bearbeiten.

      Zugriff auf Zeichen nach positiver Indexnummer

      Durch Verweisen von Indexnummern können wir eins der Zeichen in einer Zeichenfolge isolieren. Wir tun dies durch Einfügen der Indexnummern in quadratische Klammern. Lassen Sie uns eine Zeichenfolge deklarieren, drucken und die Indexnummer in quadratischen Klammern aufrufen:

      ss = "Sammy Shark!"
      print(ss[4])
      

      Output

      y

      Wenn wir auf eine bestimmte Indexnummer einer Zeichenfolge verweisen, gibt Python das Zeichen zurück, das sich in dieser Position befindet. Da sich der Buchstabe y an der Indexnummer 4 der Zeichenfolge ss = „Sammy Shark!“ befindet, erhalten wir beim Drucken von ss [4] y als Ausgabe.

      Indexnummern ermöglichen es uns, auf bestimmte Zeichen innerhalb einer Zeichenfolge zuzugreifen.

      Zugriff auf Zeichen nach negativer Indexnummer

      Wenn wir eine lange Zeichenfolge haben und ein Element am Ende anlegen möchten, können wir auch am Ende der Zeichenfolge rückwärts zählen, beginnend mit der Indexnummer -1.

      Für die gleiche Zeichenfolge Sammy Shark! sieht die negative Indexaufschlüsselung folgendermaßen aus:

      S a m m y S h a r k !
      -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

      Durch die Verwendung negativer Indexzahlen können wir das Zeichen r ausdrucken, indem wir uns wie folgt auf seine Position am -3-Index beziehen:

      print(ss[-3])
      

      Output

      r

      Die Verwendung negativer Indexnummern kann nützlich sein, um ein einzelnes Zeichen am Ende einer langen Zeichenfolge zu isolieren.

      Schneiden von Zeichenfolgen

      Wir können auch eine Reihe von Zeichen aus der Zeichenfolge aufrufen. Angenommen, wir möchten nur das Wort Shark drucken. Wir können dies tun, indem wir eine Scheibeerstellen, die eine Folge von Zeichen innerhalb einer ursprünglichen Zeichenfolge ist. Mit Scheiben können wir mehrere Zeichenwerte aufrufen, indem wir einen Bereich von Indexnummern erstellen, die durch einen Doppelpunkt [x:y] getrennt sind:

      print(ss[6:11])
      

      Output

      Shark

      Beim Erstellen einer Scheibe wie in [6:11] beginnt bei der ersten Indexnummer die Scheibe (einschließlich), und bei der zweiten Indexnummer endet die Scheibe (exklusiv), weshalb in unserem obigen Beispiel der Bereich der Indexnummer gilt, der unmittelbar nach dem Ende der Zeichenfolge auftreten würde.

      Beim Schneiden von Zeichenfolgen erstellen wir eine Teilzeichenfolge, bei der es sich im Wesentlichen um eine Zeichenfolge handelt, die in einer anderen Zeichenfolge vorhanden ist. Wenn wir ss[6:11] aufrufen, rufen wir den Teilstring Shark auf, der in der Zeichenfolge Sammy Shark! vorhanden ist.

      Wenn wir eines der Enden einer Zeichenfolge einschließen möchten, können wir eine der Zahlen in der ZeichenfolgenSyntax [n:n] auslassen. Wenn wir beispielsweise das erste Wort der Zeichenfolge ss – „Sammy“ – drucken möchten, können Sie dies tun, indem Sie Folgendes eingeben:

      print(ss[:5])
      

      Output

      Sammy

      Dazu haben wir die Indexnummer vor dem Doppelpunkt in der Scheiben-Syntax weggelassen und nur die Indexnummer nach dem Doppelpunkt eingefügt, die sich auf das Ende der Teilzeichenfolge bezieht.

      Um eine Teilzeichenfolge zu drucken, die in der Mitte einer Zeichenfolge beginnt und bis zum Ende druckt, können Sie dazu nur die Indexnummer vor dem Doppelpunkt einfügen:

      print(ss[7:])
      

      Output

      hark!

      Indem nur die Indexnummer vor dem Doppelpunkt eingefügt und die zweite Indexnummer aus der Syntax herausgelassen wird, wechselt die Teilzeichenfolge vom Zeichen der aufgerufenen Indexnummer zum Ende der Zeichenfolge.

      Sie können auch negative Indexnummern verwenden, um eine Zeichenfolge zu trennen. Wie bereits erwähnt, beginnen negative Indexzahlen einer Zeichenfolge bei -1 und zählen von dort herunter, bis wir den Anfang der Zeichenfolge erreichen. Wenn man negative Indexzahlen verwendet, beginnen wir zuerst mit der niedrigeren Zahl, wie sie früher in der Zeichenfolge vorkommt.

      Verwenden wir zwei negative Indexzahlen, um die Zeichenfolge ss zu schneiden:

      print(ss[-4:-1])
      

      Output

      ark

      Die Teilzeichenfolge „Arche“ ist aus der Zeichenfolge „Sammy Shark!“ , weil das Zeichen „a“ an der Position der Indexnummer -4 auftritt und das Zeichen „k“ unmittelbar vor der Position der Indexnummer -1 auftritt.

      Festlegen des Schrittes beim Schneiden von Zeichenfolgen

      Das Schneiden von Zeichenfolgen kann zusätzlich zu zwei Indexnummern einen dritten Parameter akzeptieren. Der dritte Parameter gibt den Schritt an, der angibt, wie viele Zeichen vorwärts bewegt werden sollen, nachdem das erste Zeichen aus der Zeichenfolge abgerufen wurde. Bisher haben wir den Schrittparameter weggelassen, und Python verwendet standardmäßig den Schritt 1, sodass jedes Zeichen zwischen zwei Indexnummern abgerufen wird.

      Schauen wir uns noch einmal das obige Beispiel an, in dem die Teilzeichenfolge „Shark“ ausgedruckt wird:

      print(ss[6:11])
      

      Output

      Shark

      Wir können die gleichen Ergebnisse erzielen, indem wir einen dritten Parameter mit einem Schritt von 1 einfügen:

      print(ss[6:11:1])
      

      Output

      Shark

      Ein Schritt von 1 nimmt also jedes Zeichen zwischen zwei Indexnummern eines Schrittes auf. Wenn wir den Schrittparameter weglassen, wird Python standardmäßig mit 1 angegeben.

      Wenn wir stattdessen den Schritt erhöhen, sehen wir, dass Zeichen übersprungen werden:

      print(ss[0:12:2])
      

      Output

      SmySak

      Die Angabe des Schrittes 2 als letzter Parameter in der Python-Syntax ss[0:12:2] überspringt jedes zweite Zeichen. Schauen wir uns die Zeichen an, die in rot ausgedruckt werden:

      Sammy Shark!

      Beachten Sie, dass das Leerzeichen bei der Indexnummer 5 auch mit einem angegebenen Schritt von 2 übersprungen wird.

      Wenn wir eine größere Zahl für unseren Schrittparameter verwenden, haben wir eine deutlich kleinere Teilzeichenfolge:

      print(ss[0:12:4])
      

      Output

      Sya

      Die Angabe des Schrittes 4 als letzter Parameter in der Python-Syntax ss[0:12:4] druckt nur jedes vierte Zeichen. Schauen wir uns nochmals die Zeichen an, die in rot ausgedruckt werden:

      Sammy Shark!

      In diesem Beispiel wird auch das Leerzeichen übersprungen.

      Da wir die gesamte Zeichenfolge drucken, können wir die beiden Indexnummern weglassen und die beiden Doppelpunkte in der Syntax behalten, um das gleiche Ergebnis zu erzielen:

      print(ss[::4])
      

      Output

      Sya

      Durch Weglassen der beiden Indexnummern und Beibehalten von Doppelpunkten bleibt die gesamte Zeichenfolge im Bereich, während durch Hinzufügen eines letzten Parameters für den Schritt die Anzahl der zu überspringenden Zeichen angegeben wird.

      Zusätzlich können Sie einen negativen numerischen Wert für den Schritt angeben, mit dem wir die ursprüngliche Zeichenfolge in umgekehrter Reihenfolge drucken können, wenn wir den Schritt auf -1 setzen:

      print(ss[::-1])
      

      Output

      !krahS ymmaS

      Die beiden Doppelpunkte ohne angegebenen Parameter enthalten alle Zeichen aus der ursprünglichen Zeichenfolge. Ein Schritt von 1 enthält alle Zeichen ohne Überspringen. Wenn Sie diesen Schritt negieren, wird die Reihenfolge der Zeichen umgekehrt.

      Lassen Sie uns dies erneut tun, aber mit einem Schritt von -2:

      print(ss[::-2])
      

      Output

      !rh ma

      In diesem Beispiel, ss[::-2], handelt es sich um die Gesamtheit der ursprünglichen Zeichenfolge, da in den Parametern keine Indexnummern enthalten sind, und die Umkehrung der Zeichenfolge durch den negativen Schritt. Außerdem überspringen wir mit einem Schritt von -2 jeden zweiten Buchstaben der umgekehrten Zeichenfolge:

      ! krahS[Leerzeichen]ymmaS

      Das Leerzeichen wird in diesem Beispiel ausgedruckt.

      Indem Sie den dritten Parameter der Python-Scheiben-Syntax angeben, geben Sie den Schritt der Teilzeichenfolge an, den Sie aus der ursprünglichen Zeichenfolge ziehen.

      Zählmethoden

      Während wir über die relevanten Indexnummern nachdenken, die Zeichen in Zeichenfolgen entsprechen, lohnt es sich, einige der Methoden durchzugehen, die Zeichenfolgen zählen oder Indexnummern zurückgeben. Dies kann nützlich sein, um die Anzahl der Zeichen zu begrenzen, die wir in einem Benutzereingabeformular akzeptieren möchten, oder um Zeichenfolgen zu vergleichen. Wie bei anderen sequentiellen Datentypen können Zeichenfolgen mit verschiedenen Methoden gezählt werden.

      Wir werden uns zunächst die len() -Methode ansehen, mit der die Länge jedes Datentyps ermittelt werden kann, der eine geordnete oder ungeordnete Sequenz ist, einschließlich Zeichenfolgen, Listen, Tupeln und Wörterbüchern.

      Drucken wir die Länge der Zeichenfolge ss:

      print(len(ss))
      

      Output

      12

      Die Länge der Zeichenfolge „Sammy Shark!“ ist 12 Zeichen lang, einschließlich des Leerzeichens und des Ausrufezeichens.

      Anstatt eine Variable zu verwenden, können wir auch eine Zeichenfolge direkt an die len() -Methode übergeben:

      print(len("Let's print the length of this string."))
      

      Output

      38

      Die len() -Methode zählt die Gesamtzahl der Zeichen innerhalb einer Zeichenfolge.

      Wenn wir zählen möchten, wie oft entweder ein bestimmtes Zeichen oder eine Folge von Zeichen in einer Zeichenfolge angezeigt wird, können wir dies mit der str.count()-Methode tun. Arbeiten wir mit unserer Zeichenfolge ss = „Sammy Shark!“ und zählen die Anzahl der erscheinenden Zeichen „a“:

      print(ss.count("a"))
      

      Output

      2

      Wir können nach einem anderen Zeichen suchen:

      print(ss.count("s"))
      

      Output

      0

      Obwohl sich der Buchstabe „S“ in der Zeichenfolge befindet, ist es wichtig zu beachten, dass bei jedem Zeichen zwischen Groß- und Kleinschreibung unterschieden wird. Wenn wir unabhängig von der Groß- und Kleinschreibung nach allen Buchstaben in einer Zeichenfolge suchen möchten, können wir die Zeichenfolge mit der str.lower() -Methode zuerst in Kleinbuchstaben konvertieren. Weitere Informationen zu dieser Methode finden Sie unter „Eine Einführung in Zeichenfolgenmethoden in Python 3“.

      Versuchen wir str.count() mit einer Sequenz von Zeichen:

      likes = "Sammy likes to swim in the ocean, likes to spin up servers, and likes to smile."
      print(likes.count("likes"))
      

      Output

      3

      In den Zeichenfolgen likes kommt die Zeichenfolge, die „likes“ entspricht, in der ursprünglichen Zeichenfolge dreimal vor.

      Wir können auch herausfinden, an welcher Position ein Zeichen oder eine Zeichenfolge in einer Zeichenfolge vorkommt. Wir können dies mit der str.find()-Methode tun, die die Position des Zeichens basierend auf der Indexnummer zurückgibt.

      Wir können überprüfen, wo das erste „m“ in der Zeichenfolge ss vorkommt:

      print(ss.find("m"))
      

      Ouput

      2

      Das erste Zeichen „m“ tritt an der Indexposition 2 in der Zeichenfolge „Sammy Shark!“ auf. Wir können die Indexnummerpositionen der oben beschriebenen Zeichenfolge ss überprüfen.

      Überprüfen wir, wo die erste Zeichenfolge „likes“ in der Zeichenfolge likes vorkommt:

      print(likes.find("likes"))
      

      Ouput

      6

      Die erste Instanz der Zeichenfolge „likes“ beginnt an der Indexnummernposition 6, an der sich das Zeichen l der Sequenz likes befindet.

      Was, wenn wir sehen möchten, wo die zweite Sequenz von „likes“ beginnt? Wir können dazu einen zweiten Parameter an die str.find()-Methode übergeben, die mit einer bestimmten Indexnummer beginnt. Anstatt also am Anfang der Zeichenfolge zu beginnen, beginnen wir nach der Indexnummer 9:

      print(likes.find("likes", 9))
      

      Output

      34

      In diesem zweiten Beispiel, das an der Indexnummer 9 beginnt, beginnt das erste Ereignis der Zeichenfolge „likes“ bei der Indexnummer 34.

      Zusätzlich können wir ein Ende für den Bereich als dritten Parameter angeben. Wie beim Schneiden können wir dies tun, indem wir mit einer negativen Indexzahl rückwärts zählen:

      print(likes.find("likes", 40, -6))
      

      Output

      64

      Dieses letzte Beispiel sucht nach der Position der Sequenz „likes“ zwischen den Indexnummern 40 und -6. Da der letzte eingegebene Parameter eine negative Zahl ist, zählt er vom Ende der ursprünglichen Zeichenfolge.

      Die Zeichenfolgemethoden len(), str.count() und str.find() können verwendet werden, um die Länge, die Zählungen von Zeichen oder Zeichenfolgen sowie Indexpositionen von Zeichen oder Zeichenfolgen in Zeichenfolgen zu bestimmen.

      Zusammenfassung

      Die Möglichkeit, bestimmte Indexnummern von Zeichenfolgen oder eine bestimmte Scheibe einer Zeichenfolge aufzurufen, bietet uns eine größere Flexibilität bei der Arbeit mit diesem Datentyp. Da Zeichenfolgen wie Listen und Tupel ein sequenzbasierter Datentyp sind, kann durch Indizieren und Schneiden auf sie zugegriffen werden.

      Sie können mehr über das Formatieren von Zeichenfolgen und Zeichenfolgenmethoden lesen, um weitere Informationen zu Zeichenfolgen zu erhalten.



      Source link