Integrierte Funktionen¶

Der Python-Interpreter verfügt über eine Reihe integrierter Funktionen und Typen,die jederzeit verfügbar sind. Sie sind hier in alphabetischer Reihenfolge aufgeführt.

Integrierte Funktionen
A `abs()` `aiter()` `all()` `anext()` `any()` `ascii()` B `bin()` `bool()` `breakpoint()` `bytearray()` `bytes()` C `callable()` `chr()` `classmethod()` `compile()` `complex()` D `delattr()` `dict()` `dir()` `divmod()`	E `enumerate()` `eval()` `exec()` F `filter()` `float()` `format()` `frozenset()` G `getattr()` `globals()` H `hasattr()` `hash()` `help()` `hex()` I `id()` `input()` `int()` `isinstance()` `issubclass()` `iter()`	L `len()` `list()` `locals()` M `map()` `max()` `memoryview()` `min()` N `next()` O `object()` `oct()` `open()` `ord()` P `pow()` `print()` `property()`	R `range()` `repr()` `reversed()` `round()` S `set()` `setattr()` `slice()` `sorted()` `staticmethod()` `str()` `sum()` `super()` T `tuple()` `type()` V `vars()` Z `zip()` _ `__import__()`

abs(number, /)¶: Gibt den Absolutwert einer Zahl zurück. Das Argument kann eine Ganzzahl, eine Gleitkommazahl oder ein Objekt sein, das __abs__() implementiert. Handelt es sich bei dem Argument um eine komplexe Zahl, wird deren Betrag zurückgegeben.

aiter(async_iterable, /)¶

Gibt einen asynchronous iterator für ein asynchronous iterable zurück. Entspricht dem Aufruf von x.__aiter__().

Hinweis: Im Gegensatz zu iter() gibt es bei aiter() keine Variante mit zwei Argumenten

Added in version 3.10.

all(iterable, /)¶

Gibt True zurück, wenn alle Elemente des iterable wahr sind (oder wenn das iterable leer ist). Entspricht::“

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

awaitable anext(async_iterator, /)¶

awaitable anext(async_iterator, default, /)

When awaited, return the next item from the given asynchronous iterator, or default if given and the iterator is exhausted.

Dies ist die asynchrone Variante der eingebauten Funktion next() und verhält sich ähnlich.

Dies ruft die Methode __anext__() von async_iterator auf und gibt ein awaitable zurück. Das Warten auf dieses (mittels await) liefert den nächsten Wert des Iterators. Wenn default angegeben ist, wird dieser Wert zurückgegeben, falls der Iterator erschöpft ist; andernfalls wird StopAsyncIteration ausgelöst.

Added in version 3.10.

any(iterable, /)¶

Gibt True zurück, wenn mindestens ein Element des iterable wahr ist. Wenn das Iterable leer ist, wird False zurückgegeben. Entspricht:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

ascii(object, /)¶: Gibt wie repr() einen String zurück, der eine druckbare Darstellung eines Objekts enthält; allerdings werden Nicht-ASCII-Zeichen in dem von repr() zurückgegebenen String mittels \x-, \u- oder \U-Escapes maskiert. Dies erzeugt einen String, der dem ähnelt, den repr() in Python 2 zurückgibt.

bin(integer, /)¶

Wandelt eine Ganzzahl in eine Binärzeichenkette mit dem Präfix „0b“ um. Das Ergebnis ist ein gültiger Python-Ausdruck. Wenn integer kein Python-Objekt vom Typ int ist, muss es eine __index__()-Methode definieren, die eine Ganzzahl zurückgibt. Einige Beispiele:

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

Je nachdem, ob das Präfix „0b“ gewünscht ist oder nicht, können Sie eine der folgenden Methoden verwenden.

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

Siehe auch enum.bin(), um negative Werte als Zweierkomplement darzustellen.

Weitere Informationen findest du unter format().

class bool(object=False, /)¶: Gibt einen booleschen Wert zurück, d. h. entweder True oder False. Das Argument wird mithilfe des Standardverfahrens zur Wahrheitsprüfung truth testing procedure umgewandelt. Ist das Argument falsch oder wird es weggelassen, wird False zurückgegeben; andernfalls wird True zurückgegeben. Die Klasse bool ist eine Unterklasse von int (siehe Numerische Typen — int, float, complex). Sie kann nicht weiter unterteilt werden. Ihre einzigen Instanzen sind False und True (siehe Boolescher Typ – bool).

Geändert in Version 3.7: Der Parameter ist jetzt rein positionsgebunden.

breakpoint(*args, **kws)¶

Diese Funktion ruft an der Aufrufstelle den Debugger auf. Genauer gesagt ruft sie sys.breakpointhook() auf und reicht dabei args und kws direkt weiter. Standardmäßig ruft sys.breakpointhook() die Funktion pdb.set_trace() ohne Argumente auf. In diesem Fall handelt es sich lediglich um eine Komfortfunktion, damit Sie pdb nicht explizit importieren oder viel Code schreiben müssen, um in den Debugger zu gelangen. sys.breakpointhook() kann jedoch auf eine andere Funktion gesetzt werden, die dann automatisch von breakpoint() aufgerufen wird; so können Sie den Debugger Ihrer Wahl verwenden. Ist sys.breakpointhook() nicht verfügbar, löst diese Funktion einen RuntimeError aus.

Standardmäßig lässt sich das Verhalten von breakpoint() über die Umgebungsvariable PYTHONBREAKPOINT ändern. Einzelheiten zur Verwendung finden Sie unter sys.breakpointhook().

Beachte, dass dies nicht garantiert ist, wenn sys.breakpointhook() ersetzt wurde.

Löst ein Audit-Ereignis builtins.breakpoint mit dem Argument breakpointhook aus.

Added in version 3.7.

class bytearray(source=b'')

class bytearray(source, encoding, errors='strict')

Gibt ein neues Byte-Array zurück. Die Klasse bytearray ist eine veränderbare Sequenz von Ganzzahlen im Bereich 0 <= x < 256. Sie verfügt über die meisten der üblichen Methoden veränderbarer Sequenzen, die unter Veränderliche Sequenztypen beschrieben sind, sowie über die meisten Methoden des Typs bytes, siehe Bytes- und Bytearray-Operationen.

Der optionale Parameter source kann verwendet werden, um das Array auf unterschiedlichen Wegen zu initialisieren:“

Wenn es sich um einen string handelt, musst du auch die Parameter encoding (und optional errors) angeben; bytearray() wandelt den String dann mithilfe von str.encode() in Bytes um.“
Wenn es sich um eine Ganzzahl (integer) handelt, erhält das Array diese Größe und wird mit Null-Bytes initialisiert.“
Handelt es sich um ein Objekt, das dem buffer interface entspricht, so wird ein schreibgeschützter Puffer des Objekts verwendet, um das Bytes-Array zu initialisieren.“
Wenn es sich um ein iterable handelt, muss es eine Liste von Ganzzahlen im Bereich 0 <= x < 256 sein, die als anfänglicher Inhalt des Arrays verwendet werden.“

Ohne Argument wird ein Array der Größe 0 erstellt.

Siehe auch Binäre Sequenztypen – bytes, bytearray, memoryview und Bytearray-Objekte.

class bytes(source=b'')

class bytes(source, encoding, errors='strict')

Gibt ein neues „bytes“-Objekt zurück, bei dem es sich um eine unveränderliche Sequenz von Ganzzahlen im Bereich 0 <= x < 256 handelt. bytes ist eine unveränderliche Version von bytearray – es verfügt über dieselben nicht-modifizierenden Methoden sowie dasselbe Verhalten bei Indizierung und Slicing.

Demzufolge werden die Konstruktorargumente wie bei bytearray() interpretiert.

Bytes-Objekte können auch mithilfe von Literalen erstellt werden; siehe String and Bytes literals.

Siehe auch Binäre Sequenztypen – bytes, bytearray, memoryview, Bytes-Objekte und Bytes- und Bytearray-Operationen.

callable(object, /)¶: Gibt True zurück, wenn das Argument object aufrufbar erscheint, andernfalls False. Wenn dies True zurückgibt, ist es dennoch möglich, dass ein Aufruf fehlschlägt; ist es jedoch False, wird der Aufruf von object niemals erfolgreich sein. Beachte, dass Klassen aufrufbar sind (der Aufruf einer Klasse gibt eine neue Instanz zurück); Instanzen sind aufrufbar, wenn ihre Klasse über eine Methode __call__() verfügt.

Added in version 3.2: Diese Funktion wurde zunächst in Python 3.0 entfernt und dann in Python 3.2 wieder eingeführt.

chr(codepoint, /)¶

Gibt den String zurück, der das Zeichen mit dem angegebenen Unicode-Codepunkt darstellt. Zum Beispiel liefert chr(97) den String 'a', während chr(8364) den String '€' liefert. Dies ist die Umkehrfunktion zu ord().

Der zulässige Wertebereich für das Argument reicht von 0 bis 1.114.111 (0x10FFFF im Hexadezimalsystem). Liegt der Wert außerhalb dieses Bereichs, wird eine ValueError-Ausnahme ausgelöst.

@classmethod¶

Wandeln Sie eine Methode in eine Klassenmethode um.

Eine Klassenmethode erhält die Klasse als implizites erstes Argument, genau wie eine Instanzmethode die Instanz erhält. Um eine Klassenmethode zu deklarieren, verwenden Sie dieses Idiom:

class C:
    @classmethod
    def f(cls, arg1, arg2): ...

Die @classmethod-Form ist eine Funktion decorator – siehe Funktionsdefinitionen für Details.“

Eine Klassenmethode kann entweder auf der Klasse (z. B. C.f()) oder auf einer Instanz (z. B. C().f()) aufgerufen werden. Die Instanz wird dabei ignoriert, mit Ausnahme ihrer Klasse. Wird eine Klassenmethode für eine abgeleitete Klasse aufgerufen, so wird das Objekt der abgeleiteten Klasse als implizites erstes Argument übergeben.

Klassenmethoden unterscheiden sich von statischen Methoden in C++ oder Java. Wenn Sie solche benötigen, siehe staticmethod() in diesem Abschnitt. Weitere Informationen zu Klassenmethoden finden Sie unter Die Standardtyp-Hierarchie.

Geändert in Version 3.9: Klassenmethoden können nun andere Deskriptoren wie property() umschließen.

Geändert in Version 3.10: Klassenmethoden erben nun die Methodenattribute (__module__, __name__, __qualname__, __doc__ und __annotations__) und verfügen über ein neues __wrapped__-Attribut.

Veraltet seit Version 3.11, entfernt in Version 3.13: Klassenmethoden können keine anderen Deskriptoren mehr kapseln, wie etwa property().

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)¶

Kompiliere source zu einem Code- oder AST-Objekt. Code-Objekte können mit exec() oder eval() ausgeführt werden. source kann entweder ein normaler String, ein Byte-String oder ein AST-Objekt sein. Informationen zur Arbeit mit AST-Objekten findest du in der Dokumentation zum Modul ast.

Das Argument filename sollte die Datei angeben, aus der der Code gelesen wurde; übergeben Sie einen erkennbaren Wert, falls er nicht aus einer Datei gelesen wurde (häufig wird '<string>' verwendet).

Das Argument mode legt fest, welche Art von Code kompiliert werden soll; es kann 'exec' sein, wenn source aus einer Folge von Anweisungen besteht, 'eval', wenn es aus einem einzelnen Ausdruck besteht, oder 'single', wenn es aus einer einzelnen interaktiven Anweisung besteht (im letzteren Fall werden Ausdrucksanweisungen, die einen anderen Wert als None ergeben, ausgegeben).

Die optionalen Argumente flags und dont_inherit steuern, welche Compiler-Optionen aktiviert und welche future features zugelassen werden sollen. Wenn keines der Argumente angegeben ist (oder beide null sind), wird der Code mit denselben Flags kompiliert, die auch für den Code gelten, der compile() aufruft. Wird das Argument flags angegeben, dont_inherit jedoch nicht (oder ist es null), so werden die durch flags festgelegten Compiler-Optionen und future-Anweisungen zusätzlich zu jenen verwendet, die ohnehin zur Anwendung kämen. Ist dont_inherit eine Ganzzahl ungleich null, so ist das Argument flags allein maßgeblich – die Flags (future-Funktionen und Compiler-Optionen) des umgebenden Codes werden ignoriert.

Compiler-Optionen und Future-Anweisungen werden durch Bits festgelegt, die mittels bitweiser ODER-Verknüpfung kombiniert werden können, um mehrere Optionen anzugeben. Das für eine bestimmte Future-Funktion erforderliche Bitfeld ist als Attribut compiler_flag der Instanz von _Feature im Modul __future__ zu finden. Compiler-Flags sind im Modul ast unter dem Präfix PyCF_ zu finden.

Das Argument optimize legt die Optimierungsstufe des Compilers fest; der Standardwert -1 wählt die Optimierungsstufe des Interpreters, wie sie durch die Optionen -O bestimmt wird. Explizite Stufen sind 0 (keine Optimierung; __debug__ ist wahr), 1 (Erklärungen werden entfernt, __debug__ ist falsch) oder 2 (auch Docstrings werden entfernt).

This function raises SyntaxError if the compiled source is invalid, including a source containing a null character or that cannot be decoded; ValueError if mode or flags is invalid, or if a string source contains surrogate characters; MemoryError or RecursionError if source is too complex to parse or compile, for example an expression with many thousands of nested operators; and OverflowError if source is too large.

Wenn du Python-Code in seine AST-Darstellung parsen möchtest, siehe ast.parse().

Löst ein Audit-Ereignis namens compile mit den Argumenten source und filename aus. Dieses Ereignis kann auch durch implizite Kompilierung ausgelöst werden.

Bemerkung

Beim Kompilieren einer Zeichenkette mit mehrzeiligem Code im Modus 'single' oder 'eval' muss die Eingabe mit mindestens einem Zeilenumbruchzeichen enden. Dies dient dazu, die Erkennung unvollständiger und vollständiger Anweisungen im Modul code zu erleichtern.

Warnung

Es ist möglich, den Python-Interpreter beim Kompilieren in ein AST-Objekt mit einem hinreichend großen oder komplexen String zum Absturz zu bringen – bedingt durch die Beschränkungen der Stack-Tiefe im AST-Compiler von Python.

Geändert in Version 3.2: Unterstützung für Zeilenumbrüche unter Windows und Mac hinzugefügt. Zudem muss die Eingabe im Modus 'exec' nicht mehr mit einem Zeilenumbruch enden. Der Parameter optimize wurde hinzugefügt.

Geändert in Version 3.5: Früher wurde ein TypeError ausgelöst, wenn in source Null-Bytes auftraten.

Geändert in Version 3.8: ast.PyCF_ALLOW_TOP_LEVEL_AWAIT kann nun in den Flags übergeben werden, um die Unterstützung für await, async for und async with auf oberster Ebene zu aktivieren.

Geändert in Version 3.12: SyntaxError is raised instead of ValueError when null bytes are encountered in source.

class complex(number=0, /)¶

class complex(string, /)

class complex(real=0, imag=0)

Wandeln Sie eine einzelne Zeichenkette oder Zahl in eine komplexe Zahl um oder erstellen Sie eine komplexe Zahl aus Real- und Imaginärteil.

Beispiele:

>>> complex('+1.23')
(1.23+0j)
>>> complex('-4.5j')
-4.5j
>>> complex('-1.23+4.5j')
(-1.23+4.5j)
>>> complex('\t( -1.23+4.5J )\n')
(-1.23+4.5j)
>>> complex('-Infinity+NaNj')
(-inf+nanj)
>>> complex(1.23)
(1.23+0j)
>>> complex(imag=-4.5)
-4.5j
>>> complex(-1.23, 4.5)
(-1.23+4.5j)

Wenn das Argument ein String ist, muss es entweder einen Realteil (im gleichen Format wie für float()) oder einen Imaginärteil (im gleichen Format, jedoch mit dem Suffix 'j' oder 'J') oder sowohl einen Real- als auch einen Imaginärteil enthalten (wobei das Vorzeichen des Imaginärteils in diesem Fall zwingend erforderlich ist). Der String kann optional von Leerzeichen sowie den runden Klammern '(' und ')' umschlossen sein; diese werden ignoriert. Der String darf keine Leerzeichen zwischen '+', '-', dem Suffix 'j' oder 'J' und der Dezimalzahl enthalten. So ist beispielsweise complex('1+2j') zulässig, während complex('1 + 2j') einen ValueError auslöst. Genauer gesagt muss die Eingabe – nach Entfernung von Klammern sowie führenden und nachgestellten Leerzeichen – der Produktionsregel complexvalue in der folgenden Grammatik entsprechen:

complexvalue ::= floatvalue |
                 floatvalue ("j" | "J") |
                 floatvalue sign absfloatvalue ("j" | "J")

Wenn das Argument eine Zahl ist, fungiert der Konstruktor als numerische Umwandlung, ähnlich wie int und float. Bei einem allgemeinen Python-Objekt x delegiert complex(x) an x.__complex__(). Ist __complex__() nicht definiert, wird auf __float__() zurückgegriffen. Ist __float__() nicht definiert, wird auf __index__() zurückgegriffen.“

Wenn zwei Argumente übergeben oder Schlüsselwortargumente verwendet werden, kann jedes Argument von einem beliebigen numerischen Typ (einschließlich komplexer Zahlen) sein. Sind beide Argumente reelle Zahlen, wird eine komplexe Zahl mit dem Realteil real und dem Imaginärteil imag zurückgegeben. Sind beide Argumente komplexe Zahlen, wird eine komplexe Zahl mit dem Realteil real.real-imag.imag und dem Imaginärteil real.imag+imag.real zurückgegeben. Ist eines der Argumente eine reelle Zahl, wird in den obigen Ausdrücken nur deren Realteil verwendet.

Wenn keine Argumente angegeben werden, wird 0j zurückgegeben.

Der komplexe Typ wird unter Numerische Typen — int, float, complex beschrieben.

Geändert in Version 3.6: Die Gruppierung von Ziffern mittels Unterstrichen, wie bei Code-Literalen, ist zulässig.

Geändert in Version 3.8: Fällt auf __index__() zurück, wenn __complex__() und __float__() nicht definiert sind.

delattr(object, name, /)¶: Dies ist ein Gegenstück zu setattr(). Die Argumente sind ein Objekt und eine Zeichenkette. Die Zeichenkette muss der Name eines der Attribute des Objekts sein. Die Funktion löscht das benannte Attribut, sofern das Objekt dies zulässt. So entspricht beispielsweise delattr(x, 'foobar') der Anweisung del x.foobar. name muss kein Python-Bezeichner sein (siehe setattr()).

class dict(**kwargs)

class dict(mapping, /, **kwargs)

class dict(iterable, /, **kwargs)

Erstellt ein neues Dictionary. Das Objekt dict ist die Dictionary-Klasse. Siehe auch Mapping-Typen – dict für die Dokumentation zu dieser Klasse.

Für weitere Container siehe die eingebauten Klassen list, set und tuple sowie das Modul collections.

dir()¶

dir(object, /)

Ohne Argumente wird die Liste der Namen im aktuellen lokalen Gültigkeitsbereich zurückgegeben. Mit einem Argument wird versucht, eine Liste der gültigen Attribute für dieses Objekt zurückzugeben.

Wenn das Objekt eine Methode namens __dir__() besitzt, wird diese Methode aufgerufen und muss die Liste der Attribute zurückgeben. Dies ermöglicht es Objekten, die eine benutzerdefinierte Funktion __getattr__() oder __getattribute__() implementieren, die Art und Weise anzupassen, wie dir() ihre Attribute auflistet.“

Wenn das Objekt kein __dir__() bereitstellt, versucht die Funktion, so viele Informationen wie möglich aus dem __dict__-Attribut des Objekts (sofern definiert) sowie aus dessen Typobjekt zu gewinnen. Die resultierende Liste ist nicht zwangsläufig vollständig und kann ungenau sein, wenn das Objekt über eine benutzerdefinierte __getattr__()-Methode verfügt.

Der Standardmechanismus von dir() verhält sich bei verschiedenen Objekttypen unterschiedlich, da er versucht, die relevantesten – und nicht etwa die vollständigen – Informationen zu liefern:

Wenn es sich bei dem Objekt um ein Modulobjekt handelt, enthält die Liste die Namen der Attribute des Moduls.
Wenn es sich bei dem Objekt um ein Typ- oder Klassenobjekt handelt, enthält die Liste die Namen seiner Attribute sowie – rekursiv – die Namen der Attribute seiner Basisklassen.
Andernfalls enthält die Liste die Namen der Attribute des Objekts, die Namen der Attribute seiner Klasse sowie – rekursiv – die Namen der Attribute der Basisklassen seiner Klasse.

Die resultierende Liste ist alphabetisch sortiert. Zum Beispiel:

>>> import struct
>>> dir()   # show the names in the module namespace
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
...
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

Bemerkung

Da dir() in erster Linie als Hilfsmittel für die Verwendung an einer interaktiven Eingabeaufforderung gedacht ist, zielt die Funktion eher darauf ab, eine interessante Menge von Namen zu liefern, als eine streng oder konsistent definierte Menge; zudem kann sich ihr detailliertes Verhalten zwischen verschiedenen Releases ändern. So sind beispielsweise Metaklassen-Attribute nicht in der Ergebnisliste enthalten, wenn das Argument eine Klasse ist.

divmod(a, b, /)¶: Nimmt zwei (nicht komplexe) Zahlen als Argumente entgegen und gibt ein Zahlenpaar zurück, das aus dem Quotienten und dem Rest der Ganzzahldivision besteht. Bei gemischten Operandentypen gelten die Regeln für binäre arithmetische Operatoren. Bei Ganzzahlen entspricht das Ergebnis (a // b, a % b). Bei Gleitkomma-zahlen lautet das Ergebnis (q, a % b), wobei q normalerweise math.floor(a / b) entspricht, aber auch um 1 kleiner sein kann. In jedem Fall liegt q * b + a % b sehr nahe bei a; ist a % b ungleich null, so hat es dasselbe Vorzeichen wie b, und es gilt 0 <= abs(a % b) < abs(b).

enumerate(iterable, start=0)¶

Gibt ein enumerate-Objekt zurück. iterable muss eine Sequenz, ein Iterator oder ein anderes Objekt sein, das Iteration unterstützt. Die __next__()-Methode des von enumerate() zurückgegebenen Iterators liefert ein Tupel, das einen Zähler (beginnend bei start, standardmäßig 0) und die durch Iteration über iterable erhaltenen Werte enthält.

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

Gleichbedeutend mit:

def enumerate(iterable, start=0):
    n = start
    for elem in iterable:
        yield n, elem
        n += 1

eval(source, /, globals=None, locals=None)¶

Parameter:

source (str | code object) – Ein Python Ausdruck
globals (dict | None) – Der globale Namensraum (default: None).
locals (mapping | None) – Der lokale Namensraum (default: None).

Rückgabe:

Das Ergebnis des ausgewerteten Ausdrucks.

Meldung:

Syntaxfehler werden als Ausnahmen gemeldet.

Warnung

Diese Funktion führt beliebigen Code aus. Der Aufruf mit nicht vertrauenswürdigen, benutzerdefinierten Eingaben führt zu Sicherheitslücken.

Das Argument source wird als Python-Ausdruck geparst und ausgewertet (genauer gesagt als Ausdrucksliste), wobei die Mappings globals und locals als globaler bzw. lokaler Namensraum verwendet werden. Ist das Dictionary globals vorhanden und enthält keinen Wert für den Schlüssel __builtins__, wird vor dem Parsen von source ein Verweis auf das Dictionary des eingebauten Moduls builtins unter diesem Schlüssel eingefügt. Das Überschreiben von __builtins__ kann verwendet werden, um die verfügbaren Namen einzuschränken oder zu ändern, dies ist jedoch kein Sicherheitsmechanismus: Der ausgeführte Code kann weiterhin auf alle Builtins zugreifen. Wird das Mapping locals weggelassen, wird standardmäßig das Dictionary globals verwendet. Werden beide Mappings weggelassen, wird der Quelltext mit den globals und locals der Umgebung ausgeführt, in der eval() aufgerufen wird. Beachte, dass eval() nur dann Zugriff auf verschachtelte Gültigkeitsbereiche (nicht-lokale Variablen) in der umschließenden Umgebung hat, wenn diese bereits im Gültigkeitsbereich referenziert werden, der eval() aufruft (z. B. über eine nonlocal-Anweisung).

Beispiel:

>>> x = 1
>>> eval('x+1')
2

>>> eval("1, 2")
(1, 2)

Diese Funktion kann auch verwendet werden, um beliebige Code-Objekte (wie etwa solche, die mit compile() erstellt wurden) auszuführen. Übergeben Sie in diesem Fall ein Code-Objekt anstelle einer Zeichenkette. Wenn das Code-Objekt mit 'exec' als mode-Argument kompiliert wurde, ist der Rückgabewert von eval() None.

Hinweise: Die dynamische Ausführung von Anweisungen wird durch die Funktion exec() unterstützt. Die Funktionen globals() und locals() liefern das aktuelle globale beziehungsweise lokale Dictionary zurück; dies kann nützlich sein, um sie an eval() oder exec() weiterzugeben.

Wenn die angegebene Quelle eine Zeichenkette ist, werden führende und nachstehende Leerzeichen sowie Tabulatoren entfernt.

Siehe ast.literal_eval() für eine Funktion, um Zeichenketten mit Ausdrücken auszuwerten, die nur Literale enthalten.

Löst ein Audit-Ereignis exec mit dem Code-Objekt als Argument aus. Es können auch Ereignisse zur Code-Kompilierung ausgelöst werden.

Geändert in Version 3.13: Die Argumente globals und locals können nun als Schlüsselwortargumente übergeben werden.

Geändert in Version 3.13: Die Semantik des Standard-Namensraums für lokale Variablen (locals) wurde wie für die eingebaute Funktion locals() beschrieben angepasst.

exec(source, /, globals=None, locals=None, *, closure=None)¶

Warnung

Diese Funktion führt beliebigen Code aus. Der Aufruf mit nicht vertrauenswürdigen, benutzerdefinierten Eingaben führt zu Sicherheitslücken.

Diese Funktion unterstützt die dynamische Ausführung von Python-Code. source muss entweder eine Zeichenkette oder ein Code-Objekt sein. Handelt es sich um eine Zeichenkette, so wird diese als eine Folge von Python-Anweisungen geparst und anschließend ausgeführt (sofern kein Syntaxfehler auftritt). [1] Handelt es sich um ein Code-Objekt, so wird dieses einfach ausgeführt. In jedem Fall muss der ausgeführte Code als Dateieingabe gültig sein (siehe den Abschnitt File input im Referenzhandbuch). Beachten Sie, dass die Anweisungen nonlocal, yield und return auch innerhalb des an die Funktion exec() übergebenen Codes nicht außerhalb von Funktionsdefinitionen verwendet werden dürfen. Der Rückgabewert ist None.

In allen Fällen wird der Code im aktuellen Gültigkeitsbereich ausgeführt, wenn die optionalen Argumente weggelassen werden. Wird nur globals angegeben, muss es sich um ein Dictionary handeln (und nicht um eine Unterklasse davon), das sowohl für die globalen als auch für die lokalen Variablen verwendet wird. Werden sowohl globals als auch locals angegeben, so dienen sie jeweils als globale beziehungsweise lokale Variablen. Falls angegeben, kann locals ein beliebiges Mapping-Objekt sein. Beachten Sie, dass auf Modulebene globale und lokale Variablen dasselbe Dictionary darstellen.

Bemerkung

Wenn „exec“ zwei separate Objekte als globals und locals erhält, wird der Code so ausgeführt, als wäre er in eine Klassendefinition eingebettet. Das bedeutet, dass im ausgeführten Code definierte Funktionen und Klassen nicht auf Variablen zugreifen können, die auf der obersten Ebene zugewiesen wurden (da diese Variablen der „obersten Ebene“ in einer Klassendefinition als Klassenvariablen behandelt werden).

Enthält das Dictionary globals keinen Wert für den Schlüssel __builtins__, wird ein Verweis auf das Dictionary des eingebauten Moduls builtins unter diesem Schlüssel eingefügt. Das Überschreiben von __builtins__ kann verwendet werden, um die verfügbaren Namen einzuschränken oder zu ändern, dies ist jedoch kein Sicherheitsmechanismus: Der ausgeführte Code kann weiterhin auf alle Builtins zugreifen.

Das Argument closure spezifiziert einen Closure – ein Tupel von Cell-Variablen. Es ist nur dann gültig, wenn das Objekt ein Code-Objekt ist, das freie (Closure-)Variablen enthält. Die Länge des Tupels muss exakt der Länge des Attributs co_freevars des Code-Objekts entsprechen.

Löst ein Audit-Ereignis exec mit dem Code-Objekt als Argument aus. Es können auch Ereignisse zur Code-Kompilierung ausgelöst werden.

Bemerkung

Die eingebauten Funktionen globals() und locals() geben den aktuellen globalen beziehungsweise lokalen Namensraum zurück; dies kann nützlich sein, um sie als zweites und drittes Argument an exec() zu übergeben.

Bemerkung

Die Standard locals wirken wie für die Funktion locals() weiter unten beschrieben. Übergeben Sie ein explizites locals-Dictionary, wenn Sie die Auswirkungen des Codes auf die locals sehen möchten, nachdem die Funktion exec() zurückgekehrt ist.

Geändert in Version 3.11: Der Parameter closure wurde hinzugefügt.

Geändert in Version 3.13: Die Argumente globals und locals können nun als Schlüsselwortargumente übergeben werden.

Geändert in Version 3.13: Die Semantik des Standard-Namensraums für lokale Variablen (locals) wurde wie für die eingebaute Funktion locals() beschrieben angepasst.

filter(function, iterable, /)¶

Erstellt einen Iterator aus denjenigen Elementen von iterable, für die function wahr ergibt. iterable kann entweder eine Sequenz, ein Container, der Iteration unterstützt, oder ein Iterator sein. Ist function None, so wird die Identitätsfunktion angenommen; das heißt, alle Elemente von iterable, die „falsch“ sind, werden entfernt.

Beachte, dass filter(function, iterable) dem Generatorausdruck (item for item in iterable if function(item)) entspricht, wenn function nicht None ist, und (item for item in iterable if item), wenn function None ist.

Siehe itertools.filterfalse() für die komplementäre Funktion, die Elemente von iterable zurückgibt, für die function falsch ist.

class float(number=0.0, /)¶

class float(string, /)

Geben Sie eine Gleitkommazahl zurück, die aus einer Zahl oder einer Zeichenkette erstellt wurde.

Beispiele:

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

Wenn das Argument eine Zeichenkette ist, muss sie eine Dezimalzahl enthalten, der optional ein Vorzeichen vorangestellt ist und die optional von Leerzeichen umgeben sein kann. Das optionale Vorzeichen kann '+' oder '-' sein; ein '+'-Zeichen hat keinen Einfluss auf den resultierenden Wert. Das Argument kann auch eine Zeichenkette sein, die NaN (Not-a-Number) oder positive bzw. negative Unendlichkeit darstellt. Genauer gesagt muss die Eingabe – nach Entfernung führender und nachfolgender Leerzeichen – der Produktionsregel floatvalue in der folgenden Grammatik entsprechen:“

sign          ::= "+" | "-"
infinity      ::= "Infinity" | "inf"
nan           ::= "nan"
digit         ::= <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
digitpart     ::= digit (["_"] digit)*
number        ::= [digitpart] "." digitpart | digitpart ["."]
exponent      ::= ("e" | "E") [sign] digitpart
floatnumber   ::= number [exponent]
absfloatvalue ::= floatnumber | infinity | nan
floatvalue    ::= [sign] absfloatvalue

Die Groß-/Kleinschreibung spielt keine Rolle; so sind beispielsweise „inf“, „Inf“, „INFINITY“ und „iNfINity“ allesamt zulässige Schreibweisen für positive Unendlichkeit.

Handelt es sich bei dem Argument andernfalls um eine Ganzzahl oder eine Gleitkommazahl, so wird eine Gleitkommazahl mit demselben Wert (innerhalb der Gleitkommapräzision von Python) zurückgegeben. Liegt das Argument außerhalb des Wertebereichs eines Python-Floats, wird ein OverflowError ausgelöst.

Für ein allgemeines Python-Objekt x delegiert float(x) an x.__float__(). Wenn __float__() nicht definiert ist, fällt es „zurück zu __index__().“

Wenn kein Argument angegeben wird, wird 0.0 zurückgegeben.

Der Typ „float“ wird in Numerische Typen — int, float, complex beschrieben.

Geändert in Version 3.6: Die Gruppierung von Ziffern mittels Unterstrichen, wie bei Code-Literalen, ist zulässig.

Geändert in Version 3.7: Der Parameter ist jetzt rein positionsgebunden.

Geändert in Version 3.8: Fällt auf __index__() zurück, wenn __float__() nicht definiert ist.

format(value, format_spec='', /)¶

Wandelt einen Wert in eine „formatierte“ Darstellung um, wie durch format_spec festgelegt. Die Interpretation von format_spec hängt vom Typ des Arguments Wert ab; es gibt jedoch eine Standard-Formatierungssyntax, die von den meisten eingebauten Typen verwendet wird: Formatspezifikation Mini-Sprache.

Die Standard format_spec ist eine leere Zeichenkette, was normalerweise denselben Effekt hat wie der Aufruf von str(value).

Ein Aufruf von format(value, format_spec) wird in type(value).__format__(value, format_spec) übersetzt, wodurch das Instanz-Dictionary bei der Suche nach der __format__()-Methode des Werts umgangen wird. Eine TypeError-Ausnahme wird ausgelöst, wenn die Methodensuche object erreicht und format_spec nicht leer ist, oder wenn entweder format_spec oder der Rückgabewert keine Zeichenkette ist.

Geändert in Version 3.4: object().__format__(format_spec) löst TypeError aus, wenn format_spec keine leere Zeichenkette ist.

class frozenset(iterable=(), /)

Gibt ein neues Objekt frozenset zurück, optional mit Elementen aus iterable. frozenset ist eine eingebaute Klasse. Siehe auch Mengen-Typen – set, frozenset für die Dokumentation zu dieser Klasse.

Für weitere Container siehe die eingebauten Klassen set, list, tuple und dict sowie das Modul collections.

getattr(object, name, /)¶
getattr(object, name, default, /): Gibt den Wert des benannten Attributs von object zurück. name muss ein String sein. Wenn der String der Name eines der Attribute des Objekts ist, ist das Ergebnis der Wert dieses Attributs. Zum Beispiel entspricht getattr(x, 'foobar') dem Ausdruck x.foobar. Existiert das benannte Attribut nicht, wird default zurückgegeben, sofern angegeben; andernfalls wird ein AttributeError ausgelöst. name muss kein Python-Bezeichner sein (siehe setattr()).

Bemerkung

Da Private Name Mangling zur Kompilierzeit erfolgt, muss der Name eines privaten Attributs (Attribute mit zwei führenden Unterstrichen) manuell umgewandelt werden, um es mittels getattr() abrufen zu können.

globals()¶: Geben Sie das Dictionary zurück, das den Namespace des aktuellen Moduls implementiert. Bei Code innerhalb von Funktionen wird dieses bei der Definition der Funktion festgelegt und bleibt unverändert, unabhängig davon, von wo aus die Funktion aufgerufen wird.

hasattr(object, name, /)¶: Die Argumente sind ein Objekt und ein String. Das Ergebnis ist True, wenn der String der Name eines Attributs des Objekts ist, andernfalls False. (Dies wird implementiert, indem getattr(object, name) aufgerufen und geprüft wird, ob ein AttributeError ausgelöst wird oder nicht.)

hash(object, /)¶: Gibt den Hash-Wert des Objekts zurück (sofern es einen besitzt). Hash-Werte sind Ganzzahlen. Sie dienen dazu, Dictionary-Schlüssel bei einer Suche im Dictionary schnell zu vergleichen. Numerische Werte, die als gleich gelten, haben denselben Hash-Wert (selbst wenn sie unterschiedlichen Typs sind, wie es bei 1 und 1.0 der Fall ist).

Bemerkung

Beachte bei Objekten mit benutzerdefinierten __hash__()-Methoden, dass hash() den Rückgabewert basierend auf der Bitbreite des Host-Rechners abschneidet.

help()¶

help(request)

Ruft das integrierte Hilfesystem auf. (Diese Funktion ist für die interaktive Nutzung vorgesehen.) Wenn kein Argument angegeben wird, startet das interaktive Hilfesystem auf der Interpreterkonsole. Wenn das Argument eine Zeichenkette ist, wird diese als Name eines Moduls, einer Funktion, einer Klasse, einer Methode, eines Schlüsselworts oder eines Dokumentationsthemas nachgeschlagen und eine Hilfeseite auf der Konsole ausgegeben. Wenn das Argument ein anderes Objekt ist, wird eine Hilfeseite zu diesem Objekt generiert.

Beachten Sie: Wenn beim Aufruf von help() ein Schrägstrich (/) in der Parameterliste einer Funktion erscheint, bedeutet dies, dass die Parameter vor dem Schrägstrich reine Positionsparameter sind. Weitere Informationen finden Sie unter dem FAQ-Eintrag zu reinen Positionsparametern.

Diese Funktion wird vom Modul site dem eingebauten Namensraum hinzugefügt.

Geändert in Version 3.4: Änderungen an pydoc und inspect führen dazu, dass die für aufrufbare Objekte (Callables) gemeldeten Signaturen nun umfassender und konsistenter sind.

hex(integer, /)¶

Wandelt eine Ganzzahl in eine hexadezimale Zeichenkette in Kleinbuchstaben mit dem Präfix „0x“ um. Wenn integer kein Python-Objekt vom Typ int ist, muss es eine __index__()-Methode definieren, die eine Ganzzahl zurückgibt. Einige Beispiele:

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

Wenn Sie eine Ganzzahl in eine hexadezimale Zeichenkette in Groß- oder Kleinbuchstaben umwandeln möchten – wahlweise mit oder ohne Präfix –, können Sie eine der folgenden Methoden verwenden:

>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

Weitere Informationen findest du unter format().

Siehe auch int() für die Umwandlung einer Hexadezimalzeichenkette in eine Ganzzahl unter Verwendung der Basis 16.

Bemerkung

Um eine hexadezimale String-Darstellung für einen Float-Wert zu erhalten, verwenden Sie die Methode float.hex().

id(object, /)¶

Gibt die „Identität“ eines Objekts zurück. Dies ist eine Ganzzahl, die garantiert eindeutig ist und während der Lebensdauer des Objekts konstant bleibt. Zwei Objekte, deren Lebensdauern sich nicht überschneiden, können denselben id()-Wert haben.

Dies ist die Adresse des Objekts im Speicher.

Löst ein Audit-Ereignis builtins.id mit dem Argument id aus.

input()¶

input(prompt, /)

Wenn das Argument prompt angegeben ist, wird es ohne abschließendes Zeilenumbruchzeichen auf die Standardausgabe geschrieben. Die Funktion liest dann eine Zeile von der Eingabe, wandelt sie in eine Zeichenkette um (wobei ein abschließendes Zeilenumbruchzeichen entfernt wird) und gibt diese zurück. Beim Erreichen des Dateiendes (EOF) wird EOFError ausgelöst. Beispiel::“

>>> s = input('--> ')
--> Monty Python's Flying Circus
>>> s
"Monty Python's Flying Circus"

Wenn das Modul readline geladen wurde, verwendet input() es, um umfangreiche Funktionen zur Zeilenbearbeitung und Historienverwaltung bereitzustellen.

Löst ein Audit-Ereignis builtins.input mit dem Argument prompt aus, bevor die Eingabe gelesen wird

Löst ein Audit-Ereignis builtins.input/result mit dem Ergebnis nach erfolgreichem Einlesen der Eingabe aus.

class int(number=0, /)¶

class int(string, /, base=10)

Gibt ein Integer-Objekt zurück, das aus einer Zahl oder einer Zeichenkette erstellt wurde, oder gibt 0 zurück, wenn keine Argumente angegeben sind.

Beispiele:

>>> int(123.45)
123
>>> int('123')
123
>>> int('   -12_345\n')
-12345
>>> int('FACE', 16)
64206
>>> int('0xface', 0)
64206
>>> int('01110011', base=2)
115

If the argument defines __int__(), int(x) returns x.__int__(). If the argument defines __index__(), it returns x.__index__(). If the argument defines __trunc__(), it returns x.__trunc__(). For floating-point numbers, this truncates towards zero.

Wenn das Argument keine Zahl ist oder wenn base angegeben wird, muss es sich um eine Zeichenkette, bytes oder bytearray Instanz handeln, die eine Ganzzahl zur Basis base darstellt. Optional kann der Zeichenkette ein + oder - vorangestellt sein (ohne Leerzeichen dazwischen); zudem kann sie führende Nullen aufweisen, von Leerzeichen umgeben sein und einzelne Unterstriche zwischen den Ziffern enthalten.

Eine Zeichenkette, die eine Ganzzahl zur Basis n darstellt, besteht aus Ziffern, von denen jede einen Wert von 0 bis n-1 repräsentiert. Die Werte 0 bis 9 können durch jede beliebige Unicode-Dezimalziffer dargestellt werden. Die Werte 10 bis 35 lassen sich durch a bis z (oder A bis Z) ausdrücken. Die Standardbasis ist 10. Zulässige Basen sind 0 sowie der Bereich von 2 bis 36. Zeichenketten für die Basen 2, 8 und 16 können optional mit einem Präfix wie 0b/0B, 0o/0O oder 0x/0X versehen werden, ähnlich wie bei Ganzzahl-Literalen im Quellcode. Bei der Basis 0 wird die Zeichenkette ähnlich wie ein Ganzzahl-Literal im Quellcode interpretiert, wobei die tatsächliche Basis 2, 8, 10 oder 16 durch das Präfix bestimmt wird. Zudem sind bei der Basis 0 keine führenden Nullen zulässig: int('010', 0) ist ungültig, während int('010') und int('010', 8) zulässig sind.

Der Ganzzahltyp wird in Numerische Typen — int, float, complex beschrieben.

Geändert in Version 3.4: Wenn base keine Instanz von int ist und das base-Objekt über eine base.__index__-Methode verfügt, wird diese Methode aufgerufen, um eine Ganzzahl für die Basis zu erhalten. In früheren Versionen wurde base.__int__ anstelle von base.__index__ verwendet.

Geändert in Version 3.6: Die Gruppierung von Ziffern mittels Unterstrichen, wie bei Code-Literalen, ist zulässig.

Geändert in Version 3.7: Der erste Parameter ist nun rein positional.

Geändert in Version 3.8: Greift auf __index__() zurück, wenn __int__() nicht definiert ist.

Geändert in Version 3.11: The delegation to __trunc__() is deprecated.

Geändert in Version 3.11: Die Länge von Zeichenketten bei der Umwandlung in oder aus einem int kann begrenzt werden, um Denial-of-Service-Angriffe zu verhindern. Es wird ein ValueError ausgelöst, wenn das Limit bei der Umwandlung einer Zeichenkette in ein int überschritten wird oder wenn die Umwandlung eines int in eine Zeichenkette das Limit überschreiten würde. Siehe die Dokumentation zur Längenbegrenzung bei der Umwandlung von Ganzzahlen in Zeichenketten.

isinstance(object, classinfo, /)¶: Gibt True zurück, wenn das Argument object eine Instanz des Arguments classinfo oder einer (direkten, indirekten oder virtuellen) Unterklasse davon ist. Wenn object kein Objekt des angegebenen Typs ist, gibt die Funktion stets False zurück. Wenn classinfo ein Tupel von Typ-Objekten (oder rekursiv weiteren solchen Tupeln) oder eine Union-Typ aus mehreren Typen ist, wird True zurückgegeben, falls object eine Instanz eines dieser Typen ist. Wenn classinfo weder ein Typ noch ein Tupel von Typen (und solchen Tupeln) ist, wird eine TypeError-Ausnahme ausgelöst. Eine TypeError-Ausnahme wird für einen ungültigen Typ möglicherweise nicht ausgelöst, wenn eine frühere Überprüfung erfolgreich ist.

Geändert in Version 3.10: classinfo kann eine Union-Typ sein.

issubclass(class, classinfo, /)¶: Gibt True zurück, wenn class eine Unterklasse (direkt, indirekt oder virtuell) von classinfo ist. Eine Klasse gilt als Unterklasse ihrer selbst. classinfo kann ein Tupel von Klassenobjekten (oder rekursiv weitere solcher Tupel) oder eine Union-Typ sein; in diesem Fall wird True zurückgegeben, wenn class eine Unterklasse irgendeines Eintrags in classinfo ist. In allen anderen Fällen wird eine TypeError-Ausnahme ausgelöst.

Geändert in Version 3.10: classinfo kann eine Union-Typ sein.

iter(iterable, /)¶

iter(callable, sentinel, /)

Gibt ein Iterator-Objekt zurück. Das erste Argument wird je nach Vorhandensein des zweiten Arguments sehr unterschiedlich interpretiert. Ohne ein zweites Argument muss das einzige Argument ein Container-Objekt sein, das das iterable-Protokoll (die Methode __iter__()) oder das Sequenzprotokoll (die Methode __getitem__() mit ganzzahligen Argumenten beginnend bei 0) unterstützt. Wird keines dieser Protokolle unterstützt, so wird ein TypeError ausgelöst. Wenn das zweite Argument, sentinel, angegeben ist, muss das erste Argument ein aufrufbares Objekt (callable) sein. Der in diesem Fall erzeugte Iterator ruft bei jedem Aufruf seiner Methode __next__() das aufrufbare Objekt ohne Argumente auf; entspricht der Rückgabewert sentinel, so wird StopIteration ausgelöst, andernfalls wird der Wert zurückgegeben.

Siehe auch Iterator-Typen.

Eine nützliche Anwendung der zweiten Form von iter() ist die Erstellung eines Block-Readers. Zum Beispiel das Lesen von Blöcken fester Größe aus einer binären Datenbankdatei bis zum Erreichen des Dateiende:

from functools import partial
with open('mydata.db', 'rb') as f:
    for block in iter(partial(f.read, 64), b''):
        process_block(block)

len(object, /)¶: Gibt die Länge (die Anzahl der Elemente) eines Objekts zurück. Das Argument kann eine Sequenz (wie etwa ein String, Bytes, ein Tupel, eine Liste oder ein Range-Objekt) oder eine Collection (wie etwa ein Dictionary, ein Set oder ein Frozen Set) sein.

len löst bei Längen größer als sys.maxsize eine OverflowError-Ausnahme aus.Z. B. range(2 ** 100).

class list(iterable=(), /): Anstatt eine Funktion zu sein, ist list eigentlich ein veränderbarer Sequenztyp, wie in Listen und Sequenztypen – list, tuple, range dokumentiert.

locals()¶

Gibt ein Mapping-Objekt zurück, das die aktuelle lokale Symboltabelle repräsentiert, wobei die Variablennamen als Schlüssel und die aktuell daran gebundenen Referenzen als Werte dienen.

Auf Modulebene sowie bei der Verwendung von exec() oder eval() mit einem einzigen Namensraum gibt diese Funktion denselben Namensraum zurück wie globals().

Auf Klassenebene gibt es den Namensraum zurück, der an den Metaklassen-Konstruktor übergeben wird.

Bei der Verwendung von exec() oder eval() mit separaten lokalen und globalen Argumenten wird der lokale Namensraum zurückgegeben, der an den Funktionsaufruf übergeben wurde.

In allen oben genannten Fällen gibt jeder Aufruf von locals() in einem bestimmten Ausführungs-Frame dasselbe Mapping-Objekt zurück. Änderungen, die über das von locals() zurückgegebene Mapping-Objekt vorgenommen werden, zeigen sich als zugewiesene, neu zugewiesene oder gelöschte lokale Variablen; umgekehrt wirken sich Zuweisungen, Neuzuweisungen oder das Löschen lokaler Variablen unmittelbar auf den Inhalt des zurückgegebenen Mapping-Objekts aus.

In einem optimierten Gültigkeitsbereich (einschließlich Funktionen, Generatoren und Coroutinen) liefert jeder Aufruf von locals() stattdessen ein neues Dictionary zurück, das die aktuellen Bindungen der lokalen Variablen der Funktion sowie etwaige nonlocal-Zellreferenzen enthält. In diesem Fall werden Änderungen an Namensbindungen, die über das zurückgegebene Dictionary vorgenommen werden, nicht in die entsprechenden lokalen Variablen oder nonlocal-Zellreferenzen zurückgeschrieben; zudem hat das Zuweisen, Neuzuweisen oder Löschen lokaler Variablen und nonlocal-Zellreferenzen keine Auswirkungen auf den Inhalt zuvor zurückgegebener Dictionaries.

Der Aufruf von locals() als Teil einer Listen-Abstraktion (comprehension) in einer Funktion, einem Generator oder einer Coroutine entspricht dem Aufruf im umschließenden Gültigkeitsbereich, mit der Ausnahme, dass die initialisierten Iterationsvariablen der Listen-Abstraktion (comprehension) einbezogen werden. In anderen Gültigkeitsbereichen verhält es sich so, als würde die Listen-Abstraktion (comprehension) als verschachtelte Funktion ausgeführt.

Der Aufruf von locals() als Teil eines Generatorausdrucks ist gleichbedeutend mit dem Aufruf innerhalb einer verschachtelten Generatorfunktion.

Geändert in Version 3.12: Das Verhalten von locals() in einer Listen-Abstraktion (comprehension) wurde wie in PEP 709 beschrieben aktualisiert.

Geändert in Version 3.13: Im Rahmen von PEP 667 ist nun die Semantik für die Veränderung der von dieser Funktion zurückgegebenen Mapping-Objekte definiert. Das Verhalten in optimierten Gültigkeitsbereichen entspricht nun der obigen Beschreibung. Abgesehen von dieser Definition bleibt das Verhalten in anderen Gültigkeitsbereichen gegenüber früheren Versionen unverändert.

map(function, iterable, *iterables)¶: Return an iterator that applies function to every item of iterable, yielding the results. If additional iterables arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. With multiple iterables, the iterator stops when the shortest iterable is exhausted. For cases where the function inputs are already arranged into argument tuples, see itertools.starmap().

max(iterable, /, *, key=None)¶

max(iterable, /, *, default, key=None)

max(arg1, arg2, /, *args, key=None)

Gibt das größte Element eines iterierbaren Objekts oder das größte von zwei oder mehr Argumenten zurück.

Wird ein einzelnes Positionsargument übergeben, so muss es sich um ein iterable handeln. Das größte Element des Iterables wird zurückgegeben. Werden zwei oder mehr Positionsargumente übergeben, so wird das größte der Positionsargumente zurückgegeben.

Es gibt zwei optionale Argumente, die nur als Schlüsselwortargumente übergeben werden können. Das Argument key legt eine Sortierfunktion mit einem Argument fest, wie sie auch bei list.sort() verwendet wird. Das Argument default gibt ein Objekt an, das zurückgegeben wird, falls das übergebene Iterable leer ist. Ist das Iterable leer und wird kein default-Wert angegeben, so wird ein ValueError ausgelöst.

Wenn mehrere Elemente maximal sind, gibt die Funktion das erste zurück, auf das sie stößt. Dies steht im Einklang mit anderen Werkzeugen, die die Sortierstabilität bewahren, wie etwa sorted(iterable, key=keyfunc, reverse=True)[0] und heapq.nlargest(1, iterable, key=keyfunc).“

Geändert in Version 3.4: Der default-Parameter (nur als Keyword-Argument verwendbar) wurde hinzugefügt.

Geändert in Version 3.8: Der Schlüssel kann None sein.

class memoryview(object): Gibt ein aus dem angegebenen Argument erstelltes „memory-View“-Objekt zurück. Siehe Memory-Views für weitere Informationen.

min(iterable, /, *, key=None)¶

min(iterable, /, *, default, key=None)

min(arg1, arg2, /, *args, key=None)

Geben Sie das kleinste Element eines iterierbaren Objekts oder das kleinste von zwei oder mehr Argumenten zurück.

Wird ein einzelnes Positionsargument übergeben, so muss es sich um ein Iterable handeln. Das kleinste Element des Iterables wird zurückgegeben. Werden zwei oder mehr Positionsargumente übergeben, so wird das kleinste der Positionsargumente zurückgegeben.

Es gibt zwei optionale Argumente, die nur als Schlüsselwortargumente übergeben werden können. Das Argument key legt eine Sortierfunktion mit einem Argument fest, wie sie auch bei list.sort() verwendet wird. Das Argument default gibt ein Objekt an, das zurückgegeben wird, falls das übergebene Iterable leer ist. Ist das Iterable leer und wird kein default-Wert angegeben, so wird ein ValueError ausgelöst.

Wenn mehrere Elemente das Minimum darstellen, gibt die Funktion das erste zurück, auf das sie stößt. Dies steht im Einklang mit anderen Werkzeugen, die die Sortierstabilität wahren, wie etwa sorted(iterable, key=keyfunc)[0] und heapq.nsmallest(1, iterable, key=keyfunc).“

Geändert in Version 3.4: Der default-Parameter (nur als Keyword-Argument verwendbar) wurde hinzugefügt.

Geändert in Version 3.8: Der Schlüssel kann None sein.

next(iterator, /)¶
next(iterator, default, /): Retrieve the next item from the iterator by calling its __next__() method. If default is given, it is returned if the iterator is exhausted, otherwise StopIteration is raised.

class object¶: Dies ist die oberste Basisklasse aller anderen Klassen. Sie verfügt über Methoden, die allen Instanzen von Python-Klassen gemeinsam sind. Beim Aufruf des Konstruktors wird ein neues, eigenschaftsloses Objekt zurückgegeben. Der Konstruktor akzeptiert keine Argumente.

Bemerkung

Instanzen von object besitzen keine __dict__-Attribute; daher können Sie einer Instanz von object keine beliebigen Attribute zuweisen.

oct(integer, /)¶

Wandelt eine Ganzzahl in einen Oktal-String mit dem Präfix „0o“ um. Das Ergebnis ist ein gültiger Python-Ausdruck. Wenn integer kein Python int Objekt ist, muss es eine __index__()-Methode definieren, die eine Ganzzahl zurückgibt. Zum Beispiel:

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

Wenn du eine Ganzzahl mit oder ohne das Präfix „0o“ in eine Oktalzeichenkette umwandeln möchtest, kannst du eine der folgenden Möglichkeiten nutzen.

>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

Weitere Informationen findest du unter format().

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)¶

Öffnet file und gibt ein entsprechendes Dateiobjekt zurück. Wenn die Datei nicht geöffnet werden kann, wird ein OSError ausgelöst. Weitere Beispiele für die Verwendung dieser Funktion finden Sie unter Dateien lesen und schreiben.

file ist ein pfadartiges Objekt (path-like object), das den Pfadnamen (absolut oder relativ zum aktuellen Arbeitsverzeichnis) der zu öffnenden Datei angibt, oder ein ganzzahliger Dateideskriptor der zu umschließenden Datei. (Wird ein Dateideskriptor angegeben, so wird dieser geschlossen, wenn das zurückgegebene E/A-Objekt geschlossen wird, es sei denn, closefd ist auf False gesetzt.)

mode ist eine optionale Zeichenkette, die den Modus angibt, in dem die Datei geöffnet wird. Der Standardwert ist 'r', was das Öffnen zum Lesen im Textmodus bedeutet. Weitere gebräuchliche Werte sind 'w' zum Schreiben (wobei die Datei geleert wird, falls sie bereits existiert), 'x' für die exklusive Erstellung und 'a' zum Anhängen (was auf einigen Unix-Systemen bedeutet, dass alle Schreibvorgänge Daten an das Ende der Datei anhängen, unabhängig von der aktuellen Schreib-/Leseposition). Wenn im Textmodus kein encoding angegeben wird, hängt die verwendete Zeichenkodierung vom Betriebssystem ab: locale.getencoding() wird aufgerufen, um die Kodierung der aktuellen Locale zu ermitteln. (Verwenden Sie für das Lesen und Schreiben von Rohbytes den Binärmodus und lassen Sie encoding weg.) Die verfügbaren Modi sind:

Zeichen	<Bedeutung
`'r'`	zum Lesen öffnen (Standardwert)
`'w'`	zum Schreiben öffnen und die Datei dabei zunächst auf die Länge Null kürzen
`'x'`	zum exklusiven Erstellen öffnen; schlägt fehl, wenn die Datei bereits existiert
`'a'`	zum Schreiben öffnen; an das Ende der Datei anhängen, falls diese existiert
`'b'`	Binärmodus
`'t'`	Textmodus (default)
`'+'`	zum Aktualisieren öffnen (Lesen und Schreiben)

Der Standardmodus ist 'r' (zum Lesen von Text geöffnet, ein Synonym für 'rt').Die Modi 'w+' und 'w+b' öffnen und kürzen die Datei. Die Modi 'r+' und 'r+b‘ öffnet die Datei ohne Kürzung.“

Wie in der Overview erwähnt, unterscheidet Python zwischen Binär- und Text-E/A. Dateien, die im Binärmodus geöffnet werden (wobei das Argument mode ein 'b' enthält), geben ihren Inhalt als bytes-Objekte ohne jegliche Dekodierung zurück. Im Textmodus (der Standardeinstellung oder wenn das Argument mode ein 't' enthält) wird der Dateiinhalt als str zurückgegeben, wobei die Bytes zuvor mithilfe einer plattformabhängigen Kodierung oder – falls angegeben – mithilfe des spezifizierten encoding dekodiert wurden.

Bemerkung

Python ist nicht von den Eigenschaften des zugrundeliegenden Betriebssystems von Textdateien abhängig; die gesamte Verarbeitung erfolgt durch Python selbst und ist daher plattformunabhängig.

buffering ist eine optionale Ganzzahl, die zur Festlegung der Pufferungsstrategie dient. Übergeben Sie 0, um die Pufferung zu deaktivieren (nur im Binärmodus zulässig), 1, um Zeilenpufferung zu wählen (nur beim Schreiben im Textmodus verwendbar), und eine Ganzzahl > 1, um die Größe eines Puffers fester Größe in Bytes anzugeben. Beachten Sie, dass die Angabe einer Puffergröße auf diese Weise für gepufferte Binär-E/A gilt, während TextIOWrapper (d. h. mit mode='r+' geöffnete Dateien) eine andere Pufferung verwendet. Um die Pufferung in TextIOWrapper zu deaktivieren, können Sie das Flag write_through für io.TextIOWrapper.reconfigure() verwenden. Wenn kein buffering-Argument angegeben wird, funktioniert die Standard-Pufferungsstrategie wie folgt:

Binary files are buffered in fixed-size chunks; the size of the buffer is chosen using a heuristic trying to determine the underlying device’s „block size“ and falling back on io.DEFAULT_BUFFER_SIZE. On many systems, the buffer will typically be 4096 or 8192 bytes long.
„Interaktive“ Textdateien (Dateien, für die isatty() True zurückgibt) verwenden Zeilenpufferung. Andere Textdateien verwenden das für Binärdateien beschriebene Verfahren.

encoding ist der Name der Zeichenkodierung, die zum Dekodieren oder Kodieren der Datei verwendet wird. Dies sollte nur im Textmodus verwendet werden. Die Standardkodierung ist plattformabhängig (entsprechend dem Rückgabewert von locale.getencoding()), es kann jedoch jede von Python unterstützte Textkodierung verwendet werden. Eine Liste der unterstützten Kodierungen finden Sie im Modul codecs.

errors ist eine optionale Zeichenkette, die festlegt, wie mit Fehlern bei der Kodierung und Dekodierung umgegangen werden soll – dies kann nicht im Binärmodus verwendet werden. Es stehen verschiedene Standard-Fehlerbehandlungsroutinen zur Verfügung (aufgeführt unter Error Handlers), wobei auch jeder Name für eine Fehlerbehandlungsroutine zulässig ist, der mit codecs.register_error() registriert wurde. Zu den Standardnamen gehören:“

'strict', um eine ValueError-Ausnahme auszulösen, wenn ein Kodierungsfehler auftritt. Der Standardwert None hat dieselbe Wirkung.
'ignore' ignoriert Fehler. Beachten Sie, dass das Ignorieren von Kodierungsfehlern zu Datenverlust führen kann.“
'replace' bewirkt, dass an Stellen mit fehlerhaften Daten ein Ersetzungszeichen (wie etwa '?') eingefügt wird.“
'surrogateescape' stellt fehlerhafte Bytes als reduzierte Ersatz-Codeeinheiten (low surrogate code) im Bereich von U+DC80 bis U+DCFF dar. Diese Ersatz-Codeeinheiten werden beim Schreiben von Daten – sofern der Fehlerbehandler surrogateescape verwendet wird – wieder in die ursprünglichen Bytes zurückgewandelt. Dies ist nützlich für die Verarbeitung von Dateien mit unbekannter Zeichenkodierung.
'xmlcharrefreplace' wird nur beim Schreiben in eine Datei unterstützt. Zeichen, die von der Zeichenkodierung nicht unterstützt werden, werden durch die entsprechende XML-Zeichenreferenz &#nnn; ersetzt.“
'backslashreplace' ersetzt fehlerhafte Daten durch Pythons Escape-Sequenzen mit Backslash.“
'namereplace' (wird ebenfalls nur beim Schreiben unterstützt) ersetzt nicht unterstützte Zeichen durch \N{...}-Escape-Sequenzen.“

newline legt fest, wie Zeilenumbruchzeichen aus dem Datenstrom verarbeitet werden. Es kann die Werte None, '', '\n', '\r' oder '\r\n' annehmen. Die Funktionsweise ist wie folgt:

Beim Lesen von Eingaben aus dem Stream wird der Modus für universelle Zeilenumbrüche aktiviert, wenn newline den Wert None hat. Zeilen in der Eingabe können mit '\n', '\r' oder '\r\n' enden; diese werden in '\n' umgewandelt, bevor sie an den Aufrufer zurückgegeben werden. Hat newline den Wert '', ist der Modus für universelle Zeilenumbrüche ebenfalls aktiviert, jedoch werden die Zeilenenden unverändert an den Aufrufer zurückgegeben. Bei allen anderen zulässigen Werten werden Eingabezeilen ausschließlich durch die angegebene Zeichenkette begrenzt, und das Zeilenende wird unverändert an den Aufrufer zurückgegeben.
Beim Schreiben von Ausgaben in den Stream werden – sofern newline den Wert None hat – alle geschriebenen '\n'-Zeichen in das systemübliche Zeilenumbruchzeichen os.linesep umgewandelt. Ist newline gleich '' oder '\n', findet keine Umwandlung statt. Nimmt newline einen der anderen zulässigen Werte an, werden alle geschriebenen '\n'-Zeichen in die angegebene Zeichenkette umgewandelt.

Wenn closefd auf False gesetzt ist und anstelle eines Dateinamens ein Dateideskriptor übergeben wurde, bleibt der zugrundeliegende Dateideskriptor beim Schließen der Datei geöffnet. Wird ein Dateiname angegeben, muss closefd auf True (dem Standardwert) stehen; andernfalls wird ein Fehler ausgelöst.

Ein benutzerdefinierter Opener kann verwendet werden, indem ein aufrufbares Objekt als opener übergeben wird. Der zugrundeliegende Dateideskriptor für das Dateiobjekt wird dann durch den Aufruf von opener mit (file, flags) ermittelt. opener muss einen offenen Dateideskriptor zurückgeben (die Übergabe von os.open als opener führt zu einer Funktionalität, die der Übergabe von None ähnelt).

Die neu erstellte Datei ist nicht vererbbar.

Das folgende Beispiel verwendet den Parameter dir_fd der Funktion os.open(), um eine Datei relativ zu einem bestimmten Verzeichnis zu öffnen:

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('Das wird geschrieben in somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

Der Typ des von der Funktion open() zurückgegebenen Datei-Objekts hängt vom Modus ab. Wird open() verwendet, um eine Datei im Textmodus ('w', 'r', 'wt', 'rt' usw.) zu öffnen, wird eine Unterklasse von io.TextIOBase (speziell io.TextIOWrapper) zurückgegeben. Wird die Funktion verwendet, um eine Datei im Binärmodus mit Pufferung zu öffnen, ist die zurückgegebene Klasse eine Unterklasse von io.BufferedIOBase. Die genaue Klasse variiert: Im Binär-Lesemodus wird ein io.BufferedReader zurückgegeben; im Binär-Schreib- und Binär-Anhängemodus ein io.BufferedWriter und im Lese-/Schreibmodus ein io.BufferedRandom. Ist die Pufferung deaktiviert, wird der Rohdatenstrom (Raw Stream) zurückgegeben – eine Unterklasse von io.RawIOBase, nämlich io.FileIO.

Siehe auch die Module zur Dateiverarbeitung, wie fileinput, io (wo open() definiert ist), os, os.path, tempfile und shutil.

Löst ein Audit-Ereignis open mit den Argumenten path, mode und flags aus.

Die Argumente „mode“ und „flags“ wurden möglicherweise modifiziert oder aus dem ursprünglichen Aufruf abgeleitet.

Geändert in Version 3.3:

Der Parameter opener wurde hinzugefügt.
Der Modus 'x' wurde hinzugefügt.
Früher wurde IOError ausgelöst; mittlerweile ist es ein Alias für OSError.
Ein FileExistsError wird nun ausgelöst, wenn die im exklusiven Erstellungsmodus ('x') geöffnete Datei bereits existiert.

Geändert in Version 3.4:

Die Datei ist nun nicht mehr vererbbar.

Geändert in Version 3.5:

Wenn der Systemaufruf unterbrochen wird und der Signal-Handler keine Ausnahme auslöst, wiederholt die Funktion nun den Systemaufruf, anstatt eine InterruptedError-Ausnahme auszulösen (siehe PEP 475 für die Begründung).
Der Fehlerbehandlungsmechanismus „namereplace“ wurde hinzugefügt.

Geändert in Version 3.6:

Unterstützung für Objekte hinzugefügt, die os.PathLike implementieren.
Unter Windows kann das Öffnen eines Konsolenpuffers eine Unterklasse von io.RawIOBase zurückgeben, bei der es sich nicht um io.FileIO handelt.

Geändert in Version 3.11: Der Modus „U“ wurde entfernt.

ord(character, /)¶

Gibt den Ordinalwert eines Zeichens zurück.

Wenn das Argument eine Zeichenkette der Länge 1 ist, wird der Unicode-Codepunkt dieses Zeichens zurückgegeben. Beispielsweise liefert ord('a') die Ganzzahl 97 und ord('€') (Euro-Zeichen) liefert 8364. Dies ist die Umkehrfunktion zu chr().

Wenn das Argument ein bytes- oder bytearray-Objekt der Länge 1 ist, wird dessen einzelner Bytewert zurückgegeben. Beispielsweise gibt ord(b'a') die Ganzzahl 97 zurück.“

pow(base, exp, mod=None)¶

Gibt base hoch exp zurück; ist mod angegeben, wird base hoch exp modulo mod zurückgegeben (effizienter berechnet als pow(base, exp) % mod). Die Form mit zwei Argumenten pow(base, exp) entspricht der Verwendung des Potenzoperators: base**exp.

Wenn es sich bei den Argumenten um numerische Typen mit unterschiedlichen Operandentypen handelt, gelten die Regeln zur Typanpassung für binäre arithmetische Operatoren. Bei Operanden vom Typ int hat das Ergebnis denselben Typ wie die Operanden (nach der Typanpassung), es sei denn, das zweite Argument ist negativ; in diesem Fall werden alle Argumente in float umgewandelt und ein float-Ergebnis geliefert. So liefert beispielsweise pow(10, 2) den Wert 100, während pow(10, -2) den Wert 0.01 ergibt. Bei einer negativen Basis vom Typ int oder float und einem nicht ganzzahligen Exponenten wird ein komplexes Ergebnis geliefert. Zum Beispiel liefert pow(-9, 0.5) einen Wert nahe 3j. Ist die Basis hingegen negativ (vom Typ int oder float) und der Exponent ganzzahlig, so wird ein float-Ergebnis geliefert. So ergibt pow(-9, 2.0) beispielsweise 81.0.

Wenn base und exp vom Typ int sind und mod angegeben ist, muss auch mod vom Typ Integer sein und darf nicht null sein. Wenn mod angegeben ist und exp negativ ist, müssen base und mod teilerfremd sein. In diesem Fall wird pow(inv_base, -exp, mod) zurückgegeben, wobei inv_base das Inverse von base modulo mod ist.

Hier ist ein Beispiel für die Berechnung des Inversen von 38 modulo 97:

>>> pow(38, -1, mod=97)
23
>>> 23 * 38 % 97 == 1
True

Geändert in Version 3.8: Bei int-Operanden erlaubt die Form von pow mit drei Argumenten nun ein negatives zweites Argument, was die Berechnung modularer Inverser ermöglicht.

Geändert in Version 3.8: Erlaube Schlüsselwortargumente. Zuvor wurden nur Positionsargumente unterstützt.

print(*objects, sep=' ', end='\n', file=None, flush=False)¶

Gibt die objects in den Textdatenstrom file aus, getrennt durch sep und gefolgt von end. sep, end, file und flush müssen, sofern angegeben, als Schlüsselwortargumente übergeben werden.

Alle Argumente, die keine Schlüsselwortargumente sind, werden wie bei str() in Zeichenketten umgewandelt und in den Stream geschrieben, wobei sie durch sep getrennt und von end gefolgt werden. Sowohl sep als auch end müssen Zeichenketten sein; sie können auch None sein, was bedeutet, dass die Standardwerte verwendet werden. Werden keine objects angegeben, schreibt print() lediglich end.

Das Argument file muss ein Objekt mit einer write(string)-Methode sein; ist es nicht vorhanden oder None, wird sys.stdout verwendet. Da die ausgegebenen Argumente in Textzeichenketten umgewandelt werden, kann print() nicht mit Dateiobjekten im Binärmodus verwendet werden. Verwenden Sie für diese stattdessen file.write(...).

Die Ausgabepufferung wird normalerweise durch file bestimmt. Wenn flush jedoch auf „true“ gesetzt ist, wird der Stream zwangsweise geleert.

Geändert in Version 3.3: Das Keyword-Argument flush wurde hinzugefügt.

class property(fget=None, fset=None, fdel=None, doc=None)¶

Gibt ein Eigenschaftsattribut zurück.

fget ist eine Funktion zum Abrufen eines Attributwerts. fset ist eine Funktion zum Setzen eines Attributwerts. fdel ist eine Funktion zum Löschen eines Attributwerts. Und doc erstellt einen Docstring für das Attribut.

Eine typische Verwendung ist die Definition eines verwalteten Attributs x:

class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "Ich bin die 'x' Eigenschaft.")

Wenn c eine Instanz von C ist, ruft c.x den Empfänger (getter) auf, c.x = value den Einsetzer (setter) und del c.x den Löscher (deleter).

Falls angegeben, wird doc der Docstring des Property-Attributs sein. Andernfalls übernimmt die Property den Docstring von fget (sofern vorhanden). Dies ermöglicht es, mit @property als Decorator auf einfache Weise Nur-Lese-Properties zu erstellen:

class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Hole die aktuelle Spannung."""
        return self._voltage

Der @property-Dekorateur wandelt die Methode voltage() in einen „Empfänger“ für ein gleichnamiges Attribut mit Lesezugriff um und setzt den Docstring für voltage auf „Hole die aktuelle Spannung.“

@getter¶

@setter¶

@deleter¶

Ein Property-Objekt verfügt über getter-, setter- und deleter-Methoden, die als Dekorateur verwendet werden können; sie erstellen eine Kopie der Property, bei der die entsprechende Zugriffsfunktion auf die dekorierte Funktion gesetzt ist. Dies lässt sich am besten anhand eines Beispiels erläutern:

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """Ich bin die 'x' Eigenschaft."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

Dieser Code ist exakt gleichbedeutend mit dem ersten Beispiel. Achte darauf, den zusätzlichen Funktionen denselben Namen zu geben wie der ursprünglichen Eigenschaft (in diesem Fall x).

Das zurückgegebene Property-Objekt verfügt zudem über die Attribute fget, fset und fdel, die den Konstruktorargumenten entsprechen.

Geändert in Version 3.5: Die Docstrings von Property-Objekten sind jetzt beschreibbar.

__name__¶: Attribut, das den Namen der Eigenschaft enthält. Der Name der Eigenschaft kann zur Laufzeit geändert werden.

Added in version 3.13.

class range(stop, /)
class range(start, stop, step=1, /): Anstatt eine Funktion zu sein, ist range tatsächlich ein unveränderlicher Sequenztyp, wie in Ranges und Sequenztypen – list, tuple, range dokumentiert.

repr(object, /)¶

Gibt eine Zeichenkette zurück, die eine druckbare Darstellung eines Objekts enthält. Bei vielen Typen versucht diese Funktion, eine Zeichenkette zurückzugeben, die bei Übergabe an eval() ein Objekt mit demselben Wert ergeben würde; andernfalls besteht die Darstellung aus einer in spitze Klammern eingeschlossenen Zeichenkette, die den Namen des Objekttyps sowie zusätzliche Informationen – häufig einschließlich Name und Adresse des Objekts – enthält. Eine Klasse kann steuern, was diese Funktion für ihre Instanzen zurückgibt, indem sie eine __repr__()-Methode definiert. Ist sys.displayhook() nicht verfügbar, löst diese Funktion einen RuntimeError aus.

Diese Klasse verfügt über eine benutzerdefinierte Darstellung, die ausgewertet werden kann:

class Person:
   def __init__(self, name, age):
      self.name = name
      self.age = age

   def __repr__(self):
      return f"Person('{self.name}', {self.age})"

reversed(object, /)¶: Gibt einen umgekehrten Iterator zurück. Das Argument muss ein Objekt sein, das über eine __reversed__()-Methode verfügt oder das Sequenzprotokoll unterstützt (die __len__()-Methode und die __getitem__()-Methode mit ganzzahligen Argumenten beginnend bei 0).

round(number, ndigits=None)¶

Gibt number auf ndigits Nachkommastellen gerundet zurück. Wenn ndigits weggelassen wird oder None ist, wird die dem Eingabewert nächstgelegene Ganzzahl zurückgegeben.

Bei den eingebauten Typen, die round() unterstützen, werden Werte auf das nächste Vielfache von 10 hoch minus ndigits gerundet; liegen zwei Vielfache gleich nah, wird zur geraden Zahl hin gerundet (so ergeben beispielsweise sowohl round(0.5) als auch round(-0.5) den Wert 0, und round(1.5) ergibt 2). Für ndigits ist jeder Ganzzahlwert zulässig (positiv, null oder negativ). Der Rückgabewert ist eine Ganzzahl, wenn ndigits weggelassen wird oder None ist. Andernfalls hat der Rückgabewert denselben Typ wie number.

Bei einem allgemeinen Python-Objekt number delegiert round an number.__round__.

Bemerkung

Das Verhalten von round() bei Gleitkommazahlen kann überraschend sein: So ergibt round(2.675, 2) beispielsweise 2.67 anstelle der erwarteten 2.68. Dies ist kein Fehler, sondern liegt daran, dass die meisten Dezimalbrüche nicht exakt als Gleitkommazahl dargestellt werden können. Weitere Informationen finden Sie unter Gleitkommaarithmetik: Probleme und Einschränkungen.

class set(iterable=(), /)

Gibt ein neues Objekt set zurück, optional mit Elementen aus iterable. set ist eine eingebaute Klasse. Siehe auch Mengen-Typen – set, frozenset für die Dokumentation zu dieser Klasse.

Für weitere Container siehe die eingebauten Klassen frozenset, list, tuple und dict sowie das Modul collections.

setattr(object, name, value, /)¶

Dies ist das Gegenstück zu getattr(). Die Argumente sind ein Objekt, eine Zeichenkette und ein beliebiger Wert. Die Zeichenkette kann ein vorhandenes oder ein neues Attribut bezeichnen. Die Funktion weist dem Attribut den Wert zu, sofern das Objekt dies zulässt. So entspricht beispielsweise setattr(x, 'foobar', 123) der Anweisung x.foobar = 123.

name muss kein Python-Bezeichner im Sinne von Identifiers and keywords sein, es sei denn, das Objekt erzwingt dies, beispielsweise in einer benutzerdefinierten __getattribute__()-Methode oder über __slots__. Ein Attribut, dessen Name kein Bezeichner ist, kann nicht über die Punktnotation angesprochen werden, ist jedoch über getattr() usw. zugänglich.“

Bemerkung

Da Private Name Mangling zur Kompilierzeit erfolgt, muss der Name eines privaten Attributs (Attribute mit zwei führenden Unterstrichen) manuell umgewandelt werden, um es mittels setattr() zu setzen.

class slice(stop, /)¶

class slice(start, stop, step=None, /)

Gibt ein slice-Objekt zurück, das die durch range(start, stop, step) festgelegte Menge an Indizes repräsentiert. Die Argumente start und step haben standardmäßig den Wert None.

Slice objects have read-only data attributes start, stop, and step which merely return the argument values (or their default). They have no other explicit functionality; however, they are used by NumPy and other third-party packages.

start¶

stop¶

step¶

Slice objects are also generated when extended indexing syntax is used. For example: a[start:stop:step] or a[start:stop, i]. See itertools.islice() for an alternate version that returns an iterator.

Geändert in Version 3.12: Slice-Objekte sind jetzt hashbar (sofern start, stop und step hashbar sind).

sorted(iterable, /, *, key=None, reverse=False)¶

Gibt eine neue sortierte Liste der Elemente aus iterable zurück.

Verfügt über zwei optionale Argumente, die als Schlüsselwortargumente angegeben werden müssen.

key gibt eine Funktion mit einem Argument an, die dazu dient, einen Vergleichsschlüssel aus jedem Element in iterable zu extrahieren (zum Beispiel key=str.lower). Der Standardwert ist None (die Elemente werden direkt verglichen).

reverse ist ein boolescher Wert. Wenn er auf True gesetzt ist, werden die Listenelemente so sortiert, als ob jeder Vergleich umgekehrt würde.

Verwende functools.cmp_to_key(), um eine veraltete cmp-Funktion in eine key-Funktion umzuwandeln.

Die integrierte Funktion sorted() ist garantiert stabil. Ein Sortierverfahren ist stabil, wenn es die relative Reihenfolge von Elementen, die als gleich gelten, nicht verändert – dies ist hilfreich bei Sortierungen in mehreren Durchläufen (zum Beispiel Sortierung nach Abteilung und anschließend nach Gehaltsgruppe).

Der Sortieralgorithmus verwendet nur <-Vergleiche zwischen Elementen. Während das Definieren einer Methode __lt__() für die Sortierung ausreicht, empfiehlt PEP 8, alle sechs erweiterten Vergleichsoperationen zu implementieren. Dies hilft, Fehler zu vermeiden, wenn dieselben Daten mit anderen Sortierwerkzeugen wie max() verwendet werden, die sich auf eine andere zugrunde liegende Methode stützen. Die Implementierung aller sechs Vergleiche hilft außerdem, Verwirrung bei gemischten Typvergleichen zu vermeiden, die die gespiegelte Methode __gt__() aufrufen können.

Beispiele und eine kurze Anleitung zum Sortieren finden Sie unter Sorting Techniques.

@staticmethod¶

Wandelt eine Methode in eine statische Methode um.

Eine statische Methode erhält kein implizites erstes Argument. Um eine statische Methode zu deklarieren, verwenden Sie dieses Idiom:

class C:
    @staticmethod
    def f(arg1, arg2, argN): ...

Die Form @staticmethod ist ein Funktions-Dekorateur – siehe Funktionsdefinitionen für Einzelheiten.

Eine statische Methode kann entweder über die Klasse (z. B. C.f()) oder über eine Instanz (z. B. C().f()) aufgerufen werden. Darüber hinaus ist der statische Methoden-Deskriptor selbst aufrufbar, sodass er in der Klassendefinition verwendet werden kann (z. B. f()).

Statische Methoden in Python ähneln denen in Java oder C++. Siehe auch das @classmethod, eine Variante, die sich zum Erstellen alternativer Klassenkonstruktoren eignet.

Wie bei allen Dekorateuren ist es auch möglich, staticmethod als reguläre Funktion aufzurufen und mit dem Ergebnis weiterzuarbeiten. Dies ist in Fällen erforderlich, in denen man innerhalb des Klassenkörpers eine Referenz auf eine Funktion benötigt und die automatische Umwandlung in eine Instanzmethode vermeiden möchte. Für solche Fälle verwendet man folgendes Idiom:

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

Weitere Informationen zu statischen Methoden finden Sie unter Die Standardtyp-Hierarchie.

Geändert in Version 3.10: Statische Methoden erben nun die Methodenattribute (__module__, __name__, __qualname__, __doc__ und __annotations__), verfügen über ein neues __wrapped__-Attribut und sind nun wie reguläre Funktionen aufrufbar.

class str(*, encoding='utf-8', errors='strict')

class str(object)

class str(object, encoding, errors='strict')

class str(object, *, errors)

Gibt eine str-Version von object zurück. Siehe str() für Details.

str ist die integrierte Zeichenketten-Klasse. Allgemeine Informationen zu Zeichenketten finden Sie unter Textsequenztyp – str.“

sum(iterable, /, start=0)¶

Summiert start und die Elemente eines Iterables von links nach rechts auf und gibt die Gesamtsumme zurück. Die Elemente des Iterables sind normalerweise Zahlen, und der Startwert darf kein String sein.“

Für einige Anwendungsfälle gibt es gute Alternativen zu sum(). Die bevorzugte, schnelle Methode zum Verketten einer Sequenz von Zeichenketten ist der Aufruf von ''.join(sequence). Für die Addition von Gleitkommazahlen mit erhöhter Genauigkeit siehe math.fsum(). Zum Verketten einer Reihe von Iterables empfiehlt sich die Verwendung von itertools.chain().

Geändert in Version 3.8: Der Parameter start kann als Schlüsselwortargument angegeben werden.

Geändert in Version 3.12: Die Summation von Gleitkommazahlen wurde auf einen Algorithmus umgestellt, der bei den meisten Builds eine höhere Genauigkeit und eine bessere Kommutativität bietet.

class super¶

class super(type, object_or_type=None, /)

Gibt ein Proxy-Objekt zurück, das Methodenaufrufe an eine Eltern- oder Geschwisterklasse von type delegiert. Dies ist nützlich für den Zugriff auf geerbte Methoden, die in einer Klasse überschrieben wurden.

Das object_or_type bestimmt die Methodenauflösungsreihenfolge (method resolution order), die durchsucht werden soll. Die Suche beginnt bei der Klasse, die direkt auf den type folgt.

Wenn zum Beispiel __mro__ von object_or_type D -> B -> C -> A -> object lautet und der Wert von type B ist, dann durchsucht super() C -> A -> object.

Das Attribut __mro__ der Klasse, die object_or_type entspricht, listet die Suchreihenfolge für die Methodenauflösung auf, die sowohl von getattr() als auch von super() verwendet wird. Das Attribut ist dynamisch und kann sich ändern, wann immer die Vererbungshierarchie aktualisiert wird.

Wird das zweite Argument weggelassen, ist das zurückgegebene super-Objekt ungebunden. Ist das zweite Argument ein Objekt, muss isinstance(obj, type) wahr sein. Ist das zweite Argument ein Typ, muss issubclass(type2, type) wahr sein (dies ist nützlich für Klassenmethoden).“

Wenn der Aufruf direkt innerhalb einer gewöhnlichen Methode einer Klasse erfolgt, können beide Argumente weggelassen werden („super() ohne Argumente“). In diesem Fall ist type die umschließende Klasse und obj das erste Argument der unmittelbar umschließenden Funktion (typischerweise self). (Dies bedeutet, dass super() ohne Argumente innerhalb verschachtelter Funktionen – einschließlich Generator-Ausdrücken, die implizit verschachtelte Funktionen erzeugen – nicht wie erwartet funktioniert.)

Es gibt zwei typische Anwendungsfälle für super. In einer Klassenhierarchie mit einfacher Vererbung kann super verwendet werden, um auf Elternklassen zu verweisen, ohne diese explizit zu benennen, wodurch der Code wartungsfreundlicher wird. Diese Verwendung entspricht weitgehend der Verwendung von super in anderen Programmiersprachen.

Der zweite Anwendungsfall ist die Unterstützung kooperativer Mehrfachvererbung in einer dynamischen Ausführungsumgebung. Dieser Anwendungsfall ist spezifisch für Python und kommt weder in statisch kompilierten Sprachen noch in Sprachen vor, die lediglich Einfachvererbung unterstützen. Dies ermöglicht die Implementierung von „Diamantstrukturen“, bei denen mehrere Basisklassen dieselbe Methode implementieren. Ein gutes Design erfordert, dass derartige Implementierungen stets dieselbe Aufrufsignatur aufweisen (da die Aufrufreihenfolge zur Laufzeit bestimmt wird, sich an Änderungen der Klassenhierarchie anpasst und auch Geschwisterklassen einbeziehen kann, die vor der Laufzeit noch unbekannt sind).

Für beide Anwendungsfälle sieht ein typischer Aufruf der Superklasse folgendermaßen aus:

class C(B):
    def method(self, arg):
        super().method(arg)    # Dies bewirkt dasselbe wie:
                               # super(C, self).method(arg)

Neben der Methodensuche funktioniert super() auch bei der Attributsuche. Ein möglicher Anwendungsfall hierfür ist der Aufruf von Deskriptoren in einer Eltern- oder Geschwisterklasse.

Beachte, dass super() als Teil des Bindungsprozesses für explizite Attributzugriffe mit Punktnotation – wie etwa super().__getitem__(name) – implementiert ist. Dies geschieht durch die Implementierung einer eigenen __getattribute__()-Methode, die Klassen in einer vorhersagbaren Reihenfolge durchsucht und so kooperative Mehrfachvererbung unterstützt. Folglich ist super() für implizite Zugriffe mittels Anweisungen oder Operatoren, wie beispielsweise super()[name], nicht definiert.

Beachteaußerdem, dass super() – abgesehen von der Variante ohne Argumente – nicht auf die Verwendung innerhalb von Methoden beschränkt ist. Die Variante mit zwei Argumenten legt die Argumente genau fest und stellt die entsprechenden Bezüge her. Die Variante ohne Argumente funktioniert hingegen nur innerhalb einer Klassendefinition, da der Compiler die erforderlichen Details ergänzt, um die gerade definierte Klasse korrekt zu ermitteln und bei gewöhnlichen Methoden auf die aktuelle Instanz zuzugreifen.

Praktische Vorschläge zur Gestaltung kooperativer Klassen unter Verwendung von super() finden Sie im Leitfaden zur Verwendung von super().

class tuple(iterable=(), /): Anstatt eine Funktion zu sein, ist tuple eigentlich ein unveränderlicher Sequenztyp, wie in Tupel und Sequenztypen – list, tuple, range dokumentiert.

class type(object, /)¶

class type(name, bases, dict, /, **kwargs)

Geben Sie mit einem Argument den Typ eines Objekts zurück. Der Rückgabewert ist ein Typobjekt und im Allgemeinen dasselbe Objekt, das von object.__class__ zurückgegeben wird.

Die eingebaute Funktion isinstance() wird empfohlen, um den Typ eines Objekts zu überprüfen, da sie Unterklassen berücksichtigt.

Gibt bei Angabe von drei Argumenten ein neues Typobjekt zurück. Dies ist im Wesentlichen eine dynamische Form der class-Anweisung. Die Zeichenkette name ist der Klassenname und wird zum Attribut __name__. Das Tupel bases enthält die Basisklassen und wird zum Attribut __bases__; ist es leer, wird object – die gemeinsame Basisklasse aller Klassen – hinzugefügt. Das Dictionary dict enthält Attribut- und Methodendefinitionen für den Klassenkörper; es kann kopiert oder gekapselt werden, bevor es zum Attribut __dict__ wird. Die folgenden beiden Anweisungen erzeugen identische type-Objekte:

>>> class X:
...     a = 1
...
>>> X = type('X', (), dict(a=1))

Siehe auch:

Schlüsselwortargumente, die der Form mit drei Argumenten übergeben werden, werden an den entsprechenden Metaklassen-Mechanismus (üblicherweise __init_subclass__()) weitergereicht – auf dieselbe Weise, wie dies bei Schlüsselwörtern in einer Klassendefinition (abgesehen von metaclass) der Fall wäre.

Anders als bei einer class-Anweisung ruft die dreiargumentige Form nicht die Metaklassen-Methode __prepare__ auf (siehe Vorbereiten des Klassen-Namespace). Verwende types.new_class(), um eine Klasse dynamisch unter Verwendung der passenden Metaklasse zu erstellen.

Siehe auch Anpassung der Klassenerstellung.

Geändert in Version 3.6: Unterklassen von type, die type.__new__ nicht überschreiben, dürfen nicht mehr die Form mit einem Argument verwenden, um den Typ eines Objekts zu ermitteln.

vars()¶

vars(object, /)

Geben Sie das Attribut __dict__ für ein Modul, eine Klasse, eine Instanz oder ein beliebiges anderes Objekt mit einem __dict__-Attribut zurück.

Objekte wie Module und Instanzen verfügen über ein aktualisierbares __dict__-Attribut; andere Objekte können jedoch Schreibbeschränkungen für ihre __dict__-Attribute aufweisen (Klassen verwenden beispielsweise ein types.MappingProxyType, um direkte Aktualisierungen des Dictionarys zu verhindern).

Ohne Argument verhält sich vars() wie locals().

Eine TypeError-Ausnahme wird ausgelöst, wenn ein Objekt angegeben wird, das kein __dict__-Attribut besitzt (zum Beispiel, wenn seine Klasse das __slots__-Attribut definiert).

Geändert in Version 3.13: Das Ergebnis des Aufrufs dieser Funktion ohne Argument wurde wie für die eingebaute Funktion locals() beschrieben aktualisiert.

zip(*iterables, strict=False)¶

Über mehrere Iterables parallel iterieren und dabei Tupel mit je einem Element aus jedem Iterable erzeugen.“

Beispiel:

>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
...     print(item)
...
(1, 'sugar')
(2, 'spice')
(3, 'everything nice')

Etwas formeller ausgedrückt: zip() gibt einen Iterator von Tupeln zurück, wobei das i-te Tupel das i-te Element aus jedem der als Argument übergebenen Iterables enthält.

Eine weitere Möglichkeit, sich zip() vorzustellen, ist, dass es Zeilen in Spalten und Spalten in Zeilen umwandelt. Dies ähnelt dem Transponieren einer Matrix.

zip() arbeitet verzögert (lazy): Die Elemente werden erst verarbeitet, wenn über das Iterable iteriert wird, z. B. mittels einer for-Schleife oder durch Umwandlung in eine list.

Es ist zu beachten, dass die an zip() übergebenen Iterables unterschiedliche Längen aufweisen können – manchmal beabsichtigt, manchmal aufgrund eines Fehlers in dem Code, der diese Iterables erstellt hat. Python bietet drei verschiedene Ansätze für den Umgang mit diesem Problem:

By default, zip() stops when the shortest iterable is exhausted. It will ignore the remaining items in the longer iterables, cutting off the result to the length of the shortest iterable:
```
>>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
[(0, 'fee'), (1, 'fi'), (2, 'fo')]
```
zip() wird häufig in Fällen verwendet, in denen davon ausgegangen wird, dass die Iterables gleich lang sind. In solchen Fällen empfiehlt sich die Verwendung der Option strict=True. Die Ausgabe entspricht der von regulärem zip():
```
>>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
[('a', 1), ('b', 2), ('c', 3)]
```
Unlike the default behavior, it raises a ValueError if one iterable is exhausted before the others:
```
>>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):
...     print(item)
...
(0, 'fee')
(1, 'fi')
(2, 'fo')
Traceback (most recent call last):
  ...
ValueError: zip() argument 2 is longer than argument 1
```
Ohne das Argument „strict=True“ werden Fehler, die zu Iterables unterschiedlicher Länge führen, unterdrückt; dies kann sich möglicherweise als schwer zu findender Fehler an einer anderen Stelle des Programms äußern.
Kürzere Iterables können mit einem konstanten Wert aufgefüllt werden, damit alle Iterables dieselbe Länge haben. Dies geschieht mit itertools.zip_longest().

Grenzfälle: Bei einem einzelnen iterierbaren Argument gibt zip() einen Iterator von 1-Tupeln zurück. Ohne Argumente gibt es einen leeren Iterator zurück.

Tipps und Tricks:

Die Auswertungsreihenfolge der Iterables von links nach rechts ist garantiert. Dies ermöglicht ein Idiom, um eine Datensequenz mithilfe von zip(*[iter(s)]*n, strict=True) in Gruppen der Länge n zu unterteilen. Dabei wird derselbe Iterator n-mal verwendet, sodass jedes Ergebnis-Tupel die Resultate von n Aufrufen des Iterators enthält. Dies bewirkt eine Aufteilung der Eingabe in Abschnitte der Länge n.

zip() kann in Verbindung mit dem *-Operator verwendet werden, um eine Liste zu entpacken:

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> list(zip(x, y))
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True

Geändert in Version 3.10: Das Argument strict wurde hinzugefügt.

__import__(name, globals=None, locals=None, fromlist=(), level=0)¶

Bemerkung

Dies ist eine fortgeschrittene Funktion, die im Gegensatz zu importlib.import_module() in der alltäglichen Python-Programmierung nicht benötigt wird.

Diese Funktion wird durch die import-Anweisung aufgerufen. Sie kann ersetzt werden (durch Importieren des Moduls builtins und Zuweisung an builtins.__import__), um die Semantik der import-Anweisung zu ändern; davon wird jedoch dringend abgeraten. Es ist meist einfacher, Import-Hooks (siehe PEP 302) zu verwenden, um dieselben Ziele zu erreichen, ohne Probleme bei Code zu verursachen, der von der Standard-Importimplementierung ausgeht. Auch von der direkten Verwendung von __import__() wird zugunsten von importlib.import_module() abgeraten.

Die Funktion importiert das Modul name und verwendet dabei gegebenenfalls die angegebenen globals und locals, um zu bestimmen, wie der Name im Kontext eines Pakets zu interpretieren ist. Über fromlist werden die Namen von Objekten oder Untermodulen angegeben, die aus dem durch name bezeichneten Modul importiert werden sollen. Die Standardimplementierung verwendet das Argument locals überhaupt nicht und nutzt globals lediglich dazu, den Paketkontext der import-Anweisung zu bestimmen.

level gibt an, ob absolute oder relative Importe verwendet werden sollen. 0 (der Standard) bedeutet, dass nur absolute Importe durchgeführt werden. Positive Werte für „level“ geben die Anzahl der übergeordneten Verzeichnisse an, die ausgehend vom Verzeichnis des Moduls, das __import__() aufruft, durchsucht werden sollen. (siehe PEP 328 für mehr Details).

Wenn die Variable name die Form package.module hat, wird normalerweise das Paket der obersten Ebene (der Name bis zum ersten Punkt) zurückgegeben, nicht das durch name bezeichnete Modul. Wird jedoch ein nicht leeres fromlist-Argument angegeben, so wird das durch name bezeichnete Modul zurückgegeben.

Die Anweisung „import spam“ führt beispielsweise zu Bytecode, der dem folgenden Code ähnelt:

spam = __import__('spam', globals(), locals(), [], 0)

Die Anweisung import spam.ham führt zu diesem Aufruf:

spam = __import__('spam.ham', globals(), locals(), [], 0)

Beachte, wie __import__() hier das Modul der obersten Ebene zurückgibt, da dies das Objekt ist, das durch die import-Anweisung an einen Namen gebunden wird.

Andererseits führt die Anweisung from spam.ham import eggs, sausage as saus zu

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage

Hier wird das Modul spam.ham von __import__() zurückgegeben. Aus diesem Objekt werden die zu importierenden Namen abgerufen und den entsprechenden Namen zugewiesen.

Wenn Sie ein Modul (möglicherweise innerhalb eines Pakets) einfach anhand seines Namens importieren möchten, verwenden Sie importlib.import_module().

Geändert in Version 3.3: Negative Werte für level werden nicht mehr unterstützt (wodurch sich auch der Standardwert auf 0 ändert).

Geändert in Version 3.9: Wenn die Befehlszeilenoptionen -E oder -I verwendet werden, wird die Umgebungsvariable PYTHONCASEOK nun ignoriert.

Fußnoten

Integrierte Funktionen¶

Vorheriges Thema

Nächstes Thema

Diese Seite