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