Python Sequenzen (C) 2019-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 String
t1 = ( True, "hallo", 3.14 ) t2 = () # Tupel + leerer Tupel
l1 = [ 123, 456, 789 ] l2 = [] # Liste + leere Liste
01234 # Positive Indices (0 .. Länge-1)
"hallo" # Sequenz (str)
-1 # Negative Indices (-1 .. -Länge) = Abkürzung für len(s) - 1
-2 # len(s) - 2
-3 # len(s) - 3
-4 # len(s) - 4
-5 # len(s) - 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 (z.B. welchen
Index hat ein bestimmter 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 "<") |
| sum(S) | Summe der Elemente in S (müssen Zahlen sein) | |
| all(S) | True falls alle Elemente True (oder S leer), sonst F. |
| any(S) | False falls alle Elemente False (oder S leer), s. F. |
+--------------------+-------------------------------------------------------+
| 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 |
+--------------------+-------------------------------------------------------+
| reversed(S) | Iterator mit Elementen in umgekehrter Reihenfolge |
| sorted(S) | Sortierte Liste der Elemente (gemäß Vergleich "<") |
+--------------------+-------------------------------------------------------+
HINWEIS: Die Formulierung "gemäß Vergleich <" bedingt, dass ALLE Elemente
mit dem Operator "<" vergleichbar sind (d.h. entweder Zahlen sind oder alle
den gleichen Datentyp str, tupel, list haben).
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 (eindeutig) |
+--------------------+-------------------------------------------------------+
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 eine 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 an Position I durch E ersetzen |
| S[I:J] = T | Elemente von I..J-1 durch Inhalt von Iterable T ersetz. |
| 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 ersetzen |
| 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 Position I einfügen: s[I:I] = [E] |
+--------------------+---------------------------------------------------------+
| E = S.pop([I]) | Element an Position I (STD: 0) entfernen und zurück |
| S.remove(E) | Erstes Element mit Wert E entfernen (Suche!) |
+--------------------+---------------------------------------------------------+
| S *= N | Sequenz N-mal vervielfachen + verketten |
| S.reverse() | Reihenfolge der Elemente umdrehen |
| S.clear() | Sequenz leeren (alle Elemente entfernen): del S[:] |
| S2 = S.copy() | Shallow/Flache Kopie erzeugen: S[:] |
+--------------------+---------------------------------------------------------+
HINWEIS: Indexwerte I und J sowie Schrittweite K dürfen auch negativ sein.
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) |
+--------------------+-------------------------------------------------------+