Built-in Functions von Python (C) 2015-2025 T.Birnthaler OSTC GmbH
=============================
In Python sind 69 Funktionen fest eingebaut ("BUILT-IN"), sie können
überschrieben werden, sollten dies aber nicht unbedingt (da sonst z.B. die
Funktion "print()" oder Datentypen wie "list" nicht mehr funktionieren).
Doku --> docs.python.org/3/library/functions.html
docs.python.org/3/library/builtins.html
Diese GENERISCHEN FUNKTIONEN sind auf ALLE (oder zumindest mehrere) Datentypen
anwendbar, daher sind sie NICHT als METHODE eines DATENTYPS realisiert und
werden auch nicht in MODULE ausgelagert.
Ihnen ist gemeinsam, dass Sie KEINE ÄNDERUNG an den beim Aufruf übergebenen
Parametern durchführen, sondern nur ein ERGEBNIS zurückgeben (reine/pure
Functions, einzige Ausnahme: delattr() und setattr()).
text = "Hallo Welt" # Variable "text" definieren
anz = len(text) # Variable "text" wird nur gelesen (nicht verändert!)
print("ANZ", anz) # Variable "anz" enthält Ergebnis des Funktionsaufrufs
Eine Liste aller "built-in"-Funktionen erhält man folgendermaßen:
pydoc builtins # A) Auf der Kommandozeile
python -Mpydoc builtins # B) Auf der Kommandozeile
import builtins # C) Im Python-Skript
dir(builtins) # "
Ein Zugriff auf alle in Python direkt eingebauten Elemente (Funktionen,
Konstanten, ...) ist über das Modul "builtins" grundsätzlich immer möglich:
import builtins # Modul importieren
builtins.print(...) # Statt print(...)
+------------------------+-----------------------------------------------------+
| Funktion | Beschreibung |
+------------------------+-----------------------------------------------------+
| id(OBJ) | Identität von Objekt (Ganzzahl = Speicheradresse) |
| type(OBJ) | Datentyp von Objekt (bzw. Klasse von Objekt) |
| dir([OBJ]) | Elemente von (lokalem) Namensraum/Objektattribute |
| hash(OBJ) | Hashwert zu Objekt erstellen --> OBJ.__hash__() |
| help(OBJ) | Doku zu Objekt ausgeben --> OBJ.__doc__ |
+------------------------+-----------------------------------------------------+
| abs(N) | Absolutwert von Zahl N |
| divmod(A,B) | Ergibt Quotient/Rest-Tupel (A // B, A % B) |
| round(N,M) | Zahl N runden auf M Nachkommastellen (oder Ganzzahl)|
| pow(X,Y[,Z]) | X hoch Y (modulo Z) |
+------------------------+-----------------------------------------------------+
| all(ITBL) | True falls alle Elemente True (oder ITBL leer) |
| any(ITBL) | False falls alle Elemente False (oder ITBL leer) |
| max(ITBL) | Größtes Element (Vergleich < muss funktionieren) |
| min(ITBL) | Kleinstes Element (Vergleich < muss funktionieren) |
| sum(ITBL,START=0) | Summe der Elemente (müssen Zahlen sein) |
+------------------------+-----------------------------------------------------+
| repr(OBJ) | Maschinenlesbarer String zu Objekt (Repräsentation) |
| ascii(OBJ) | repr() + non-ASCII Zeichen escaped (\x \u \U) |
+------------------------+-----------------------------------------------------+
| chr(N) | Zeichen mit Unicode N |
| ord(STR) | Unicode des 1. Zeichens von STR |
+------------------------+-----------------------------------------------------+
| bin(N) | Zahl N als Binär-String "0b..." zurückgeben |
| hex(N) | Zahl N als Hexadezimal-String "0x..." zurückgeben |
| oct(N) | Zahl N als Oktal-String "0o..." zurückgeben |
+------------------------+-----------------------------------------------------+
| bool(VAL) | Datentyp-Konvertierung nach "bool" |
| bytearray(SRC,ENC,ERR) | Datentyp-Konvert. nach "bytearray" (mutable int seq)|
| bytes(SRC,ENC,ERR) | Datentyp-Konvert. nach "bytes" (im-mutable int seq) |
| complex(REAL,IMAG=0) | Datentyp-Konvertierung nach "complex" |
| dict(OBJ) | Datentyp-Konvertierung nach "dict" |
| float(VAL) | Datentyp-Konvertierung nach "float" |
| frozenset(ITBL) | Datentyp-Konvertierung nach "frozenset" |
| int(OBJ,BASE=10) | Datentyp-Konvertierung nach "int" (zur Basis BASE) |
| list(ITBL) | Datentyp-Konvertierung nach "list" |
| memoryview(OBJ) | Datentyp-Konvertierung nach "memoryview" |
| set(ITBL) | Datentyp-Konvertierung nach "set" |
| str(OBJ) | Datentyp-Konvertierung nach "str" |
| tuple(ITBL) | Datentyp-Konvertierung nach "tuple" |
+------------------------+-----------------------------------------------------+
| globals() | Globale Variablen im aktuellen Namensraum (Modul) |
| locals() | Lokale Variablen im aktuellen Namensraum (Funktion) |
| vars() vars(OBJ) | Analog locals() bzw. OBJ.__dict__ |
+------------------------+-----------------------------------------------------+
| delattr(OBJ,ATTR) | Attribut zu Objekt löschen --> del OBJ.ATTR |
| getattr(OBJ,ATTR,DFLT) | Wert zu Attribut von Objekt holen (DFLT falls fehlt)|
| hasattr(OBJ,ATTR) | True falls Objekt Attribut hat, sonst False |
| setattr(OBJ,ATTR,VAL) | Attribut in Objekt auf Wert setzen |
+------------------------+-----------------------------------------------------+
| callable(OBJ) | True falls Objekt aufrufbar (Func/Class/Object) |
| isinstance(OBJ,CLS) | Objekt ist Instanz von Kl. oder einer ihrer Unterkl.|
| issubclass(CLS,CLS2) | Klasse ist Unterklasse (auch von sich selbst) |
| super(TYPE,OBJ/TYPE) | Elternklasse oder Geschwisterklasse |
+------------------------+-----------------------------------------------------+
| object() | Neues leeres Objekt (Basisklasse aller Klassen) |
| @property(GET,SET,DEL,DOC) Property-Attribut erzeugen (verpackt 4 Methoden) |
| @classmethod() | Decorator für Klassenmethode C.f(cls) |
| @staticmethod() | Decorator für Statische Methode C.f() |
+------------------------+-----------------------------------------------------+
| open(FILE,MODE="r",BUF=-1,ENC=None,ERR=None,NL=None,CLOSEFD=True,OPENER=None)|
| | Datei öffnen und Fileobjekt zurückgeben |
| input(PROMPT) | Terminal-Eingabe als "str" einlesen |
| print(LIST,SEP=" ",END="\n",FILE=sys.stdout,FLUSH=False) |
| | Alle Elemente von LIST per str() ausgeben |
| format(VAL,FORMAT) | Formatierter Wert |
+------------------------+-----------------------------------------------------+
| len(SEQ) | Anz. Elem. (Sequenz, Range, Collection, Container) |
| reversed(SEQ) | Umgedrehten Iterator zurückg. (von hinten nach vorn)|
| sorted(ITBL,KEY,REV) | Sortierte Folge zurückgeben (Vgl. < muss funkt.) |
| iter(ITBL,SENTINEL) | Iterator-Objekt zurückgeben --> __iter__() |
| next(ITOR,DEFAULT) | Nächstes Element aus Iterator holen --> __next__() |
| range(BEG=0,END,STEP=1)| Zahlenliste BEG...END-1 mit Schrittw. STEP erzeugen |
| slice(BEG=0,END,STEP=1)| Slice-Objekt so [BEG:END:STEP] erzeugen --> SEQ[so] |
+------------------------+-----------------------------------------------------+
| enumerate(ITBL,BEG=0) | Elemente mit aufsteigender Nummer versehen |
| filter(FUNC,ITBL) | Elemente filtern gemäß Funktion --> True |
| map(FUNC,ITBL) | Elemente abbilden gemäß Funktion |
| zip(*ITBL) | 2 oder mehr Folgen zu Folge von Tupeln verschränken |
+------------------------+-----------------------------------------------------+
| breakpoint(*, **) | Sprung in Debugger |
| | sys.breakpointhook() --> pdb.set_trace() |
| compile(SRC,FILE,MOD,FLG,DONTINHERIT=False,OPT=-1) |
| | Kompil. SRC in Code oder AST Objekt --> exec/eval() |
| eval(STR,GLOBAL,LOCAL) | String/Code-Objekt als Python-Ausdruck auswerten |
| exec(OBJ,GLOBAL,LOCAL) | String/Code-Objekt als Python-Skript ausführen |
+------------------------+-----------------------------------------------------+
| __import__(NAME,...) | Von "import" aufgerufen |
+------------------------+-----------------------------------------------------+
HINWEIS: ITBL steht für ITERABLE, also ein Collection-Objekt, dessen Elemente
per ITERATOR-PROTOKOLL (iter(), next(), StopIteration) durchlaufen werden
können (z.B. Sequenz, Set, Comprehension, Generator, Range, File, ...).
for ELEM in ITBL:
print(ELEM)
HINWEIS: ITOR steht für einen ITERATOR, also ein Objekt, mit dessen Hilfe die
ELEMENTE eines ITERABLE (z.B. Sequenz, Set, Comprehension, Generator, Range,
File, ...) einzeln durchlaufen werden können.
ITOR = iter(ITBL)
elem1 = next(ITOR)
elem2 = next(ITOR)