Sequentielle Datentypen

Einführung

Endless Python

Sequenzen sind neben Zahlen, Zuordnungen, Dateien, Instanzen und Ausnahmen einer der wichtigsten integrierten Datentypen. Python bietet sechs sequenzielle (oder sequentielle) Datentypen:

Zeichenketten (Strings) Byte-Sequenzen Byte-Arrays Listen Tupel Entfernungsobjekte 

Zeichenfolgen, Listen, Tupel, Bytes und Bereichsobjekte sehen möglicherweise ganz anders aus, haben jedoch noch einige grundlegende Konzepte gemeinsam:

  • Die Elemente oder Elemente von Zeichenfolgen, Listen und Tupeln sind in einer definierten Reihenfolge angeordnet.
  • Auf die Elemente kann über Indizes zugegriffen werden.
text = "Auf Listen und Strings kann über Indizes zugegriffen werden!" print(text[0], text[11], text[-2]) 
A u n 

Zugriff auf Listen:

lst = ["Wien", "London", "Paris", "Berlin", "Zürich", "Hamburg"] print(lst[0]) print(lst[2]) print(lst[-1]) 
Wien Paris Hamburg 

Im Gegensatz zu anderen Programmiersprachen verwendet Python die gleichen Syntax- und Funktionsnamen, um sequentielle Datentypen zu bearbeiten. Beispielsweise kann die Länge eines Strings, einer Liste und eines Tupels mit einer Funktion namens len () bestimmt werden:

Länder = ["Deutschland", "Schweiz", "Österreich", "Frankreich", "Belgien", "Niederlande", "England"] len(Länder) # die Länge der Liste; die Anzahl der Objekte 
Ausgabe: :

7
fib = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] len(fib) 
Ausgabe: :

10

Bytes

Das Byte-Objekt ist eine Folge kleiner Ganzzahlen. Die Elemente eines Byte-Objekts liegen im Bereich von 0 bis 255, entsprechend ASCII-Zeichen, und werden als solche gedruckt.

s = "Glückliche Fügung" s_bytes = s.encode('utf-8') s_bytes 
Ausgabe: :

b'Gl\xc3\xbcckliche F\xc3\xbcgung'

Python-Listen

Bisher haben wir bereits einige Listen verwendet, und hier folgt eine angemessene Einführung. Listen beziehen sich auf Arrays von Programmiersprachen wie C, C ++ oder Java, aber Python-Listen sind weitaus flexibler und leistungsfähiger als "klassische" Arrays. Beispielsweise müssen nicht alle Elemente in einer Liste denselben Typ haben. Darüber hinaus können Listen in einem Programmlauf wachsen, während in C die Größe eines Arrays zur Kompilierungszeit festgelegt werden muss.

Im Allgemeinen ist eine Liste eine Sammlung von Objekten. Genauer gesagt: Eine Liste in Python ist eine geordnete Gruppe von Elementen oder Elementen. Es ist wichtig zu beachten, dass diese Listenelemente nicht vom gleichen Typ sein müssen. Es kann eine beliebige Mischung von Elementen wie Zahlen, Zeichenfolgen, anderen Listen usw. sein. Der Listentyp ist für Python-Skripte und -Programme unerlässlich. Mit anderen Worten, Sie werden ohne Liste kaum ernsthaften Python-Code finden.

Die Haupteigenschaften von Python-Listen:

• Sie sind ordentlich. • Sie enthalten beliebige Objekte. • Auf Elemente einer Liste kann über einen Index zugegriffen werden. • Sie können beliebig verschachtelt werden. Sie können andere Listen als Unterlisten enthalten. • Variable Größe • Sie sind veränderlich. Die Elemente einer Liste können geändert werden. 

Listennotation und Beispiele

Listenobjekte werden in eckige Klammern eingeschlossen und durch Kommas getrennt. Die folgende Tabelle enthält einige Beispiele für Listen:

Listen Beschreibung
[] Eine leere Liste
[1, 1, 2, 3, 5, 8] Eine Liste mit ganzen Zahlen
[42, "What's the question?", 3.1415] Eine Liste mit gemischten Datentypen
["Stuttgart", "Freiburg", "München", "Nürnberg", "Würzburg", "Ulm", "Friedrichshafen", "Zürich", "Wien"] Eine Liste von Strings
[["London", "England", 7556900], ["Paris", "France",2193031], ["Bern", "Switzerland", 123466]] Eine verschachtelte Liste
["Oberste Ebene", ["Ein Level runter", ["noch tiefer", ["und tiefer", 42]]]] Eine tief verschachtelte Liste

Zugriff auf Listenelemente

Zuweisen einer Liste zu einer Variablen:

 Sprachen = ["Python", "C", "C++", "Java", "Perl"] 

Es gibt verschiedene Möglichkeiten, auf die Elemente einer Liste zuzugreifen. Der wahrscheinlich einfachste Weg für C-Programmierer sind Indizes. Die Nummern der Listen werden beginnend mit 0 aufgelistet:

Sprachen = ["Python", "C", "C++", "Java", "Perl"] print(Sprachen[0] + " sind " + Sprachen[1] + " unterschiedlich!") print("Zugriff auf das letzte Element der Liste: " + Sprachen[-1]) 
Python sind C unterschiedlich! Zugriff auf das letzte Element der Liste: Perl 

Das vorherige Beispiel einer Liste war eine Liste mit Elementen gleichen Datentyps. Wie wir bereits gesehen haben, können Listen verschiedene Datentypen haben, wie im folgenden Beispiel gezeigt:

 Gruppe = ["Bob", 23, "George", 72, "Myriam", 29] 

Unterlisten

Listen können Unterlisten als Elemente enthalten. Diese Unterlisten können auch Unterlisten enthalten, d. H. Listen können durch Unterlistenstrukturen rekursiv erstellt werden.

Person = [["Marc", "Mayer"], ["17, Oxford Str", "12345", "London"], "07876-7876"] Name = Person[0] print(Name) 
['Marc', 'Mayer'] 
Vor_name = Person[0][0] print(Vor_Name) 
Marc 
Nach_name = Person[0][1] print(Nach_name) 
Mayer 
Adresse = Person[1] Straße = Person[1][0] print(Straße) 
17, Oxford Str 

Das nächste Beispiel zeigt eine komplexere Liste mit einer tief strukturierten Liste:

komplexe_Liste = [["a", ["b", ["c", "x"]]]] komplexe_Liste = [["a", ["b", ["c", "x"]]], 42] komplexe_Liste[0][1] 
Ausgabe: :

['b', ['c', 'x']]
komplexe_Liste[0][1][1][0] 
Ausgabe: :

'c'

Listen ändern

Sprachen = ["Python", "C", "C++", "Java", "Perl"] Sprachen[4] = "Lisp" Sprachen 
Ausgabe: :

['Python', 'C', 'C++', 'Java', 'Lisp']
Sprachen.append("Haskell") Sprachen 
Ausgabe: :

['Python', 'C', 'C++', 'Java', 'Lisp', 'Haskell']
Sprachen.insert(1, "Perl") Sprachen 
Ausgabe: :

['Python', 'Perl', 'C', 'C++', 'Java', 'Lisp', 'Haskell']
Einkaufsliste = ['Milch', 'Joghurt', 'Ei', 'Butter', 'Brot', 'Bananen'] 

Wir gehen in einen virtuellen Supermarkt. Holen Sie sich einen Einkaufswagen und beginnen Sie mit dem Einkauf:

Einkaufsliste = ['Milch', 'Joghurt', 'Ei', 'Butter', 'Brot', 'Bananen'] Einkaufswagen = [] # "pop()"" Entfernt das letzte Element der Liste und gibt es zurück Artikel = Einkaufsliste.pop() print(Artikel, Einkaufsliste) Einkaufswagen.append(Artikel) print(Einkaufswagen) # wir machen so weiter: Artikel = Einkaufsliste.pop() print("shopping_list:", Einkaufsliste) Einkaufswagen.append(Artikel) print("cart: ", Einkaufswagen) 
Bananen ['Milch', 'Joghurt', 'Ei', 'Butter', 'Brot'] ['Bananen'] shopping_list: ['Milch', 'Joghurt', 'Ei', 'Butter'] cart: ['Bananen', 'Brot'] 

Mit einer while-Schleife:

Einkaufsliste = ['milk', 'yoghurt', 'egg', 'butter', 'bread', 'bananas'] Einkaufswagen = [] while Einkaufsliste != []: Artikel = Einkaufsliste.pop() Einkaufswagen.append(Artikel) print(Artikel, Einkaufsliste, Einkaufswagen) print("Einkaufsliste: ", Einkaufsliste) print("Einkaufswagen: ", Einkaufswagen) 
bananas ['milk', 'yoghurt', 'egg', 'butter', 'bread'] ['bananas'] bread ['milk', 'yoghurt', 'egg', 'butter'] ['bananas', 'bread'] butter ['milk', 'yoghurt', 'egg'] ['bananas', 'bread', 'butter'] egg ['milk', 'yoghurt'] ['bananas', 'bread', 'butter', 'egg'] yoghurt ['milk'] ['bananas', 'bread', 'butter', 'egg', 'yoghurt'] milk [] ['bananas', 'bread', 'butter', 'egg', 'yoghurt', 'milk'] Einkaufsliste: [] Einkaufswagen: ['bananas', 'bread', 'butter', 'egg', 'yoghurt', 'milk'] 

Tupel

Ein Tupel ist eine unveränderliche Liste, d. H. Ein Tupel kann nach seiner Erstellung in keiner Weise geändert werden. Ein Tupel wird analog zu Listen definiert, mit der Ausnahme, dass die Elementmenge in Klammern anstelle von eckigen Klammern steht. Die Regeln für Indizes sind dieselben wie für Listen. Sobald ein Tupel erstellt wurde, können Sie einem Tupel keine Elemente hinzufügen oder Elemente aus einem Tupel entfernen.

Wo ist der Nutzen von Tupeln?

 • Tupel sind schneller als Listen. • Wenn Sie wissen, dass einige Daten nicht geändert werden müssen, sollten Sie Tupel anstelle von Listen verwenden, da dies Ihre Daten vor versehentlichen Änderungen schützt. • Der Hauptvorteil von Tupeln besteht darin, dass Tupel als Schlüssel in Wörterbüchern verwendet werden können, Listen jedoch nicht. 

Das folgende Beispiel zeigt, wie Sie ein Tupel definieren und auf ein Tupel zugreifen. Außerdem können wir sehen, dass wir einen Fehler auslösen, wenn wir versuchen, einem Element eines Tupels einen neuen Wert zuzuweisen:

t = ("Tupels", "sind", "unveränderlich") t[0] 
Ausgabe: :

'Tupels'
t[0] = "Zuordnungen zu Elementen sind nicht möglich" 
 --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-24-055c11c313f3> in <module> ----> 1 t[0] = "Zuordnungen zu Elementen sind nicht möglich" TypeError: 'tuple' object does not support item assignment

Ausschneiden / Slicing

In vielen Programmiersprachen kann es ziemlich schwierig sein, einen Teil eines Strings zu schneiden, und noch schwieriger, wenn Sie ein "Subarray" ansprechen möchten. Python macht es mit seinem Slice-Operator sehr einfach. Slicing wird häufig in anderen Sprachen als Funktion mit möglichen Namen wie "Teilstring", "gstr" oder "substr" implementiert.

Jedes Mal, wenn Sie einen Teil eines Strings oder einer Liste in Python extrahieren möchten, sollten Sie den Slice-Operator verwenden. Die Syntax ist einfach. Eigentlich sieht es ein bisschen so aus, als würde man auf ein einzelnes Element mit einem Index zugreifen, aber statt nur einer Zahl haben wir mehr, getrennt durch einen Doppelpunkt ":". Wir haben einen Start- und einen Endindex, einer oder beide fehlen möglicherweise. Es ist am besten, die Funktionsweise von Slice anhand von Beispielen zu untersuchen:

Slogan = "Python ist großartig" erste_fünf = Slogan[0:5] erste_fünf 
Ausgabe: :

'Pytho'
ab_fünf = Slogan[5:] ab_fünf 
Ausgabe: :

'n ist großartig'
eine_Kopie = Slogan[:] ohne_letzte_fünf = Slogan[0:-5] ohne_letzte_fünf 
Ausgabe: :

'Python ist groß'

Syntaktisch gibt es keinen Unterschied bei Listen. Wir werden mit europäischen Städtenamen zu unserem vorherigen Beispiel zurückkehren:

Städte = ["Wien", "London", "Paris", "Berlin", "Zürich", "Hamburg"] erste_drei = Städte[0:3] # oder einfacher: erste_drei = Städte[:3] print(erste_drei) 
['Wien', 'London', 'Paris'] 

Jetzt extrahieren wir alle Städte außer den letzten beiden, "Zürich" und "Hamburg":

alles_außer_letzte_zwei = Städte[:-2] print(alles_außer_letzte_zwei) 
['Wien', 'London', 'Paris', 'Berlin'] 

Das Schneiden funktioniert auch mit drei Argumenten. Wenn das dritte Argument beispielsweise 3 ist, wird nur jedes dritte Element der Liste, Zeichenfolge oder Tupel aus dem Bereich der ersten beiden Argumente verwendet.

Wenn s ein sequentieller Datentyp ist, funktioniert dies folgendermaßen:

 s [Anfang: Ende: Schritt] 

Die resultierende Sequenz besteht aus folgenden Elementen:

 s[Anfang], s[Anfang + 1 * Schritt], ... s[Anfang + i * Schritt] für alle (Anfang + i * Schritt) < end. 

Im folgenden Beispiel definieren wir eine Zeichenfolge und drucken jedes dritte Zeichen dieser Zeichenfolge:

Slogan = "Python unter Linux ist großartig" Slogan[::3] 
Ausgabe: :

'Ph t n trai'

Die folgende Zeichenfolge, die wie ein Buchstabensalat aussieht, enthält zwei Sätze. Eine davon enthält verdeckte Werbung für meine Python-Kurse in Kanada:

 "TPoyrtohnotno ciosu rtshees lianr gTeosrto nCtiot yb yi nB oCdaennasdeao" 

Versuchen Sie, den versteckten Satz mit Slicing herauszufinden. Die Lösung besteht aus 2 Schritten!

s = "TPoyrtohnotno ciosu rtshees lianr gTeosrto nCtiot yb yi nB oCdaennasdeao" print(s) 
TPoyrtohnotno ciosu rtshees lianr gTeosrto nCtiot yb yi nB oCdaennasdeao 
s[::2] 
Ausgabe: :

'Toronto is the largest City in Canada'
s[1::2] 
Ausgabe: :

'Python courses in Toronto by Bodenseo'

Vielleicht interessiert Sie auch, wie wir den String erstellt haben. Sie müssen das Listenverständnis verstehen, um Folgendes zu verstehen:

s = "Toronto is the largest City in Canada" t = "Python courses in Toronto by Bodenseo" s = "".join(["".join(x) for x in zip(s,t)]) s 
Ausgabe: :

'TPoyrtohnotno ciosu rtshees lianr gTeosrto nCtiot yb yi nB oCdaennasdeao'

Länge

Meter

Die Länge einer Sequenz, d. H. Einer Liste, eines Strings oder eines Tupels, kann mit der Funktion len () bestimmt werden. Bei Zeichenfolgen wird die Anzahl der Zeichen und bei Listen oder Tupeln die Anzahl der Elemente gezählt, während eine Unterliste als ein Element zählt.

txt = "Hallo Welt" len(txt) 
Ausgabe: :

10
a = ["Swen", 45, 3.54, "Basel"] len(a) 
Ausgabe: :

4

Verkettung von Sequenzen

Das Kombinieren von zwei Sequenzen wie Zeichenfolgen oder Listen ist so einfach wie das Addieren von zwei Zahlen. Sogar das Bedienerzeichen ist das gleiche. Das folgende Beispiel zeigt, wie zwei Zeichenfolgen zu einer verkettet werden:

Vorname = "Homer" Nachname = "Simpson" Name = Vorname + " " + Nachname print(Name) 
Homer Simpson 

So einfach ist das für Listen:

Farben1 = ["rot", "grün","blau"] Farben2 = ["schwarz", "weiß"] Farben = Farben1 + Farben2 print(Farben) 
['rot', 'grün', 'blau', 'schwarz', 'weiß'] 

Die erweiterte Zuordnung "+ =", die für arithmetische Zuweisungen bekannt ist, funktioniert auch für Sequenzen.

s + = t

ist syntaktisch dasselbe wie:

s = s + t

Aber es ist nur syntaktisch dasselbe. Die Implementierung ist anders: Im ersten Fall muss die linke Seite nur einmal ausgewertet werden. Augment-Zuweisungen können als Optimierung für veränderbare Objekte angewendet werden.

Überprüfen, ob ein Element in der Liste enthalten ist

Es ist einfach zu überprüfen, ob ein Element in einer Sequenz enthalten ist. Zu diesem Zweck können wir den Operator "in" oder "not in" verwenden. Das folgende Beispiel zeigt, wie dieser Operator angewendet werden kann:

abc = ["a","b","c","d","e"] "a" in abc 
Ausgabe: :

True
"a" not in abc 
Ausgabe: :

False
"e" not in abc 
Ausgabe: :

False
"f" not in abc 
Ausgabe: :

True
Slogan = "Python ist einfach!" "y" in Slogan 
Ausgabe: :

True
"x" in Slogan 
Ausgabe: :

False

Wiederholungen

Bisher hatten wir einen "+" - Operator für Sequenzen. Es ist auch ein "∗" - Operator verfügbar. Natürlich ist keine "Multiplikation" zwischen zwei Sequenzen möglich. "*" ist für eine Sequenz und eine ganze Zahl definiert, d. h. "s ∗ n" oder "n ∗ s". Es ist eine Art Abkürzung für eine n-fache Verkettung, d.h.

str ∗ 4

ist das gleiche wie

str + str + str + str

Weitere Beispiele:

3 * "xyz-" 
Ausgabe: :

'xyz-xyz-xyz-'
"xyz-" * 3 
Ausgabe: :

'xyz-xyz-xyz-'
3 * ["a","b","c"] 
Ausgabe: :

['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

Die erweiterte Zuordnung für "∗" kann ebenfalls verwendet werden: s *= n ist dasselbe wie s = s * n.

Die Fallstricke von Wiederholungen

In unseren vorherigen Beispielen haben wir den Wiederholungsoperator auf Zeichenfolgen und flache Listen angewendet. Wir können es auch auf verschachtelte Listen anwenden:

x = ["a","b","c"] y = [x] * 4 y 
Ausgabe: :

[['a', 'b', 'c'], ['a', 'b', 'c'], ['a', 'b', 'c'], ['a', 'b', 'c']]
y[0][0] = "p" y 
Ausgabe: :

[['p', 'b', 'c'], ['p', 'b', 'c'], ['p', 'b', 'c'], ['p', 'b', 'c']]

Repetitions with References

Dieses Ergebnis ist für Anfänger der Python-Programmierung ziemlich erstaunlich. Wir haben dem ersten Element der ersten Unterliste von y einen neuen Wert zugewiesen, dh y [0] [0], und wir haben die ersten Elemente aller Unterlisten in y "automatisch" geändert, dh y [1] [0]. , y [2] [0], y [3] [0].

Der Grund ist, dass der Wiederholungsoperator * 4 4 Verweise auf die Liste x erstellt: und es ist daher klar, dass jedes Element von y geändert wird, wenn wir einen neuen Wert auf y [0] [0] anwenden.

box

Python Tutorial

Die Bücher zur Webseite

Bücher zur Webseite

Im Hanser-Verlag sind vier Bücher von Bernd Klein und Philip Klein erschienen, die auf den Inhalten dieser Webseite aufbauen, aber auch über die Inhalte hinausgehen. Es lohnt sich also die Bücher zu kaufen, womit Sie außerdem diese Webseite unterstützen!

Einführung in Python3

Einführung in Python von Bernd Klein
Zum Online-Shop des Hanser-Verlages, wo Sie das Buch versandkostenfrei bestellen können!


Numerisches Python: Arbeiten mit NumPy, Matplotlib und Pandas

Bernd Klein: Python-Buch Numerisches Python Buch kaufen

Bernd Klein, Philip Klein:
Funktionale Programmierung mit Python

Bernd Klein, Philip Klein: Funktionale Programmierung mit Python Buch kaufen Python-Grundlagen | eLearning
Mit dem Hanser eCampus „Python-Grundlagen“ erhalten Einsteiger:innen eine Einführung in die Programmiersprache Python.

Python Grundlagen: elearning, Bernd Klein Buch kaufen



Bücher kaufen

Wenn Ihnen diese Webseite gefällt, - was wir natürlich sehr hoffen, - dann können Sie meine Arbeit unterstützen, wenn Sie eines meiner Bücher oder beide Bücher kaufen oder weiterempfehlen.

Die Bücher können Sie über jede Buchhandlung in Ihrer Nähe beziehen. Alternativ können Sie sie auch direkt über den Hanser-Verlag beziehen:
Bücher von Bernd Klein und Philip Klein

Spenden

Ihre Unterstützung ist dringend benötigt. Diese Webseite ist frei von Werbeblöcken und -bannern! So soll es auch bleiben! Dazu benötigen wir Ihre Unterstützung:

Weshalb wir Ihre Spende dringend benötigen erfahren Sie hier

Tutorial

Diese Webseite bietet ein Tutorial für Python. Der Unterschied zu anderen Online-Tutorials und Python-Kursen besteht darin, dass wir hier mehr Beispiele und Übungen bieten wollen. Außerdem werden komplexe Probleme in zahlreichen Diagrammen und Bildern veranschaulicht, um einen leichteren Zugang zu gewährleisten. In zahlreichen Python-Kursen hat Bernd Klein die Erfahrungen gesammelt, die in die Entwicklung dieser Webseite eingeflossen sind.

Fortgeschrittene Themen

Auf dieser Webseite befinden sich auch zahlreiche fortgeschrittene Themen zu Python, wie man sie in dieser Art vergeblich in anderen Python-Tutorials sucht. Themen, die insbesondere auch für Studierende der Informatik von besonderem Interesse sind: Turingmaschine, Endliche Automaten, Threads, Graphentheorie

Aber auch für Mathematikerinnen und Mathematiker, Ingenieurinnen und Ingenieure und andere naturwissenschaftlich Orientierte sind zum Beispiel die Einführungen in NumPy, Matplotlib und Pandas von großem Nutzen.


 


Suchen in dieser Webseite:

Webseite durchsuchen:

English Version / Englische Übersetzung

This chapter is also available in our English Python tutorial: Sequential Data Types

Sitenin Türkçe çevirisi / Türkische Übersetzung


Klicke hier, um dieses Thema auf Türkisch anzuzeigen / Bu konuyu Türkçe görüntülemek için tıklayın:
Seri Veri Türleri

Kurse und Schulungen

Dieser Online-Kurs ist so aufgebaut, dass man prinzipiell Python auch alleine lernen kann. Schneller und effizienter geht es aber in einem "richtigen" Kurs, also in einer Schulung mit einem erfahrenen Dozenten. Die Autoren dieses Online-Kurses veranstalten auch bei dem Kursanbieter Bodenseo eine Vielzahl von Python-Kursen. Schulungen und Kurse in Python

For those who prefer training courses in English: Each course is available in English as well: Python Course



Dem Autor Bernd Klein auf Facebook folgen:


Bernd Klein on Facebook

Spenden

Ihre Unterstützung ist dringend benötigt. Diese Webseite ist frei von Werbeblöcken und -bannern! So soll es auch bleiben! Dazu benötigen wir Ihre Unterstützung:

Weshalb wir Ihre Spende benötigen erfahren Sie hier

Spruch des Tages:

Wenn man sich fragt, ob Computer denken können, dann ist das, als ob man sich fragte, ob U-Boote schwimmen können. (frei nach Dijkstra)


Und noch ein Spruch:

Die Mathematik allein befriedigt den Geist durch ihre außerordentliche Gewissheit.
Johannes Kepler (1571 - 1630)

Hilfe

Diese Dokumentation zu Python mit Einführung und Tutorial wurde mit großer Sorgfalt erstellt und wird ständig erweitert. Dennoch können wir für die Korrektheit der Texte und der zahlreichen Beispiele keine Garantie übernehmen. Die Benutzung und Anwendung der Beispiele erfolgt auf eigenes Risiko. Wir freuen uns über alle Anregungen und Fehlerkorrekturen!



Datenschutzerklärung

Datenschutzerklärung nach DSGVO