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#mapping-types-dict-frozendict
--> 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ßk.zahl, 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, ... } {} |
| frozendict | i Dict Imu:Obj | frozendict({ KEY1:OBJ1, KEY2:OBJ2, ... }) | PY3.15
+------------+----------------+------------------------------------------------+
| set | m Set Imu | { KEY1, KEY2, ... } set({}) |
| frozenset | i Set Imu | frozenset({ KEY1, KEY2, ... }) |
+------------+----------------+------------------------------------------------+
| bytearray | m Seq Byte | bytearray(b"AF0310FF3404") |
| bytes | i Seq Byte | b"AF0310FF3404" |
+------------+----------------+------------------------------------------------+
| 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 + im-mutable):
+------------+------------+--------------------------------------------------+
| list | mutable | Array (änderbar) |
| tuple | im-mutable | Array/Record/Datensatz (nicht mehr änderbar) |
+------------+------------+--------------------------------------------------+
| dict | mutable | Dictionary (änderbar) |
| frozendict | im-mutable | Dictionary (nicht mehr änderbar) |
+------------+------------+--------------------------------------------------+
| set | mutable | Menge (änderbar) |
| frozenset | im-mutable | Menge (nicht mehr änderbar) |
+------------+------------+--------------------------------------------------+
| bytearray | mutable | Byte-Strom (änderbar) |
| bytes | im-mutable | Byte-Strom (nicht mehr änderbar) |
+------------+------------+--------------------------------------------------+
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'' |
+----------+---------------+-------------------------------------------------+