Eingebaute Datentypen von Python            (C) 2016-2025 T.Birnthaler OSTC GmbH
================================

Python stellt eingebaute STANDARD-DATENTYPEN bereit, die von vornherein nach
dem Start des Python-Interpreters verfügbar sind und typische Einsatzfälle
abdecken. Zusätzlich stellt es weitere Datentypen über die STANDARD-BIBLIOTHEK
bereit, dazu ist aber vorher ein passendes Modul zu laden (z.B. "array", "time",
"datetime", "calendar", "decimal", "fractions", "collections", "enum").

Doku --> docs.python.org/3/library/stdtypes.html
     --> docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex
     --> docs.python.org/3/library/stdtypes.html#boolean-type-bool
     --> docs.python.org/3/library/stdtypes.html#iterator-types
     --> docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range
     --> docs.python.org/3/library/stdtypes.html#text-sequence-type-str
     --> docs.python.org/3/library/stdtypes.html#binary-sequence-types-bytes-bytearray-memoryview
     --> docs.python.org/3/library/stdtypes.html#set-types-set-frozenset
     --> docs.python.org/3/library/stdtypes.html#mapping-types-dict
     --> docs.python.org/3/library/stdtypes.html#context-manager-types
     --> docs.python.org/3/library/stdtypes.html#type-annotation-types-generic-alias-union
     --> docs.python.org/3/library/stdtypes.html#other-built-in-types
     --> docs.python.org/3/library/stdtypes.html#special-attributes
     --> docs.python.org/3/library/stdtypes.html#integer-string-conversion-length-limitation

+-----------+----------------+-------------------------------------------------+
| DATENTYP  | EIGENSCHAFTEN  | SYNTAX UND WERTE(BEREICH)                       |
+-----------+----------------+-------------------------------------------------+
| NoneType  | i  1           | None      (un-bekannt/definiert/gültig/möglich) |
| bool      | i  1   Boolean | True/False     (Wert 1/0 bei Rechnung)          |
| int       | i  1   Integer | 1234  -5  0    (Ganze Zahl, beliebig groß!)     |
| float     | i  1   Float   | 1.0  1e2  1E-2 (64-Bit Fließkommazahl, IEEE-754)|
| complex   | i  1   2xFloat | (1+2j)  (0+0j) (Real+Imaginärteil: 2x float)    |
+-----------+----------------+-------------------------------------------------+
| str       | i Seq  UTF8    | "abc"   'abc'   """abc"""   '''abc'''       ""  |
| tuple     | i Seq  Obj     | ( OBJ1, OBJ2, ... )               (OBJ1,)   ()  |
| list      | m Seq  Obj     | [ OBJ1, OBJ2, ... ]                         []  |
+-----------+----------------+-------------------------------------------------+
| dict      | m Dict Imu:Obj | { KEY1:OBJ1, KEY2:OBJ2, ... }               {}  |
| set       | m Set  Imu     | { KEY1, KEY2, ... }                    set({})  |
+-----------+----------------+-------------------------------------------------+
| bytearray | m Seq  Byte    | bytearray(b"AF0310FF3404")                      |
| bytes     | i Seq  Byte    | b"AF0310FF3404"                                 |
| frozenset | i Set  Imu     | frozenset({ KEY1, KEY2, ... })                  |
+-----------+----------------+-------------------------------------------------+
| Klasse    | m Attr Scope   | class CLASSNAME: ...                            |
| Objekt    | m Attr         | OBJNAME = CLASSNAME(CLASS,...)                  |
| Funktion  | i Attr Scope   | def FUNCNAME(PARAM,...): ...                    |
| Funktion  | i Attr Scope   | lambda PARAM,...: EXPRESSION                    |
| Modul     | m Attr Scope   | import MODULNAME (Bezeichner ohne Ext. ".py"!)  |
+-----------+----------------+-------------------------------------------------+
| Datentyp  |                | NoneType bool int float complex str tuple       |
|           |                | list dict set bytearray bytes frozenset ...     |
+-----------+----------------+-------------------------------------------------+

Legende:

  Attr = Attribut   (OBJ.ATTR = WERT für beliebige Attribute ATTR möglich)
  Byte = Byte       (Byte im Bereich 0..255 als Element)
  Dict = Dictionary (ungeordnete Key+Value-Paare, Key unique + im-mutable)
   Seq = Sequenz    (geordnete Folge von Werten  = indiziert von 0..n-1)
   Set = Set        (ungeordnete unique + im-mutable Keys, "degeneriertes" Dict)
  None = NoneType   (entspricht "NULL" in SQL = un-definiert/bekannt/gültig)
     1 = EIN Wert   (Skalar, IMMER im-mutable)
     i = im-mutable ("read-only", frozen, static, const, Wert NICHT änderbar)
     m = mutable    ("read-write", Wert änderbar)
   Obj = Object     (beliebiges Python-Objekt als Element)
   Imu = Im-mutable (beliebiges im-mutable Python-Objekt als Key/Element)
  UTF8 = Character  (Zeichen in UTF-8 Codierung als Element)
 Scope = Name Scope (Lokaler Namensraum)

Begriffe:

  Zahl       = bool + int + float + complex (in Rechenausdruck verwendbar)
  Collection = Seq + Dict + Set + ... (Sammlung beliebig vieler Werte, auch leer)
  Container  = Analog
  Float      = 64 Bit Fließkommazahl (IEEE 754 Standard)
  Bezeichner = 1. Zeichen aus "A-Za-z_", folgende Zeichen aus "A-Za-z_0-9"
  Objekt     = Speicher mit Wert + Datentyp + Referenzzähler + Id (Adresse)
  Referenz   = Zeiger auf Objekt (nur Referenzen zugewiesen/weitergereicht)
               Referenzzähler erreicht 0 --> Objekt wird freigegeben (Speicher)
  Variable   = Enthält Referenz auf Objekt (Name per Referenz an Obj "gebunden")
               del VAR    --> Name VAR weg + Referenzzähler dekrementiert
               VAR = OBJ1 --> Objekt OBJ1 erzeugt, Referenzzähler auf 1,
                              Referenz darauf in VAR
               VAR2 = VAR --> Referenz auf OBJ1 nach VAR2 kopiert,
                              Referenzzähler auf 2
               VAR = OBJ2 --> Objekt OBJ2 erzeugt, Referenzzähler auf 1,
                              Referenz darauf in VAR,
                              Referenzzahler von OBJ1 dekrementiert
  COW        = Copy on Write (bei Zuweisung)

Doppelt vorhandene Datentypen (mutable und im-mutable):

  +-----------+------------+---------------------------------------------------+
  | list      |    mutable | Array                                             |
  | tuple     | im-mutable | Array/Record                                      |
  +-----------+------------+---------------------------------------------------+
  | set       |    mutable | Menge                                             |
  | frozenset | im-mutable | Menge                                             |
  +-----------+------------+---------------------------------------------------+
  | bytearray |    mutable | Byte-Strom                                        |
  | bytes     | im-mutable | Byte-Strom                                        |
  +-----------+------------+---------------------------------------------------+

Datentypen von Python 2 (in Python 3 nicht mehr vorhanden oder geändert):

  +----------+---------------+-------------------------------------------------+
  | DATENTYP | EIGENSCHAFTEN | SYNTAX UND WERTE(BEREICH)                       |
  +----------+---------------+-------------------------------------------------+
  | int      | i  1          | -2147483648 .. +2147483647    (32-Bit Ganzzahl) |
  | long     | i  1          | -9223372036854775808..+9223372036854775807 (64) |
  | str      | i Seq  Byte   | "ZEICHENKETTE"   'abc'   ""   ''                |
  | unicode  | i Seq  UTF8   | u"ZEICHENKETTE"  u'abc'  u""  u''               |
  +----------+---------------+-------------------------------------------------+