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)             |
+--------------------+-------------------------------------------------------+