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
Führt man obigen Code aus, erhält man Folgendes:
7
fib = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
len(fib)
Der obige Python-Code führt zu folgender 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
Der obige Python-Code führt zu folgender 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]
Wir erhalten die folgende Ergebnisse:
['b', ['c', 'x']]
komplexe_Liste[0][1][1][0]
Wir erhalten die folgende Ausgabe:
'c'

Listen ändern

Sprachen = ["Python", "C", "C++", "Java", "Perl"]
Sprachen[4] = "Lisp"
Sprachen
Wir erhalten die folgende Ergebnisse:
['Python', 'C', 'C++', 'Java', 'Lisp']
Sprachen.append("Haskell")
Sprachen
Der obige Python-Code führt zu folgender Ausgabe:
['Python', 'C', 'C++', 'Java', 'Lisp', 'Haskell']
Sprachen.insert(1, "Perl")
Sprachen
Der obige Python-Code liefert Folgendes:
['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]
Wir erhalten die folgende Ergebnisse:
'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
Führt man obigen Code aus, erhält man Folgendes:
'Pytho'
ab_fünf = Slogan[5:]
ab_fünf
Führt man obigen Code aus, erhält man folgende Ausgabe:
'n ist großartig'
eine_Kopie = Slogan[:]
ohne_letzte_fünf = Slogan[0:-5]
ohne_letzte_fünf
Wir können die folgende Ausgabe erwarten, wenn wir den obigen Python-Code ausführen:
'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]
Der obige Code führt zu folgendem Ergebnis:
'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]
Der obige Python-Code liefert Folgendes:
'Toronto is the largest City in Canada'
s[1::2]
Der obige Code führt zu folgendem Ergebnis:
'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
Wir erhalten die folgende 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)
Wir erhalten die folgende Ergebnisse:
10
a = ["Swen", 45, 3.54, "Basel"]
len(a)
Wir erhalten die folgende Ergebnisse:
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
Führt man obigen Code aus, erhält man folgendes Ergebnis:
True
"a" not in abc
Wir können die folgende Ausgabe erwarten, wenn wir den obigen Python-Code ausführen:
False
"e" not in abc
Führt man obigen Code aus, erhält man folgendes Ergebnis:
False
"f" not in abc
Der obige Python-Code führt zu folgender Ausgabe:
True
Slogan = "Python ist einfach!"
"y" in Slogan
Wir erhalten die folgende Ausgabe:
True
"x" in Slogan
Der obige Code führt zu folgendem Ergebnis:
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-"
Führt man obigen Code aus, erhält man folgende Ausgabe:
'xyz-xyz-xyz-'
"xyz-" * 3
Führt man obigen Code aus, erhält man Folgendes:
'xyz-xyz-xyz-'
3 * ["a","b","c"]
Der obige Python-Code führt zu folgender 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
Der obige Python-Code führt zu folgender Ausgabe:
[['a', 'b', 'c'], ['a', 'b', 'c'], ['a', 'b', 'c'], ['a', 'b', 'c']]
y[0][0] = "p"
y
Führt man obigen Code aus, erhält man folgende 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.