Python Sequenzen (C) 2020 T.Birnthaler OSTC GmbH
----------------
Doku --> docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range
Sequenzen sind eine "geordnete" Folge von Elementen, jedem Element wird eine
Ganzzahl als "Index" zugeordnet (beginnend mit 0), über den es angesprochen
werden kann. Der Index läuft aufsteigend von 0 bis Länge der Sequenz minus 1
bzw. absteigend von minus 1 bis minus Länge der Sequenz:
s1 = "hallo" s2 = "" # String + leerer Strin
t1 = ( True, "hallo", 3.14 ) t2 = () # Tupel + leerer Tupel
l1 = [ 123, 456, 789 ] l2 = [] # Liste + leere Liste
01234 # Positive Indices
"hallo" # Sequenz (str)
-1 # Negative Indices
-2 #
-3 #
-4 #
-5 #
Die Zugriffsgeschwindigkeit auf ein bestimmtes Element über seinen Index ist
unabhängig von der Sequenz-Länge immer gleich schnell ("RANDOM ACCESS").
Die Zugriffsgeschwindigkeit auf einen bestimmten Element-Wert ist abhängig von
der Sequenz-Größe und immer langsam (erfordert das Durchsuchen der gesamten
Sequenz)
Folgende Operationen werden von (fast) allen Sequenz-Typen (str, tuple, list,
bytes, bytearray) unterstützt (sowohl mutable als auch immutable). S und T sind
Sequenzen des gleichen Typs, I, J, K, N sind Ganzzahlen und E ist ein
beliebiges Objekt, das die Beschränkungen der Sequenz S erfüllt.
+--------------------+-------------------------------------------------------+
| Operation | Bedeutung |
+--------------------+-------------------------------------------------------+
| E in S | Element E in S vorhanden? |
| E not in S | Element E in S nicht vorhanden? |
+--------------------+-------------------------------------------------------+
| S + T | Verkettung von S und T |
| S * N N * S | Sequenz N-mal verketten |
+--------------------+-------------------------------------------------------+
| S[I] | Element mit Index I (Start bei 0) |
| S[I:J] | Slice von I bis J-1 (mit Schrittweite 1) |
| S[I:J:K] | Slice von I bis J-1 mit Schrittweite K |
+--------------------+-------------------------------------------------------+
| len(S) | Länge von S (Anzahl Elemente) |
| min(S) | Kleinstes Element in S (gemäß Vergleich "<") |
| max(S) | Größtes Element in S (gemäß Vergleich "<") |
+--------------------+-------------------------------------------------------+
| S.index(E[,I[,J]]) | Index des 1. Elements gleich E in S |
| | (von Index I bis J-1; Standard: 0 und len(S)-1) |
| S.count(E) | Anzahl Vorkommen von Element E in S |
+--------------------+-------------------------------------------------------+
Immutable Sequenzen
-------------------
Folgende Operation wird von Immutable Sequenzen (z.B. str, tuple, bytes)
zusätzlich zu obigen unterstützt (S ist eine immutable Sequenz):
+--------------------+-------------------------------------------------------+
| Operation | Bedeutung |
+--------------------+-------------------------------------------------------+
| hash(S) | Hashwert erstellen |
+--------------------+-------------------------------------------------------+
Mutable Sequenzen
-----------------
Folgende Operationen werden von mutable Sequenzen (z.B. list, bytearray)
zusätzlich zu den allgemeinen Sequenz-Operationen unterstützt (S ist eine
mutable Sequenz, T ist ein Sequenz oder ein Iterator des gleichen Typs, I, J,
K, N sind Ganzzahlen und E ist ein beliebiges Objekt, das die Beschränkungen
der Sequenz S erfüllt):
+--------------------+-------------------------------------------------------+
| Operation | Bedeutung |
+--------------------+-------------------------------------------------------+
| S[I] = E | Element mit Index I durch E ersetzen |
| S[I:J] = T | Elemente von I..J-1 durch Inhalt von Iterable T ers. |
| del s[I:J] | Elemente von I..J-1 aus Liste entfernen |
| S[I:J:K] = T | Elemente s[I:J:K] durch Inhalt von Iterable T ers. |
| del s[I:J:K] | Elemente s[I:J:K] aus Liste entfernen |
+--------------------+-------------------------------------------------------+
| S.append(E) | E am Sequenz-Ende anhängen: S[len(S):len(S)] = [E] |
| S.extend(T) s += T| Elemente von T anhängen: S[len(S):len(S)] = T |
| S.insert(I, E) | Element E an Indexposition I einfügen: s[I:I] = [E] |
+--------------------+-------------------------------------------------------+
| S.remove(E) | Erstes Element mit Wert E entfernen |
| E = S.pop([I]) | Element an Position I (STD: 0) entfernen und zurück |
+--------------------+-------------------------------------------------------+
| S *= N | Sequenz N-mal verketten |
| S.reverse() | Reihenfolge der Elemente umdrehen |
| S.clear() | Sequenz leeren (alle Elemente entfernen): del S[:] |
| S2 = S.copy() | Shallow/Flache Kopie erzeugen: S[:] |
+--------------------+-------------------------------------------------------+
list-Sequenz
------------
Folgende Operation wird von Listen zusätzlich zu den allgemeinen
Sequenz-Operationen und den Operationen für mutable Sequenzen unterstützt:
+--------------------+-------------------------------------------------------+
| Operation | Bedeutung |
+--------------------+-------------------------------------------------------+
| L.sort(key,reverse)| Elemente aufsteigend sortieren (gemäß Vergleich "<") |
| | (key=MAPFUNC, reverse=True -> absteigend) |
+--------------------+-------------------------------------------------------+