From ddf6ce1c6bc2909deadb0bfed75cd057624a1dab Mon Sep 17 00:00:00 2001 From: JystBreisgau Date: Thu, 6 Aug 2026 14:22:23 +0200 Subject: [PATCH 01/13] German translations finished, now checking for errors Update German translations for various Python functions and concepts in functions.po. --- library/functions.po | 314 ++++++++++++++++++++++++++++++++++++++----- 1 file changed, 277 insertions(+), 37 deletions(-) diff --git a/library/functions.po b/library/functions.po index 1de6360..a634ef6 100644 --- a/library/functions.po +++ b/library/functions.po @@ -3263,6 +3263,9 @@ msgid "" "see :func:`classmethod` for a variant that is useful for creating alternate " "class constructors." msgstr "" +"Statische Methoden in Python ähneln denen in Java oder C++. Siehe auch " +":func:`classmethod` für eine Variante, die sich zur Erstellung alternativer " +"Klassenkonstruktoren eignet." msgid "" "Like all decorators, it is also possible to call ``staticmethod`` as a " @@ -3271,6 +3274,11 @@ msgid "" "want to avoid the automatic transformation to instance method. For these " "cases, use this idiom::" msgstr "" +"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::" msgid "" "def regular_function():\n" @@ -3279,9 +3287,14 @@ msgid "" "class C:\n" " method = staticmethod(regular_function)" msgstr "" +"def regular_function():\n" +" ...\n" +"\n" +"class C:\n" +" method = staticmethod(regular_function)" msgid "For more information on static methods, see :ref:`types`." -msgstr "" +msgstr "Weitere Informationen zu statischen Methoden finden Sie unter :ref:`types`." msgid "" "Static methods now inherit the method attributes (:attr:`~function." @@ -3289,21 +3302,31 @@ msgid "" "attr:`~function.__doc__` and :attr:`~function.__annotations__`), have a new " "``__wrapped__`` attribute, and are now callable as regular functions." msgstr "" +"Statische Methoden erben nun die Methodenattribute (:attr:`~function." +"__module__`, :attr:`~function.__name__`, :attr:`~function.__qualname__`, :" +"attr:`~function.__doc__` und :attr:`~function.__annotations__`), verfügen über ein neues " +"``__wrapped__``-Attribut und sind nun wie reguläre Funktionen aufrufbar." msgid "" "Return a :class:`str` version of *object*. See :func:`str` for details." msgstr "" +"Gibt eine :class:`str`-Version von *object* zurück. Siehe :func:`str` für Details." msgid "" "``str`` is the built-in string :term:`class`. For general information about " "strings, see :ref:`textseq`." msgstr "" +"``str`` ist die integrierte Zeichenketten-:term:`Klasse`. Allgemeine Informationen zu " +"Zeichenketten finden Sie unter :ref:`textseq`.“ msgid "" "Sums *start* and the items of an *iterable* from left to right and returns " "the total. The *iterable*'s items are normally numbers, and the start value " "is not allowed to be a string." msgstr "" +"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.“ msgid "" "For some use cases, there are good alternatives to :func:`sum`. The " @@ -3312,36 +3335,55 @@ msgid "" "see :func:`math.fsum`\\. To concatenate a series of iterables, consider " "using :func:`itertools.chain`." msgstr "" +"Für einige Anwendungsfälle gibt es gute Alternativen zu :func:`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 " +":func:`math.fsum`. Zum Verketten einer Reihe von Iterables empfiehlt " +"sich die Verwendung von :func:`itertools.chain`." msgid "The *start* parameter can be specified as a keyword argument." -msgstr "" +msgstr "Der Parameter *start* kann als Schlüsselwortargument angegeben werden." msgid "" "Summation of floats switched to an algorithm that gives higher accuracy and " "better commutativity on most builds." msgstr "" +"Die Summation von Gleitkommazahlen wurde auf einen Algorithmus umgestellt, " +"der bei den meisten Builds eine höhere Genauigkeit und eine bessere Kommutativität bietet." msgid "" "Added specialization for summation of complexes, using same algorithm as for " "summation of floats." msgstr "" +"Spezialisierung für die Summation komplexer Zahlen hinzugefügt; dabei wird " +"derselbe Algorithmus wie für die Summation von Gleitkommazahlen verwendet." msgid "" "Return a proxy object that delegates method calls to a parent or sibling " "class of *type*. This is useful for accessing inherited methods that have " "been overridden in a class." msgstr "" +"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." msgid "" "The *object_or_type* determines the :term:`method resolution order` to be " "searched. The search starts from the class right after the *type*." msgstr "" +"Das *object_or_type* bestimmt die :term:`Methodenauflösungsreihenfolge` " +"(method resolution order), die durchsucht werden soll. Die Suche beginnt " +"bei der Klasse, die direkt auf den *type* folgt." msgid "" "For example, if :attr:`~type.__mro__` of *object_or_type* is ``D -> B -> C -" "> A -> object`` and the value of *type* is ``B``, then :func:`super` " "searches ``C -> A -> object``." msgstr "" +"Wenn zum Beispiel :attr:`~type.__mro__` von *object_or_type* ``D -> B -> C -> A -> object`` " +"lautet und der Wert von *type* ``B`` ist, dann durchsucht :func:`super` " +"``C -> A -> object``." msgid "" "The :attr:`~type.__mro__` attribute of the class corresponding to " @@ -3349,6 +3391,10 @@ msgid "" "`getattr` and :func:`super`. The attribute is dynamic and can change " "whenever the inheritance hierarchy is updated." msgstr "" +"Das Attribut :attr:`~type.__mro__` der Klasse, die *object_or_type* entspricht, " +"listet die Suchreihenfolge für die Methodenauflösung auf, die sowohl von :func:" +"`getattr` als auch von :func:`super` verwendet wird. Das Attribut ist dynamisch " +"und kann sich ändern, wann immer die Vererbungshierarchie aktualisiert wird." msgid "" "If the second argument is omitted, the super object returned is unbound. If " @@ -3356,6 +3402,10 @@ msgid "" "If the second argument is a type, ``issubclass(type2, type)`` must be true " "(this is useful for classmethods)." msgstr "" +"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).“ msgid "" "When called directly within an ordinary method of a class, both arguments " @@ -3365,6 +3415,13 @@ msgid "" "argument :func:`!super` will not work as expected within nested functions, " "including generator expressions, which implicitly create nested functions.)" msgstr "" +"Wenn der Aufruf direkt innerhalb einer gewöhnlichen Methode einer Klasse erfolgt, " +"können beide Argumente weggelassen werden („:func:`!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 :func:`!super` ohne Argumente innerhalb verschachtelter Funktionen – " +"einschließlich Generator-Ausdrücken, die implizit verschachtelte Funktionen erzeugen – " +"nicht wie erwartet funktioniert.)" msgid "" "There are two typical use cases for *super*. In a class hierarchy with " @@ -3372,6 +3429,11 @@ msgid "" "naming them explicitly, thus making the code more maintainable. This use " "closely parallels the use of *super* in other programming languages." msgstr "" +"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." msgid "" "The second use case is to support cooperative multiple inheritance in a " @@ -3384,9 +3446,18 @@ msgid "" "changes in the class hierarchy, and because that order can include sibling " "classes that are unknown prior to runtime)." msgstr "" +"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)." msgid "For both use cases, a typical superclass call looks like this::" -msgstr "" +msgstr "Für beide Anwendungsfälle sieht ein typischer Aufruf der Superklasse folgendermaßen aus:" msgid "" "class C(B):\n" @@ -3394,12 +3465,20 @@ msgid "" " super().method(arg) # This does the same thing as:\n" " # super(C, self).method(arg)" msgstr "" +"class C(B):\n" +" def method(self, arg):\n" +" super().method(arg) # Dies bewirkt dasselbe wie:\n" +" # super(C, self).method(arg)" + msgid "" "In addition to method lookups, :func:`super` also works for attribute " "lookups. One possible use case for this is calling :term:`descriptors " "` in a parent or sibling class." msgstr "" +"Neben der Methodensuche funktioniert :func:`super` auch bei der " +"Attributsuche. Ein möglicher Anwendungsfall hierfür ist der Aufruf " +"von :term:`Deskriptoren ` in einer Eltern- oder Geschwisterklasse." msgid "" "Note that :func:`super` is implemented as part of the binding process for " @@ -3409,6 +3488,13 @@ msgid "" "inheritance. Accordingly, :func:`super` is undefined for implicit lookups " "using statements or operators such as ``super()[name]``." msgstr "" +"Beachte, dass :func:`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 " +":meth:`~object.__getattribute__`-Methode, die Klassen in einer vorhersagbaren " +"Reihenfolge durchsucht und so kooperative Mehrfachvererbung unterstützt. " +"Folglich ist :func:`super` für implizite Zugriffe mittels Anweisungen oder " +"Operatoren, wie beispielsweise ``super()[name]``, nicht definiert." msgid "" "Also note that, aside from the zero argument form, :func:`super` is not " @@ -3418,33 +3504,51 @@ msgid "" "necessary details to correctly retrieve the class being defined, as well as " "accessing the current instance for ordinary methods." msgstr "" +"Beachteaußerdem, dass :func:`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." msgid "" "For practical suggestions on how to design cooperative classes using :func:" "`super`, see `guide to using super() `_." msgstr "" +"Praktische Vorschläge zur Gestaltung kooperativer Klassen unter Verwendung " +"von :func:`super` finden Sie im `Leitfaden zur Verwendung von super() " +"`_." msgid "" ":class:`super` objects are now :mod:`pickleable ` and :mod:" "`copyable `." msgstr "" +"`:class:`super`-Objekte sind jetzt :mod:`picklebar ` und :mod:`kopierbar `." msgid "" "Rather than being a function, :class:`tuple` is actually an immutable " "sequence type, as documented in :ref:`typesseq-tuple` and :ref:`typesseq`." msgstr "" +"Anstatt eine Funktion zu sein, ist :class:`tuple` eigentlich ein unveränderlicher " +"Sequenztyp, wie in :ref:`typesseq-tuple` und :ref:`typesseq` dokumentiert." msgid "" "With one argument, return the type of an *object*. The return value is a " "type object and generally the same object as returned by :attr:`object." "__class__`." msgstr "" +"Geben Sie mit einem Argument den Typ eines *Objekts* zurück. Der Rückgabewert ist ein " +"Typobjekt und im Allgemeinen dasselbe Objekt, das von :attr:`object." +"__class__` zurückgegeben wird." msgid "" "The :func:`isinstance` built-in function is recommended for testing the type " "of an object, because it takes subclasses into account." msgstr "" +"Die eingebaute Funktion :func:`isinstance` wird empfohlen, um den Typ eines " +"Objekts zu überprüfen, da sie Unterklassen berücksichtigt." msgid "" "With three arguments, return a new type object. This is essentially a " @@ -3457,17 +3561,27 @@ msgid "" "__dict__` attribute. The following two statements create identical :class:`!" "type` objects:" msgstr "" +"Gibt bei Angabe von drei Argumenten ein neues Typobjekt zurück. Dies ist im Wesentlichen eine " +"dynamische Form der :keyword:`class`-Anweisung. Die Zeichenkette *name* ist der " +"Klassenname und wird zum Attribut :attr:`~type.__name__`. Das Tupel *bases* " +"enthält die Basisklassen und wird zum Attribut :attr:`~type.__bases__`; " +"ist es leer, wird :class:`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 " +":attr:`~type.__dict__` wird. Die folgenden beiden Anweisungen erzeugen identische " +":class:`type`-Objekte:" msgid "See also:" -msgstr "" +msgstr "Siehe auch:" msgid "" ":ref:`Documentation on attributes and methods on classes `." msgstr "" +":ref:`Dokumentation zu Attributen und Methoden von Klassen `." msgid ":ref:`bltin-type-objects`" -msgstr "" +msgstr ":ref:`bltin-type-objects`" msgid "" "Keyword arguments provided to the three argument form are passed to the " @@ -3475,19 +3589,30 @@ msgid "" "in the same way that keywords in a class definition (besides *metaclass*) " "would." msgstr "" +"Schlüsselwortargumente, die der Form mit drei Argumenten übergeben werden, " +"werden an den entsprechenden Metaklassen-Mechanismus (üblicherweise " +":meth:`~object.__init_subclass__`) weitergereicht – auf dieselbe Weise, " +"wie dies bei Schlüsselwörtern in einer Klassendefinition (abgesehen von " +"*metaclass*) der Fall wäre." msgid "See also :ref:`class-customization`." -msgstr "" +msgstr "Siehe auch :ref:`class-customization`." msgid "" "Subclasses of :class:`!type` which don't override ``type.__new__`` may no " "longer use the one-argument form to get the type of an object." msgstr "" +"Unterklassen von :class:`!type`, die ``type.__new__`` nicht überschreiben, " +"dürfen nicht mehr die Form mit einem Argument verwenden, um den Typ eines " +"Objekts zu ermitteln." msgid "" "Return the :attr:`~object.__dict__` attribute for a module, class, instance, " "or any other object with a :attr:`!__dict__` attribute." msgstr "" +"Geben Sie das Attribut :attr:`~object.__dict__` für ein Modul, eine Klasse, " +"eine Instanz oder ein beliebiges anderes Objekt mit einem :attr:`!__dict__`" +"-Attribut zurück." msgid "" "Objects such as modules and instances have an updateable :attr:`~object." @@ -3495,28 +3620,39 @@ msgid "" "their :attr:`!__dict__` attributes (for example, classes use a :class:`types." "MappingProxyType` to prevent direct dictionary updates)." msgstr "" +"Objekte wie Module und Instanzen verfügen über ein aktualisierbares :attr:`~object." +"__dict__`-Attribut; andere Objekte können jedoch Schreibbeschränkungen für " +"ihre :attr:`!__dict__`-Attribute aufweisen (Klassen verwenden beispielsweise ein :class:`types." +"MappingProxyType`, um direkte Aktualisierungen des Dictionarys zu verhindern)." msgid "Without an argument, :func:`vars` acts like :func:`locals`." -msgstr "" +msgstr "Ohne Argument verhält sich :func:`vars` wie :func:`locals`." msgid "" "A :exc:`TypeError` exception is raised if an object is specified but it " "doesn't have a :attr:`~object.__dict__` attribute (for example, if its class " "defines the :attr:`~object.__slots__` attribute)." msgstr "" +"Eine :exc:`TypeError`-Ausnahme wird ausgelöst, wenn ein Objekt angegeben wird, " +"das kein :attr:`~object.__dict__`-Attribut besitzt (zum Beispiel, wenn seine " +"Klasse das :attr:`~object.__slots__`-Attribut definiert)." msgid "" "The result of calling this function without an argument has been updated as " "described for the :func:`locals` builtin." msgstr "" +"Das Ergebnis des Aufrufs dieser Funktion ohne Argument wurde wie für die " +"eingebaute Funktion :func:`locals` beschrieben aktualisiert." msgid "" "Iterate over several iterables in parallel, producing tuples with an item " "from each one." msgstr "" +"Über mehrere Iterables parallel iterieren und dabei Tupel mit je einem Element " +"aus jedem Iterable erzeugen.“ msgid "Example::" -msgstr "" +msgstr "Beispiel::" msgid "" ">>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):\n" @@ -3526,23 +3662,37 @@ msgid "" "(2, 'spice')\n" "(3, 'everything nice')" msgstr "" +">>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):\n" +"... print(item)\n" +"...\n" +"(1, 'sugar')\n" +"(2, 'spice')\n" +"(3, 'everything nice')" msgid "" "More formally: :func:`zip` returns an iterator of tuples, where the *i*-th " "tuple contains the *i*-th element from each of the argument iterables." msgstr "" +"Etwas formeller ausgedrückt: :func:`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." msgid "" "Another way to think of :func:`zip` is that it turns rows into columns, and " "columns into rows. This is similar to `transposing a matrix `_." msgstr "" +"Eine weitere Möglichkeit, sich :func:`zip` vorzustellen, ist, dass es Zeilen in Spalten " +"und Spalten in Zeilen umwandelt. Dies ähnelt dem `Transponieren einer Matrix `_." msgid "" ":func:`zip` is lazy: The elements won't be processed until the iterable is " "iterated on, e.g. by a :keyword:`!for` loop or by wrapping in a :class:" "`list`." msgstr "" +":func:`zip` arbeitet verzögert (lazy): Die Elemente werden erst verarbeitet, " +"wenn über das Iterable iteriert wird, z. B. mittels einer :keyword:`!for`-Schleife " +"oder durch Umwandlung in eine :class:`list`." msgid "" "One thing to consider is that the iterables passed to :func:`zip` could have " @@ -3550,28 +3700,44 @@ msgid "" "the code that prepared these iterables. Python offers three different " "approaches to dealing with this issue:" msgstr "" +"Es ist zu beachten, dass die an :func:`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:" msgid "" "By default, :func:`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::" msgstr "" +"Standardmäßig hält :func:`zip` an, sobald das kürzeste Iterable erschöpft " +"ist. Es ignoriert die verbleibenden Elemente in den längeren Iterables und " +"begrenzt das Ergebnis auf die Länge des kürzesten Iterables::" msgid "" ">>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))\n" "[(0, 'fee'), (1, 'fi'), (2, 'fo')]" msgstr "" +">>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))\n" +"[(0, 'fee'), (1, 'fi'), (2, 'fo')]" msgid "" ":func:`zip` is often used in cases where the iterables are assumed to be of " "equal length. In such cases, it's recommended to use the ``strict=True`` " "option. Its output is the same as regular :func:`zip`::" msgstr "" +":func:`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 :func:`zip`::" msgid "" ">>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))\n" "[('a', 1), ('b', 2), ('c', 3)]" msgstr "" +">>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))\n" +"[('a', 1), ('b', 2), ('c', 3)]" msgid "" "Unlike the default behavior, it raises a :exc:`ValueError` if one iterable " @@ -3583,20 +3749,28 @@ msgid "" "different lengths will be silenced, possibly manifesting as a hard-to-find " "bug in another part of the program." msgstr "" +"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." msgid "" "Shorter iterables can be padded with a constant value to make all the " "iterables have the same length. This is done by :func:`itertools." "zip_longest`." msgstr "" +"Kürzere Iterables können mit einem konstanten Wert aufgefüllt werden, " +"damit alle Iterables dieselbe Länge haben. Dies geschieht mit " +":func:`itertools.zip_longest`." msgid "" "Edge cases: With a single iterable argument, :func:`zip` returns an iterator " "of 1-tuples. With no arguments, it returns an empty iterator." msgstr "" +"Grenzfälle: Bei einem einzelnen iterierbaren Argument gibt :func:`zip` einen Iterator " +"von 1-Tupeln zurück. Ohne Argumente gibt es einen leeren Iterator zurück." msgid "Tips and tricks:" -msgstr "" +msgstr "Tipps und Tricks:" msgid "" "The left-to-right evaluation order of the iterables is guaranteed. This " @@ -3605,11 +3779,19 @@ msgid "" "``n`` times so that each output tuple has the result of ``n`` calls to the " "iterator. This has the effect of dividing the input into n-length chunks." msgstr "" +"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``." msgid "" ":func:`zip` in conjunction with the ``*`` operator can be used to unzip a " "list::" msgstr "" +":func:`zip` kann in Verbindung mit dem ``*``-Operator verwendet werden, um eine " +"Liste zu entpacken::" msgid "" ">>> x = [1, 2, 3]\n" @@ -3620,6 +3802,13 @@ msgid "" ">>> x == list(x2) and y == list(y2)\n" "True" msgstr "" +">>> x = [1, 2, 3]\n" +">>> y = [4, 5, 6]\n" +">>> list(zip(x, y))\n" +"[(1, 4), (2, 5), (3, 6)]\n" +">>> x2, y2 = zip(*zip(x, y))\n" +">>> x == list(x2) and y == list(y2)\n" +"True" msgid "Added the ``strict`` argument." msgstr "" @@ -3628,6 +3817,9 @@ msgid "" "This is an advanced function that is not needed in everyday Python " "programming, unlike :func:`importlib.import_module`." msgstr "" +"Dies ist eine fortgeschrittene Funktion, die im Gegensatz zu " +":func:`importlib.import_module` in der alltäglichen Python-Programmierung " +"nicht benötigt wird." msgid "" "This function is invoked by the :keyword:`import` statement. It can be " @@ -3639,6 +3831,15 @@ msgid "" "implementation is in use. Direct use of :func:`__import__` is also " "discouraged in favor of :func:`importlib.import_module`." msgstr "" +"Diese Funktion wird durch die :keyword:`import`-Anweisung aufgerufen. " +"Sie kann ersetzt werden (durch Importieren des Moduls :mod:`builtins` " +"und Zuweisung an ``builtins.__import__``), um die Semantik der " +":keyword:`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 :func:`__import__` wird zugunsten von " +":func:`importlib.import_module` abgeraten." msgid "" "The function imports the module *name*, potentially using the given " @@ -3648,6 +3849,13 @@ msgid "" "does not use its *locals* argument at all and uses its *globals* only to " "determine the package context of the :keyword:`import` statement." msgstr "" +"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 :keyword:`import`-Anweisung zu bestimmen." msgid "" "*level* specifies whether to use absolute or relative imports. ``0`` (the " @@ -3656,6 +3864,11 @@ msgid "" "directory of the module calling :func:`__import__` (see :pep:`328` for the " "details)." msgstr "" +"*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)." msgid "" "When the *name* variable is of the form ``package.module``, normally, the " @@ -3663,57 +3876,80 @@ msgid "" "module named by *name*. However, when a non-empty *fromlist* argument is " "given, the module named by *name* is returned." msgstr "" +"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." msgid "" "For example, the statement ``import spam`` results in bytecode resembling " "the following code::" msgstr "" +"Die Anweisung „import spam“ führt beispielsweise zu Bytecode, der dem " +"folgenden Code ähnelt::" msgid "spam = __import__('spam', globals(), locals(), [], 0)" -msgstr "" +msgstr "spam = __import__('spam', globals(), locals(), [], 0)" msgid "The statement ``import spam.ham`` results in this call::" -msgstr "" +msgstr "Die Anweisung ``import spam.ham`` führt zu diesem Aufruf::" msgid "spam = __import__('spam.ham', globals(), locals(), [], 0)" -msgstr "" +msgstr "spam = __import__('spam.ham', globals(), locals(), [], 0)" msgid "" "Note how :func:`__import__` returns the toplevel module here because this is " "the object that is bound to a name by the :keyword:`import` statement." msgstr "" +"Beachte, wie :func:`__import__` hier das Modul der obersten Ebene zurückgibt, da dies " +"das Objekt ist, das durch die :keyword:`import`-Anweisung an einen Namen gebunden wird." msgid "" "On the other hand, the statement ``from spam.ham import eggs, sausage as " "saus`` results in ::" msgstr "" +Andererseits führt die Anweisung ``from spam.ham import eggs, sausage as " +"saus`` zu ::" msgid "" "_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)\n" "eggs = _temp.eggs\n" "saus = _temp.sausage" msgstr "" +"_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)\n" +"eggs = _temp.eggs\n" +"saus = _temp.sausage" msgid "" "Here, the ``spam.ham`` module is returned from :func:`__import__`. From " "this object, the names to import are retrieved and assigned to their " "respective names." msgstr "" +"Hier wird das Modul ``spam.ham`` von :func:`__import__` zurückgegeben. Aus " +"diesem Objekt werden die zu importierenden Namen abgerufen und den " +"entsprechenden Namen zugewiesen." msgid "" "If you simply want to import a module (potentially within a package) by " "name, use :func:`importlib.import_module`." msgstr "" +"Wenn Sie ein Modul (möglicherweise innerhalb eines Pakets) einfach anhand " +"seines Namens importieren möchten, verwenden Sie :func:`importlib.import_module`." msgid "" "Negative values for *level* are no longer supported (which also changes the " "default value to 0)." msgstr "" +"Negative Werte für *level* werden nicht mehr unterstützt (wodurch sich auch " +"der Standardwert auf 0 ändert)." msgid "" "When the command line options :option:`-E` or :option:`-I` are being used, " "the environment variable :envvar:`PYTHONCASEOK` is now ignored." msgstr "" +"Wenn die Befehlszeilenoptionen :option:`-E` oder :option:`-I` verwendet werden, " +"wird die Umgebungsvariable :envvar:`PYTHONCASEOK` nun ignoriert." msgid "Footnotes" msgstr "Fußnoten" @@ -3723,84 +3959,88 @@ msgid "" "you are reading the code from a file, make sure to use newline conversion " "mode to convert Windows or Mac-style newlines." msgstr "" +"Beachte, dass der Parser nur Zeilenenden im Unix-Format akzeptiert. Wenn " +"Du den Code aus einer Datei liest, stelle sicher, dass Du den Modus zur " +"Umwandlung von Zeilenumbrüchen verwendest, um Zeilenumbrüche im Windows- " +"oder Mac-Format zu konvertieren." msgid "Boolean" -msgstr "" +msgstr "Boolescher Wert" msgid "type" msgstr "Typ" msgid "built-in function" -msgstr "" +msgstr "Eingebaute Funktion" msgid "exec" -msgstr "" +msgstr "Ausführen" msgid "NaN" -msgstr "" +msgstr "Keine Nummer (NaN, Not a Number)" msgid "Infinity" -msgstr "" +msgstr "Unendlichkeit" msgid "__format__" -msgstr "" +msgstr "__format__" msgid "string" -msgstr "" +msgstr "Zeichenkette" msgid "format() (built-in function)" -msgstr "" +msgstr "format() (Eingebaute Funktion)" msgid "file object" -msgstr "" +msgstr "Datei Objekt" msgid "open() built-in function" -msgstr "" +msgstr "open() Eingebaute Funktion" msgid "file" -msgstr "" +msgstr "Datei" msgid "modes" -msgstr "" +msgstr "Modus / Modi" msgid "universal newlines" -msgstr "" +msgstr "Universal Neue Zeile" msgid "line-buffered I/O" -msgstr "" +msgstr "Zeilen gepufferte I/O" msgid "unbuffered I/O" -msgstr "" +msgstr "Ungepufferte I/O" msgid "buffer size, I/O" -msgstr "" +msgstr "Puffer Größe, I/O" msgid "I/O control" -msgstr "" +msgstr "I/O Kontrolle" msgid "buffering" -msgstr "" +msgstr "Puffern" msgid "text mode" -msgstr "" +msgstr "Text Modus" msgid "module" -msgstr "" +msgstr "Modul" msgid "sys" msgstr "sys" msgid "str() (built-in function)" -msgstr "" +msgstr "str() (Eingebaute Funktion)" msgid "object" -msgstr "" +msgstr "Objekt" msgid "statement" -msgstr "" +msgstr "Ausdruck" msgid "import" -msgstr "" +msgstr "Import" msgid "builtins" -msgstr "" +msgstr "Eingebaute Funktionen" From a0972500e3cf3be265e928275762cdc89f43febe Mon Sep 17 00:00:00 2001 From: JystBreisgau Date: Thu, 6 Aug 2026 14:30:29 +0200 Subject: [PATCH 02/13] Update German translation - first errors fixed! --- library/functions.po | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/library/functions.po b/library/functions.po index a634ef6..9d8bc9b 100644 --- a/library/functions.po +++ b/library/functions.po @@ -952,7 +952,7 @@ msgid "" "Passing a complex number as the *real* or *imag* argument is now deprecated; " "it should only be passed as a single positional argument." msgstr "" -„Die Übergabe einer komplexen Zahl als *real*- oder *imag*-Argument ist veraltet;" +"Die Übergabe einer komplexen Zahl als *real*- oder *imag*-Argument ist veraltet;" "sie sollte nur noch als einzelnes Positionsargument übergeben werden.“ msgid "" @@ -2099,11 +2099,11 @@ msgstr "" "übergeben, so wird das größte der Positionsargumente zurückgegeben." msgid "" - "There are two optional keyword-only arguments. The *key* argument specifies " - "a one-argument ordering function like that used for :meth:`list.sort`. The " - "*default* argument specifies an object to return if the provided iterable is " - "empty. If the iterable is empty and *default* is not provided, a :exc:" - "`ValueError` is raised." +"There are two optional keyword-only arguments. The *key* argument specifies " +"a one-argument ordering function like that used for :meth:`list.sort`. The " +"*default* argument specifies an object to return if the provided iterable is " +"empty. If the iterable is empty and *default* is not provided, a :exc:" +"`ValueError` is raised." msgstr "" "Es gibt zwei optionale Argumente, die nur als Schlüsselwortargumente übergeben " "werden können. Das Argument *key* legt eine Sortierfunktion mit einem Argument " @@ -3244,7 +3244,7 @@ msgid "" "The ``@staticmethod`` form is a function :term:`decorator` -- see :ref:" "`function` for details." msgstr "" -„Die Form ``@staticmethod`` ist ein Funktions-:term:`Dekorateur` – siehe :ref:`" +"Die Form ``@staticmethod`` ist ein Funktions-:term:`Dekorateur` – siehe :ref:`" "`function` für Einzelheiten.“ msgid "" @@ -3909,7 +3909,7 @@ msgid "" "On the other hand, the statement ``from spam.ham import eggs, sausage as " "saus`` results in ::" msgstr "" -Andererseits führt die Anweisung ``from spam.ham import eggs, sausage as " +"Andererseits führt die Anweisung ``from spam.ham import eggs, sausage as " "saus`` zu ::" msgid "" From 9cbf249f886153c34fe2d391b637912b7dc2a486 Mon Sep 17 00:00:00 2001 From: JystBreisgau Date: Thu, 6 Aug 2026 14:36:50 +0200 Subject: [PATCH 03/13] Improve German translations - some beauty adjustments Updated German translations for asynchronous iterator and module object descriptions. completed version, not the final version , need a pause to cool my brain! --- library/functions.po | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/library/functions.po b/library/functions.po index 9d8bc9b..e986d3f 100644 --- a/library/functions.po +++ b/library/functions.po @@ -349,7 +349,8 @@ msgid "" "When awaited, return the next item from the given :term:`asynchronous " "iterator`, or *default* if given and the iterator is exhausted." msgstr "" -"Gibt, wenn erwartet, das nächste Element des angegebenen :term:`asynchronen Iterators ` " +"Gibt, wenn erwartet, das nächste Element des angegebenen :term:`asynchronen " +"Iterators ` " "zurück – oder *default*, falls angegeben und der Iterator erschöpft ist." msgid "" @@ -1031,7 +1032,8 @@ msgid "" "If the object is a module object, the list contains the names of the " "module's attributes." msgstr "" -"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 Modulobjekt handelt, enthält die " +"Liste die Namen der Attribute des Moduls." msgid "" "If the object is a type or class object, the list contains the names of its " From 6a9669d2b4de5c14127b78bd7707c32ba522eaf5 Mon Sep 17 00:00:00 2001 From: JystBreisgau Date: Mon, 10 Aug 2026 11:51:02 +0200 Subject: [PATCH 04/13] machine Translation inserted in Github Next step: check for errors --- glossary.po | 2716 +++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 2179 insertions(+), 537 deletions(-) diff --git a/glossary.po b/glossary.po index 8107873..4f4ce7d 100644 --- a/glossary.po +++ b/glossary.po @@ -22,7 +22,7 @@ msgstr "" "Plural-Forms: nplurals=2; plural=(n != 1);\n" msgid "Glossary" -msgstr "" +msgstr "Glossar" msgid "``>>>``" msgstr "``>>>``" @@ -31,12 +31,15 @@ msgid "" "The default Python prompt of the :term:`interactive` shell. Often seen for " "code examples which can be executed interactively in the interpreter." msgstr "" +"Die Standard-Python-Eingabeaufforderung der :term:`interaktiven` Shell. " +"Wird häufig bei Code-Beispielen verwendet, die interaktiv im Interpreter " +"ausgeführt werden können." msgid "``...``" msgstr "``...``" msgid "Can refer to:" -msgstr "" +msgstr "Kann sich beziehen auf:" msgid "" "The default Python prompt of the :term:`interactive` shell when entering the " @@ -44,13 +47,19 @@ msgid "" "right delimiters (parentheses, square brackets, curly braces or triple " "quotes), or after specifying a decorator." msgstr "" +"Die Standard-Python-Eingabeaufforderung der :term:`interactive`-Shell bei " +"der Eingabe von Code für einen eingerückten Codeblock, wenn dieser sich " +"innerhalb eines Paares übereinstimmender linker und rechter Begrenzer " +"(Klammern, eckige Klammern, geschweifte Klammern oder dreifache " +"Anführungszeichen) befindet, oder nach der Angabe eines Dekorators." msgid "" "The three dots form of the :ref:`Ellipsis ` object." msgstr "" +"Die drei Punkte bilden das :ref:`Ellipsis- ` -Objekt." msgid "abstract base class" -msgstr "" +msgstr "Abstrakte Basisklasse" msgid "" "Abstract base classes complement :term:`duck-typing` by providing a way to " @@ -64,9 +73,20 @@ msgid "" "module), import finders and loaders (in the :mod:`importlib.abc` module). " "You can create your own ABCs with the :mod:`abc` module." msgstr "" +"Abstrakte Basisklassen ergänzen :term:`Duck-Typing`, indem sie eine " +"Möglichkeit bieten, Schnittstellen zu definieren, wenn andere Techniken wie " +":func:`hasattr` umständlich oder in subtiler Weise falsch wären (zum " +"Beispiel bei :ref:`magischen Methoden `). ABCs führen " +"virtuelle Unterklassen ein – das sind Klassen, die nicht von einer Klasse " +"erben, aber dennoch von :func:`isinstance` und :func:`issubclass` erkannt " +"werden; siehe die Dokumentation zum Modul :mod:`abc`. Python enthält viele " +"integrierte ABCs für Datenstrukturen (im Modul „ :mod:`collections.abc` “), " +"Zahlen (im Modul :mod:`numbers` ), Streams (im Modul „ :mod:`io` “) sowie" +" Import-Finder und Loader (im Modul „ :mod:`importlib.abc` “). Mit dem Modul" +" :mod:`abc` können Sie eigene ABCs erstellen." msgid "annotate function" -msgstr "" +msgstr "Funktion „annotate“ msgid "" "A function that can be called to retrieve the :term:`annotations " @@ -75,14 +95,23 @@ msgid "" "Annotate functions are a subset of :term:`evaluate functions `." msgstr "" +"Eine Callable-Funktion, die aufgerufen werden kann, um die " +":term:`Annotationen ` eines Objekts abzurufen. Annotate-" +"Funktionen sind in der Regel :term:`Funktionen `, die automatisch " +"als Attribut „ :attr:`~object.__annotate__` “ von Funktionen, Klassen und " +"Modulen generiert werden. Annotate-Funktionen sind eine Teilmenge der " +":term:`Evaluate-Funktionen `." msgid "annotation" -msgstr "" +msgstr "Anmerkung" msgid "" "A label associated with a variable, a class attribute or a function " "parameter or return value, used by convention as a :term:`type hint`." msgstr "" +"Eine Bezeichnung, die einer Variablen, einem Klassenattribut oder einem " +"Funktionsparameter bzw. Rückgabewert zugeordnet ist und üblicherweise als " +":term:`Typhinweis` verwendet wird." msgid "" "Annotations of local variables cannot be accessed at runtime, but " @@ -90,20 +119,31 @@ msgid "" "retrieved by calling :func:`annotationlib.get_annotations` on modules, " "classes, and functions, respectively." msgstr "" +"Auf Annotationen lokaler Variablen kann zur Laufzeit nicht zugegriffen " +"werden, doch Annotationen globaler Variablen, Klassenattribute und " +"Funktionen lassen sich durch Aufruf von ` " +":func:`annotationlib.get_annotations` ` für Module, Klassen bzw. Funktionen " +"abrufen." msgid "" "See :term:`variable annotation`, :term:`function annotation`, :pep:`484`, :" "pep:`526`, and :pep:`649`, which describe this functionality. Also see :ref:" "`annotations-howto` for best practices on working with annotations." msgstr "" +"Siehe :term:`Variablen-Annotation`, :term:`Funktions-Annotation`, " +":pep:`484`, :pep:`526` und :pep:`649`, wo diese Funktionalität beschrieben " +"wird. Siehe außerdem :ref:`annotations-howto` für bewährte Vorgehensweisen " +"beim Umgang mit Annotationen." msgid "argument" -msgstr "" +msgstr "Argument" msgid "" "A value passed to a :term:`function` (or :term:`method`) when calling the " "function. There are two kinds of argument:" msgstr "" +"Ein Wert, der beim Aufruf einer :term:`Funktion` (oder :term:`Methode`) an " +"diese übergeben wird. Es gibt zwei Arten von Argumenten:" msgid "" ":dfn:`keyword argument`: an argument preceded by an identifier (e.g. " @@ -111,11 +151,18 @@ msgid "" "by ``**``. For example, ``3`` and ``5`` are both keyword arguments in the " "following calls to :func:`complex`::" msgstr "" +":dfn:`Schlüsselwortargument`: Ein Argument, dem in einem Funktionsaufruf ein" +" Bezeichner vorangestellt ist (z. B. ` ``name=```) oder das in einem " +"Wörterbuch als Wert übergeben wird, dem ` ``**``` vorangestellt ist. " +"Beispielsweise sind sowohl ` ``3`` ` als auch ` ``5`` ` " +"Schlüsselwortargumente in den folgenden Aufrufen von ` :func:`complex`` ::" msgid "" "complex(real=3, imag=5)\n" "complex(**{'real': 3, 'imag': 5})" msgstr "" +"complex(real=3, imag=5)\n" +"complex(**{'real': 3, 'imag': 5})" msgid "" ":dfn:`positional argument`: an argument that is not a keyword argument. " @@ -123,11 +170,18 @@ msgid "" "be passed as elements of an :term:`iterable` preceded by ``*``. For example, " "``3`` and ``5`` are both positional arguments in the following calls::" msgstr "" +":dfn:`Positionsargument`: Ein Argument, das kein Schlüsselwortargument ist. " +"Positionsargumente können am Anfang einer Argumentliste stehen und/oder als " +"Elemente eines :term:`iterable` übergeben werden, dem „ ``*`` “ " +"vorangestellt ist. Beispielsweise sind sowohl „ ``3`` “ als auch „ ``5`` “ " +"Positionsargumente in den folgenden Aufrufen::" msgid "" "complex(3, 5)\n" "complex(*(3, 5))" msgstr "" +"complex(3, 5)\n" +"complex(*(3, 5))" msgid "" "Arguments are assigned to the named local variables in a function body. See " @@ -135,48 +189,80 @@ msgid "" "Syntactically, any expression can be used to represent an argument; the " "evaluated value is assigned to the local variable." msgstr "" +"Argumente werden im Funktionskörper den benannten lokalen Variablen " +"zugewiesen. Die Regeln für diese Zuweisung finden Sie im Abschnitt „ " +":ref:`calls` “. Syntaktisch kann jeder Ausdruck zur Darstellung eines " +"Arguments verwendet werden; der ausgewertete Wert wird der lokalen Variablen" +" zugewiesen." msgid "" "See also the :term:`parameter` glossary entry, the FAQ question on :ref:`the " "difference between arguments and parameters `, " "and :pep:`362`." msgstr "" +"Siehe auch den Glossareintrag zu :term:`parameter`, die FAQ-Frage zum " +":ref:`Unterschied zwischen Argumenten und Parametern ` sowie :pep:`362`." msgid "asynchronous context manager" -msgstr "" +msgstr "asynchroner Kontextmanager" msgid "" "An object which controls the environment seen in an :keyword:`async with` " "statement by defining :meth:`~object.__aenter__` and :meth:`~object." "__aexit__` methods. Introduced by :pep:`492`." msgstr "" +"Ein Objekt, das die in einer :keyword:`async with`-Anweisung angezeigte " +"Umgebung steuert, indem es die Methoden ` :meth:`~object.__aenter__` ` und `" +" :meth:`~object.__aexit__` ` definiert. Eingeführt durch :pep:`492`." msgid "asynchronous generator" -msgstr "" +msgstr "asynchroner Generator" msgid "" -"A function which returns an :term:`asynchronous generator iterator`. It " -"looks like a coroutine function defined with :keyword:`async def` except " -"that it contains :keyword:`yield` expressions for producing a series of " -"values usable in an :keyword:`async for` loop." +msgid "" +"Informally used to mean either an :term:`asynchronous generator function` or" +" an :term:`asynchronous generator iterator`, depending on context. The " +"formal terms :term:`asynchronous generator function` and :term:`asynchronous" +" generator iterator` are uncommon in practice; \"asynchronous generator\" " +"alone is almost always sufficient." msgstr "" +"Wird umgangssprachlich je nach Kontext entweder für eine :term:`asynchrone " +"Generatorfunktion` oder einen :term:`asynchronen Generator-Iterator` " +"verwendet. Die formalen Begriffe :term:`asynchrone Generatorfunktion` und " +":term:`asynchroner Generator-Iterator` sind in der Praxis selten; " +"„asynchroner Generator“ allein reicht fast immer aus." + +msgid "asynchronous generator function" +msgstr "asynchrone Generatorfunktion" msgid "" -"Usually refers to an asynchronous generator function, but may refer to an " -"*asynchronous generator iterator* in some contexts. In cases where the " -"intended meaning isn't clear, using the full terms avoids ambiguity." +"A function which returns an :term:`asynchronous generator iterator`. It " +"looks like a coroutine function defined with :keyword:`async def` except " +"that it contains :keyword:`yield` expressions for producing a series of " +"values usable in an :keyword:`async for` loop. See :pep:`525`." msgstr "" +"Eine Funktion, die einen :term:`asynchronen Generator-Iterator` zurückgibt. " +"Sie ähnelt einer mit :keyword:`async def` definierten Coroutine-Funktion, " +"enthält jedoch Ausdrücke vom Typ :keyword:`yield`, um eine Reihe von Werten " +"zu erzeugen, die in einer :keyword:`async for`-Schleife verwendet werden " +"können. Siehe :pep:`525`." msgid "" "An asynchronous generator function may contain :keyword:`await` expressions " "as well as :keyword:`async for`, and :keyword:`async with` statements." msgstr "" +"Eine asynchrone Generatorfunktion kann sowohl : :keyword:`await` -Ausdrücke " +"als auch :keyword:`async for`- und :keyword:`async with`-Anweisungen " +"enthalten." msgid "asynchronous generator iterator" -msgstr "" +msgstr "asynchrone Generator-Iterator" msgid "An object created by an :term:`asynchronous generator` function." msgstr "" +"Ein Objekt, das von einer :term:`asynchronen Generatorfunktion` erstellt " +"wurde." msgid "" "This is an :term:`asynchronous iterator` which when called using the :meth:" @@ -184,6 +270,10 @@ msgid "" "the body of the asynchronous generator function until the next :keyword:" "`yield` expression." msgstr "" +"Dies ist ein :term:`asynchroner Iterator`, der beim Aufruf mit der Methode „" +" :meth:`~object.__anext__` “ ein „awaitable“-Objekt zurückgibt, das den " +"Körper der asynchronen Generatorfunktion bis zum nächsten „ :keyword:`yield`" +" “-Ausdruck ausführt." msgid "" "Each :keyword:`yield` temporarily suspends processing, remembering the " @@ -192,18 +282,27 @@ msgid "" "awaitable returned by :meth:`~object.__anext__`, it picks up where it left " "off. See :pep:`492` and :pep:`525`." msgstr "" +"Jeder „ :keyword:`yield` “ unterbricht die Verarbeitung vorübergehend und " +"speichert dabei den Ausführungsstatus (einschließlich lokaler Variablen und " +"ausstehender „try“-Anweisungen). Wenn der *asynchrone Generator-Iterator* " +"mit einem anderen von „ :meth:`~object.__anext__` “ zurückgegebenen " +"„awaitable“ effektiv fortgesetzt wird, setzt er die Ausführung an der Stelle" +" fort, an der er unterbrochen wurde. Siehe :pep:`492` und :pep:`525`." msgid "asynchronous iterable" -msgstr "" +msgstr "asynchrones Iterabel" msgid "" "An object, that can be used in an :keyword:`async for` statement. Must " "return an :term:`asynchronous iterator` from its :meth:`~object.__aiter__` " "method. Introduced by :pep:`492`." msgstr "" +"Ein Objekt, das in einer :keyword:`async for`-Anweisung verwendet werden " +"kann. Es muss über seine Methode :meth:`~object.__aiter__` einen " +":term:`asynchronen Iterator` zurückgeben. Eingeführt durch :pep:`492`." msgid "asynchronous iterator" -msgstr "" +msgstr "asynchroner Iterator" msgid "" "An object that implements the :meth:`~object.__aiter__` and :meth:`~object." @@ -212,17 +311,49 @@ msgid "" "an asynchronous iterator's :meth:`~object.__anext__` method until it raises " "a :exc:`StopAsyncIteration` exception. Introduced by :pep:`492`." msgstr "" +"Ein Objekt, das die Methoden ` :meth:`~object.__aiter__` ` und ` " +":meth:`~object.__anext__` ` implementiert. ` :meth:`~object.__anext__` ` " +"muss ein :term:`awaitable`-Objekt zurückgeben. :keyword:`async for` " +"verarbeitet die von der Methode ` :meth:`~object.__anext__` ` eines " +"asynchronen Iterators zurückgegebenen `awaitables`, bis eine Ausnahme vom " +"Typ ` :exc:`StopAsyncIteration` ` ausgelöst wird. Eingeführt durch " +":pep:`492`." + +msgid "atomic operation" +msgstr "atomare Operation" + +msgid "" +"An operation that appears to execute as a single, indivisible step: no other" +" thread can observe it half-done, and its effects become visible all at " +"once. Python does not guarantee that high-level statements are atomic (for " +"example, ``x += 1`` performs multiple bytecode operations and is not " +"atomic). Atomicity is only guaranteed where explicitly documented. See " +"also :term:`race condition` and :term:`data race`." +msgstr "" +"Eine Operation, die scheinbar als ein einziger, unteilbarer Schritt " +"ausgeführt wird: Kein anderer Thread kann sie in einem unvollendeten Zustand" +" beobachten, und ihre Auswirkungen werden auf einmal sichtbar. Python " +"garantiert nicht, dass Anweisungen auf hoher Ebene atomar sind " +"(beispielsweise führt „ ``x += 1`` “ mehrere Bytecode-Operationen aus und " +"ist nicht atomar). Atomarität wird nur dort garantiert, wo dies " +"ausdrücklich dokumentiert ist. Siehe auch :term:`Race Condition` und " +":term:`Data Race`." msgid "attached thread state" -msgstr "" +msgstr "Zustand des angehängten Threads" msgid "A :term:`thread state` that is active for the current OS thread." msgstr "" +"Ein :term:`Thread-Status`, der für den aktuellen Betriebssystem-Thread aktiv" +" ist." msgid "" "When a :term:`thread state` is attached, the OS thread has access to the " "full Python C API and can safely invoke the bytecode interpreter." msgstr "" +"Wenn ein :term:`Thread-Status` zugeordnet ist, hat der Betriebssystem-Thread" +" Zugriff auf die vollständige Python-C-API und kann den Bytecode-Interpreter" +" sicher aufrufen." msgid "" "Unless a function explicitly notes otherwise, attempting to call the C API " @@ -231,6 +362,12 @@ msgid "" "user through the C API, or implicitly by the runtime, including during " "blocking C calls and by the bytecode interpreter in between calls." msgstr "" +"Sofern in einer Funktion nicht ausdrücklich anders angegeben, führt der " +"Versuch, die C-API ohne angehängten Thread-Status aufzurufen, zu einem " +"schwerwiegenden Fehler oder zu undefiniertem Verhalten. Ein Thread-Status " +"kann vom Benutzer explizit über die C-API angehängt und entfernt werden oder" +" implizit von der Laufzeitumgebung, unter anderem während blockierender " +"C-Aufrufe und durch den Bytecode-Interpreter zwischen den Aufrufen." msgid "" "On most builds of Python, having an attached thread state implies that the " @@ -240,6 +377,13 @@ msgid "" "an attached thread state, allowing for true parallelism of the bytecode " "interpreter." msgstr "" +"Bei den meisten Python-Builds bedeutet ein zugeordneter Thread-Zustand, dass" +" der Aufrufer den :term:`GIL` für den aktuellen Interpreter hält, sodass zu " +"einem bestimmten Zeitpunkt nur ein Betriebssystem-Thread einen zugeordneten " +"Thread-Zustand haben kann. In :term:`free-threaded-Versionen ` von Python können mehrere Threads gleichzeitig einen angehängten " +"Thread-Status halten, was eine echte Parallelität des Bytecode-Interpreters " +"ermöglicht." msgid "attribute" msgstr "Attribut" @@ -249,6 +393,10 @@ msgid "" "dotted expressions. For example, if an object *o* has an attribute *a* it " "would be referenced as *o.a*." msgstr "" +"Ein Wert, der einem Objekt zugeordnet ist und auf den in der Regel mithilfe " +"von Punktnotation unter Angabe des Namens verwiesen wird. Wenn " +"beispielsweise ein Objekt *o* ein Attribut *a* hat, würde darauf als *o.a* " +"verwiesen werden." msgid "" "It is possible to give an object an attribute whose name is not an " @@ -257,26 +405,36 @@ msgid "" "using a dotted expression, and would instead need to be retrieved with :func:" "`getattr`." msgstr "" +"Es ist möglich, einem Objekt ein Attribut zuzuweisen, dessen Name kein " +"Bezeichner im Sinne von :ref:`identifiers` ist, beispielsweise mithilfe von " +":func:`setattr`, sofern das Objekt dies zulässt. Auf ein solches Attribut " +"kann nicht über einen Punktausdruck zugegriffen werden; stattdessen muss es " +"mit :func:`getattr` abgerufen werden." msgid "awaitable" -msgstr "" +msgstr "abwartbar" msgid "" "An object that can be used in an :keyword:`await` expression. Can be a :" "term:`coroutine` or an object with an :meth:`~object.__await__` method. See " "also :pep:`492`." msgstr "" +"Ein Objekt, das in einem Ausdruck vom Typ „ :keyword:`await` “ verwendet " +"werden kann. Kann eine :term:`coroutine` oder ein Objekt mit einer Methode " +"vom Typ „ :meth:`~object.__await__` “ sein. Siehe auch :pep:`492`." msgid "BDFL" -msgstr "" +msgstr "BDFL" msgid "" "Benevolent Dictator For Life, a.k.a. `Guido van Rossum `_, Python's creator." msgstr "" +"„Wohltätiger Diktator auf Lebenszeit“, auch bekannt als „Guido van Rossum " +"`_ “, der Schöpfer von Python." msgid "binary file" -msgstr "" +msgstr "Binärdatei" msgid "" "A :term:`file object` able to read and write :term:`bytes-like objects " @@ -285,14 +443,21 @@ msgid "" "stdin>`, :data:`sys.stdout.buffer `, and instances of :class:`io." "BytesIO` and :class:`gzip.GzipFile`." msgstr "" +"Ein :term:`Dateiobjekt`, das :term:`byteähnliche Objekte ` lesen und schreiben kann. Beispiele für Binärdateien sind Dateien, " +"die im Binärmodus geöffnet wurden (``'rb'``, ``'wb'`` oder ``'rb+'``), " +":data:`sys.stdin.buffer `, :data:`sys.stdout.buffer `" +" sowie Instanzen von :class:`io.BytesIO` und :class:`gzip.GzipFile`." msgid "" "See also :term:`text file` for a file object able to read and write :class:" "`str` objects." msgstr "" +"Siehe auch :term:`Textdatei` für ein Dateiobjekt, das Objekte vom Typ ` " +":class:`str` ` lesen und schreiben kann." msgid "borrowed reference" -msgstr "" +msgstr "entlehnte Referenz" msgid "" "In Python's C API, a borrowed reference is a reference to an object, where " @@ -300,6 +465,11 @@ msgid "" "pointer if the object is destroyed. For example, a garbage collection can " "remove the last :term:`strong reference` to the object and so destroy it." msgstr "" +"In der C-API von Python ist eine ausgeliehene Referenz eine Referenz auf ein" +" Objekt, wobei der Code, der das Objekt verwendet, nicht Eigentümer der " +"Referenz ist. Sie wird zu einem „dangling pointer“, wenn das Objekt zerstört" +" wird. Beispielsweise kann eine Garbage Collection die letzte :term:`starke " +"Referenz` auf das Objekt entfernen und es so zerstören." msgid "" "Calling :c:func:`Py_INCREF` on the :term:`borrowed reference` is recommended " @@ -308,9 +478,15 @@ msgid "" "func:`Py_NewRef` function can be used to create a new :term:`strong " "reference`." msgstr "" +"Es wird empfohlen, die Funktion ` :c:func:`Py_INCREF` ` auf die " +":term:`geliehene Referenz` anzuwenden, um diese an Ort und Stelle in eine " +":term:`starke Referenz` umzuwandeln – es sei denn, das Objekt kann nicht vor" +" der letzten Verwendung der geliehenen Referenz zerstört werden. Mit der " +"Funktion ` :c:func:`Py_NewRef` ` kann eine neue :term:`starke Referenz` " +"erstellt werden." msgid "bytes-like object" -msgstr "" +msgstr "Byte-ähnliches Objekt" msgid "" "An object that supports the :ref:`bufferobjects` and can export a C-:term:" @@ -320,6 +496,14 @@ msgid "" "with binary data; these include compression, saving to a binary file, and " "sending over a socket." msgstr "" +"Ein Objekt, das die Schnittstelle „ :ref:`bufferobjects` “ unterstützt und " +"einen C-:term:`contiguous`-Puffer exportieren kann. Dazu gehören alle " +"Objekte vom Typ „ :class:`bytes` “, „ :class:`bytearray` “ und „ " +":class:`array.array` “ sowie viele gängige Objekte vom Typ „ " +":class:`memoryview` “. Bytes-ähnliche Objekte können für verschiedene " +"Operationen verwendet werden, die mit Binärdaten arbeiten; dazu gehören " +"Komprimierung, das Speichern in einer Binärdatei und das Senden über einen " +"Socket." msgid "" "Some operations need the binary data to be mutable. The documentation often " @@ -329,9 +513,17 @@ msgid "" "immutable objects (\"read-only bytes-like objects\"); examples of these " "include :class:`bytes` and a :class:`memoryview` of a :class:`bytes` object." msgstr "" +"Bei einigen Operationen müssen die Binärdaten veränderbar sein. In der " +"Dokumentation werden diese häufig als „les- und schreibbare byteähnliche " +"Objekte“ bezeichnet. Beispiele für veränderbare Pufferobjekte sind „ " +":class:`bytearray` “ und ein „ :class:`memoryview` “ eines „ " +":class:`bytearray` “-Objekts. Andere Operationen erfordern, dass die " +"Binärdaten in unveränderbaren Objekten („read-only bytes-like objects“) " +"gespeichert werden; Beispiele hierfür sind „ :class:`bytes` “ und ein „ " +":class:`memoryview` “ eines „ :class:`bytes` “-Objekts." msgid "bytecode" -msgstr "" +msgstr "Bytecode" msgid "" "Python source code is compiled into bytecode, the internal representation of " @@ -343,55 +535,80 @@ msgid "" "expected to work between different Python virtual machines, nor to be stable " "between Python releases." msgstr "" +"Python-Quellcode wird zu Bytecode kompiliert, der internen Darstellung eines" +" Python-Programms im CPython-Interpreter. Der Bytecode wird zudem in „ " +"``.pyc`` “-Dateien zwischengespeichert, sodass die Ausführung derselben " +"Datei beim zweiten Mal schneller erfolgt (eine Neukompilierung vom Quellcode" +" zum Bytecode kann vermieden werden). Diese „Zwischensprache“ läuft auf " +"einer :term:`virtuellen Maschine`, die den jedem Bytecode entsprechenden " +"Maschinencode ausführt. Beachten Sie jedoch, dass Bytecodes nicht unbedingt " +"zwischen verschiedenen virtuellen Python-Maschinen funktionieren und auch " +"nicht über Python-Versionen hinweg stabil sind." msgid "" "A list of bytecode instructions can be found in the documentation for :ref:" "`the dis module `." msgstr "" +"Eine Liste der Bytecode-Befehle finden Sie in der Dokumentation zum " +":ref:`dis-Modul `." msgid "callable" -msgstr "" +msgstr "abrufbar" msgid "" "A callable is an object that can be called, possibly with a set of arguments " "(see :term:`argument`), with the following syntax::" msgstr "" +"Ein „Callable“ ist ein Objekt, das aufgerufen werden kann, gegebenenfalls " +"mit einer Reihe von Argumenten (siehe :term:`argument`), und zwar mit " +"folgender Syntax::" msgid "callable(argument1, argument2, argumentN)" -msgstr "" +msgstr "callable(argument1, argument2, argumentN)" msgid "" "A :term:`function`, and by extension a :term:`method`, is a callable. An " "instance of a class that implements the :meth:`~object.__call__` method is " "also a callable." msgstr "" +"Eine :term:`Funktion` und im weiteren Sinne auch eine :term:`Methode` ist " +"ein aufrufbares Objekt. Eine Instanz einer Klasse, die die Methode ` " +":meth:`~object.__call__` ` implementiert, ist ebenfalls ein aufrufbares " +"Objekt." msgid "callback" -msgstr "" +msgstr "Callback" msgid "" "A subroutine function which is passed as an argument to be executed at some " "point in the future." msgstr "" +"Eine Unterprogrammfunktion, die als Argument übergeben wird, um zu einem " +"späteren Zeitpunkt ausgeführt zu werden." msgid "class" -msgstr "" +msgstr "Klasse" msgid "" "A template for creating user-defined objects. Class definitions normally " "contain method definitions which operate on instances of the class." msgstr "" +"Eine Vorlage zum Erstellen benutzerdefinierter Objekte. Klassendefinitionen " +"enthalten in der Regel Methodendefinitionen, die auf Instanzen der Klasse " +"angewendet werden." msgid "class variable" -msgstr "" +msgstr "Klassenvariable" msgid "" "A variable defined in a class and intended to be modified only at class " "level (i.e., not in an instance of the class)." msgstr "" +"Eine Variable, die in einer Klasse definiert ist und nur auf Klassenebene " +"(d. h. nicht in einer Instanz der Klasse) geändert werden soll." msgid "closure variable" -msgstr "" +msgstr "Schließvariable" msgid "" "A :term:`free variable` referenced from a :term:`nested scope` that is " @@ -400,12 +617,22 @@ msgid "" "`nonlocal` keyword to allow write access, or implicitly defined if the " "variable is only being read." msgstr "" +"Eine :term:`freie Variable`, auf die aus einem :term:`verschachtelten " +"Gültigkeitsbereich` verwiesen wird und die in einem äußeren " +"Gültigkeitsbereich definiert ist, anstatt zur Laufzeit aus den globalen oder" +" integrierten Namensräumen aufgelöst zu werden. Sie kann explizit mit dem " +"Schlüsselwort „ :keyword:`nonlocal` “ definiert werden, um Schreibzugriff zu" +" ermöglichen, oder implizit definiert werden, wenn die Variable nur gelesen " +"wird." msgid "" "For example, in the ``inner`` function in the following code, both ``x`` and " "``print`` are :term:`free variables `, but only ``x`` is a " "*closure variable*::" msgstr "" +"Beispielsweise sind in der Funktion „ ``inner`` “ im folgenden Code sowohl " +"``x`` als auch ``print``:term:`freie Variablen `, aber nur " +"``x`` ist eine *Closure-Variable*::" msgid "" "def outer():\n" @@ -416,6 +643,13 @@ msgid "" " print(x)\n" " return inner" msgstr "" +"def outer():\n" +" x = 0\n" +" def inner():\n" +" nonlocal x\n" +" x += 1\n" +" print(x)\n" +" return inner" msgid "" "Due to the :attr:`codeobject.co_freevars` attribute (which, despite its " @@ -424,9 +658,14 @@ msgid "" "sometimes used even when the intended meaning is to refer specifically to " "closure variables." msgstr "" +"Aufgrund des Attributs „ :attr:`codeobject.co_freevars` “ (das trotz seines " +"Namens lediglich die Namen von Closure-Variablen enthält, anstatt alle " +"referenzierten freien Variablen aufzulisten) wird der allgemeinere Begriff " +":term:`freie Variable` manchmal verwendet, selbst wenn eigentlich speziell " +"auf Closure-Variablen Bezug genommen werden soll." msgid "complex number" -msgstr "" +msgstr "komplexe Zahl" msgid "" "An extension of the familiar real number system in which all numbers are " @@ -439,72 +678,151 @@ msgid "" "Use of complex numbers is a fairly advanced mathematical feature. If you're " "not aware of a need for them, it's almost certain you can safely ignore them." msgstr "" +"Eine Erweiterung des bekannten Systems der reellen Zahlen, in der alle " +"Zahlen als Summe aus einem reellen und einem imaginären Teil ausgedrückt " +"werden. Imaginäre Zahlen sind reelle Vielfache der imaginären Einheit (der " +"Quadratwurzel von ``-1``), die in der Mathematik häufig als ``i`` und im " +"Ingenieurwesen als ``j`` geschrieben werden. Python bietet integrierte " +"Unterstützung für komplexe Zahlen, die in der letztgenannten Notation " +"geschrieben werden; der Imaginärteil wird mit dem Suffix „ ``j`` “ " +"angegeben, z. B. „ ``3+1j`` “. Um auf die komplexen Entsprechungen des " +"Moduls „ :mod:`math` “ zuzugreifen, verwenden Sie „ :mod:`cmath` “. Die " +"Verwendung komplexer Zahlen ist eine recht fortgeschrittene mathematische " +"Funktion. Wenn Sie keinen Bedarf dafür sehen, können Sie diese Funktionen " +"mit ziemlicher Sicherheit getrost ignorieren." + +msgid "concurrency" +msgstr "Parallelität" + +msgid "" +"The ability of a computer program to perform multiple tasks at the same " +"time. Python provides libraries for writing programs that make use of " +"different forms of concurrency. :mod:`asyncio` is a library for dealing " +"with asynchronous tasks and coroutines. :mod:`threading` provides access to" +" operating system threads and :mod:`multiprocessing` to operating system " +"processes. Multi-core processors can execute threads and processes on " +"different CPU cores at the same time (see :term:`parallelism`)." +msgstr "" +"Die Fähigkeit eines Computerprogramms, mehrere Aufgaben gleichzeitig " +"auszuführen. Python bietet Bibliotheken zum Schreiben von Programmen, die " +"verschiedene Formen der Parallelität nutzen. „ :mod:`asyncio` “ ist eine " +"Bibliothek für den Umgang mit asynchronen Aufgaben und Coroutinen. „ " +":mod:`threading` “ bietet Zugriff auf Betriebssystem-Threads und „ " +":mod:`multiprocessing` “ auf Betriebssystem-Prozesse. Multi-Core-Prozessoren" +" können Threads und Prozesse gleichzeitig auf verschiedenen CPU-Kernen " +"ausführen (siehe :term:`Parallelität`)." + +msgid "concurrent modification" +msgstr "parallele Änderung" + +msgid "" +"When multiple threads modify shared data at the same time. Concurrent " +"modification without proper synchronization can cause :term:`race conditions" +" `, and might also trigger a :term:`data race `, " +"data corruption, or both." +msgstr "" +"Wenn mehrere Threads gleichzeitig gemeinsam genutzte Daten ändern. Eine " +"gleichzeitige Änderung ohne ordnungsgemäße Synchronisation kann zu " +":term:`Race Conditions ` führen und möglicherweise auch " +"einen :term:`Datenkonflikt `, Datenbeschädigungen oder beides " +"auslösen." msgid "context" -msgstr "" +msgstr "Kontext" msgid "" -"This term has different meanings depending on where and how it is used. Some " -"common meanings:" +"This term has different meanings depending on where and how it is used. Some" +" common meanings:" msgstr "" +"Dieser Begriff hat je nach Kontext und Verwendung unterschiedliche " +"Bedeutungen. Einige gängige Bedeutungen:" msgid "" "The temporary state or environment established by a :term:`context manager` " "via a :keyword:`with` statement." msgstr "" +"Der temporäre Zustand oder die Umgebung, die von einem :term:`Context " +"Manager` über eine ` :keyword:`with` `-Anweisung eingerichtet wird." msgid "" -"The collection of key­value bindings associated with a particular :class:" -"`contextvars.Context` object and accessed via :class:`~contextvars." -"ContextVar` objects. Also see :term:`context variable`." +"The collection of key­value bindings associated with a particular " +":class:`contextvars.Context` object and accessed via " +":class:`~contextvars.ContextVar` objects. Also see :term:`context " +"variable`." msgstr "" +"Die Sammlung von Schlüssel-Wert-Zuordnungen, die einem bestimmten " +":class:`contextvars.Context` -Objekt zugeordnet sind und über " +":class:`~contextvars.ContextVar` -Objekte abgerufen werden. Siehe auch: " +":term:`Kontextvariable`." msgid "" "A :class:`contextvars.Context` object. Also see :term:`current context`." msgstr "" +"Ein ` :class:`contextvars.Context` `-Objekt. Siehe auch: :term:`aktueller " +"Kontext`." msgid "context management protocol" -msgstr "" +msgstr "Kontextverwaltungsprotokoll" msgid "" -"The :meth:`~object.__enter__` and :meth:`~object.__exit__` methods called by " -"the :keyword:`with` statement. See :pep:`343`." +"The :meth:`~object.__enter__` and :meth:`~object.__exit__` methods called by" +" the :keyword:`with` statement. See :pep:`343`." msgstr "" +"Die Methoden „ :meth:`~object.__enter__` “ und „ :meth:`~object.__exit__` “," +" die von der Anweisung „ :keyword:`with` “ aufgerufen werden. Siehe " +":pep:`343`." msgid "context manager" -msgstr "" +msgstr "Kontextmanager" msgid "" "An object which implements the :term:`context management protocol` and " -"controls the environment seen in a :keyword:`with` statement. See :pep:" -"`343`." +"controls the environment seen in a :keyword:`with` statement. See " +":pep:`343`." msgstr "" +"Ein Objekt, das das :term:`Kontextverwaltungsprotokoll` implementiert und " +"die Umgebung steuert, die in einer :keyword:`with` -Anweisung sichtbar ist. " +"Siehe :pep:`343`." msgid "context variable" -msgstr "" +msgstr "Kontextvariable" msgid "" "A variable whose value depends on which context is the :term:`current " -"context`. Values are accessed via :class:`contextvars.ContextVar` objects. " -"Context variables are primarily used to isolate state between concurrent " +"context`. Values are accessed via :class:`contextvars.ContextVar` objects." +" Context variables are primarily used to isolate state between concurrent " "asynchronous tasks." msgstr "" +"Eine Variable, deren Wert davon abhängt, welcher Kontext gerade aktiv ist, " +"wird als :term:`aktueller Kontext` bezeichnet. Der Zugriff auf die Werte " +"erfolgt über Objekte vom Typ „ :class:`contextvars.ContextVar` “. " +"Kontextvariablen werden in erster Linie dazu verwendet, den Zustand zwischen" +" parallel laufenden asynchronen Aufgaben zu isolieren." msgid "contiguous" -msgstr "" +msgstr "zusammenhängend" msgid "" "A buffer is considered contiguous exactly if it is either *C-contiguous* or " "*Fortran contiguous*. Zero-dimensional buffers are C and Fortran " -"contiguous. In one-dimensional arrays, the items must be laid out in memory " -"next to each other, in order of increasing indexes starting from zero. In " -"multidimensional C-contiguous arrays, the last index varies the fastest when " -"visiting items in order of memory address. However, in Fortran contiguous " +"contiguous. In one-dimensional arrays, the items must be laid out in memory" +" next to each other, in order of increasing indexes starting from zero. In " +"multidimensional C-contiguous arrays, the last index varies the fastest when" +" visiting items in order of memory address. However, in Fortran contiguous " "arrays, the first index varies the fastest." msgstr "" +"Ein Puffer gilt genau dann als zusammenhängend, wenn er entweder " +"*C-zusammenhängend* oder *Fortran-zusammenhängend* ist. Null-dimensionale " +"Puffer sind sowohl C- als auch Fortran-zusammenhängend. In eindimensionalen" +" Arrays müssen die Elemente im Speicher nebeneinander angeordnet sein, und " +"zwar in aufsteigender Reihenfolge der Indizes, beginnend bei Null. In " +"mehrdimensionalen C-zusammenhängenden Arrays ändert sich der letzte Index am" +" schnellsten, wenn die Elemente in der Reihenfolge ihrer Speicheradressen " +"durchlaufen werden. In Fortran-zusammenhängenden Arrays hingegen ändert " +"sich der erste Index am schnellsten." msgid "coroutine" -msgstr "" +msgstr "Koroutine" msgid "" "Coroutines are a more generalized form of subroutines. Subroutines are " @@ -512,63 +830,144 @@ msgid "" "entered, exited, and resumed at many different points. They can be " "implemented with the :keyword:`async def` statement. See also :pep:`492`." msgstr "" +"Coroutinen sind eine verallgemeinerte Form von Unterprogrammen. " +"Unterprogramme werden an einer Stelle aufgerufen und an einer anderen Stelle" +" beendet. Coroutinen können an vielen verschiedenen Stellen aufgerufen, " +"beendet und fortgesetzt werden. Sie lassen sich mit der Anweisung " +":keyword:`async def` implementieren. Siehe auch :pep:`492`." msgid "coroutine function" -msgstr "" +msgstr "Coroutinen-Funktion" msgid "" "A function which returns a :term:`coroutine` object. A coroutine function " -"may be defined with the :keyword:`async def` statement, and may contain :" -"keyword:`await`, :keyword:`async for`, and :keyword:`async with` keywords. " -"These were introduced by :pep:`492`." +"may be defined with the :keyword:`async def` statement, and may contain " +":keyword:`await`, :keyword:`async for`, and :keyword:`async with` keywords." +" These were introduced by :pep:`492`." msgstr "" +"Eine Funktion, die ein :term:`coroutine`-Objekt zurückgibt. Eine Coroutine-" +"Funktion kann mit der Anweisung :keyword:`async def` definiert werden und " +"die Schlüsselwörter :keyword:` :keyword:`await``, :keyword:`async for` sowie" +" :keyword:`async with` enthalten. Diese wurden mit :pep:`492` eingeführt." msgid "CPython" -msgstr "" +msgstr "CPython" msgid "" "The canonical implementation of the Python programming language, as " -"distributed on `python.org `_. The term \"CPython\" " -"is used when necessary to distinguish this implementation from others such " +"distributed on `python.org `_. The term \"CPython\"" +" is used when necessary to distinguish this implementation from others such " "as Jython or IronPython." msgstr "" +"Die kanonische Implementierung der Programmiersprache Python, wie sie auf " +"`python.org `_ bereitgestellt wird. Der Begriff " +"„CPython“ wird bei Bedarf verwendet, um diese Implementierung von anderen " +"wie Jython oder IronPython zu unterscheiden." msgid "current context" -msgstr "" +msgstr "aktueller Kontext" msgid "" "The :term:`context` (:class:`contextvars.Context` object) that is currently " "used by :class:`~contextvars.ContextVar` objects to access (get or set) the " -"values of :term:`context variables `. Each thread has its " -"own current context. Frameworks for executing asynchronous tasks (see :mod:" -"`asyncio`) associate each task with a context which becomes the current " -"context whenever the task starts or resumes execution." -msgstr "" +"values of :term:`context variables `. Each thread has its" +" own current context. Frameworks for executing asynchronous tasks (see " +":mod:`asyncio`) associate each task with a context which becomes the current" +" context whenever the task starts or resumes execution." +msgstr "" +"Der :term:`Kontext` (:class:`contextvars.Context` -Objekt), der derzeit von " +":class:`~contextvars.ContextVar` -Objekten verwendet wird, um auf die Werte " +"von :term:`Kontextvariablen ` zuzugreifen (abzurufen oder " +"festzulegen). Jeder Thread verfügt über einen eigenen aktuellen Kontext. " +"Frameworks zur Ausführung asynchroner Aufgaben (siehe :mod:`asyncio`) ordnen" +" jeder Aufgabe einen Kontext zu, der zum aktuellen Kontext wird, sobald die " +"Aufgabe ihre Ausführung beginnt oder fortsetzt." msgid "cyclic isolate" -msgstr "" +msgstr "zyklisches Isolat" msgid "" "A subgroup of one or more objects that reference each other in a reference " -"cycle, but are not referenced by objects outside the group. The goal of " -"the :term:`cyclic garbage collector ` is to identify " -"these groups and break the reference cycles so that the memory can be " -"reclaimed." -msgstr "" +"cycle, but are not referenced by objects outside the group. The goal of the" +" :term:`cyclic garbage collector ` is to identify these " +"groups and break the reference cycles so that the memory can be reclaimed." +msgstr "" +"Eine Untergruppe aus einem oder mehreren Objekten, die sich in einem " +"Referenzzyklus gegenseitig referenzieren, aber von Objekten außerhalb der " +"Gruppe nicht referenziert werden. Das Ziel des :term:`zyklischen Garbage " +"Collectors ` besteht darin, diese Gruppen zu " +"identifizieren und die Referenzzyklen aufzubrechen, damit der Speicher " +"freigegeben werden kann." + +msgid "data race" +msgstr "Datenkonflikt" + +msgid "" +"A situation where multiple threads access the same memory location " +"concurrently, at least one of the accesses is a write, and the threads do " +"not use any synchronization to control their access. Data races lead to " +":term:`non-deterministic` behavior and can cause data corruption. Proper use" +" of :term:`locks ` and other :term:`synchronization primitives " +"` prevents data races. Note that data races can " +"only happen in native code, but that :term:`native code` might be exposed in" +" a Python API. See also :term:`race condition` and :term:`thread-safe`." +msgstr "" +"Eine Situation, in der mehrere Threads gleichzeitig auf denselben " +"Speicherort zugreifen, wobei mindestens einer der Zugriffe ein " +"Schreibzugriff ist und die Threads keine Synchronisation zur Steuerung ihres" +" Zugriffs verwenden. Datenkonflikte führen zu :term:`nicht-" +"deterministischem` Verhalten und können Datenbeschädigungen verursachen. Die" +" korrekte Verwendung von :term:`Locks ` und anderen " +":term:`Synchronisationsprimitiven ` verhindert " +"Datenrennen. Beachten Sie, dass Datenrennen nur in nativem Code auftreten " +"können, dieser :term:`native Code` jedoch möglicherweise in einer Python-API" +" verfügbar ist. Siehe auch :term:`Race Condition` und :term:`thread-safe`." + +msgid "deadlock" +msgstr "Pattsituation" + +msgid "" +"A situation in which two or more tasks (threads, processes, or coroutines) " +"wait indefinitely for each other to release resources or complete actions, " +"preventing any from making progress. For example, if thread A holds lock 1 " +"and waits for lock 2, while thread B holds lock 2 and waits for lock 1, both" +" threads will wait indefinitely. In Python this often arises from acquiring" +" multiple locks in conflicting orders or from circular join/await " +"dependencies. Deadlocks can be avoided by always acquiring multiple " +":term:`locks ` in a consistent order. See also :term:`lock` and " +":term:`reentrant`." +msgstr "" +"Eine Situation, in der zwei oder mehr Aufgaben (Threads, Prozesse oder " +"Coroutinen) unbegrenzt darauf warten, dass die jeweils anderen Ressourcen " +"freigeben oder Aktionen abschließen, wodurch keine der Aufgaben vorankommt." +" Wenn beispielsweise Thread A die Sperre 1 hält und auf die Sperre 2 " +"wartet, während Thread B die Sperre 2 hält und auf die Sperre 1 wartet, " +"werden beide Threads auf unbestimmte Zeit warten. In Python entsteht dies " +"häufig durch das Erlangen mehrerer Sperren in widersprüchlicher Reihenfolge " +"oder durch zirkuläre „join/await“-Abhängigkeiten. Deadlocks lassen sich " +"vermeiden, indem mehrere :term:`Sperren ` stets in einer konsistenten " +"Reihenfolge erworben werden. Siehe auch :term:`Sperre` und " +":term:`reentrant`." msgid "decorator" -msgstr "" +msgstr "Dekorateur" msgid "" "A function returning another function, usually applied as a function " "transformation using the ``@wrapper`` syntax. Common examples for " -"decorators are :func:`classmethod` and :func:`staticmethod`." +"decorators are :deco:`classmethod` and :deco:`staticmethod`." msgstr "" +"Eine Funktion, die eine andere Funktion zurückgibt und in der Regel als " +"Funktionstransformation mithilfe der Syntax „ ``@wrapper`` “ angewendet " +"wird. Gängige Beispiele für Dekoratoren sind :deco:`classmethod` und " +":deco:`staticmethod`." msgid "" "The decorator syntax is merely syntactic sugar, the following two function " "definitions are semantically equivalent::" msgstr "" +"Die Dekorator-Syntax ist lediglich „Syntactic Sugar“; die folgenden beiden " +"Funktionsdefinitionen sind semantisch gleichbedeutend::" msgid "" "def f(arg):\n" @@ -579,65 +978,105 @@ msgid "" "def f(arg):\n" " ..." msgstr "" +"def f(arg):\n" +" ...\n" +"f = staticmethod(f)\n" +"\n" +"@staticmethod\n" +"def f(arg):\n" +" ..." msgid "" "The same concept exists for classes, but is less commonly used there. See " -"the documentation for :ref:`function definitions ` and :ref:`class " -"definitions ` for more about decorators." +"the documentation for :ref:`function definitions ` and :ref:`class" +" definitions ` for more about decorators." msgstr "" +"Das gleiche Konzept gibt es auch für Klassen, wird dort jedoch seltener " +"verwendet. Weitere Informationen zu Dekoratoren finden Sie in der " +"Dokumentation zu :ref:`Funktionsdefinitionen ` und " +":ref:`Klassendefinitionen `." msgid "descriptor" -msgstr "" +msgstr "Deskriptor" msgid "" -"Any object which defines the methods :meth:`~object.__get__`, :meth:`~object." -"__set__`, or :meth:`~object.__delete__`. When a class attribute is a " -"descriptor, its special binding behavior is triggered upon attribute " -"lookup. Normally, using *a.b* to get, set or delete an attribute looks up " -"the object named *b* in the class dictionary for *a*, but if *b* is a " -"descriptor, the respective descriptor method gets called. Understanding " +"Any object which defines the methods :meth:`~object.__get__`, " +":meth:`~object.__set__`, or :meth:`~object.__delete__`. When a class " +"attribute is a descriptor, its special binding behavior is triggered upon " +"attribute lookup. Normally, using *a.b* to get, set or delete an attribute " +"looks up the object named *b* in the class dictionary for *a*, but if *b* is" +" a descriptor, the respective descriptor method gets called. Understanding " "descriptors is a key to a deep understanding of Python because they are the " "basis for many features including functions, methods, properties, class " "methods, static methods, and reference to super classes." msgstr "" +"Jedes Objekt, das die Methoden „ :meth:`~object.__get__` “, „ " +":meth:`~object.__set__` “ oder „ :meth:`~object.__delete__` “ definiert. " +"Wenn ein Klassenattribut ein Deskriptor ist, wird sein spezielles " +"Bindungsverhalten bei der Attributsuche ausgelöst. Normalerweise wird bei " +"der Verwendung von *a.b* zum Abrufen, Setzen oder Löschen eines Attributs " +"das Objekt mit dem Namen *b* im Klassenwörterbuch von *a* nachgeschlagen; " +"ist *b* jedoch ein Deskriptor, wird die entsprechende Deskriptormethode " +"aufgerufen. Das Verständnis von Deskriptoren ist der Schlüssel zu einem " +"tiefgreifenden Verständnis von Python, da sie die Grundlage für viele " +"Funktionen bilden, darunter Funktionen, Methoden, Eigenschaften, " +"Klassenmethoden, statische Methoden und Verweise auf Oberklassen." msgid "" "For more information about descriptors' methods, see :ref:`descriptors` or " "the :ref:`Descriptor How To Guide `." msgstr "" +"Weitere Informationen zu den Methoden von Deskriptoren finden Sie unter " +":ref:`descriptors` oder im :ref:`Descriptor How To Guide `." msgid "dictionary" -msgstr "" +msgstr "Wörterbuch" msgid "" "An associative array, where arbitrary keys are mapped to values. The keys " "can be any object with :meth:`~object.__hash__` and :meth:`~object.__eq__` " "methods. Called a hash in Perl." msgstr "" +"Ein assoziatives Array, bei dem beliebige Schlüssel Werten zugeordnet " +"werden. Die Schlüssel können beliebige Objekte sein, die über die Methoden „" +" :meth:`~object.__hash__` “ und „ :meth:`~object.__eq__` “ verfügen. In Perl" +" wird dies als „Hash“ bezeichnet." msgid "dictionary comprehension" -msgstr "" +msgstr "Wörterbuchverständnis" msgid "" "A compact way to process all or part of the elements in an iterable and " "return a dictionary with the results. ``results = {n: n ** 2 for n in " -"range(10)}`` generates a dictionary containing key ``n`` mapped to value ``n " -"** 2``. See :ref:`comprehensions`." +"range(10)}`` generates a dictionary containing key ``n`` mapped to value ``n" +" ** 2``. See :ref:`comprehensions`." msgstr "" +"Eine kompakte Möglichkeit, alle oder einen Teil der Elemente eines " +"iterierbaren Objekts zu verarbeiten und ein Wörterbuch mit den Ergebnissen " +"zurückzugeben. ` ``results = {n: n ** 2 for n in range(10)}`` ` generiert " +"ein Wörterbuch, das Schlüssel- ``n`` enthält, die den Wert- ``n ** 2`` " +"zugeordnet sind. Siehe :ref:`comprehensions`." msgid "dictionary view" -msgstr "" +msgstr "Wörterbuchansicht" msgid "" -"The objects returned from :meth:`dict.keys`, :meth:`dict.values`, and :meth:" -"`dict.items` are called dictionary views. They provide a dynamic view on the " -"dictionary’s entries, which means that when the dictionary changes, the view " -"reflects these changes. To force the dictionary view to become a full list " -"use ``list(dictview)``. See :ref:`dict-views`." +"The objects returned from :meth:`dict.keys`, :meth:`dict.values`, and " +":meth:`dict.items` are called dictionary views. They provide a dynamic view " +"on the dictionary’s entries, which means that when the dictionary changes, " +"the view reflects these changes. To force the dictionary view to become a " +"full list use ``list(dictview)``. See :ref:`dict-views`." msgstr "" +"Die Objekte, die von den Methoden „ :meth:`dict.keys` “, „ " +":meth:`dict.values` “ und „ :meth:`dict.items` “ zurückgegeben werden, " +"werden als „Dictionary-Ansichten“ bezeichnet. Sie bieten eine dynamische " +"Ansicht der Einträge im Dictionary, was bedeutet, dass sich Änderungen am " +"Dictionary unmittelbar in der Ansicht widerspiegeln. Um die Dictionary-" +"Ansicht zwangsweise in eine vollständige Liste umzuwandeln, verwenden Sie „ " +"``list(dictview)`` “. Siehe :ref:`dict-views`." msgid "docstring" -msgstr "" +msgstr "docstring" msgid "" "A string literal which appears as the first expression in a class, function " @@ -646,33 +1085,53 @@ msgid "" "enclosing class, function or module. Since it is available via " "introspection, it is the canonical place for documentation of the object." msgstr "" +"Ein String-Literal, das als erster Ausdruck in einer Klasse, Funktion oder " +"einem Modul erscheint. Es wird zwar bei der Ausführung der Testsuite " +"ignoriert, jedoch vom Compiler erkannt und in das Attribut „ " +":attr:`~definition.__doc__` “ der umschließenden Klasse, Funktion oder des " +"Moduls übernommen. Da es über Introspektion verfügbar ist, stellt es den " +"kanonischen Ort für die Dokumentation des Objekts dar." msgid "duck-typing" -msgstr "" +msgstr "Duck-Typing" msgid "" "A programming style which does not look at an object's type to determine if " "it has the right interface; instead, the method or attribute is simply " -"called or used (\"If it looks like a duck and quacks like a duck, it must be " -"a duck.\") By emphasizing interfaces rather than specific types, well-" -"designed code improves its flexibility by allowing polymorphic " -"substitution. Duck-typing avoids tests using :func:`type` or :func:" -"`isinstance`. (Note, however, that duck-typing can be complemented with :" -"term:`abstract base classes `.) Instead, it typically " -"employs :func:`hasattr` tests or :term:`EAFP` programming." -msgstr "" +"called or used (\"If it looks like a duck and quacks like a duck, it must be" +" a duck.\") By emphasizing interfaces rather than specific types, well-" +"designed code improves its flexibility by allowing polymorphic substitution." +" Duck-typing avoids tests using :func:`type` or :func:`isinstance`. (Note," +" however, that duck-typing can be complemented with :term:`abstract base " +"classes `.) Instead, it typically employs " +":func:`hasattr` tests or :term:`EAFP` programming." +msgstr "" +"Ein Programmierstil, bei dem nicht der Typ eines Objekts herangezogen wird, " +"um festzustellen, ob es über die richtige Schnittstelle verfügt; stattdessen" +" wird die Methode oder das Attribut einfach aufgerufen bzw. verwendet („Wenn" +" es wie eine Ente aussieht und wie eine Ente quakt, muss es eine Ente " +"sein.“) Durch die Betonung von Schnittstellen anstelle spezifischer Typen " +"verbessert gut gestalteter Code seine Flexibilität, indem er polymorphe " +"Substitution ermöglicht. Duck-Typing vermeidet Tests mit „ :func:`type` “ " +"oder „ :func:`isinstance` “. (Beachten Sie jedoch, dass Duck-Typing durch " +":term:`abstrakte Basisklassen ` ergänzt werden kann.) " +"Stattdessen werden typischerweise „ :func:`hasattr` “-Tests oder " +":term:`EAFP`-Programmierung eingesetzt." msgid "dunder" -msgstr "" +msgstr "dunder" msgid "" -"An informal short-hand for \"double underscore\", used when talking about a :" -"term:`special method`. For example, ``__init__`` is often pronounced " +"An informal short-hand for \"double underscore\", used when talking about a " +":term:`special method`. For example, ``__init__`` is often pronounced " "\"dunder init\"." msgstr "" +"Eine umgangssprachliche Abkürzung für „doppelter Unterstrich“, die verwendet" +" wird, wenn von einer :term:`speziellen Methode` die Rede ist. So wird " +"beispielsweise „ ``__init__`` “ oft als „dunder init“ ausgesprochen." msgid "EAFP" -msgstr "" +msgstr "EAFP" msgid "" "Easier to ask for forgiveness than permission. This common Python coding " @@ -682,18 +1141,28 @@ msgid "" "statements. The technique contrasts with the :term:`LBYL` style common to " "many other languages such as C." msgstr "" +"Es ist einfacher, um Verzeihung zu bitten als um Erlaubnis. Dieser gängige " +"Python-Programmierstil geht von der Existenz gültiger Schlüssel oder " +"Attribute aus und fängt Ausnahmen ab, falls sich diese Annahme als falsch " +"erweist. Dieser übersichtliche und schnelle Stil zeichnet sich durch das " +"häufige Vorkommen von :keyword:`try` - und :keyword:`except` -Anweisungen " +"aus. Diese Technik steht im Gegensatz zum :term:`LBYL`-Stil, der in vielen " +"anderen Sprachen wie beispielsweise C üblich ist." msgid "evaluate function" -msgstr "" +msgstr "Funktion auswerten" msgid "" -"A function that can be called to evaluate a lazily evaluated attribute of an " -"object, such as the value of type aliases created with the :keyword:`type` " +"A function that can be called to evaluate a lazily evaluated attribute of an" +" object, such as the value of type aliases created with the :keyword:`type` " "statement." msgstr "" +"Eine Funktion, die aufgerufen werden kann, um ein verzögert ausgewertetes " +"Attribut eines Objekts zu berechnen, beispielsweise den Wert von Typaliasen," +" die mit der Anweisung „ :keyword:`type` “ erstellt wurden." msgid "expression" -msgstr "" +msgstr "Ausdruck" msgid "" "A piece of syntax which can be evaluated to some value. In other words, an " @@ -701,106 +1170,154 @@ msgid "" "attribute access, operators or function calls which all return a value. In " "contrast to many other languages, not all language constructs are " "expressions. There are also :term:`statement`\\s which cannot be used as " -"expressions, such as :keyword:`while`. Assignments are also statements, not " -"expressions." +"expressions, such as :keyword:`while`. Assignments are also statements, not" +" expressions." msgstr "" +"Ein Syntaxelement, das zu einem Wert ausgewertet werden kann. Mit anderen " +"Worten: Ein Ausdruck ist eine Zusammenstellung von Ausdruckselementen wie " +"Literalen, Namen, Attributzugriffen, Operatoren oder Funktionsaufrufen, die " +"alle einen Wert zurückgeben. Im Gegensatz zu vielen anderen Sprachen sind " +"nicht alle Sprachkonstrukte Ausdrücke. Es gibt auch :term:`Anweisungen`\\s, " +"die nicht als Ausdrücke verwendet werden können, wie beispielsweise " +":keyword:`while`. Auch Zuweisungen sind Anweisungen und keine Ausdrücke." msgid "extension module" -msgstr "" +msgstr "Erweiterungsmodul" msgid "" -"A module written in C or C++, using Python's C API to interact with the core " -"and with user code." +"A module written in C or C++, using Python's C API to interact with the core" +" and with user code." msgstr "" +"Ein in C oder C++ geschriebenes Modul, das die C-API von Python nutzt, um " +"mit dem Kern und dem Anwendercode zu interagieren." msgid "f-string" -msgstr "" +msgstr "f-String" msgid "f-strings" -msgstr "" +msgstr "f-Strings" msgid "" -"String literals prefixed with ``f`` or ``F`` are commonly called \"f-" -"strings\" which is short for :ref:`formatted string literals `. " -"See also :pep:`498`." +"String literals prefixed with ``f`` or ``F`` are commonly called " +"\"f-strings\" which is short for :ref:`formatted string literals " +"`. See also :pep:`498`." msgstr "" +"Zeichenfolgenliterale, denen „ ``f`` “ oder „ ``F`` “ vorangestellt ist, " +"werden gemeinhin als „f-Strings“ bezeichnet, was die Abkürzung für " +":ref:`formatierte Zeichenfolgenliterale ` ist. Siehe auch " +":pep:`498`." msgid "file object" -msgstr "" +msgstr "Dateiobjekt" msgid "" "An object exposing a file-oriented API (with methods such as :meth:`!read` " "or :meth:`!write`) to an underlying resource. Depending on the way it was " "created, a file object can mediate access to a real on-disk file or to " -"another type of storage or communication device (for example standard input/" -"output, in-memory buffers, sockets, pipes, etc.). File objects are also " -"called :dfn:`file-like objects` or :dfn:`streams`." -msgstr "" - -msgid "" -"There are actually three categories of file objects: raw :term:`binary files " -"`, buffered :term:`binary files ` and :term:`text " -"files `. Their interfaces are defined in the :mod:`io` module. " +"another type of storage or communication device (for example standard " +"input/output, in-memory buffers, sockets, pipes, etc.). File objects are " +"also called :dfn:`file-like objects` or :dfn:`streams`." +msgstr "" +"Ein Objekt, das eine dateiorientierte API (mit Methoden wie „ :meth:`!read` " +"“ oder „ :meth:`!write` “) für eine zugrunde liegende Ressource " +"bereitstellt. Je nach Art seiner Erstellung kann ein Dateiobjekt den " +"Zugriff auf eine echte Datei auf der Festplatte oder auf eine andere Art von" +" Speicher- oder Kommunikationsgerät vermitteln (z. B. " +"Standardeingabe/-ausgabe, Puffer im Arbeitsspeicher, Sockets, Pipes usw.). " +"Dateiobjekte werden auch als :dfn:`dateiähnliche Objekte` oder " +":dfn:`Streams` bezeichnet." + +msgid "" +"There are actually three categories of file objects: raw :term:`binary files" +" `, buffered :term:`binary files ` and :term:`text" +" files `. Their interfaces are defined in the :mod:`io` module. " "The canonical way to create a file object is by using the :func:`open` " "function." msgstr "" +"Es gibt insgesamt drei Kategorien von Dateiobjekten: rohe " +":term:`Binärdateien `, gepufferte :term:`Binärdateien ` und :term:`Textdateien `. Ihre Schnittstellen sind im " +"Modul „ :mod:`io` “ definiert. Die übliche Vorgehensweise zum Erstellen " +"eines Dateiobjekts ist die Verwendung der Funktion „ :func:`open` “." msgid "file-like object" -msgstr "" +msgstr "dateiähnliches Objekt" msgid "A synonym for :term:`file object`." -msgstr "" +msgstr "Ein Synonym für :term:`Dateiobjekt`." msgid "filesystem encoding and error handler" -msgstr "" +msgstr "Dateisystem-Kodierung und Fehlerbehandlung" msgid "" -"Encoding and error handler used by Python to decode bytes from the operating " -"system and encode Unicode to the operating system." +"Encoding and error handler used by Python to decode bytes from the operating" +" system and encode Unicode to the operating system." msgstr "" +"Von Python verwendete Kodierung und Fehlerbehandlung zum Dekodieren von " +"Bytes aus dem Betriebssystem und zum Kodieren von Unicode für das " +"Betriebssystem." msgid "" "The filesystem encoding must guarantee to successfully decode all bytes " "below 128. If the file system encoding fails to provide this guarantee, API " "functions can raise :exc:`UnicodeError`." msgstr "" +"Die Dateisystemkodierung muss gewährleisten, dass alle Bytes unter 128 " +"erfolgreich dekodiert werden. Wenn die Dateisystemkodierung diese Garantie " +"nicht bieten kann, können API-Funktionen die Ausnahme „ :exc:`UnicodeError` " +"“ auslösen." msgid "" -"The :func:`sys.getfilesystemencoding` and :func:`sys." -"getfilesystemencodeerrors` functions can be used to get the filesystem " -"encoding and error handler." +"The :func:`sys.getfilesystemencoding` and " +":func:`sys.getfilesystemencodeerrors` functions can be used to get the " +"filesystem encoding and error handler." msgstr "" +"Mit den Funktionen ` :func:`sys.getfilesystemencoding` ` und ` " +":func:`sys.getfilesystemencodeerrors` ` lassen sich die Kodierung des " +"Dateisystems und der Fehlerbehandler abrufen." msgid "" "The :term:`filesystem encoding and error handler` are configured at Python " -"startup by the :c:func:`PyConfig_Read` function: see :c:member:`~PyConfig." -"filesystem_encoding` and :c:member:`~PyConfig.filesystem_errors` members of :" -"c:type:`PyConfig`." +"startup by the :c:func:`PyConfig_Read` function: see " +":c:member:`~PyConfig.filesystem_encoding` and " +":c:member:`~PyConfig.filesystem_errors` members of :c:type:`PyConfig`." msgstr "" +"Die :term:`Dateisystem-Kodierung und der Fehlerbehandler` werden beim Start " +"von Python über die Funktion ` :c:func:`PyConfig_Read` ` konfiguriert: siehe" +" :c:member:`~PyConfig.filesystem_encoding` und " +":c:member:`~PyConfig.filesystem_errors`, die zu :c:type:`PyConfig` gehören." msgid "See also the :term:`locale encoding`." -msgstr "" +msgstr "Siehe auch den Begriff :term:`Lokalisierungskodierung`." msgid "finder" -msgstr "" +msgstr "Finder" msgid "" "An object that tries to find the :term:`loader` for a module that is being " "imported." msgstr "" +"Ein Objekt, das versucht, den :term:`loader` für ein Modul zu finden, das " +"gerade importiert wird." msgid "" "There are two types of finder: :term:`meta path finders ` " "for use with :data:`sys.meta_path`, and :term:`path entry finders ` for use with :data:`sys.path_hooks`." msgstr "" +"Es gibt zwei Arten von Suchfunktionen: :term:`Meta-Pfad-Suchfunktionen ` zur Verwendung mit :data:`sys.meta_path` sowie :term:`Pfad-" +"Eingabe-Suchfunktionen ` zur Verwendung mit " +":data:`sys.path_hooks`." msgid "" "See :ref:`finders-and-loaders` and :mod:`importlib` for much more detail." msgstr "" +"Weitere Informationen finden Sie unter :ref:`finders-and-loaders` und " +":mod:`importlib`." msgid "floor division" -msgstr "" +msgstr "Etagenaufteilung" msgid "" "Mathematical division that rounds down to nearest integer. The floor " @@ -809,19 +1326,43 @@ msgid "" "division. Note that ``(-11) // 4`` is ``-3`` because that is ``-2.75`` " "rounded *downward*. See :pep:`238`." msgstr "" +"Mathematische Division, bei der auf die nächste ganze Zahl abgerundet wird. " +"Der Operator für die Floor-Division lautet ``//``. Der Ausdruck ``11 // 4`` " +"ergibt beispielsweise ``2`` – im Gegensatz zu ``2.75``, das bei einer echten" +" Float-Division zurückgegeben wird. Beachten Sie, dass ``(-11) // 4`` gleich" +" ``-3`` ist, da es sich dabei um ``-2.75`` handelt, das *nach unten* " +"abgerundet wurde. Siehe :pep:`238`." msgid "free threading" -msgstr "" +msgstr "freies Einfädeln" msgid "" "A threading model where multiple threads can run Python bytecode " -"simultaneously within the same interpreter. This is in contrast to the :" -"term:`global interpreter lock` which allows only one thread to execute " +"simultaneously within the same interpreter. This is in contrast to the " +":term:`global interpreter lock` which allows only one thread to execute " "Python bytecode at a time. See :pep:`703`." msgstr "" +"Ein Threading-Modell, bei dem mehrere Threads Python-Bytecode gleichzeitig " +"innerhalb desselben Interpreters ausführen können. Dies steht im Gegensatz " +"zum :term:`global interpreter lock`, bei dem jeweils nur ein Thread Python-" +"Bytecode ausführen kann. Siehe :pep:`703`." -msgid "free variable" +msgid "free-threaded build" +msgstr "Build mit freien Threads" + +msgid "" +"A build of :term:`CPython` that supports :term:`free threading`, configured " +"using the :option:`--disable-gil` option before compilation." msgstr "" +"Eine Version von :term:`CPython`, die :term:`Free Threading` unterstützt und" +" vor der Kompilierung mit der Option „ :option:`--disable-gil` “ " +"konfiguriert wurde." + +msgid "See :ref:`freethreading-python-howto`." +msgstr "Siehe :ref:`freethreading-python-howto`." + +msgid "free variable" +msgstr "freie Variable" msgid "" "Formally, as defined in the :ref:`language execution model `, a " @@ -831,64 +1372,97 @@ msgid "" "attribute, the term is also sometimes used as a synonym for :term:`closure " "variable`." msgstr "" +"Formal gesehen ist, gemäß der Definition im :ref:`Sprachausführungsmodell " +"`, eine freie Variable jede Variable, die in einem Namensraum " +"verwendet wird und keine lokale Variable in diesem Namensraum ist. Ein " +"Beispiel finden Sie unter :term:`Closure-Variable`. In der Praxis wird der " +"Begriff aufgrund des Namens des Attributs „ :attr:`codeobject.co_freevars` “" +" manchmal auch als Synonym für :term:`Closure-Variable` verwendet." msgid "function" -msgstr "" +msgstr "Funktion" msgid "" "A series of statements which returns some value to a caller. It can also be " "passed zero or more :term:`arguments ` which may be used in the " -"execution of the body. See also :term:`parameter`, :term:`method`, and the :" -"ref:`function` section." +"execution of the body. See also :term:`parameter`, :term:`method`, and the " +":ref:`function` section." msgstr "" +"Eine Anweisungsfolge, die einen Wert an den Aufrufer zurückgibt. Ihr können " +"zudem null oder mehr :term:`Argumente ` übergeben werden, die bei " +"der Ausführung des Hauptteils verwendet werden können. Siehe auch " +":term:`Parameter`, :term:`Methode` sowie den Abschnitt „ :ref:`function` “." msgid "function annotation" -msgstr "" +msgstr "Funktionsanmerkung" msgid "An :term:`annotation` of a function parameter or return value." msgstr "" +"Eine :term:`Annotation` eines Funktionsparameters oder eines Rückgabewerts." msgid "" "Function annotations are usually used for :term:`type hints `: " "for example, this function is expected to take two :class:`int` arguments " "and is also expected to have an :class:`int` return value::" msgstr "" +"Funktionsannotationen werden in der Regel für :term:`Typangaben `: verwendet. Beispielsweise wird erwartet, dass diese Funktion zwei " +":class:`int` Argumente entgegennimmt und zudem einen :class:`int` " +"Rückgabewert hat::" msgid "" "def sum_two_numbers(a: int, b: int) -> int:\n" " return a + b" msgstr "" +"def sum_two_numbers(a: int, b: int) -> int:\n" +" return a + b" msgid "Function annotation syntax is explained in section :ref:`function`." msgstr "" +"Die Syntax für Funktionsannotationen wird im Abschnitt „ :ref:`function` “ " +"erläutert." msgid "" "See :term:`variable annotation` and :pep:`484`, which describe this " "functionality. Also see :ref:`annotations-howto` for best practices on " "working with annotations." msgstr "" +"Siehe :term:`Variablen-Annotation` und :pep:`484`, wo diese Funktionalität " +"beschrieben wird. Siehe außerdem :ref:`annotations-howto` für bewährte " +"Vorgehensweisen beim Umgang mit Annotationen." msgid "__future__" -msgstr "" +msgstr "__Zukunft__" msgid "" "A :ref:`future statement `, ``from __future__ import ``, " -"directs the compiler to compile the current module using syntax or semantics " -"that will become standard in a future release of Python. The :mod:" -"`__future__` module documents the possible values of *feature*. By " +"directs the compiler to compile the current module using syntax or semantics" +" that will become standard in a future release of Python. The " +":mod:`__future__` module documents the possible values of *feature*. By " "importing this module and evaluating its variables, you can see when a new " -"feature was first added to the language and when it will (or did) become the " -"default::" +"feature was first added to the language and when it will (or did) become the" +" default::" msgstr "" +"Eine :ref:`Future-Anweisung `, ``from __future__ import ``," +" weist den Compiler an, das aktuelle Modul unter Verwendung einer Syntax " +"oder Semantik zu kompilieren, die in einer zukünftigen Version von Python " +"zum Standard werden wird. Das Modul „ :mod:`__future__` “ dokumentiert die " +"möglichen Werte von *feature*. Durch Importieren dieses Moduls und Auswerten" +" seiner Variablen können Sie sehen, wann eine neue Funktion erstmals in die " +"Sprache aufgenommen wurde und wann sie zur Standardeinstellung wird (oder " +"wurde):" msgid "" ">>> import __future__\n" ">>> __future__.division\n" "_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)" msgstr "" +">>> import __future__\n" +">>> __future__.division\n" +"_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)" msgid "garbage collection" -msgstr "" +msgstr "Garbage Collection" msgid "" "The process of freeing memory when it is not used anymore. Python performs " @@ -896,38 +1470,79 @@ msgid "" "that is able to detect and break reference cycles. The garbage collector " "can be controlled using the :mod:`gc` module." msgstr "" +"Der Vorgang, bei dem Speicher freigegeben wird, wenn er nicht mehr benötigt " +"wird. Python führt die Speicherbereinigung mithilfe der Referenzzählung und " +"eines zyklischen Garbage Collectors durch, der Referenzzyklen erkennen und " +"auflösen kann. Der Garbage Collector lässt sich über das Modul „ :mod:`gc` “" +" steuern." msgid "generator" -msgstr "" +msgstr "Generator" msgid "" -"A function which returns a :term:`generator iterator`. It looks like a " -"normal function except that it contains :keyword:`yield` expressions for " -"producing a series of values usable in a for-loop or that can be retrieved " -"one at a time with the :func:`next` function." +"Informally used to mean either a :term:`generator function` or a " +":term:`generator iterator`, depending on context. The formal terms " +":term:`generator function` and :term:`generator iterator` are uncommon in " +"practice; \"generator\" alone is almost always sufficient." msgstr "" +"Wird umgangssprachlich je nach Kontext entweder für eine " +":term:`Generatorfunktion` oder einen :term:`Generator-Iterator` verwendet. " +"Die formalen Begriffe :term:`Generatorfunktion` und :term:`Generator-" +"Iterator` sind in der Praxis selten; der Begriff „Generator“ allein reicht " +"fast immer aus." + +msgid "generator function" +msgstr "Generatorfunktion" msgid "" -"Usually refers to a generator function, but may refer to a *generator " -"iterator* in some contexts. In cases where the intended meaning isn't " -"clear, using the full terms avoids ambiguity." +"A function which returns a :term:`generator` object. It looks like a normal" +" function except that it contains :keyword:`yield` expressions for producing" +" a series of values usable in a :keyword:`for`\\-loop or that can be " +"retrieved one at a time with the :func:`next` function. See " +":ref:`yieldexpr`." msgstr "" +"Eine Funktion, die ein :term:`generator`-Objekt zurückgibt. Sie sieht wie " +"eine normale Funktion aus, enthält jedoch Ausdrücke vom Typ „ " +":keyword:`yield` “, um eine Reihe von Werten zu erzeugen, die in einer " +":keyword:`for`\\-Schleife verwendet oder mit der Funktion :func:`next` " +"einzeln abgerufen werden können. Siehe :ref:`yieldexpr`." msgid "generator iterator" -msgstr "" +msgstr "Generator-Iterator" -msgid "An object created by a :term:`generator` function." +msgid "" +"An object created by a :term:`generator function` or a :term:`generator " +"expression`." msgstr "" +"Ein Objekt, das durch eine :term:`Generatorfunktion` oder einen " +":term:`Generatorausdruck` erstellt wurde." msgid "" "Each :keyword:`yield` temporarily suspends processing, remembering the " -"execution state (including local variables and pending try-statements). " -"When the *generator iterator* resumes, it picks up where it left off (in " +"execution state (including local variables and pending try-statements). When" +" the *generator iterator* resumes, it picks up where it left off (in " "contrast to functions which start fresh on every invocation)." msgstr "" +"Jeder „ :keyword:`yield` “ unterbricht die Verarbeitung vorübergehend und " +"speichert dabei den Ausführungszustand (einschließlich lokaler Variablen und" +" ausstehender „try“-Anweisungen). Wenn der *Generator-Iterator* fortgesetzt " +"wird, setzt er dort fort, wo er aufgehört hat (im Gegensatz zu Funktionen, " +"die bei jedem Aufruf von vorne beginnen)." -msgid "generator expression" +msgid "" +"Generator iterators also implement the :meth:`~generator.send` method to " +"send a value into the suspended generator, and the :meth:`~generator.throw` " +"method to raise an exception at the point where the generator was paused. " +"See :ref:`generator-methods`." msgstr "" +"Generator-Iteratoren implementieren außerdem die Methode „ " +":meth:`~generator.send` “, um einen Wert an den angehaltenen Generator zu " +"übergeben, sowie die Methode „ :meth:`~generator.throw` “, um an der Stelle," +" an der der Generator angehalten wurde, eine Ausnahme auszulösen. Siehe " +":ref:`generator-methods`." + +msgid "generator expression" +msgstr "Generatorausdruck" msgid "" "An :term:`expression` that returns an :term:`iterator`. It looks like a " @@ -935,48 +1550,68 @@ msgid "" "variable, range, and an optional :keyword:`!if` clause. The combined " "expression generates values for an enclosing function::" msgstr "" +"Ein :term:`Ausdruck`, der einen :term:`Iterator` zurückgibt. Er sieht aus " +"wie ein normaler Ausdruck, gefolgt von einer :keyword:`!for` -Klausel, die " +"eine Schleifenvariable und einen Bereich definiert, sowie einer optionalen " +":keyword:`!if` -Klausel. Der kombinierte Ausdruck generiert Werte für eine " +"umschließende Funktion::" msgid "" ">>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81\n" "285" msgstr "" +">>> sum(i*i for i in range(10)) # Summe der Quadrate von 0, 1, 4, ..., 81\n" +"285" msgid "generic function" -msgstr "" +msgstr "generische Funktion" msgid "" "A function composed of multiple functions implementing the same operation " "for different types. Which implementation should be used during a call is " "determined by the dispatch algorithm." msgstr "" +"Eine Funktion, die aus mehreren Funktionen besteht, welche dieselbe " +"Operation für verschiedene Typen implementieren. Welche Implementierung bei " +"einem Aufruf verwendet werden soll, wird durch den Dispatch-Algorithmus " +"bestimmt." msgid "" -"See also the :term:`single dispatch` glossary entry, the :func:`functools." -"singledispatch` decorator, and :pep:`443`." +"See also the :term:`single dispatch` glossary entry, the " +":deco:`functools.singledispatch` decorator, and :pep:`443`." msgstr "" +"Siehe auch den Glossareintrag :term:`single dispatch`, den Dekorator " +":deco:`functools.singledispatch` sowie :pep:`443`." msgid "generic type" -msgstr "" +msgstr "generischer Typ" msgid "" "A :term:`type` that can be parameterized; typically a :ref:`container " -"class` such as :class:`list` or :class:`dict`. Used for :" -"term:`type hints ` and :term:`annotations `." +"class` such as :class:`list` or :class:`dict`. Used for " +":term:`type hints ` and :term:`annotations `." msgstr "" +"Ein :term:`Typ`, der parametrisiert werden kann; typischerweise eine " +":ref:`Containerklasse` wie beispielsweise :class:`list` oder" +" :class:`dict`. Wird für :term:`Typ-Hinweise ` und " +":term:`Annotationen ` verwendet." msgid "" -"For more details, see :ref:`generic alias types`, :pep:" -"`483`, :pep:`484`, :pep:`585`, and the :mod:`typing` module." +"For more details, see :ref:`generic alias types`, " +":pep:`483`, :pep:`484`, :pep:`585`, and the :mod:`typing` module." msgstr "" +"Weitere Informationen finden Sie unter :ref:`generische Alias-Typen`, :pep:`483`, :pep:`484`, :pep:`585` sowie im Modul „ " +":mod:`typing` “." msgid "GIL" -msgstr "" +msgstr "GIL" msgid "See :term:`global interpreter lock`." -msgstr "" +msgstr "Siehe :term:`Global Interpreter Lock`." msgid "global interpreter lock" -msgstr "" +msgstr "Global Interpreter Lock" msgid "" "The mechanism used by the :term:`CPython` interpreter to assure that only " @@ -987,40 +1622,84 @@ msgid "" "multi-threaded, at the expense of much of the parallelism afforded by multi-" "processor machines." msgstr "" +"Der Mechanismus, den der :term:`CPython`-Interpreter verwendet, um " +"sicherzustellen, dass jeweils nur ein Thread Python-:term:`Bytecode` " +"ausführt. Dies vereinfacht die CPython-Implementierung, indem das " +"Objektmodell (einschließlich kritischer integrierter Typen wie " +":class:`dict`) implizit gegen gleichzeitigen Zugriff abgesichert wird. Das " +"Sperren des gesamten Interpreters erleichtert die Multithread-Fähigkeit des " +"Interpreters, geht jedoch zu Lasten eines Großteils der Parallelität, die " +"Multiprozessor-Rechner bieten." msgid "" "However, some extension modules, either standard or third-party, are " -"designed so as to release the GIL when doing computationally intensive tasks " -"such as compression or hashing. Also, the GIL is always released when doing " -"I/O." +"designed so as to release the GIL when doing computationally intensive tasks" +" such as compression or hashing. Also, the GIL is always released when " +"doing I/O." msgstr "" +"Einige Erweiterungsmodule – sei es Standardmodule oder Module von " +"Drittanbietern – sind jedoch so konzipiert, dass sie das GIL bei " +"rechenintensiven Aufgaben wie Komprimierung oder Hashing freigeben. Außerdem" +" wird das GIL bei E/A-Vorgängen stets freigegeben." msgid "" -"As of Python 3.13, the GIL can be disabled using the :option:`--disable-gil` " -"build configuration. After building Python with this option, code must be " +"As of Python 3.13, the GIL can be disabled using the :option:`--disable-gil`" +" build configuration. After building Python with this option, code must be " "run with :option:`-X gil=0 <-X>` or after setting the :envvar:`PYTHON_GIL=0 " "` environment variable. This feature enables improved " -"performance for multi-threaded applications and makes it easier to use multi-" -"core CPUs efficiently. For more details, see :pep:`703`." +"performance for multi-threaded applications and makes it easier to use " +"multi-core CPUs efficiently. For more details, see :pep:`703`." msgstr "" +"Ab Python 3.13 kann der GIL mithilfe der Build-Konfiguration „ " +":option:`--disable-gil` “ deaktiviert werden. Nach dem Kompilieren von " +"Python mit dieser Option muss der Code mit der Option :option:`-X gil=0 " +"<-X>` ` ausgeführt werden oder nachdem die Umgebungsvariable " +":envvar:`PYTHON_GIL=0 ` ` gesetzt wurde. Diese Funktion " +"ermöglicht eine verbesserte Leistung für Multithread-Anwendungen und " +"erleichtert die effiziente Nutzung von Multi-Core-CPUs. Weitere Details " +"finden Sie unter :pep:`703`." msgid "" "In prior versions of Python's C API, a function might declare that it " -"requires the GIL to be held in order to use it. This refers to having an :" -"term:`attached thread state`." +"requires the GIL to be held in order to use it. This refers to having an " +":term:`attached thread state`." msgstr "" +"In früheren Versionen der C-API von Python konnte eine Funktion angeben, " +"dass für ihre Verwendung das GIL gesperrt sein muss. Dies bezieht sich auf " +"einen :term:`angeschlossenen Thread-Zustand`." -msgid "hash-based pyc" +msgid "global state" +msgstr "globaler Zustand" + +msgid "" +"Data that is accessible throughout a program, such as module-level " +"variables, class variables, or C static variables in :term:`extension " +"modules `. In multi-threaded programs, global state " +"shared between threads typically requires synchronization to avoid " +":term:`race conditions ` and :term:`data races `." msgstr "" +"Daten, auf die im gesamten Programm zugegriffen werden kann, wie " +"beispielsweise Variablen auf Modulebene, Klassenvariablen oder statische " +"C-Variablen in :term:`Erweiterungsmodulen `. In " +"Multithread-Programmen erfordert der zwischen Threads gemeinsam genutzte " +"globale Zustand in der Regel eine Synchronisation, um " +":term:`Wettlaufbedingungen ` und :term:`Datenwettläufe ` zu vermeiden." + +msgid "hash-based pyc" +msgstr "Hash-basierte PYC-Datei" msgid "" "A bytecode cache file that uses the hash rather than the last-modified time " "of the corresponding source file to determine its validity. See :ref:`pyc-" "invalidation`." msgstr "" +"Eine Bytecode-Cache-Datei, die zur Überprüfung ihrer Gültigkeit den Hash-" +"Wert anstelle des Zeitstempels der letzten Änderung der entsprechenden " +"Quelldatei heranzieht. Siehe :ref:`pyc-invalidation`." msgid "hashable" -msgstr "" +msgstr "hashbar" msgid "" "An object is *hashable* if it has a hash value which never changes during " @@ -1028,88 +1707,162 @@ msgid "" "compared to other objects (it needs an :meth:`~object.__eq__` method). " "Hashable objects which compare equal must have the same hash value." msgstr "" +"Ein Objekt ist *hashbar*, wenn es einen Hash-Wert besitzt, der sich während " +"seiner Lebensdauer nicht ändert (es benötigt eine ` :meth:`~object.__hash__`" +" `-Methode), und wenn es mit anderen Objekten verglichen werden kann (es " +"benötigt eine ` :meth:`~object.__eq__` `-Methode). Hashbare Objekte, die als" +" gleich verglichen werden, müssen denselben Hash-Wert haben." msgid "" "Hashability makes an object usable as a dictionary key and a set member, " "because these data structures use the hash value internally." msgstr "" +"Dank der Hashbarkeit kann ein Objekt als Schlüssel in einem Wörterbuch und " +"als Element in einer Menge verwendet werden, da diese Datenstrukturen intern" +" den Hashwert nutzen." msgid "" -"Most of Python's immutable built-in objects are hashable; mutable containers " -"(such as lists or dictionaries) are not; immutable containers (such as " +"Most of Python's immutable built-in objects are hashable; mutable containers" +" (such as lists or dictionaries) are not; immutable containers (such as " "tuples and frozensets) are only hashable if their elements are hashable. " -"Objects which are instances of user-defined classes are hashable by " -"default. They all compare unequal (except with themselves), and their hash " -"value is derived from their :func:`id`." +"Objects which are instances of user-defined classes are hashable by default." +" They all compare unequal (except with themselves), and their hash value is" +" derived from their :func:`id`." msgstr "" +"Die meisten unveränderlichen, in Python integrierten Objekte sind hashbar; " +"veränderbare Container (wie Listen oder Wörterbücher) sind es nicht; " +"unveränderliche Container (wie Tupel und FrozenSets) sind nur dann hashbar, " +"wenn ihre Elemente hashbar sind. Objekte, die Instanzen benutzerdefinierter" +" Klassen sind, sind standardmäßig hashbar. Sie sind alle ungleich (außer mit" +" sich selbst), und ihr Hash-Wert wird aus ihrem „ :func:`id` “ abgeleitet." msgid "IDLE" -msgstr "" +msgstr "LEERLAUF" msgid "" "An Integrated Development and Learning Environment for Python. :ref:`idle` " "is a basic editor and interpreter environment which ships with the standard " "distribution of Python." msgstr "" +"Eine integrierte Entwicklungs- und Lernumgebung für Python. „ :ref:`idle` “ " +"ist eine einfache Editor- und Interpreter-Umgebung, die im Lieferumfang der " +"Standarddistribution von Python enthalten ist." msgid "immortal" -msgstr "" +msgstr "unsterblich" msgid "" -"*Immortal objects* are a CPython implementation detail introduced in :pep:" -"`683`." +"*Immortal objects* are a CPython implementation detail introduced in " +":pep:`683`." msgstr "" +"*Unsterbliche Objekte* sind ein Implementierungsdetail von CPython, das in " +":pep:`683` eingeführt wurde." msgid "" -"If an object is immortal, its :term:`reference count` is never modified, and " -"therefore it is never deallocated while the interpreter is running. For " +"If an object is immortal, its :term:`reference count` is never modified, and" +" therefore it is never deallocated while the interpreter is running. For " "example, :const:`True` and :const:`None` are immortal in CPython." msgstr "" +"Ist ein Objekt unsterblich, wird seine :term:`Referenzanzahl` niemals " +"geändert, sodass es während der Laufzeit des Interpreters niemals " +"freigegeben wird. Beispielsweise sind „ :const:`True` “ und „ :const:`None` " +"“ in CPython unsterblich." msgid "" -"Immortal objects can be identified via :func:`sys._is_immortal`, or via :c:" -"func:`PyUnstable_IsImmortal` in the C API." +"Immortal objects can be identified via :func:`sys._is_immortal`, or via " +":c:func:`PyUnstable_IsImmortal` in the C API." msgstr "" +"Unsterbliche Objekte können über ` :func:`sys._is_immortal`` oder über ` " +":c:func:`PyUnstable_IsImmortal` ` in der C-API identifiziert werden." msgid "immutable" -msgstr "" +msgstr "unveränderlich" msgid "" "An object with a fixed value. Immutable objects include numbers, strings " "and tuples. Such an object cannot be altered. A new object has to be " "created if a different value has to be stored. They play an important role " "in places where a constant hash value is needed, for example as a key in a " -"dictionary." -msgstr "" +"dictionary. Immutable objects are inherently :term:`thread-safe` because " +"their state cannot be modified after creation, eliminating concerns about " +"improperly synchronized :term:`concurrent modification`." +msgstr "" +"Ein Objekt mit einem festen Wert. Zu den unveränderlichen Objekten zählen " +"Zahlen, Zeichenketten und Tupel. Ein solches Objekt kann nicht verändert " +"werden. Wenn ein anderer Wert gespeichert werden soll, muss ein neues Objekt" +" erstellt werden. Sie spielen eine wichtige Rolle in Fällen, in denen ein " +"konstanter Hash-Wert benötigt wird, beispielsweise als Schlüssel in einem " +"Wörterbuch. Unveränderliche Objekte sind von Natur aus :term:`thread-safe`," +" da ihr Zustand nach der Erstellung nicht mehr geändert werden kann, wodurch" +" Bedenken hinsichtlich unsachgemäß synchronisierter :term:`gleichzeitiger " +"Änderungen` entfallen." msgid "import path" -msgstr "" +msgstr "Importpfad" msgid "" -"A list of locations (or :term:`path entries `) that are searched " -"by the :term:`path based finder` for modules to import. During import, this " -"list of locations usually comes from :data:`sys.path`, but for subpackages " +"A list of locations (or :term:`path entries `) that are searched" +" by the :term:`path based finder` for modules to import. During import, this" +" list of locations usually comes from :data:`sys.path`, but for subpackages " "it may also come from the parent package's ``__path__`` attribute." msgstr "" +"Eine Liste von Speicherorten (oder :term:`Pfadeinträge `), die " +"vom :term:`Pfad-basierten Finder` nach zu importierenden Modulen durchsucht " +"werden. Beim Import stammt diese Liste der Speicherorte in der Regel aus " +":data:`sys.path`, bei Unterpaketen kann sie jedoch auch aus dem Attribut " +"``__path__`` des übergeordneten Pakets stammen." msgid "importing" -msgstr "" +msgstr "Importieren" msgid "" "The process by which Python code in one module is made available to Python " "code in another module." msgstr "" +"Der Vorgang, durch den Python-Code in einem Modul für Python-Code in einem " +"anderen Modul verfügbar gemacht wird." msgid "importer" +msgstr "Importeur" + +msgid "" +"An object that both finds and loads a module; both a :term:`finder` and " +":term:`loader` object." msgstr "" +"Ein Objekt, das sowohl ein Modul findet als auch lädt; es ist sowohl ein " +":term:`Finder`- als auch ein :term:`Loader`-Objekt." + +msgid "index" +msgstr "Inhaltsverzeichnis" msgid "" -"An object that both finds and loads a module; both a :term:`finder` and :" -"term:`loader` object." +"A numeric value that represents the position of an element in a " +":term:`sequence`." msgstr "" +"Ein numerischer Wert, der die Position eines Elements in einer " +":term:`Sequenz` angibt." -msgid "interactive" +msgid "" +"In Python, indexing starts at zero. For example, ``things[0]`` names the " +"*first* element of ``things``; ``things[1]`` names the second one." +msgstr "" +"In Python beginnt die Indizierung bei Null. So bezeichnet beispielsweise „ " +"``things[0]`` “ das *erste* Element von „ ``things`` “; „ ``things[1]`` “ " +"bezeichnet das zweite Element." + +msgid "" +"In some contexts, Python allows negative indexes for counting from the end " +"of a sequence, and indexing using :term:`slices `." msgstr "" +"In bestimmten Kontexten erlaubt Python negative Indizes, um vom Ende einer " +"Sequenz aus zu zählen, sowie die Indizierung mithilfe von :term:`Slices " +"`." + +msgid "See also :term:`subscript`." +msgstr "Siehe auch :term:`Index`." + +msgid "interactive" +msgstr "interaktiv" msgid "" "Python has an interactive interpreter which means you can enter statements " @@ -1119,167 +1872,288 @@ msgid "" "test out new ideas or inspect modules and packages (remember ``help(x)``). " "For more on interactive mode, see :ref:`tut-interac`." msgstr "" +"Python verfügt über einen interaktiven Interpreter, d. h., Sie können " +"Anweisungen und Ausdrücke an der Interpreter-Eingabeaufforderung eingeben, " +"diese sofort ausführen und die Ergebnisse anzeigen lassen. Starten Sie " +"einfach „ ``python`` “ ohne Argumente (z. B. über das Hauptmenü Ihres " +"Computers). Dies ist eine sehr leistungsstarke Methode, um neue Ideen " +"auszuprobieren oder Module und Pakete zu untersuchen (siehe auch " +"``help(x)``). Weitere Informationen zum interaktiven Modus finden Sie unter " +":ref:`tut-interac`." msgid "interpreted" -msgstr "" +msgstr "interpretiert" msgid "" "Python is an interpreted language, as opposed to a compiled one, though the " -"distinction can be blurry because of the presence of the bytecode compiler. " -"This means that source files can be run directly without explicitly creating " -"an executable which is then run. Interpreted languages typically have a " -"shorter development/debug cycle than compiled ones, though their programs " -"generally also run more slowly. See also :term:`interactive`." -msgstr "" +"distinction can be blurry because of the presence of the bytecode compiler." +" This means that source files can be run directly without explicitly " +"creating an executable which is then run. Interpreted languages typically " +"have a shorter development/debug cycle than compiled ones, though their " +"programs generally also run more slowly. See also :term:`interactive`." +msgstr "" +"Python ist eine interpretierte Sprache im Gegensatz zu einer kompilierten " +"Sprache, auch wenn diese Unterscheidung aufgrund des Bytecode-Compilers " +"nicht immer eindeutig ist. Das bedeutet, dass Quelldateien direkt ausgeführt" +" werden können, ohne dass zuvor explizit eine ausführbare Datei erstellt und" +" anschließend ausgeführt werden muss. Interpretierte Sprachen haben in der " +"Regel einen kürzeren Entwicklungs- und Debugging-Zyklus als kompilierte " +"Sprachen, allerdings laufen ihre Programme im Allgemeinen auch langsamer. " +"Siehe auch :term:`interaktiv`." msgid "interpreter shutdown" -msgstr "" - -msgid "" -"When asked to shut down, the Python interpreter enters a special phase where " -"it gradually releases all allocated resources, such as modules and various " -"critical internal structures. It also makes several calls to the :term:" -"`garbage collector `. This can trigger the execution of " -"code in user-defined destructors or weakref callbacks. Code executed during " -"the shutdown phase can encounter various exceptions as the resources it " -"relies on may not function anymore (common examples are library modules or " -"the warnings machinery)." -msgstr "" +msgstr "Beenden des Interpreters" + +msgid "" +"When asked to shut down, the Python interpreter enters a special phase where" +" it gradually releases all allocated resources, such as modules and various " +"critical internal structures. It also makes several calls to the " +":term:`garbage collector `. This can trigger the " +"execution of code in user-defined destructors or weakref callbacks. Code " +"executed during the shutdown phase can encounter various exceptions as the " +"resources it relies on may not function anymore (common examples are library" +" modules or the warnings machinery)." +msgstr "" +"Wenn der Python-Interpreter zum Beenden aufgefordert wird, wechselt er in " +"eine spezielle Phase, in der er nach und nach alle zugewiesenen Ressourcen, " +"wie beispielsweise Module und verschiedene wichtige interne Strukturen, " +"freigibt. Außerdem ruft er mehrmals den :term:`Garbage Collector ` auf. Dies kann die Ausführung von Code in benutzerdefinierten " +"Destruktoren oder weakref-Callbacks auslösen. Bei der Ausführung von Code " +"während der Beendigungsphase können verschiedene Ausnahmen auftreten, da die" +" Ressourcen, auf die er angewiesen ist, möglicherweise nicht mehr " +"funktionieren (häufige Beispiele sind Bibliotheksmodule oder die " +"Warnmechanismen)." msgid "" "The main reason for interpreter shutdown is that the ``__main__`` module or " "the script being run has finished executing." msgstr "" +"Der Hauptgrund für das Beenden des Interpreters ist, dass das Modul „ " +"``__main__`` “ oder das ausgeführte Skript die Ausführung abgeschlossen hat." msgid "iterable" -msgstr "" +msgstr "iterierbar" msgid "" "An object capable of returning its members one at a time. Examples of " "iterables include all sequence types (such as :class:`list`, :class:`str`, " -"and :class:`tuple`) and some non-sequence types like :class:`dict`, :term:" -"`file objects `, and objects of any classes you define with an :" -"meth:`~object.__iter__` method or with a :meth:`~object.__getitem__` method " -"that implements :term:`sequence` semantics." +"and :class:`tuple`) and some non-sequence types like :class:`dict`, " +":term:`file objects `, and objects of any classes you define " +"with an :meth:`~object.__iter__` method or with a " +":meth:`~object.__getitem__` method that implements :term:`sequence` " +"semantics." msgstr "" +"Ein Objekt, das seine Elemente nacheinander zurückgeben kann. Beispiele für " +"iterierbare Objekte sind alle Sequenztypen (wie :class:`list`, :class:`str` " +"und :class:`tuple`) sowie einige Nicht-Sequenztypen wie :class:`dict`, " +":term:`Dateiobjekte ` und Objekte beliebiger Klassen, die Sie " +"mit einer :meth:`~object.__iter__` -Methode oder einer " +":meth:`~object.__getitem__` -Methode definieren, die die " +":term:`sequence`-Semantik implementiert." msgid "" "Iterables can be used in a :keyword:`for` loop and in many other places " "where a sequence is needed (:func:`zip`, :func:`map`, ...). When an " -"iterable object is passed as an argument to the built-in function :func:" -"`iter`, it returns an iterator for the object. This iterator is good for " -"one pass over the set of values. When using iterables, it is usually not " -"necessary to call :func:`iter` or deal with iterator objects yourself. The :" -"keyword:`for` statement does that automatically for you, creating a " +"iterable object is passed as an argument to the built-in function " +":func:`iter`, it returns an iterator for the object. This iterator is good " +"for one pass over the set of values. When using iterables, it is usually " +"not necessary to call :func:`iter` or deal with iterator objects yourself. " +"The :keyword:`for` statement does that automatically for you, creating a " "temporary unnamed variable to hold the iterator for the duration of the " "loop. See also :term:`iterator`, :term:`sequence`, and :term:`generator`." msgstr "" +"Iterables können in einer „ :keyword:`for` “-Schleife und an vielen anderen " +"Stellen verwendet werden, an denen eine Sequenz benötigt wird (:func:`zip`, " +":func:`map`, …). Wenn ein iterierbares Objekt als Argument an die " +"integrierte Funktion „ :func:`iter` “ übergeben wird, gibt diese einen " +"Iterator für das Objekt zurück. Dieser Iterator reicht für einen Durchlauf " +"durch die Wertemenge aus. Bei der Verwendung von Iterables ist es in der " +"Regel nicht notwendig, ` :func:`iter` ` aufzurufen oder sich selbst um " +"Iterator-Objekte zu kümmern. Die Anweisung ` :keyword:`for` ` übernimmt dies" +" automatisch für Sie und erstellt eine temporäre, unbenannte Variable, die " +"den Iterator für die Dauer der Schleife enthält. Siehe auch " +":term:`iterator`, :term:`sequence` und :term:`generator`." msgid "iterator" -msgstr "" +msgstr "Iterator" msgid "" -"An object representing a stream of data. Repeated calls to the iterator's :" -"meth:`~iterator.__next__` method (or passing it to the built-in function :" -"func:`next`) return successive items in the stream. When no more data are " +"An object representing a stream of data. Repeated calls to the iterator's " +":meth:`~iterator.__next__` method (or passing it to the built-in function " +":func:`next`) return successive items in the stream. When no more data are " "available a :exc:`StopIteration` exception is raised instead. At this " -"point, the iterator object is exhausted and any further calls to its :meth:`!" -"__next__` method just raise :exc:`StopIteration` again. Iterators are " -"required to have an :meth:`~iterator.__iter__` method that returns the " -"iterator object itself so every iterator is also iterable and may be used in " -"most places where other iterables are accepted. One notable exception is " +"point, the iterator object is exhausted and any further calls to its " +":meth:`!__next__` method just raise :exc:`StopIteration` again. Iterators " +"are required to have an :meth:`~iterator.__iter__` method that returns the " +"iterator object itself so every iterator is also iterable and may be used in" +" most places where other iterables are accepted. One notable exception is " "code which attempts multiple iteration passes. A container object (such as " -"a :class:`list`) produces a fresh new iterator each time you pass it to the :" -"func:`iter` function or use it in a :keyword:`for` loop. Attempting this " -"with an iterator will just return the same exhausted iterator object used in " -"the previous iteration pass, making it appear like an empty container." -msgstr "" +"a :class:`list`) produces a fresh new iterator each time you pass it to the " +":func:`iter` function or use it in a :keyword:`for` loop. Attempting this " +"with an iterator will just return the same exhausted iterator object used in" +" the previous iteration pass, making it appear like an empty container." +msgstr "" +"Ein Objekt, das einen Datenstrom darstellt. Wiederholte Aufrufe der Methode " +"„ :meth:`~iterator.__next__` “ des Iterators (oder die Übergabe an die " +"integrierte Funktion „ :func:`next` “) geben aufeinanderfolgende Elemente " +"des Datenstroms zurück. Sind keine Daten mehr verfügbar, wird stattdessen " +"die Ausnahme „ :exc:`StopIteration` “ ausgelöst. Zu diesem Zeitpunkt ist " +"das Iterator-Objekt erschöpft, und weitere Aufrufe seiner Methode ` " +":meth:`!__next__` ` lösen lediglich erneut eine ` :exc:`StopIteration` " +"`-Ausnahme aus. Iteratoren müssen über eine Methode ` " +":meth:`~iterator.__iter__` ` verfügen, die das Iterator-Objekt selbst " +"zurückgibt, sodass jeder Iterator auch iterierbar ist und an den meisten " +"Stellen verwendet werden kann, an denen andere iterierbare Objekte " +"akzeptiert werden. Eine bemerkenswerte Ausnahme bildet Code, der mehrere " +"Iterationsdurchläufe versucht. Ein Containerobjekt (wie beispielsweise ein " +"` :class:`list``) erzeugt jedes Mal einen neuen Iterator, wenn man es an die" +" Funktion ` :func:`iter` ` übergibt oder in einer ` :keyword:`for` " +"`-Schleife verwendet. Versucht man dies mit einem Iterator, wird lediglich " +"dasselbe erschöpfte Iteratorobjekt zurückgegeben, das bereits im vorherigen " +"Iterationsdurchlauf verwendet wurde, wodurch es so aussieht, als wäre der " +"Container leer." msgid "More information can be found in :ref:`typeiter`." -msgstr "" +msgstr "Weitere Informationen finden Sie unter :ref:`typeiter`." msgid "" -"CPython does not consistently apply the requirement that an iterator define :" -"meth:`~iterator.__iter__`. And also please note that the free-threading " -"CPython does not guarantee the thread-safety of iterator operations." +"CPython does not consistently apply the requirement that an iterator define " +":meth:`~iterator.__iter__`. And also please note that :term:`free-threaded " +"` CPython does not guarantee :term:`thread-safe` behavior of" +" iterator operations." msgstr "" +"CPython wendet die Anforderung, dass ein Iterator ` " +":meth:`~iterator.__iter__`` definieren muss, nicht konsequent an. Beachten " +"Sie außerdem, dass :term:`free-threaded ` CPython kein " +":term:`thread-safe` Verhalten von Iterator-Operationen garantiert." -msgid "key function" -msgstr "" +msgid "key" +msgstr "Schlüssel" msgid "" -"A key function or collation function is a callable that returns a value used " -"for sorting or ordering. For example, :func:`locale.strxfrm` is used to " -"produce a sort key that is aware of locale specific sort conventions." +"A value that identifies an entry in a :term:`mapping`. See also " +":term:`subscript`." msgstr "" +"Ein Wert, der einen Eintrag in einem :term:`Mapping` identifiziert. Siehe " +"auch :term:`Index`." -msgid "" -"A number of tools in Python accept key functions to control how elements are " -"ordered or grouped. They include :func:`min`, :func:`max`, :func:`sorted`, :" -"meth:`list.sort`, :func:`heapq.merge`, :func:`heapq.nsmallest`, :func:`heapq." -"nlargest`, and :func:`itertools.groupby`." -msgstr "" +msgid "key function" +msgstr "Schlüsselfunktion" msgid "" -"There are several ways to create a key function. For example. the :meth:" -"`str.lower` method can serve as a key function for case insensitive sorts. " -"Alternatively, a key function can be built from a :keyword:`lambda` " -"expression such as ``lambda r: (r[0], r[2])``. Also, :func:`operator." -"attrgetter`, :func:`operator.itemgetter`, and :func:`operator.methodcaller` " -"are three key function constructors. See the :ref:`Sorting HOW TO " -"` for examples of how to create and use key functions." +"A key function or collation function is a callable that returns a value used" +" for sorting or ordering. For example, :func:`locale.strxfrm` is used to " +"produce a sort key that is aware of locale specific sort conventions." msgstr "" +"Eine Schlüsselfunktion oder Sortierfunktion ist ein aufrufbares Objekt, das " +"einen Wert zurückgibt, der zum Sortieren oder Ordnen verwendet wird. " +"Beispielsweise wird „ :func:`locale.strxfrm` “ verwendet, um einen " +"Sortierschlüssel zu erzeugen, der die lokalspezifischen Sortierkonventionen " +"berücksichtigt." + +msgid "" +"A number of tools in Python accept key functions to control how elements are" +" ordered or grouped. They include :func:`min`, :func:`max`, :func:`sorted`," +" :meth:`list.sort`, :func:`heapq.merge`, :func:`heapq.nsmallest`, " +":func:`heapq.nlargest`, and :func:`itertools.groupby`." +msgstr "" +"Eine Reihe von Tools in Python unterstützt Schlüssel-Funktionen, mit denen " +"sich die Anordnung oder Gruppierung von Elementen steuern lässt. Dazu " +"gehören „ :func:`min` “, „ :func:`max` “, „ :func:`sorted` “, „ " +":meth:`list.sort` “, „ :func:`heapq.merge` “, „ :func:`heapq.nsmallest` “, „" +" :func:`heapq.nlargest` “ und „ :func:`itertools.groupby` “." + +msgid "" +"There are several ways to create a key function. For example. the " +":meth:`str.casefold` method can serve as a key function for case insensitive" +" sorts. Alternatively, a key function can be built from a :keyword:`lambda`" +" expression such as ``lambda r: (r[0], r[2])``. Also, " +":func:`operator.attrgetter`, :func:`operator.itemgetter`, and " +":func:`operator.methodcaller` are three key function constructors. See the " +":ref:`Sorting HOW TO ` for examples of how to create and use " +"key functions." +msgstr "" +"Es gibt verschiedene Möglichkeiten, eine Schlüsselfunktion zu erstellen. " +"Beispielsweise kann die Methode „ :meth:`str.casefold` “ als " +"Schlüsselfunktion für die Sortierung ohne Berücksichtigung der " +"Groß-/Kleinschreibung dienen. Alternativ kann eine Schlüsselfunktion aus " +"einem Ausdruck vom Typ „ :keyword:`lambda` “ erstellt werden, wie " +"beispielsweise ``lambda r: (r[0], r[2])``. Außerdem sind " +":func:`operator.attrgetter`, :func:`operator.itemgetter` und " +":func:`operator.methodcaller` drei Konstruktoren für Schlüsselfunktionen. " +"Beispiele für die Erstellung und Verwendung von Schlüsselfunktionen finden " +"Sie im :ref:`Sorting HOW TO `." msgid "keyword argument" -msgstr "" +msgstr "Schlüsselwortargument" msgid "See :term:`argument`." -msgstr "" +msgstr "Siehe :term:`Argument`." msgid "lambda" -msgstr "" +msgstr "Lambda" msgid "" -"An anonymous inline function consisting of a single :term:`expression` which " -"is evaluated when the function is called. The syntax to create a lambda " +"An anonymous inline function consisting of a single :term:`expression` which" +" is evaluated when the function is called. The syntax to create a lambda " "function is ``lambda [parameters]: expression``" msgstr "" +"Eine anonyme Inline-Funktion, die aus einem einzigen :term:`Ausdruck` " +"besteht, der beim Aufruf der Funktion ausgewertet wird. Die Syntax zum " +"Erstellen einer Lambda-Funktion lautet ``lambda [parameters]: expression``" msgid "LBYL" -msgstr "" +msgstr "LBYL" msgid "" -"Look before you leap. This coding style explicitly tests for pre-conditions " -"before making calls or lookups. This style contrasts with the :term:`EAFP` " -"approach and is characterized by the presence of many :keyword:`if` " +"Look before you leap. This coding style explicitly tests for pre-conditions" +" before making calls or lookups. This style contrasts with the :term:`EAFP`" +" approach and is characterized by the presence of many :keyword:`if` " "statements." msgstr "" +"Erst schauen, dann springen. Bei diesem Programmierstil werden " +"Vorbedingungen explizit geprüft, bevor Funktionen aufgerufen oder Abfragen " +"durchgeführt werden. Dieser Stil steht im Gegensatz zum :term:`EAFP`-Ansatz " +"und zeichnet sich durch das häufige Vorkommen von :keyword:`if` -Anweisungen" +" aus." msgid "" "In a multi-threaded environment, the LBYL approach can risk introducing a " -"race condition between \"the looking\" and \"the leaping\". For example, " -"the code, ``if key in mapping: return mapping[key]`` can fail if another " -"thread removes *key* from *mapping* after the test, but before the lookup. " -"This issue can be solved with locks or by using the EAFP approach." -msgstr "" +":term:`race condition` between \"the looking\" and \"the leaping\". For " +"example, the code, ``if key in mapping: return mapping[key]`` can fail if " +"another thread removes *key* from *mapping* after the test, but before the " +"lookup. This issue can be solved with :term:`locks ` or by using the " +":term:`EAFP` approach. See also :term:`thread-safe`." +msgstr "" +"In einer Multithread-Umgebung besteht bei dem LBYL-Ansatz die Gefahr, dass " +"eine :term:`Race Condition` zwischen dem „Nachschlagen“ und dem „Springen“ " +"entsteht. Beispielsweise kann der Code „ ``if key in mapping: return " +"mapping[key]`` “ fehlschlagen, wenn ein anderer Thread *key* nach dem Test, " +"aber vor der Suche aus *mapping* entfernt. Dieses Problem lässt sich mit " +":term:`Locks ` oder durch Verwendung des :term:`EAFP`-Ansatzes lösen. " +"Siehe auch :term:`thread-safe`." msgid "lexical analyzer" -msgstr "" +msgstr "Lexikalischer Analysator" msgid "Formal name for the *tokenizer*; see :term:`token`." -msgstr "" +msgstr "Formale Bezeichnung für den *Tokenizer*; siehe :term:`token`." msgid "list" -msgstr "" +msgstr "Liste" msgid "" "A built-in Python :term:`sequence`. Despite its name it is more akin to an " "array in other languages than to a linked list since access to elements is " "*O*\\ (1)." msgstr "" +"Eine in Python integrierte :term:`Sequenz`. Trotz ihres Namens ähnelt sie " +"eher einem Array in anderen Sprachen als einer verketteten Liste, da der " +"Zugriff auf die Elemente *O*\\ (1) ist." msgid "list comprehension" -msgstr "" +msgstr "Listenkomprimierung" msgid "" "A compact way to process all or part of the elements in a sequence and " @@ -1288,81 +2162,163 @@ msgid "" "numbers (0x..) in the range from 0 to 255. The :keyword:`if` clause is " "optional. If omitted, all elements in ``range(256)`` are processed." msgstr "" +"Eine kompakte Möglichkeit, alle oder einen Teil der Elemente einer Sequenz " +"zu verarbeiten und eine Liste mit den Ergebnissen zurückzugeben. „ ``result" +" = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0]`` “ generiert " +"eine Liste von Zeichenketten, die gerade Hexadezimalzahlen (0x..) im Bereich" +" von 0 bis 255 enthalten. Die Klausel „ :keyword:`if` “ ist optional. Wird " +"sie weggelassen, werden alle Elemente in „ ``range(256)`` “ verarbeitet." + +msgid "lock" +msgstr "Schloss" + +msgid "" +"A :term:`synchronization primitive` that allows only one thread at a time to" +" access a shared resource. A thread must acquire a lock before accessing " +"the protected resource and release it afterward. If a thread attempts to " +"acquire a lock that is already held by another thread, it will block until " +"the lock becomes available. Python's :mod:`threading` module provides " +":class:`~threading.Lock` (a basic lock) and :class:`~threading.RLock` (a " +":term:`reentrant` lock). Locks are used to prevent :term:`race conditions " +"` and ensure :term:`thread-safe` access to shared data. " +"Alternative design patterns to locks exist such as queues, producer/consumer" +" patterns, and thread-local state. See also :term:`deadlock`, and " +":term:`reentrant`." +msgstr "" +"Eine :term:`Synchronisationsprimitive`, die es nur einem Thread gleichzeitig" +" erlaubt, auf eine gemeinsam genutzte Ressource zuzugreifen. Ein Thread muss" +" vor dem Zugriff auf die geschützte Ressource eine Sperre erwerben und diese" +" anschließend wieder freigeben. Versucht ein Thread, eine Sperre zu " +"erwerben, die bereits von einem anderen Thread gehalten wird, wird er " +"blockiert, bis die Sperre verfügbar wird. Das Python-Modul „ " +":mod:`threading` “ stellt „ :class:`~threading.Lock` “ (eine einfache " +"Sperre) und „ :class:`~threading.RLock` “ (eine :term:`reentrante` Sperre) " +"bereit. Sperren werden verwendet, um :term:`Race-Conditions ` zu verhindern und einen :term:`thread-safe` Zugriff auf " +"gemeinsam genutzte Daten zu gewährleisten. Es gibt alternative " +"Entwurfsmuster zu Sperren, wie z. B. Warteschlangen, Produzenten-" +"Konsumenten-Muster und thread-lokale Zustände. Siehe auch :term:`Deadlock` " +"und :term:`reentrant`." + +msgid "lock-free" +msgstr "sperrfrei" + +msgid "" +"An operation that does not acquire any :term:`lock` and uses atomic CPU " +"instructions to ensure correctness. Lock-free operations can execute " +"concurrently without blocking each other and cannot be blocked by operations" +" that hold locks. In :term:`free-threaded ` Python, built-in" +" types like :class:`dict` and :class:`list` provide lock-free read " +"operations, which means other threads may observe intermediate states during" +" multi-step modifications even when those modifications hold the :term:`per-" +"object lock`." +msgstr "" +"Eine Operation, die keine :term:`Sperre` erwirbt und atomare CPU-Befehle " +"verwendet, um die Korrektheit zu gewährleisten. Sperrfreie Operationen " +"können parallel ausgeführt werden, ohne sich gegenseitig zu blockieren, und " +"können nicht durch Operationen blockiert werden, die Sperren halten. In " +":term:`free-threaded ` Python bieten integrierte Typen wie " +":class:`dict` und :class:`list` lock-freie Leseoperationen, was bedeutet, " +"dass andere Threads bei mehrstufigen Änderungen Zwischenzustände beobachten " +"können, selbst wenn diese Änderungen die :term:`per-object lock` halten." msgid "loader" -msgstr "" +msgstr "Lader" msgid "" -"An object that loads a module. It must define the :meth:`!exec_module` and :" -"meth:`!create_module` methods to implement the :class:`~importlib.abc." -"Loader` interface. A loader is typically returned by a :term:`finder`. See " -"also:" +"An object that loads a module. It must define the :meth:`!exec_module` and " +":meth:`!create_module` methods to implement the " +":class:`~importlib.abc.Loader` interface. A loader is typically returned by " +"a :term:`finder`. See also:" msgstr "" +"Ein Objekt, das ein Modul lädt. Es muss die Methoden ` :meth:`!exec_module` " +"` und ` :meth:`!create_module` ` definieren, um die Schnittstelle ` " +":class:`~importlib.abc.Loader` ` zu implementieren. Ein Loader wird in der " +"Regel von einem :term:`finder` zurückgegeben. Siehe auch:" msgid ":ref:`finders-and-loaders`" -msgstr "" +msgstr ":ref:`finders-and-loaders`" msgid ":class:`importlib.abc.Loader`" -msgstr "" +msgstr ":class:`importlib.abc.Loader`" msgid ":pep:`302`" -msgstr "" +msgstr ":pep:`302`" msgid "locale encoding" -msgstr "" +msgstr "Ländereinstellung, Kodierung" msgid "" -"On Unix, it is the encoding of the LC_CTYPE locale. It can be set with :func:" -"`locale.setlocale(locale.LC_CTYPE, new_locale) `." +"On Unix, it is the encoding of the LC_CTYPE locale. It can be set with " +":func:`locale.setlocale(locale.LC_CTYPE, new_locale) `." msgstr "" +"Unter Unix handelt es sich um die Kodierung der Locale LC_CTYPE. Sie kann " +"mit :func:`locale.setlocale(locale.LC_CTYPE, new_locale) " +"`` festgelegt werden." msgid "On Windows, it is the ANSI code page (ex: ``\"cp1252\"``)." -msgstr "" +msgstr "Unter Windows ist dies die ANSI-Codepage (z. B.: ``\"cp1252\"``)." -msgid "" -"On Android and VxWorks, Python uses ``\"utf-8\"`` as the locale encoding." +msgid "On Android and VxWorks, Python uses ``\"utf-8\"`` as the locale encoding." msgstr "" +"Unter Android und VxWorks verwendet Python „ ``\"utf-8\"`` “ als Locale-" +"Kodierung." msgid ":func:`locale.getencoding` can be used to get the locale encoding." msgstr "" +":func:`locale.getencoding` kann verwendet werden, um die Kodierung der " +"Ländereinstellung abzurufen." msgid "See also the :term:`filesystem encoding and error handler`." msgstr "" +"Siehe auch den Eintrag :term:`Dateisystem-Kodierung und Fehlerbehandlung`." msgid "magic method" -msgstr "" +msgstr "magische Methode" msgid "An informal synonym for :term:`special method`." -msgstr "" +msgstr "Ein umgangssprachliches Synonym für :term:`Spezialmethode`." msgid "mapping" -msgstr "" +msgstr "Kartierung" msgid "" "A container object that supports arbitrary key lookups and implements the " -"methods specified in the :class:`collections.abc.Mapping` or :class:" -"`collections.abc.MutableMapping` :ref:`abstract base classes `. Examples include :class:`dict`, :class:" -"`collections.defaultdict`, :class:`collections.OrderedDict` and :class:" -"`collections.Counter`." -msgstr "" +"methods specified in the :class:`collections.abc.Mapping` or " +":class:`collections.abc.MutableMapping` :ref:`abstract base classes " +"`. Examples include :class:`dict`, " +":class:`collections.defaultdict`, :class:`collections.OrderedDict` and " +":class:`collections.Counter`." +msgstr "" +"Ein Container-Objekt, das die Suche nach beliebigen Schlüsseln unterstützt " +"und die Methoden implementiert, die in den :class:`collections.abc.Mapping` " +"oder :class:`collections.abc.MutableMapping`:ref:`abstrakten Basisklassen " +"` festgelegt sind. Beispiele hierfür sind" +" :class:`dict`, :class:`collections.defaultdict`, " +":class:`collections.OrderedDict` und :class:`collections.Counter`." msgid "meta path finder" -msgstr "" +msgstr "Meta-Pfadfinder" msgid "" "A :term:`finder` returned by a search of :data:`sys.meta_path`. Meta path " "finders are related to, but different from :term:`path entry finders `." msgstr "" +"Ein :term:`Finder`, der bei einer Suche auf :data:`sys.meta_path` " +"zurückgegeben wird. Meta-Pfadfinder stehen in Zusammenhang mit " +":term:`Pfadeintrags-Findern `, unterscheiden sich jedoch " +"von diesen." msgid "" "See :class:`importlib.abc.MetaPathFinder` for the methods that meta path " "finders implement." msgstr "" +"Unter :class:`importlib.abc.MetaPathFinder` finden Sie die Methoden, die " +"Meta-Path-Finder implementieren." msgid "metaclass" -msgstr "" +msgstr "Metaklasse" msgid "" "The class of a class. Class definitions create a class name, a class " @@ -1375,80 +2331,121 @@ msgid "" "access, adding thread-safety, tracking object creation, implementing " "singletons, and many other tasks." msgstr "" +"Die Klasse einer Klasse. Klassendefinitionen legen einen Klassennamen, ein " +"Klassenwörterbuch und eine Liste von Basisklassen fest. Die Metaklasse ist " +"dafür zuständig, diese drei Argumente zu übernehmen und die Klasse zu " +"erstellen. Die meisten objektorientierten Programmiersprachen bieten eine " +"Standardimplementierung. Das Besondere an Python ist, dass es möglich ist, " +"benutzerdefinierte Metaklassen zu erstellen. Die meisten Nutzer benötigen " +"dieses Werkzeug nie, doch wenn der Bedarf entsteht, können Metaklassen " +"leistungsstarke und elegante Lösungen bieten. Sie wurden bereits zur " +"Protokollierung des Zugriffs auf Attribute, zur Gewährleistung der Thread-" +"Sicherheit, zur Verfolgung der Objekterstellung, zur Implementierung von " +"Singletons und für viele andere Aufgaben eingesetzt." msgid "More information can be found in :ref:`metaclasses`." -msgstr "" +msgstr "Weitere Informationen finden Sie unter :ref:`metaclasses`." msgid "method" -msgstr "" +msgstr "Methode" msgid "" "A function which is defined inside a class body. If called as an attribute " -"of an instance of that class, the method will get the instance object as its " -"first :term:`argument` (which is usually called ``self``). See :term:" -"`function` and :term:`nested scope`." +"of an instance of that class, the method will get the instance object as its" +" first :term:`argument` (which is usually called ``self``). See " +":term:`function` and :term:`nested scope`." msgstr "" +"Eine Funktion, die innerhalb des Klassenkörpers definiert ist. Wird sie als " +"Attribut einer Instanz dieser Klasse aufgerufen, erhält die Methode das " +"Instanzobjekt als erstes :term:`Argument` (das üblicherweise als „ ``self`` " +"“ bezeichnet wird). Siehe :term:`function` und :term:`nested scope`." msgid "method resolution order" -msgstr "" +msgstr "Reihenfolge der Methodenauflösung" msgid "" "Method Resolution Order is the order in which base classes are searched for " "a member during lookup. See :ref:`python_2.3_mro` for details of the " "algorithm used by the Python interpreter since the 2.3 release." msgstr "" +"Die Auflösungsreihenfolge von Methoden ist die Reihenfolge, in der bei der " +"Suche nach einem Mitglied die Basisklassen durchsucht werden. Weitere " +"Informationen zu dem Algorithmus, der seit der Version 2.3 vom Python-" +"Interpreter verwendet wird, finden Sie unter :ref:`python_2.3_mro`." msgid "module" -msgstr "" +msgstr "Modul" msgid "" "An object that serves as an organizational unit of Python code. Modules " "have a namespace containing arbitrary Python objects. Modules are loaded " "into Python by the process of :term:`importing`." msgstr "" +"Ein Objekt, das als Organisationseinheit für Python-Code dient. Module " +"verfügen über einen Namensraum, der beliebige Python-Objekte enthält. Module" +" werden durch den Vorgang des :term:`Importierens` in Python geladen." msgid "See also :term:`package`." -msgstr "" +msgstr "Siehe auch :term:`Paket`." msgid "module spec" -msgstr "" +msgstr "Modulspezifikation" msgid "" -"A namespace containing the import-related information used to load a module. " -"An instance of :class:`importlib.machinery.ModuleSpec`." +"A namespace containing the import-related information used to load a module." +" An instance of :class:`importlib.machinery.ModuleSpec`." msgstr "" +"Ein Namespace, der die Import-bezogenen Informationen enthält, die zum Laden" +" eines Moduls verwendet werden. Eine Instanz von ` " +":class:`importlib.machinery.ModuleSpec``." msgid "See also :ref:`module-specs`." -msgstr "" +msgstr "Siehe auch :ref:`module-specs`." msgid "MRO" -msgstr "" +msgstr "MRO" msgid "See :term:`method resolution order`." -msgstr "" +msgstr "Siehe :term:`Reihenfolge der Methodenauflösung`." msgid "mutable" -msgstr "" +msgstr "veränderlich" msgid "" -"Mutable objects can change their value but keep their :func:`id`. See also :" -"term:`immutable`." +"An :term:`object` with state that is allowed to change during the course of " +"the program. In multi-threaded programs, mutable objects that are shared " +"between threads require careful synchronization to avoid :term:`race " +"conditions `. See also :term:`immutable`, :term:`thread-" +"safe`, and :term:`concurrent modification`." msgstr "" +"Ein :term:`Objekt` mit einem Zustand, der sich im Verlauf des Programms " +"ändern darf. In Multithread-Programmen erfordern veränderbare Objekte, die " +"von mehreren Threads gemeinsam genutzt werden, eine sorgfältige " +"Synchronisation, um :term:`Race-Conditions ` zu vermeiden. " +"Siehe auch :term:`unveränderlich`, :term:`thread-sicher` und " +":term:`parallele Änderung`." msgid "named tuple" -msgstr "" +msgstr "benanntes Tupel" msgid "" "The term \"named tuple\" applies to any type or class that inherits from " "tuple and whose indexable elements are also accessible using named " "attributes. The type or class may have other features as well." msgstr "" +"Der Begriff „benanntes Tupel“ bezieht sich auf jeden Typ oder jede Klasse, " +"die von „Tupel“ erbt und deren indizierbare Elemente auch über benannte " +"Attribute zugänglich sind. Der Typ oder die Klasse kann darüber hinaus noch " +"weitere Merkmale aufweisen." msgid "" -"Several built-in types are named tuples, including the values returned by :" -"func:`time.localtime` and :func:`os.stat`. Another example is :data:`sys." -"float_info`::" +"Several built-in types are named tuples, including the values returned by " +":func:`time.localtime` and :func:`os.stat`. Another example is " +":data:`sys.float_info`::" msgstr "" +"Mehrere integrierte Datentypen werden als Tupel bezeichnet, darunter die von" +" ` :func:`time.localtime` ` und ` :func:`os.stat`` zurückgegebenen Werte. " +"Ein weiteres Beispiel ist ` :data:`sys.float_info``: ::" msgid "" ">>> sys.float_info[1] # indexed access\n" @@ -1458,56 +2455,110 @@ msgid "" ">>> isinstance(sys.float_info, tuple) # kind of tuple\n" "True" msgstr "" +">>> sys.float_info[1] # indizierter Zugriff\n" +"1024\n" +">>> sys.float_info.max_exp # Zugriff auf ein benanntes Feld\n" +"1024\n" +">>> isinstance(sys.float_info, tuple) # Typ eines Tupels\n" +"True" msgid "" "Some named tuples are built-in types (such as the above examples). " "Alternatively, a named tuple can be created from a regular class definition " "that inherits from :class:`tuple` and that defines named fields. Such a " -"class can be written by hand, or it can be created by inheriting :class:" -"`typing.NamedTuple`, or with the factory function :func:`collections." -"namedtuple`. The latter techniques also add some extra methods that may not " -"be found in hand-written or built-in named tuples." -msgstr "" +"class can be written by hand, or it can be created by inheriting " +":class:`typing.NamedTuple`, or with the factory function " +":func:`collections.namedtuple`. The latter techniques also add some extra " +"methods that may not be found in hand-written or built-in named tuples." +msgstr "" +"Einige benannte Tupel sind integrierte Typen (wie die obigen Beispiele). " +"Alternativ kann ein benanntes Tupel aus einer regulären Klassendefinition " +"erstellt werden, die von ` :class:`tuple` ` erbt und benannte Felder " +"definiert. Eine solche Klasse kann manuell geschrieben werden oder durch " +"Vererbung von ` :class:`typing.NamedTuple`` bzw. mit der Factory-Funktion ` " +":func:`collections.namedtuple`` erstellt werden. Die letztgenannten " +"Techniken fügen zudem einige zusätzliche Methoden hinzu, die in manuell " +"geschriebenen oder integrierten benannten Tupeln möglicherweise nicht " +"vorhanden sind." msgid "namespace" -msgstr "" +msgstr "Namensraum" msgid "" "The place where a variable is stored. Namespaces are implemented as " "dictionaries. There are the local, global and built-in namespaces as well " -"as nested namespaces in objects (in methods). Namespaces support modularity " -"by preventing naming conflicts. For instance, the functions :func:`builtins." -"open <.open>` and :func:`os.open` are distinguished by their namespaces. " -"Namespaces also aid readability and maintainability by making it clear which " -"module implements a function. For instance, writing :func:`random.seed` or :" -"func:`itertools.islice` makes it clear that those functions are implemented " -"by the :mod:`random` and :mod:`itertools` modules, respectively." -msgstr "" +"as nested namespaces in objects (in methods). Namespaces support modularity" +" by preventing naming conflicts. For instance, the functions " +":func:`builtins.open <.open>` and :func:`os.open` are distinguished by their" +" namespaces. Namespaces also aid readability and maintainability by making " +"it clear which module implements a function. For instance, writing " +":func:`random.seed` or :func:`itertools.islice` makes it clear that those " +"functions are implemented by the :mod:`random` and :mod:`itertools` modules," +" respectively." +msgstr "" +"Der Ort, an dem eine Variable gespeichert wird. Namensräume werden als " +"Wörterbücher implementiert. Es gibt lokale, globale und integrierte " +"Namensräume sowie verschachtelte Namensräume in Objekten (in Methoden). " +"Namensräume unterstützen die Modularität, indem sie Namenskonflikte " +"verhindern. Beispielsweise unterscheiden sich die Funktionen " +":func:`builtins.open <.open>` und :func:`os.open` durch ihre Namensräume. " +"Namensräume tragen zudem zur Lesbarkeit und Wartbarkeit bei, indem sie " +"deutlich machen, welches Modul eine Funktion implementiert. Wenn man " +"beispielsweise :func:`random.seed` oder :func:`itertools.islice` schreibt, " +"wird deutlich, dass diese Funktionen jeweils von den Modulen :mod:`random` " +"und :mod:`itertools` implementiert werden." msgid "namespace package" -msgstr "" +msgstr "Namensraum-Paket" msgid "" "A :term:`package` which serves only as a container for subpackages. " -"Namespace packages may have no physical representation, and specifically are " -"not like a :term:`regular package` because they have no ``__init__.py`` file." +"Namespace packages may have no physical representation, and specifically are" +" not like a :term:`regular package` because they have no ``__init__.py`` " +"file." msgstr "" +"Ein :term:`Paket`, das ausschließlich als Container für Unterpakete dient. " +"Namespace-Pakete haben möglicherweise keine physische Darstellung und " +"unterscheiden sich insbesondere von einem :term:`normalen Paket`, da sie " +"keine Datei „ ``__init__.py`` “ enthalten." msgid "" -"Namespace packages allow several individually installable packages to have a " -"common parent package. Otherwise, it is recommended to use a :term:`regular " -"package`." +"Namespace packages allow several individually installable packages to have a" +" common parent package. Otherwise, it is recommended to use a :term:`regular" +" package`." msgstr "" +"Namespace-Pakete ermöglichen es, dass mehrere einzeln installierbare Pakete " +"ein gemeinsames übergeordnetes Paket haben. Andernfalls wird empfohlen, ein " +":term:`normales Paket` zu verwenden." msgid "" "For more information, see :pep:`420` and :ref:`reference-namespace-package`." msgstr "" +"Weitere Informationen finden Sie unter :pep:`420` und :ref:`reference-" +"namespace-package`." msgid "See also :term:`module`." +msgstr "Siehe auch :term:`Modul`." + +msgid "native code" +msgstr "Nativcode" + +msgid "" +"Code that is compiled to machine instructions and runs directly on the " +"processor, as opposed to code that is interpreted or runs in a virtual " +"machine. In the context of Python, native code typically refers to C, C++, " +"Rust or Fortran code in :term:`extension modules ` that " +"can be called from Python. See also :term:`extension module`." msgstr "" +"Code, der zu Maschinenbefehlen kompiliert wird und direkt auf dem Prozessor " +"ausgeführt wird, im Gegensatz zu Code, der interpretiert wird oder in einer " +"virtuellen Maschine läuft. Im Zusammenhang mit Python bezieht sich „nativer" +" Code“ in der Regel auf C-, C++-, Rust- oder Fortran-Code in " +":term:`Erweiterungsmodulen `, der von Python aus " +"aufgerufen werden kann. Siehe auch :term:`Erweiterungsmodul`." msgid "nested scope" -msgstr "" +msgstr "verschachtelter Gültigkeitsbereich" msgid "" "The ability to refer to a variable in an enclosing definition. For " @@ -1517,58 +2568,153 @@ msgid "" "the innermost scope. Likewise, global variables read and write to the " "global namespace. The :keyword:`nonlocal` allows writing to outer scopes." msgstr "" +"Die Möglichkeit, in einer umschließenden Definition auf eine Variable zu " +"verweisen. So kann beispielsweise eine innerhalb einer anderen Funktion " +"definierte Funktion auf Variablen in der äußeren Funktion verweisen. " +"Beachten Sie, dass verschachtelte Gültigkeitsbereiche standardmäßig nur für " +"Verweise und nicht für Zuweisungen gelten. Lokale Variablen lesen und " +"schreiben im innersten Gültigkeitsbereich. Ebenso lesen und schreiben " +"globale Variablen im globalen Namensraum. Die Anweisung „ " +":keyword:`nonlocal` “ ermöglicht das Schreiben in äußere " +"Gültigkeitsbereiche." msgid "new-style class" -msgstr "" +msgstr "Klasse im neuen Stil" msgid "" "Old name for the flavor of classes now used for all class objects. In " "earlier Python versions, only new-style classes could use Python's newer, " -"versatile features like :attr:`~object.__slots__`, descriptors, properties, :" -"meth:`~object.__getattribute__`, class methods, and static methods." -msgstr "" +"versatile features like :attr:`~object.__slots__`, descriptors, properties, " +":meth:`~object.__getattribute__`, class methods, and static methods." +msgstr "" +"Alte Bezeichnung für den „Flavor“ von Klassen, der nun für alle " +"Klassenobjekte verwendet wird. In früheren Python-Versionen konnten nur " +"Klassen des neuen Stils die neueren, vielseitigen Funktionen von Python " +"nutzen, wie beispielsweise „ :attr:`~object.__slots__` “, Deskriptoren, " +"Eigenschaften, „ :meth:`~object.__getattribute__` “, Klassenmethoden und " +"statische Methoden." + +msgid "non-deterministic" +msgstr "nicht deterministisch" + +msgid "" +"Behavior where the outcome of a program can vary between executions with the" +" same inputs. In multi-threaded programs, non-deterministic behavior often " +"results from :term:`race conditions ` where the relative " +"timing or interleaving of threads affects the result. Proper synchronization" +" using :term:`locks ` and other :term:`synchronization primitives " +"` helps ensure deterministic behavior." +msgstr "" +"Verhalten, bei dem das Ergebnis eines Programms bei gleichen Eingaben von " +"Ausführung zu Ausführung variieren kann. In Multithread-Programmen " +"resultiert nichtdeterministisches Verhalten häufig aus :term:`Race-" +"Conditions `, bei denen der relative zeitliche Ablauf oder " +"die Verflechtung von Threads das Ergebnis beeinflusst. Eine ordnungsgemäße " +"Synchronisation mithilfe von :term:`Locks ` und anderen " +":term:`Synchronisationsprimitiven ` trägt dazu " +"bei, ein deterministisches Verhalten sicherzustellen." msgid "object" -msgstr "" +msgstr "Objekt" msgid "" "Any data with state (attributes or value) and defined behavior (methods). " "Also the ultimate base class of any :term:`new-style class`." msgstr "" +"Jede Dateninstanz mit einem Zustand (Attribute oder Wert) und definiertem " +"Verhalten (Methoden). Außerdem die oberste Basisklasse jeder :term:`Klasse " +"neuen Stils`." msgid "optimized scope" -msgstr "" +msgstr "optimierter Umfang" msgid "" -"A scope where target local variable names are reliably known to the compiler " -"when the code is compiled, allowing optimization of read and write access to " -"these names. The local namespaces for functions, generators, coroutines, " +"A scope where target local variable names are reliably known to the compiler" +" when the code is compiled, allowing optimization of read and write access " +"to these names. The local namespaces for functions, generators, coroutines, " "comprehensions, and generator expressions are optimized in this fashion. " "Note: most interpreter optimizations are applied to all scopes, only those " "relying on a known set of local and nonlocal variable names are restricted " "to optimized scopes." msgstr "" +"Ein Geltungsbereich, in dem die Namen der lokalen Zielvariablen dem Compiler" +" zum Zeitpunkt der Kompilierung zuverlässig bekannt sind, wodurch der Lese- " +"und Schreibzugriff auf diese Namen optimiert werden kann. Die lokalen " +"Namensräume für Funktionen, Generatoren, Koroutinen, Comprehensions und " +"Generatorausdrücke werden auf diese Weise optimiert. Hinweis: Die meisten " +"Interpreter-Optimierungen werden auf alle Gültigkeitsbereiche angewendet; " +"nur diejenigen, die auf einer bekannten Menge lokaler und nichtlokaler " +"Variablennamen beruhen, sind auf optimierte Gültigkeitsbereiche beschränkt." -msgid "package" +msgid "optional module" +msgstr "optionales Modul" + +msgid "" +"An :term:`extension module` that is part of the :term:`standard library`, " +"but may be absent in some builds of :term:`CPython`, usually due to missing " +"third-party libraries or because the module is not available for a given " +"platform." msgstr "" +"Ein :term:`Erweiterungsmodul`, das Teil der :term:`Standardbibliothek` ist, " +"jedoch in einigen Builds von :term:`CPython` möglicherweise fehlt – in der " +"Regel aufgrund fehlender Bibliotheken von Drittanbietern oder weil das Modul" +" für eine bestimmte Plattform nicht verfügbar ist." + +msgid "" +"See :ref:`optional-module-requirements` for a list of optional modules that " +"require third-party libraries." +msgstr "" +"Eine Liste der optionalen Module, für die Bibliotheken von Drittanbietern " +"erforderlich sind, finden Sie unter :ref:`optional-module-requirements`." + +msgid "package" +msgstr "Paket" msgid "" "A Python :term:`module` which can contain submodules or recursively, " "subpackages. Technically, a package is a Python module with a ``__path__`` " "attribute." msgstr "" +"Ein Python-:term:`Modul`, das Untermodule oder – rekursiv – Unterpakete " +"enthalten kann. Technisch gesehen ist ein Paket ein Python-Modul mit einem " +"Attribut vom Typ „ ``__path__`` “." msgid "See also :term:`regular package` and :term:`namespace package`." +msgstr "Siehe auch :term:`reguläres Paket` und :term:`Namensraum-Paket`." + +msgid "parallelism" +msgstr "Parallelität" + +msgid "" +"Executing multiple operations at the same time (e.g. on multiple CPU cores)." +" In Python builds with the :term:`global interpreter lock (GIL) `, only one thread runs Python bytecode at a time, so " +"taking advantage of multiple CPU cores typically involves multiple processes" +" (e.g. :mod:`multiprocessing`) or native extensions that release the GIL. In" +" :term:`free-threaded ` Python, multiple Python threads can " +"run Python code simultaneously on different cores." msgstr "" +"Die gleichzeitige Ausführung mehrerer Operationen (z. B. auf mehreren CPU-" +"Kernen). In Python-Builds mit dem :term:`global interpreter lock (GIL) " +"` führt jeweils nur ein Thread Python-Bytecode aus." +" Um die Vorteile mehrerer CPU-Kerne nutzen zu können, sind daher in der " +"Regel mehrere Prozesse (z. B. :mod:`multiprocessing`) oder native " +"Erweiterungen erforderlich, die das GIL aufheben. In :term:`free-threaded " +"` Python können mehrere Python-Threads Python-Code " +"gleichzeitig auf verschiedenen Kernen ausführen." msgid "parameter" -msgstr "" +msgstr "Parameter" msgid "" "A named entity in a :term:`function` (or method) definition that specifies " "an :term:`argument` (or in some cases, arguments) that the function can " "accept. There are five kinds of parameter:" msgstr "" +"Eine benannte Entität in einer :term:`Funktions`- (oder " +"Methoden-)Definition, die ein :term:`Argument` (oder in manchen Fällen " +"mehrere Argumente) angibt, das bzw. die die Funktion entgegennehmen kann. Es" +" gibt fünf Arten von Parametern:" msgid "" ":dfn:`positional-or-keyword`: specifies an argument that can be passed " @@ -1576,9 +2722,13 @@ msgid "" "`. This is the default kind of parameter, for example *foo* and " "*bar* in the following::" msgstr "" +":dfn:`positional-or-keyword`: Gibt ein Argument an, das entweder " +":term:`positionsbezogen ` oder als :term:`Schlüsselwortargument " +"` übergeben werden kann. Dies ist die Standardart von Parametern, " +"zum Beispiel *foo* und *bar* im Folgenden::" msgid "def func(foo, bar=None): ..." -msgstr "" +msgstr "def func(foo, bar=None): ..." msgid "" ":dfn:`positional-only`: specifies an argument that can be supplied only by " @@ -1586,9 +2736,14 @@ msgid "" "character in the parameter list of the function definition after them, for " "example *posonly1* and *posonly2* in the following::" msgstr "" +":dfn:`positional-only`: Gibt ein Argument an, das nur über die Position " +"übergeben werden kann. Parameter, die ausschließlich über die Position " +"übergeben werden können, lassen sich definieren, indem man in der " +"Parameterliste der Funktionsdefinition hinter ihnen das Zeichen „ ``/`` “ " +"einfügt, zum Beispiel *posonly1* und *posonly2* im folgenden Beispiel::" msgid "def func(posonly1, posonly2, /, positional_or_keyword): ..." -msgstr "" +msgstr "def func(posonly1, posonly2, /, positional_or_keyword): ..." msgid "" ":dfn:`keyword-only`: specifies an argument that can be supplied only by " @@ -1597,9 +2752,15 @@ msgid "" "definition before them, for example *kw_only1* and *kw_only2* in the " "following::" msgstr "" +":dfn:`keyword-only`: Gibt ein Argument an, das nur als Schlüsselwort " +"übergeben werden kann. Schlüsselwort-Parameter können definiert werden, " +"indem ein einzelner variabler Positionsparameter oder ein reines Schlüssel " +"``*`` us in die Parameterliste der vorangehenden Funktionsdefinition " +"aufgenommen wird, zum Beispiel *kw_only1* und *kw_only2* im folgenden " +"Beispiel::" msgid "def func(arg, *, kw_only1, kw_only2): ..." -msgstr "" +msgstr "def func(arg, *, kw_only1, kw_only2): ..." msgid "" ":dfn:`var-positional`: specifies that an arbitrary sequence of positional " @@ -1608,84 +2769,143 @@ msgid "" "prepending the parameter name with ``*``, for example *args* in the " "following::" msgstr "" +":dfn:`var-positional`: Gibt an, dass eine beliebige Folge von " +"Positionsargumenten angegeben werden kann (zusätzlich zu den " +"Positionsargumenten, die bereits von anderen Parametern akzeptiert werden). " +"Ein solcher Parameter kann definiert werden, indem dem Parameternamen „ " +"``*`` “ vorangestellt wird, zum Beispiel *args* im folgenden Beispiel::" msgid "def func(*args, **kwargs): ..." -msgstr "" +msgstr "def func(*args, **kwargs): ..." msgid "" -":dfn:`var-keyword`: specifies that arbitrarily many keyword arguments can be " -"provided (in addition to any keyword arguments already accepted by other " +":dfn:`var-keyword`: specifies that arbitrarily many keyword arguments can be" +" provided (in addition to any keyword arguments already accepted by other " "parameters). Such a parameter can be defined by prepending the parameter " "name with ``**``, for example *kwargs* in the example above." msgstr "" +":dfn:`var-keyword`: Gibt an, dass beliebig viele Schlüsselwortargumente " +"angegeben werden können (zusätzlich zu den Schlüsselwortargumenten, die " +"bereits von anderen Parametern akzeptiert werden). Ein solcher Parameter " +"kann definiert werden, indem dem Parameternamen „ ``**`` “ vorangestellt " +"wird, beispielsweise *kwargs* im obigen Beispiel." msgid "" "Parameters can specify both optional and required arguments, as well as " "default values for some optional arguments." msgstr "" +"Parameter können sowohl optionale als auch erforderliche Argumente sowie " +"Standardwerte für einige optionale Argumente festlegen." msgid "" "See also the :term:`argument` glossary entry, the FAQ question on :ref:`the " "difference between arguments and parameters `, " -"the :class:`inspect.Parameter` class, the :ref:`function` section, and :pep:" -"`362`." -msgstr "" +"the :class:`inspect.Parameter` class, the :ref:`function` section, and " +":pep:`362`." +msgstr "" +"Siehe auch den Glossareintrag :term:`argument`, die FAQ-Frage zu :ref:`dem " +"Unterschied zwischen Argumenten und Parametern ``, die Klasse :class:`inspect.Parameter`, den Abschnitt " +":ref:`function` sowie :pep:`362`." + +msgid "per-object lock" +msgstr "Objektspezifische Sperre" + +msgid "" +"A :term:`lock` associated with an individual object instance rather than a " +"global lock shared across all objects. In :term:`free-threaded ` Python, built-in types like :class:`dict` and :class:`list` use " +"per-object locks to allow concurrent operations on different objects while " +"serializing operations on the same object. Operations that hold the per-" +"object lock prevent other locking operations on the same object from " +"proceeding, but do not block :term:`lock-free` operations." +msgstr "" +"Ein :term:`Lock`, der mit einer einzelnen Objektinstanz verknüpft ist, im " +"Gegensatz zu einem globalen Lock, der von allen Objekten gemeinsam genutzt " +"wird. In :term:`free-threaded ` Python verwenden integrierte" +" Typen wie :class:`dict` und :class:`list` objektbezogene Sperren, um " +"parallele Operationen an verschiedenen Objekten zu ermöglichen, während " +"Operationen am selben Objekt serialisiert werden. Operationen, die die " +"objektbezogene Sperre halten, verhindern, dass andere Sperroperationen am " +"selben Objekt fortgesetzt werden, blockieren jedoch keine :term:`lock-" +"free`-Operationen." msgid "path entry" -msgstr "" +msgstr "Pfadeintrag" msgid "" "A single location on the :term:`import path` which the :term:`path based " "finder` consults to find modules for importing." msgstr "" +"Ein einzelner Speicherort im :term:`Importpfad`, den der :term:`pfadbasierte" +" Finder` abfragt, um Module zum Importieren zu finden." msgid "path entry finder" -msgstr "" +msgstr "Pfadeintrags-Finder" msgid "" -"A :term:`finder` returned by a callable on :data:`sys.path_hooks` (i.e. a :" -"term:`path entry hook`) which knows how to locate modules given a :term:" -"`path entry`." +"A :term:`finder` returned by a callable on :data:`sys.path_hooks` (i.e. a " +":term:`path entry hook`) which knows how to locate modules given a " +":term:`path entry`." msgstr "" +"Ein :term:`finder`, der von einer auf :data:`sys.path_hooks` aufrufbaren " +"Funktion (d. h. einem :term:`path entry hook`) zurückgegeben wird, die weiß," +" wie man Module anhand eines :term:`path entry` findet." msgid "" "See :class:`importlib.abc.PathEntryFinder` for the methods that path entry " "finders implement." msgstr "" +"Unter :class:`importlib.abc.PathEntryFinder` finden Sie die Methoden, die " +"von Path-Entry-Findern implementiert werden." msgid "path entry hook" -msgstr "" +msgstr "Pfadeintrag-Hook" msgid "" "A callable on the :data:`sys.path_hooks` list which returns a :term:`path " "entry finder` if it knows how to find modules on a specific :term:`path " "entry`." msgstr "" +"Eine auf der Liste „ :data:`sys.path_hooks` “ aufrufbare Funktion, die einen" +" :term:`Pfadeintrag-Finder` zurückgibt, sofern sie weiß, wie Module auf " +"einem bestimmten :term:`Pfadeintrag` gefunden werden können." msgid "path based finder" -msgstr "" +msgstr "Pfadbasierter Sucher" msgid "" "One of the default :term:`meta path finders ` which " "searches an :term:`import path` for modules." msgstr "" +"Einer der standardmäßigen :term:`Meta-Pfadfinder `, der " +"einen :term:`Importpfad` nach Modulen durchsucht." msgid "path-like object" -msgstr "" - -msgid "" -"An object representing a file system path. A path-like object is either a :" -"class:`str` or :class:`bytes` object representing a path, or an object " -"implementing the :class:`os.PathLike` protocol. An object that supports the :" -"class:`os.PathLike` protocol can be converted to a :class:`str` or :class:" -"`bytes` file system path by calling the :func:`os.fspath` function; :func:" -"`os.fsdecode` and :func:`os.fsencode` can be used to guarantee a :class:" -"`str` or :class:`bytes` result instead, respectively. Introduced by :pep:" -"`519`." -msgstr "" +msgstr "pfadähnliches Objekt" + +msgid "" +"An object representing a file system path. A path-like object is either a " +":class:`str` or :class:`bytes` object representing a path, or an object " +"implementing the :class:`os.PathLike` protocol. An object that supports the " +":class:`os.PathLike` protocol can be converted to a :class:`str` or " +":class:`bytes` file system path by calling the :func:`os.fspath` function; " +":func:`os.fsdecode` and :func:`os.fsencode` can be used to guarantee a " +":class:`str` or :class:`bytes` result instead, respectively. Introduced by " +":pep:`519`." +msgstr "" +"Ein Objekt, das einen Dateisystempfad darstellt. Ein pfadähnliches Objekt " +"ist entweder ein „ :class:`str` “- oder ein „ :class:`bytes` “-Objekt, das " +"einen Pfad darstellt, oder ein Objekt, das das „ :class:`os.PathLike` " +"“-Protokoll implementiert. Ein Objekt, das das „ :class:`os.PathLike` " +"“-Protokoll unterstützt, kann durch Aufruf der Funktion „ :func:`os.fspath` " +"“ in einen „ :class:`str` “- oder „ :class:`bytes` “-Dateisystempfad " +"umgewandelt werden; mit „ :func:`os.fsdecode` “ bzw. „ :func:`os.fsencode` “" +" lässt sich stattdessen ein „ :class:`str` “- bzw. „ :class:`bytes` " +"“-Ergebnis gewährleisten. Eingeführt durch „ :pep:`519` “." msgid "PEP" -msgstr "" +msgstr "PEP" msgid "" "Python Enhancement Proposal. A PEP is a design document providing " @@ -1693,6 +2913,11 @@ msgid "" "or its processes or environment. PEPs should provide a concise technical " "specification and a rationale for proposed features." msgstr "" +"Python Enhancement Proposal. Ein PEP ist ein Entwurfsdokument, das der " +"Python-Community Informationen liefert oder eine neue Funktion für Python, " +"dessen Prozesse oder dessen Umgebung beschreibt. PEPs sollten eine prägnante" +" technische Spezifikation sowie eine Begründung für die vorgeschlagenen " +"Funktionen enthalten." msgid "" "PEPs are intended to be the primary mechanisms for proposing major new " @@ -1701,88 +2926,127 @@ msgid "" "responsible for building consensus within the community and documenting " "dissenting opinions." msgstr "" +"PEPs sollen als primäre Mechanismen dienen, um wichtige neue Funktionen " +"vorzuschlagen, Rückmeldungen der Community zu einem Thema einzuholen und die" +" Designentscheidungen zu dokumentieren, die in Python eingeflossen sind. Der" +" PEP-Autor ist dafür verantwortlich, einen Konsens innerhalb der Community " +"herzustellen und abweichende Meinungen zu dokumentieren." msgid "See :pep:`1`." -msgstr "" +msgstr "Siehe :pep:`1`." msgid "portion" -msgstr "" +msgstr "Anteil" msgid "" "A set of files in a single directory (possibly stored in a zip file) that " "contribute to a namespace package, as defined in :pep:`420`." msgstr "" +"Eine Sammlung von Dateien in einem einzigen Verzeichnis (die möglicherweise " +"in einer ZIP-Datei gespeichert sind), die zu einem Namespace-Paket " +"beitragen, wie unter :pep:`420` definiert." msgid "positional argument" -msgstr "" +msgstr "Positionsargument" msgid "provisional API" -msgstr "" +msgstr "vorläufige API" msgid "" "A provisional API is one which has been deliberately excluded from the " "standard library's backwards compatibility guarantees. While major changes " -"to such interfaces are not expected, as long as they are marked provisional, " -"backwards incompatible changes (up to and including removal of the " +"to such interfaces are not expected, as long as they are marked provisional," +" backwards incompatible changes (up to and including removal of the " "interface) may occur if deemed necessary by core developers. Such changes " -"will not be made gratuitously -- they will occur only if serious fundamental " -"flaws are uncovered that were missed prior to the inclusion of the API." +"will not be made gratuitously -- they will occur only if serious fundamental" +" flaws are uncovered that were missed prior to the inclusion of the API." msgstr "" +"Eine vorläufige API ist eine Schnittstelle, die bewusst von den " +"Rückwärtskompatibilitätsgarantien der Standardbibliothek ausgenommen wurde. " +"Zwar sind größere Änderungen an solchen Schnittstellen nicht zu erwarten, " +"solange sie als vorläufig gekennzeichnet sind, doch können " +"rückwärtsinkompatible Änderungen (bis hin zur Entfernung der Schnittstelle) " +"vorgenommen werden, wenn dies von den Kernentwicklern als notwendig erachtet" +" wird. Solche Änderungen werden nicht ohne triftigen Grund vorgenommen – " +"sie erfolgen nur, wenn schwerwiegende grundlegende Mängel aufgedeckt werden," +" die vor der Aufnahme der API übersehen wurden." msgid "" "Even for provisional APIs, backwards incompatible changes are seen as a " "\"solution of last resort\" - every attempt will still be made to find a " "backwards compatible resolution to any identified problems." msgstr "" +"Selbst bei vorläufigen APIs gelten rückwärtsinkompatible Änderungen als " +"„letzter Ausweg“ – es wird weiterhin alles versucht, um für alle " +"festgestellten Probleme eine rückwärtskompatible Lösung zu finden." msgid "" "This process allows the standard library to continue to evolve over time, " "without locking in problematic design errors for extended periods of time. " "See :pep:`411` for more details." msgstr "" +"Dieser Prozess ermöglicht es, dass sich die Standardbibliothek im Laufe der " +"Zeit weiterentwickeln kann, ohne dass problematische Konstruktionsfehler " +"über längere Zeiträume hinweg festgeschrieben werden. Weitere Einzelheiten " +"finden Sie unter :pep:`411`." msgid "provisional package" -msgstr "" +msgstr "vorläufiges Paket" msgid "See :term:`provisional API`." -msgstr "" +msgstr "Siehe :term:`vorläufige API`." msgid "Python 3000" -msgstr "" +msgstr "Python 3000" msgid "" "Nickname for the Python 3.x release line (coined long ago when the release " -"of version 3 was something in the distant future.) This is also abbreviated " -"\"Py3k\"." +"of version 3 was something in the distant future.) This is also abbreviated" +" \"Py3k\"." msgstr "" +"Spitzname für die Python-3.x-Versionsreihe (der vor langer Zeit geprägt " +"wurde, als die Veröffentlichung von Version 3 noch in ferner Zukunft lag). " +"Er wird auch mit „Py3k“ abgekürzt." msgid "Pythonic" -msgstr "" +msgstr "Pythonesk" msgid "" -"An idea or piece of code which closely follows the most common idioms of the " -"Python language, rather than implementing code using concepts common to " +"An idea or piece of code which closely follows the most common idioms of the" +" Python language, rather than implementing code using concepts common to " "other languages. For example, a common idiom in Python is to loop over all " "elements of an iterable using a :keyword:`for` statement. Many other " "languages don't have this type of construct, so people unfamiliar with " "Python sometimes use a numerical counter instead::" msgstr "" +"Eine Idee oder ein Codeabschnitt, der sich eng an die gängigsten " +"Konventionen der Programmiersprache Python hält, anstatt Code unter " +"Verwendung von Konzepten zu implementieren, die in anderen Sprachen üblich " +"sind. Ein gängiges Beispiel in Python ist beispielsweise die " +"Durchlaufschleife über alle Elemente eines iterierbaren Objekts mithilfe " +"einer „ :keyword:`for` “-Anweisung. Viele andere Sprachen verfügen nicht " +"über eine solche Konstruktion, sodass Personen, die mit Python nicht " +"vertraut sind, manchmal stattdessen einen numerischen Zähler verwenden::" msgid "" "for i in range(len(food)):\n" " print(food[i])" msgstr "" +"for i in range(len(food)):\n" +" print(food[i])" msgid "As opposed to the cleaner, Pythonic method::" -msgstr "" +msgstr "Im Gegensatz zu der übersichtlicheren, „pythonesken“ Methode::" msgid "" "for piece in food:\n" " print(piece)" msgstr "" +"für „Stück“ in „Essen“:\n" +" print(Stück)" msgid "qualified name" -msgstr "" +msgstr "qualifizierter Name" msgid "" "A dotted name showing the \"path\" from a module's global scope to a class, " @@ -1790,6 +3054,10 @@ msgid "" "top-level functions and classes, the qualified name is the same as the " "object's name::" msgstr "" +"Ein gepunkteter Name, der den „Pfad“ vom globalen Gültigkeitsbereich eines " +"Moduls zu einer in diesem Modul definierten Klasse, Funktion oder Methode " +"angibt, wie in :pep:`3155` definiert. Bei Funktionen und Klassen der " +"obersten Ebene entspricht der qualifizierte Name dem Namen des Objekts::" msgid "" ">>> class C:\n" @@ -1804,59 +3072,159 @@ msgid "" ">>> C.D.meth.__qualname__\n" "'C.D.meth'" msgstr "" +">>> class C:\n" +"... class D:\n" +"... def meth(self):\n" +"... pass\n" +"...\n" +">>> C.__qualname__\n" +"'C'\n" +">>> C.D.__qualname__\n" +"'C.D'\n" +">>> C.D.meth.__qualname__\n" +"'C.D.meth'" msgid "" "When used to refer to modules, the *fully qualified name* means the entire " -"dotted path to the module, including any parent packages, e.g. ``email.mime." -"text``::" +"dotted path to the module, including any parent packages, e.g. " +"``email.mime.text``::" msgstr "" +"Im Zusammenhang mit Modulen bezeichnet der *vollständige Name* den gesamten," +" durch Punkte getrennten Pfad zum Modul, einschließlich aller übergeordneten" +" Pakete, z. B. ``email.mime.text``::" msgid "" ">>> import email.mime.text\n" ">>> email.mime.text.__name__\n" "'email.mime.text'" msgstr "" +">>> import email.mime.text\n" +">>> email.mime.text.__name__\n" +"'email.mime.text'" + +msgid "race condition" +msgstr "Race-Condition" + +msgid "" +"A condition of a program where the behavior depends on the relative timing " +"or ordering of events, particularly in multi-threaded programs. Race " +"conditions can lead to :term:`non-deterministic` behavior and bugs that are " +"difficult to reproduce. A :term:`data race` is a specific type of race " +"condition involving unsynchronized access to shared memory. The " +":term:`LBYL` coding style is particularly susceptible to race conditions in " +"multi-threaded code. Using :term:`locks ` and other " +":term:`synchronization primitives ` helps prevent" +" race conditions." +msgstr "" +"Ein Zustand eines Programms, bei dem das Verhalten vom relativen zeitlichen " +"Ablauf oder der Reihenfolge von Ereignissen abhängt, insbesondere in " +"Multithread-Programmen. Race-Bedingungen können zu :term:`nicht-" +"deterministischem` Verhalten und schwer reproduzierbaren Fehlern führen. " +"Ein :term:`Datenrennen` ist eine spezielle Art von Race Condition, bei der " +"es um den nicht synchronisierten Zugriff auf gemeinsam genutzten Speicher " +"geht. Der :term:`LBYL`-Programmierstil ist in Multithread-Code besonders " +"anfällig für Race Conditions. Die Verwendung von :term:`Locks ` und " +"anderen :term:`Synchronisationsprimitiven ` " +"hilft, Race Conditions zu vermeiden." msgid "reference count" -msgstr "" +msgstr "Referenzanzahl" msgid "" "The number of references to an object. When the reference count of an " "object drops to zero, it is deallocated. Some objects are :term:`immortal` " -"and have reference counts that are never modified, and therefore the objects " -"are never deallocated. Reference counting is generally not visible to " -"Python code, but it is a key element of the :term:`CPython` implementation. " -"Programmers can call the :func:`sys.getrefcount` function to return the " +"and have reference counts that are never modified, and therefore the objects" +" are never deallocated. Reference counting is generally not visible to " +"Python code, but it is a key element of the :term:`CPython` implementation." +" Programmers can call the :func:`sys.getrefcount` function to return the " "reference count for a particular object." msgstr "" +"Die Anzahl der Verweise auf ein Objekt. Wenn die Referenzanzahl eines " +"Objekts auf null sinkt, wird es freigegeben. Einige Objekte sind " +":term:`unsterblich` und haben Referenzanzahlen, die niemals geändert werden;" +" daher werden diese Objekte niemals freigegeben. Die Referenzzählung ist " +"für Python-Code im Allgemeinen nicht sichtbar, stellt jedoch ein " +"Schlüsselelement der :term:`CPython`-Implementierung dar. Programmierer " +"können die Funktion ` :func:`sys.getrefcount` ` aufrufen, um die " +"Referenzanzahl für ein bestimmtes Objekt abzurufen." msgid "" -"In :term:`CPython`, reference counts are not considered to be stable or well-" -"defined values; the number of references to an object, and how that number " -"is affected by Python code, may be different between versions." +"In :term:`CPython`, reference counts are not considered to be stable or " +"well-defined values; the number of references to an object, and how that " +"number is affected by Python code, may be different between versions." msgstr "" +"In :term:`CPython` gelten Referenzzähler nicht als stabile oder genau " +"definierte Werte; die Anzahl der Verweise auf ein Objekt und die Art und " +"Weise, wie diese Anzahl durch Python-Code beeinflusst wird, kann je nach " +"Version variieren." msgid "regular package" -msgstr "" +msgstr "Standardpaket" msgid "" -"A traditional :term:`package`, such as a directory containing an ``__init__." -"py`` file." +"A traditional :term:`package`, such as a directory containing an " +"``__init__.py`` file." msgstr "" +"Ein herkömmliches :term:`Paket`, beispielsweise ein Verzeichnis, das eine " +"Datei vom Typ „ ``__init__.py`` “ enthält." msgid "See also :term:`namespace package`." +msgstr "Siehe auch: :term:`Namensraum-Paket`." + +msgid "reentrant" +msgstr "wiederkehrend" + +msgid "" +"A property of a function or :term:`lock` that allows it to be called or " +"acquired multiple times by the same thread without causing errors or a " +":term:`deadlock`." msgstr "" +"Eine Eigenschaft einer Funktion oder eines :term:`lock`, die es ermöglicht, " +"dass diese mehrfach vom selben Thread aufgerufen bzw. erworben wird, ohne " +"dass dabei Fehler oder ein :term:`Deadlock` auftreten." -msgid "REPL" +msgid "" +"For functions, reentrancy means the function can be safely called again " +"before a previous invocation has completed, which is important when " +"functions may be called recursively or from signal handlers. Thread-unsafe " +"functions may be :term:`non-deterministic` if they're called reentrantly in " +"a multithreaded program." msgstr "" +"Bei Funktionen bedeutet Reentranz, dass die Funktion sicher erneut " +"aufgerufen werden kann, bevor ein vorheriger Aufruf abgeschlossen ist. Dies " +"ist wichtig, wenn Funktionen rekursiv oder aus Signal-Handlern heraus " +"aufgerufen werden können. Thread-unsichere Funktionen können :term:`nicht " +"deterministisch` sein, wenn sie in einem Multithread-Programm reentrant " +"aufgerufen werden." msgid "" -"An acronym for the \"read–eval–print loop\", another name for the :term:" -"`interactive` interpreter shell." +"For locks, Python's :class:`threading.RLock` (reentrant lock) is reentrant, " +"meaning a thread that already holds the lock can acquire it again without " +"blocking. In contrast, :class:`threading.Lock` is not reentrant - " +"attempting to acquire it twice from the same thread will cause a deadlock." msgstr "" +"Was Sperren betrifft, ist die Python-Sperre „ :class:`threading.RLock` “ " +"(Reentrant-Sperre) reentrant, was bedeutet, dass ein Thread, der die Sperre " +"bereits hält, sie erneut erwerben kann, ohne zu blockieren. Im Gegensatz " +"dazu ist „ :class:`threading.Lock` “ nicht reentrant – der Versuch, sie " +"zweimal vom selben Thread aus zu erwerben, führt zu einem Deadlock." -msgid "__slots__" +msgid "See also :term:`lock` and :term:`deadlock`." +msgstr "Siehe auch :term:`lock` und :term:`deadlock`." + +msgid "REPL" +msgstr "REPL" + +msgid "" +"An acronym for the \"read–eval–print loop\", another name for the " +":term:`interactive` interpreter shell." msgstr "" +"Eine Abkürzung für „read–eval–print loop“ (Lesen–Auswerten–Ausgeben-" +"Schleife), eine andere Bezeichnung für die :term:`interaktive` Interpreter-" +"Shell." + +msgid "__slots__" +msgstr "__slots__" msgid "" "A declaration inside a class that saves memory by pre-declaring space for " @@ -1865,214 +3233,383 @@ msgid "" "cases where there are large numbers of instances in a memory-critical " "application." msgstr "" +"Eine Deklaration innerhalb einer Klasse, die Speicherplatz spart, indem " +"Speicherplatz für Instanzattribute vorab reserviert und Instanz-Dictionaries" +" vermieden werden. Obwohl diese Technik weit verbreitet ist, ist ihre " +"korrekte Anwendung etwas knifflig und sollte am besten nur in seltenen " +"Fällen eingesetzt werden, in denen in einer speicherintensiven Anwendung " +"eine große Anzahl von Instanzen vorliegt." msgid "sequence" -msgstr "" +msgstr "Sequenz" msgid "" "An :term:`iterable` which supports efficient element access using integer " -"indices via the :meth:`~object.__getitem__` special method and defines a :" -"meth:`~object.__len__` method that returns the length of the sequence. Some " -"built-in sequence types are :class:`list`, :class:`str`, :class:`tuple`, " -"and :class:`bytes`. Note that :class:`dict` also supports :meth:`~object." -"__getitem__` and :meth:`!__len__`, but is considered a mapping rather than a " -"sequence because the lookups use arbitrary :term:`hashable` keys rather than " -"integers." -msgstr "" +"indices via the :meth:`~object.__getitem__` special method and defines a " +":meth:`~object.__len__` method that returns the length of the sequence. Some" +" built-in sequence types are :class:`list`, :class:`str`, :class:`tuple`, " +"and :class:`bytes`. Note that :class:`dict` also supports " +":meth:`~object.__getitem__` and :meth:`!__len__`, but is considered a " +"mapping rather than a sequence because the lookups use arbitrary " +":term:`hashable` keys rather than integers." +msgstr "" +"Ein :term:`iterable`, das einen effizienten Zugriff auf Elemente mithilfe " +"ganzzahliger Indizes über die spezielle Methode :meth:`~object.__getitem__` " +"unterstützt und eine Methode :meth:`~object.__len__` definiert, die die " +"Länge der Sequenz zurückgibt. Einige integrierte Sequenztypen sind " +":class:`list`, :class:`str`, :class:`tuple` und :class:`bytes`. Beachten " +"Sie, dass :class:`dict` ebenfalls :meth:`~object.__getitem__` und " +":meth:`!__len__` unterstützt, jedoch eher als Mapping denn als Sequenz " +"betrachtet wird, da die Suchvorgänge beliebige :term:`hashable`-Schlüssel " +"anstelle von Ganzzahlen verwenden." msgid "" "The :class:`collections.abc.Sequence` abstract base class defines a much " -"richer interface that goes beyond just :meth:`~object.__getitem__` and :meth:" -"`~object.__len__`, adding :meth:`~sequence.count`, :meth:`~sequence.index`, :" -"meth:`~object.__contains__`, and :meth:`~object.__reversed__`. Types that " -"implement this expanded interface can be registered explicitly using :func:" -"`~abc.ABCMeta.register`. For more documentation on sequence methods " -"generally, see :ref:`Common Sequence Operations `." -msgstr "" +"richer interface that goes beyond just :meth:`~object.__getitem__` and " +":meth:`~object.__len__`, adding :meth:`~sequence.count`, " +":meth:`~sequence.index`, :meth:`~object.__contains__`, and " +":meth:`~object.__reversed__`. Types that implement this expanded interface " +"can be registered explicitly using :func:`~abc.ABCMeta.register`. For more " +"documentation on sequence methods generally, see :ref:`Common Sequence " +"Operations `." +msgstr "" +"Die abstrakte Basisklasse ` :class:`collections.abc.Sequence` ` definiert " +"eine wesentlich umfangreichere Schnittstelle, die über die Methoden ` " +":meth:`~object.__getitem__` ` und ` :meth:`~object.__len__`` hinausgeht und " +"um die Methoden ` :meth:`~sequence.count``, ` :meth:`~sequence.index``, ` " +":meth:`~object.__contains__`` sowie ` :meth:`~object.__reversed__`` " +"erweitert wird. Typen, die diese erweiterte Schnittstelle implementieren, " +"können explizit mit ` :func:`~abc.ABCMeta.register`` registriert werden. " +"Weitere Informationen zu Sequenzmethoden im Allgemeinen finden Sie unter " +":ref:`Common Sequence Operations `." msgid "set comprehension" -msgstr "" +msgstr "Mengenkomprimierung" msgid "" "A compact way to process all or part of the elements in an iterable and " "return a set with the results. ``results = {c for c in 'abracadabra' if c " -"not in 'abc'}`` generates the set of strings ``{'r', 'd'}``. See :ref:" -"`comprehensions`." +"not in 'abc'}`` generates the set of strings ``{'r', 'd'}``. See " +":ref:`comprehensions`." msgstr "" +"Eine kompakte Möglichkeit, alle oder einen Teil der Elemente einer " +"iterierbaren Struktur zu verarbeiten und eine Menge mit den Ergebnissen " +"zurückzugeben. ` ``results = {c for c in 'abracadabra' if c not in 'abc'}`` " +"` erzeugt die Menge der Zeichenfolgen ` ``{'r', 'd'}```. Siehe " +":ref:`comprehensions`." msgid "single dispatch" -msgstr "" +msgstr "Einzelversand" msgid "" "A form of :term:`generic function` dispatch where the implementation is " "chosen based on the type of a single argument." msgstr "" +"Eine Form der :term:`generischen Funktionsauswahl`, bei der die " +"Implementierung anhand des Typs eines einzelnen Arguments ausgewählt wird." msgid "slice" -msgstr "" +msgstr "Scheibe" msgid "" -"An object usually containing a portion of a :term:`sequence`. A slice is " -"created using the subscript notation, ``[]`` with colons between numbers " -"when several are given, such as in ``variable_name[1:3:5]``. The bracket " -"(subscript) notation uses :class:`slice` objects internally." +"An object of type :class:`slice`, used to describe a portion of a " +":term:`sequence`. A slice object is created when using the :ref:`slicing " +"` form of :ref:`subscript notation `, with colons " +"inside square brackets, such as in ``variable_name[1:3:5]``." msgstr "" +"Ein Objekt vom Typ :class:`slice`, das zur Beschreibung eines Teils einer " +":term:`Sequenz` dient. Ein Slice-Objekt wird erstellt, wenn die " +":ref:`Slicing- ` -Form der :ref:`Indexnotation ` " +"verwendet wird, bei der Doppelpunkte in eckigen Klammern stehen, wie " +"beispielsweise in ``variable_name[1:3:5]``." msgid "soft deprecated" -msgstr "" +msgstr "weich veraltet" msgid "" "A soft deprecated API should not be used in new code, but it is safe for " "already existing code to use it. The API remains documented and tested, but " "will not be enhanced further." msgstr "" +"Eine „soft deprecated“ API sollte in neuem Code nicht mehr verwendet werden," +" bei bereits vorhandenem Code ist ihre Verwendung jedoch unbedenklich. Die " +"API bleibt dokumentiert und wird weiterhin getestet, wird jedoch nicht mehr " +"weiterentwickelt." msgid "" "Soft deprecation, unlike normal deprecation, does not plan on removing the " "API and will not emit warnings." msgstr "" +"Im Gegensatz zur normalen Veralterung ist bei einer „Soft Deprecation“ nicht" +" vorgesehen, die API zu entfernen, und es werden keine Warnungen ausgegeben." msgid "" "See `PEP 387: Soft Deprecation `_." msgstr "" +"Siehe `PEP 387: Soft Deprecation `_." msgid "special method" -msgstr "" +msgstr "spezielle Methode" msgid "" "A method that is called implicitly by Python to execute a certain operation " "on a type, such as addition. Such methods have names starting and ending " -"with double underscores. Special methods are documented in :ref:" -"`specialnames`." +"with double underscores. Special methods are documented in " +":ref:`specialnames`." msgstr "" +"Eine Methode, die von Python implizit aufgerufen wird, um eine bestimmte " +"Operation auf einem Typ auszuführen, beispielsweise eine Addition. Die Namen" +" solcher Methoden beginnen und enden mit zwei Unterstrichen. Spezielle " +"Methoden sind unter :ref:`specialnames` dokumentiert." msgid "standard library" -msgstr "" +msgstr "Standardbibliothek" msgid "" -"The collection of :term:`packages `, :term:`modules ` and :" -"term:`extension modules ` distributed as a part of the " -"official Python interpreter package. The exact membership of the collection " -"may vary based on platform, available system libraries, or other criteria. " -"Documentation can be found at :ref:`library-index`." +"The collection of :term:`packages `, :term:`modules ` and " +":term:`extension modules ` distributed as a part of the " +"official Python interpreter package. The exact membership of the collection" +" may vary based on platform, available system libraries, or other criteria." +" Documentation can be found at :ref:`library-index`." msgstr "" +"Die Sammlung von :term:`Paketen `, :term:`Modulen ` und " +":term:`Erweiterungsmodulen `, die als Teil des offiziellen" +" Python-Interpreter-Pakets bereitgestellt wird. Der genaue Umfang der " +"Sammlung kann je nach Plattform, verfügbaren Systembibliotheken oder anderen" +" Kriterien variieren. Die Dokumentation finden Sie unter :ref:`library-" +"index`." msgid "" -"See also :data:`sys.stdlib_module_names` for a list of all possible standard " -"library module names." +"See also :data:`sys.stdlib_module_names` for a list of all possible standard" +" library module names." msgstr "" +"Eine Liste aller möglichen Namen von Standardbibliotheksmodulen finden Sie " +"unter :data:`sys.stdlib_module_names`." msgid "statement" -msgstr "" +msgstr "Erklärung" msgid "" -"A statement is part of a suite (a \"block\" of code). A statement is either " -"an :term:`expression` or one of several constructs with a keyword, such as :" -"keyword:`if`, :keyword:`while` or :keyword:`for`." +"A statement is part of a suite (a \"block\" of code). A statement is either" +" an :term:`expression` or one of several constructs with a keyword, such as " +":keyword:`if`, :keyword:`while` or :keyword:`for`." msgstr "" +"Eine Anweisung ist Teil einer Suite (eines „Code-Blocks“). Eine Anweisung " +"ist entweder ein :term:`Ausdruck` oder eine von mehreren Konstrukten mit " +"einem Schlüsselwort, wie beispielsweise „ :keyword:`if` “, „ " +":keyword:`while` “ oder „ :keyword:`for` “." msgid "static type checker" -msgstr "" +msgstr "statischer Typprüfer" msgid "" "An external tool that reads Python code and analyzes it, looking for issues " -"such as incorrect types. See also :term:`type hints ` and the :" -"mod:`typing` module." +"such as incorrect types. See also :term:`type hints ` and the " +":mod:`typing` module." msgstr "" +"Ein externes Tool, das Python-Code ausliest und analysiert, um Probleme wie " +"beispielsweise falsche Typen zu erkennen. Siehe auch :term:`Typangaben ` und das Modul „ :mod:`typing` “." msgid "stdlib" -msgstr "" +msgstr "stdlib" msgid "An abbreviation of :term:`standard library`." +msgstr "Eine Abkürzung für :term:`Standardbibliothek`." + +msgid "steal" +msgstr "stehlen" + +msgid "" +"In Python's C API, \"*stealing*\" an argument means that ownership of the " +"argument is transferred to the called function. The caller must not use that" +" reference after the call. Generally, functions that \"steal\" an argument " +"do so even if they fail." msgstr "" +"In der C-API von Python bedeutet das „*Stehlen*“ eines Arguments, dass das " +"Eigentumsrecht an dem Argument auf die aufgerufene Funktion übertragen wird." +" Der Aufrufer darf diese Referenz nach dem Aufruf nicht mehr verwenden. Im " +"Allgemeinen tun Funktionen, die ein Argument „stehlen“, dies auch dann, wenn" +" sie fehlschlagen." -msgid "strong reference" +msgid "See :ref:`api-refcountdetails` for a full explanation." msgstr "" +"Eine ausführliche Erläuterung finden Sie unter :ref:`api-refcountdetails`." + +msgid "strong reference" +msgstr "starke Referenz" msgid "" "In Python's C API, a strong reference is a reference to an object which is " "owned by the code holding the reference. The strong reference is taken by " -"calling :c:func:`Py_INCREF` when the reference is created and released with :" -"c:func:`Py_DECREF` when the reference is deleted." +"calling :c:func:`Py_INCREF` when the reference is created and released with " +":c:func:`Py_DECREF` when the reference is deleted." msgstr "" +"In der C-API von Python ist eine starke Referenz eine Referenz auf ein " +"Objekt, das dem Code gehört, der die Referenz enthält. Die starke Referenz " +"wird durch den Aufruf von ` :c:func:`Py_INCREF` ` beim Erstellen der " +"Referenz hergestellt und durch den Aufruf von ` :c:func:`Py_DECREF` ` beim " +"Löschen der Referenz freigegeben." msgid "" -"The :c:func:`Py_NewRef` function can be used to create a strong reference to " -"an object. Usually, the :c:func:`Py_DECREF` function must be called on the " +"The :c:func:`Py_NewRef` function can be used to create a strong reference to" +" an object. Usually, the :c:func:`Py_DECREF` function must be called on the " "strong reference before exiting the scope of the strong reference, to avoid " "leaking one reference." msgstr "" +"Mit der Funktion „ :c:func:`Py_NewRef` “ lässt sich eine starke Referenz auf" +" ein Objekt erstellen. In der Regel muss die Funktion „ :c:func:`Py_DECREF` " +"“ für die starke Referenz aufgerufen werden, bevor der Geltungsbereich der " +"starken Referenz verlassen wird, um ein Referenzleck zu vermeiden." msgid "See also :term:`borrowed reference`." -msgstr "" +msgstr "Siehe auch: :term:`entlehnte Referenz`." + +msgid "subscript" +msgstr "Index" + +msgid "" +"The expression in square brackets of a :ref:`subscription expression " +"`, for example, the ``3`` in ``items[3]``. Usually used to " +"select an element of a container. Also called a :term:`key` when " +"subscripting a :term:`mapping`, or an :term:`index` when subscripting a " +":term:`sequence`." +msgstr "" +"Der Ausdruck in eckigen Klammern eines :ref:`Abonnementausdrucks " +"`, zum Beispiel der ``3`` in ``items[3]``. Wird in der Regel " +"verwendet, um ein Element eines Containers auszuwählen. Wird auch als " +":term:`Schlüssel` bezeichnet, wenn ein :term:`Mapping` indiziert wird, oder " +"als :term:`Index`, wenn eine :term:`Sequenz` indiziert wird." + +msgid "synchronization primitive" +msgstr "Synchronisationsprimitive" + +msgid "" +"A basic building block for coordinating (synchronizing) the execution of " +"multiple threads to ensure :term:`thread-safe` access to shared resources. " +"Python's :mod:`threading` module provides several synchronization primitives" +" including :class:`~threading.Lock`, :class:`~threading.RLock`, " +":class:`~threading.Semaphore`, :class:`~threading.Condition`, " +":class:`~threading.Event`, and :class:`~threading.Barrier`. Additionally, " +"the :mod:`queue` module provides multi-producer, multi-consumer queues that " +"are especially useful in multithreaded programs. These primitives help " +"prevent :term:`race conditions ` and coordinate thread " +"execution. See also :term:`lock`." +msgstr "" +"Ein grundlegender Baustein zur Koordination (Synchronisation) der Ausführung" +" mehrerer Threads, um einen :term:`thread-safe` Zugriff auf gemeinsam " +"genutzte Ressourcen zu gewährleisten. Das Python-Modul „ :mod:`threading` “ " +"stellt mehrere Synchronisationsprimitive bereit, darunter „ " +":class:`~threading.Lock` “, „ :class:`~threading.RLock` “, „ " +":class:`~threading.Semaphore` “, „ :class:`~threading.Condition` “, „ " +":class:`~threading.Event` “ und „ :class:`~threading.Barrier` “. Darüber " +"hinaus bietet das Modul „ :mod:`queue` “ Multi-Producer- und Multi-Consumer-" +"Warteschlangen, die besonders in Multithread-Programmen nützlich sind. Diese" +" Primitive tragen dazu bei, :term:`Race-Conditions ` zu " +"verhindern und die Thread-Ausführung zu koordinieren. Siehe auch " +":term:`lock`." msgid "t-string" -msgstr "" +msgstr "T-String" msgid "t-strings" -msgstr "" +msgstr "T-Strings" msgid "" -"String literals prefixed with ``t`` or ``T`` are commonly called \"t-" -"strings\" which is short for :ref:`template string literals `." +"String literals prefixed with ``t`` or ``T`` are commonly called " +"\"t-strings\" which is short for :ref:`template string literals " +"`." msgstr "" +"Zeichenfolgenliterale, denen „ ``t`` “ oder „ ``T`` “ vorangestellt ist, " +"werden gemeinhin als „t-Strings“ bezeichnet, was die Abkürzung für " +":ref:`Template-Zeichenfolgenliterale ` ist." msgid "text encoding" -msgstr "" +msgstr "Textkodierung" msgid "" "A string in Python is a sequence of Unicode code points (in range " "``U+0000``--``U+10FFFF``). To store or transfer a string, it needs to be " "serialized as a sequence of bytes." msgstr "" +"Eine Zeichenkette in Python ist eine Folge von Unicode-Codepunkten (im " +"Bereich ``U+0000``--``U+10FFFF``). Um eine Zeichenkette zu speichern oder zu" +" übertragen, muss sie als Bytefolge serialisiert werden." msgid "" "Serializing a string into a sequence of bytes is known as \"encoding\", and " "recreating the string from the sequence of bytes is known as \"decoding\"." msgstr "" +"Die Umwandlung einer Zeichenkette in eine Bytefolge wird als „Kodierung“ " +"bezeichnet, und die Rekonstruktion der Zeichenkette aus der Bytefolge wird " +"als „Dekodierung“ bezeichnet." msgid "" "There are a variety of different text serialization :ref:`codecs `, which are collectively referred to as \"text encodings\"." msgstr "" +"Es gibt eine Vielzahl verschiedener Text-Serialisierungsverfahren " +":ref:`Codecs `, die zusammenfassend als " +"„Textkodierungen“ bezeichnet werden." msgid "text file" -msgstr "" +msgstr "Textdatei" msgid "" "A :term:`file object` able to read and write :class:`str` objects. Often, a " -"text file actually accesses a byte-oriented datastream and handles the :term:" -"`text encoding` automatically. Examples of text files are files opened in " -"text mode (``'r'`` or ``'w'``), :data:`sys.stdin`, :data:`sys.stdout`, and " -"instances of :class:`io.StringIO`." +"text file actually accesses a byte-oriented datastream and handles the " +":term:`text encoding` automatically. Examples of text files are files opened" +" in text mode (``'r'`` or ``'w'``), :data:`sys.stdin`, :data:`sys.stdout`, " +"and instances of :class:`io.StringIO`." msgstr "" +"Ein :term:`Dateiobjekt`, das :class:`str` -Objekte lesen und schreiben kann." +" Häufig greift eine Textdatei tatsächlich auf einen byteurientierten " +"Datenstrom zu und übernimmt die :term:`Textkodierung` automatisch. Beispiele" +" für Textdateien sind Dateien, die im Textmodus geöffnet wurden (``'r'`` " +"oder ``'w'``), :data:`sys.stdin`, :data:`sys.stdout` sowie Instanzen von " +":class:`io.StringIO`." msgid "" -"See also :term:`binary file` for a file object able to read and write :term:" -"`bytes-like objects `." +"See also :term:`binary file` for a file object able to read and write " +":term:`bytes-like objects `." msgstr "" +"Siehe auch :term:`Binärdatei` für ein Dateiobjekt, das :term:`byteähnliche " +"Objekte ` lesen und schreiben kann." msgid "thread state" -msgstr "" +msgstr "Thread-Status" msgid "" "The information used by the :term:`CPython` runtime to run in an OS thread. " "For example, this includes the current exception, if any, and the state of " "the bytecode interpreter." msgstr "" +"Die Informationen, die von der :term:`CPython`-Laufzeitumgebung verwendet " +"werden, um in einem Betriebssystem-Thread ausgeführt zu werden. Dazu gehören" +" beispielsweise die aktuelle Ausnahme (falls vorhanden) und der Zustand des " +"Bytecode-Interpreters." msgid "" "Each thread state is bound to a single OS thread, but threads may have many " "thread states available. At most, one of them may be :term:`attached " "` at once." msgstr "" +"Jeder Thread-Zustand ist an einen einzelnen Betriebssystem-Thread gebunden, " +"aber Threads können über mehrere Thread-Zustände verfügen. Höchstens einer " +"davon darf gleichzeitig :term:` ` sein." msgid "" -"An :term:`attached thread state` is required to call most of Python's C API, " -"unless a function explicitly documents otherwise. The bytecode interpreter " +"An :term:`attached thread state` is required to call most of Python's C API," +" unless a function explicitly documents otherwise. The bytecode interpreter " "only runs under an attached thread state." msgstr "" +"Für den Aufruf der meisten Funktionen der Python-C-API ist ein " +":term:`angeschlossener Thread-Zustand` erforderlich, sofern in der " +"Dokumentation einer Funktion nicht ausdrücklich etwas anderes angegeben ist." +" Der Bytecode-Interpreter läuft nur unter einem angeschlossenen Thread-" +"Zustand." msgid "" "Each thread state belongs to a single interpreter, but each interpreter may " @@ -2081,28 +3618,70 @@ msgid "" "one can be :term:`attached ` in that thread at any " "given moment." msgstr "" +"Jeder Thread-Zustand gehört zu einem einzelnen Interpreter, aber jeder " +"Interpreter kann viele Thread-Zustände haben, darunter auch mehrere für " +"denselben Betriebssystem-Thread. Thread-Zustände aus mehreren Interpretern " +"können an denselben Thread gebunden sein, aber zu jedem Zeitpunkt kann nur " +"einer in diesem Thread :term:` ` sein." msgid "" "See :ref:`Thread State and the Global Interpreter Lock ` for more " "information." msgstr "" +"Weitere Informationen finden Sie unter :ref:`Thread-Status und die globale " +"Interpreter-Sperre `." + +msgid "thread-safe" +msgstr "thread-safe" + +msgid "" +"A module, function, or class that behaves correctly when used by multiple " +"threads concurrently. Thread-safe code uses appropriate " +":term:`synchronization primitives ` like " +":term:`locks ` to protect shared mutable state, or is designed to " +"avoid shared mutable state entirely. In the :term:`free-threaded ` build, built-in types like :class:`dict`, :class:`list`, and " +":class:`set` use internal locking to make many operations thread-safe, " +"although thread safety is not necessarily guaranteed. Code that is not " +"thread-safe may experience :term:`race conditions ` and " +":term:`data races ` when used in multi-threaded programs." +msgstr "" +"Ein Modul, eine Funktion oder eine Klasse, die sich bei gleichzeitiger " +"Nutzung durch mehrere Threads korrekt verhält. Thread-sicherer Code " +"verwendet geeignete :term:`Synchronisationsprimitive ` wie :term:`Locks `, um gemeinsam genutzte, veränderbare " +"Zustände zu schützen, oder ist so konzipiert, dass gemeinsam genutzte, " +"veränderbare Zustände gänzlich vermieden werden. In der :term:`free-" +"threaded `-Version verwenden integrierte Typen wie " +":class:`dict`, :class:`list` und :class:`set` interne Sperren, um viele " +"Operationen threadsicher zu machen, obwohl die Threadsicherheit nicht " +"unbedingt garantiert ist. Code, der nicht threadsicher ist, kann bei der " +"Verwendung in Multithread-Programmen zu :term:`Race-Conditions ` und :term:`Datenkonflikten ` führen." msgid "token" -msgstr "" +msgstr "Token" msgid "" "A small unit of source code, generated by the :ref:`lexical analyzer " "` (also called the *tokenizer*). Names, numbers, strings, " "operators, newlines and similar are represented by tokens." msgstr "" +"Eine kleine Einheit des Quellcodes, die vom :ref:`lexikalischen Analysator " +"` (auch *Tokenizer* genannt) generiert wird. Namen, Zahlen, " +"Zeichenketten, Operatoren, Zeilenumbrüche und Ähnliches werden durch Token " +"dargestellt." msgid "" -"The :mod:`tokenize` module exposes Python's lexical analyzer. The :mod:" -"`token` module contains information on the various types of tokens." +"The :mod:`tokenize` module exposes Python's lexical analyzer. The " +":mod:`token` module contains information on the various types of tokens." msgstr "" +"Das Modul „ :mod:`tokenize` “ stellt den lexikalischen Analysator von Python" +" bereit. Das Modul „ :mod:`token` “ enthält Informationen zu den " +"verschiedenen Token-Typen." msgid "triple-quoted string" -msgstr "" +msgstr "Zeichenkette in dreifachen Anführungszeichen" msgid "" "A string which is bound by three instances of either a quotation mark (\") " @@ -2113,35 +3692,54 @@ msgid "" "continuation character, making them especially useful when writing " "docstrings." msgstr "" +"Eine Zeichenkette, die durch drei aufeinanderfolgende einfache " +"Anführungszeichen (\") oder Apostrophe (') begrenzt wird. Obwohl sie keine " +"Funktionen bieten, die bei Zeichenketten in einfachen Anführungszeichen " +"nicht verfügbar sind, sind sie aus verschiedenen Gründen nützlich. Sie " +"ermöglichen es, nicht maskierte einfache und doppelte Anführungszeichen in " +"eine Zeichenkette einzufügen, und sie können sich über mehrere Zeilen " +"erstrecken, ohne dass das Fortsetzungszeichen verwendet werden muss, was sie" +" besonders nützlich beim Schreiben von Docstrings macht." msgid "type" msgstr "Typ" msgid "" "The type of a Python object determines what kind of object it is; every " -"object has a type. An object's type is accessible as its :attr:`~object." -"__class__` attribute or can be retrieved with ``type(obj)``." +"object has a type. An object's type is accessible as its " +":attr:`~object.__class__` attribute or can be retrieved with ``type(obj)``." msgstr "" +"Der Typ eines Python-Objekts bestimmt, um welche Art von Objekt es sich " +"handelt; jedes Objekt hat einen Typ. Der Typ eines Objekts ist über das " +"Attribut ` :attr:`~object.__class__` ` zugänglich oder kann mit ` " +"``type(obj)``` abgerufen werden." msgid "type alias" -msgstr "" +msgstr "Typalias" msgid "A synonym for a type, created by assigning the type to an identifier." msgstr "" +"Ein Synonym für einen Typ, das durch die Zuweisung des Typs zu einem " +"Bezeichner erstellt wird." msgid "" "Type aliases are useful for simplifying :term:`type hints `. For " "example::" msgstr "" +"Typ-Aliase sind nützlich, um :term:`Typ-Hinweise ` zu " +"vereinfachen. Zum Beispiel::" msgid "" "def remove_gray_shades(\n" " colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:\n" " pass" msgstr "" +"def remove_gray_shades(\n" +" colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:\n" +" pass" msgid "could be made more readable like this::" -msgstr "" +msgstr "könnte so lesbarer gestaltet werden::" msgid "" "Color = tuple[int, int, int]\n" @@ -2149,74 +3747,105 @@ msgid "" "def remove_gray_shades(colors: list[Color]) -> list[Color]:\n" " pass" msgstr "" +"Farbe = Tupel[int, int, int]\n" +"\n" +"def remove_gray_shades(colors: Liste[Farbe]) -> Liste[Farbe]:\n" +" pass" msgid "See :mod:`typing` and :pep:`484`, which describe this functionality." msgstr "" +"Siehe :mod:`typing` und :pep:`484`, wo diese Funktion beschrieben wird." msgid "type hint" -msgstr "" +msgstr "Typhinweis" msgid "" "An :term:`annotation` that specifies the expected type for a variable, a " "class attribute, or a function parameter or return value." msgstr "" +"Eine :term:`Annotation`, die den erwarteten Typ für eine Variable, ein " +"Klassenattribut oder einen Funktionsparameter bzw. Rückgabewert angibt." msgid "" "Type hints are optional and are not enforced by Python but they are useful " "to :term:`static type checkers `. They can also aid " "IDEs with code completion and refactoring." msgstr "" +"Typangaben sind optional und werden von Python nicht erzwungen, sind jedoch " +"für :term:`statische Typprüfer ` nützlich. Außerdem " +"können sie IDEs bei der Code-Vervollständigung und beim Refactoring " +"unterstützen." msgid "" "Type hints of global variables, class attributes, and functions, but not " "local variables, can be accessed using :func:`typing.get_type_hints`." msgstr "" +"Typhinweise für globale Variablen, Klassenattribute und Funktionen, nicht " +"jedoch für lokale Variablen, können über „ :func:`typing.get_type_hints` “ " +"abgerufen werden." msgid "universal newlines" -msgstr "" +msgstr "universelle Zeilenumbrüche" msgid "" "A manner of interpreting text streams in which all of the following are " "recognized as ending a line: the Unix end-of-line convention ``'\\n'``, the " -"Windows convention ``'\\r\\n'``, and the old Macintosh convention " -"``'\\r'``. See :pep:`278` and :pep:`3116`, as well as :func:`bytes." -"splitlines` for an additional use." +"Windows convention ``'\\r\\n'``, and the old Macintosh convention ``'\\r'``." +" See :pep:`278` and :pep:`3116`, as well as :func:`bytes.splitlines` for an" +" additional use." msgstr "" +"Eine Methode zur Interpretation von Textströmen, bei der alle folgenden " +"Zeichenfolgen als Zeilenende erkannt werden: die Unix-Zeilenende-Konvention " +"``'\\n'``, die Windows-Konvention ``'\\r\\n'`` und die alte Macintosh-" +"Konvention ``'\\r'``. Siehe :pep:`278` und :pep:`3116` sowie " +":func:`bytes.splitlines` für eine weitere Anwendungsmöglichkeit." msgid "variable annotation" -msgstr "" +msgstr "Variablenbeschriftung" msgid "An :term:`annotation` of a variable or a class attribute." -msgstr "" +msgstr "Eine :term:`Annotation` einer Variablen oder eines Klassenattributs." msgid "" "When annotating a variable or a class attribute, assignment is optional::" msgstr "" +"Bei der Annotation einer Variablen oder eines Klassenattributs ist die " +"Zuweisung optional::" msgid "" "class C:\n" " field: 'annotation'" msgstr "" +"Klasse C:\n" +" Feld: 'annotation'" msgid "" "Variable annotations are usually used for :term:`type hints `: " "for example this variable is expected to take :class:`int` values::" msgstr "" +"Variablenannotationen werden in der Regel für :term:`Typangaben `verwendet – beispielsweise wird erwartet, dass diese Variable Werte " +"vom Typ :class:`int` annimmt::" msgid "count: int = 0" -msgstr "" +msgstr "Zähler: int = 0" msgid "Variable annotation syntax is explained in section :ref:`annassign`." msgstr "" +"Die Syntax für die Annotation von Variablen wird im Abschnitt „ " +":ref:`annassign` “ erläutert." msgid "" "See :term:`function annotation`, :pep:`484` and :pep:`526`, which describe " "this functionality. Also see :ref:`annotations-howto` for best practices on " "working with annotations." msgstr "" +"Siehe :term:`Funktionsannotation`, :pep:`484` und :pep:`526`, wo diese " +"Funktionalität beschrieben wird. Siehe auch :ref:`annotations-howto` für " +"bewährte Vorgehensweisen beim Umgang mit Annotationen." msgid "virtual environment" -msgstr "" +msgstr "virtuelle Umgebung" msgid "" "A cooperatively isolated runtime environment that allows Python users and " @@ -2224,50 +3853,63 @@ msgid "" "interfering with the behaviour of other Python applications running on the " "same system." msgstr "" +"Eine kooperativ isolierte Laufzeitumgebung, die es Python-Anwendern und " +"-Anwendungen ermöglicht, Python-Distributionspakete zu installieren und zu " +"aktualisieren, ohne das Verhalten anderer Python-Anwendungen zu " +"beeinträchtigen, die auf demselben System ausgeführt werden." msgid "See also :mod:`venv`." -msgstr "" +msgstr "Siehe auch :mod:`venv`." msgid "virtual machine" -msgstr "" +msgstr "virtuelle Maschine" msgid "" "A computer defined entirely in software. Python's virtual machine executes " "the :term:`bytecode` emitted by the bytecode compiler." msgstr "" +"Ein vollständig in Software definierter Computer. Die virtuelle Maschine von" +" Python führt den vom Bytecode-Compiler erzeugten :term:`Bytecode` aus." msgid "walrus operator" -msgstr "" +msgstr "Walross-Betreiber" msgid "" "A light-hearted way to refer to the :ref:`assignment expression ` operator ``:=`` because it looks a bit like a walrus if you " "turn your head." msgstr "" +"Eine scherzhafte Bezeichnung für den :ref:`Zuweisungsausdruck ` Operator ``:=``, da er ein bisschen wie ein Walross aussieht, " +"wenn man den Kopf etwas dreht." msgid "Zen of Python" -msgstr "" +msgstr "Zen von Python" msgid "" "Listing of Python design principles and philosophies that are helpful in " "understanding and using the language. The listing can be found by typing " "\"``import this``\" at the interactive prompt." msgstr "" +"Eine Auflistung der Python-Entwurfsprinzipien und -Philosophien, die zum " +"Verständnis und zur Anwendung der Sprache hilfreich sind. Die Auflistung " +"kann durch Eingabe von „``import this`` “ an der interaktiven " +"Eingabeaufforderung aufgerufen werden." msgid "..." -msgstr "" +msgstr "..." msgid "ellipsis literal" -msgstr "" +msgstr "Ellipsis-Literal" msgid "C-contiguous" -msgstr "" +msgstr "C-zusammenhängend" msgid "Fortran contiguous" -msgstr "" +msgstr "Fortran – zusammenhängend" msgid "magic" -msgstr "" +msgstr "Magie" msgid "special" -msgstr "" +msgstr "besonders" From d97094ec736bf2c940875fcfe75a69c53abd91ad Mon Sep 17 00:00:00 2001 From: JystBreisgau Date: Tue, 11 Aug 2026 11:39:41 +0200 Subject: [PATCH 05/13] Update glossary.po . deleting errors in text formatting --- glossary.po | 401 ++++++++++++++++++++++++++-------------------------- 1 file changed, 200 insertions(+), 201 deletions(-) diff --git a/glossary.po b/glossary.po index 4f4ce7d..39448ab 100644 --- a/glossary.po +++ b/glossary.po @@ -73,7 +73,7 @@ msgid "" "module), import finders and loaders (in the :mod:`importlib.abc` module). " "You can create your own ABCs with the :mod:`abc` module." msgstr "" -"Abstrakte Basisklassen ergänzen :term:`Duck-Typing`, indem sie eine " +"Abstrakte Basisklassen (abstract base class / ABC) ergänzen :term:`Duck-Typing`, indem sie eine " "Möglichkeit bieten, Schnittstellen zu definieren, wenn andere Techniken wie " ":func:`hasattr` umständlich oder in subtiler Weise falsch wären (zum " "Beispiel bei :ref:`magischen Methoden `). ABCs führen " @@ -120,10 +120,9 @@ msgid "" "classes, and functions, respectively." msgstr "" "Auf Annotationen lokaler Variablen kann zur Laufzeit nicht zugegriffen " -"werden, doch Annotationen globaler Variablen, Klassenattribute und " -"Funktionen lassen sich durch Aufruf von ` " -":func:`annotationlib.get_annotations` ` für Module, Klassen bzw. Funktionen " -"abrufen." +"werden, doch Annotationen globaler Variablen, Klassenattribute und Funktionen " +"lassen sich durch Aufruf von :func:`annotationlib.get_annotations` für Module, " +"Klassen bzw. Funktionen abrufen." msgid "" "See :term:`variable annotation`, :term:`function annotation`, :pep:`484`, :" @@ -152,10 +151,10 @@ msgid "" "following calls to :func:`complex`::" msgstr "" ":dfn:`Schlüsselwortargument`: Ein Argument, dem in einem Funktionsaufruf ein" -" Bezeichner vorangestellt ist (z. B. ` ``name=```) oder das in einem " -"Wörterbuch als Wert übergeben wird, dem ` ``**``` vorangestellt ist. " -"Beispielsweise sind sowohl ` ``3`` ` als auch ` ``5`` ` " -"Schlüsselwortargumente in den folgenden Aufrufen von ` :func:`complex`` ::" +" Bezeichner vorangestellt ist (z. B. ``name=``) oder das in einem " +"Wörterbuch als Wert übergeben wird, dem ``**`` vorangestellt ist. " +"Beispielsweise sind sowohl ``3`` als auch ``5`` " +"Schlüsselwortargumente in den folgenden Aufrufen von :func:`complex` ::" msgid "" "complex(real=3, imag=5)\n" @@ -172,8 +171,8 @@ msgid "" msgstr "" ":dfn:`Positionsargument`: Ein Argument, das kein Schlüsselwortargument ist. " "Positionsargumente können am Anfang einer Argumentliste stehen und/oder als " -"Elemente eines :term:`iterable` übergeben werden, dem „ ``*`` “ " -"vorangestellt ist. Beispielsweise sind sowohl „ ``3`` “ als auch „ ``5`` “ " +"Elemente eines :term:`iterable` übergeben werden, dem ``*`` " +"vorangestellt ist. Beispielsweise sind sowohl ``3`` als auch ``5`` " "Positionsargumente in den folgenden Aufrufen::" msgid "" @@ -190,8 +189,8 @@ msgid "" "evaluated value is assigned to the local variable." msgstr "" "Argumente werden im Funktionskörper den benannten lokalen Variablen " -"zugewiesen. Die Regeln für diese Zuweisung finden Sie im Abschnitt „ " -":ref:`calls` “. Syntaktisch kann jeder Ausdruck zur Darstellung eines " +"zugewiesen. Die Regeln für diese Zuweisung finden Sie im Abschnitt " +":ref:`calls` . Syntaktisch kann jeder Ausdruck zur Darstellung eines " "Arguments verwendet werden; der ausgewertete Wert wird der lokalen Variablen" " zugewiesen." @@ -213,8 +212,8 @@ msgid "" "__aexit__` methods. Introduced by :pep:`492`." msgstr "" "Ein Objekt, das die in einer :keyword:`async with`-Anweisung angezeigte " -"Umgebung steuert, indem es die Methoden ` :meth:`~object.__aenter__` ` und `" -" :meth:`~object.__aexit__` ` definiert. Eingeführt durch :pep:`492`." +"Umgebung steuert, indem es die Methoden :meth:`~object.__aenter__` und " +" :meth:`~object.__aexit__` definiert. Eingeführt durch :pep:`492`." msgid "asynchronous generator" msgstr "asynchroner Generator" @@ -231,7 +230,7 @@ msgstr "" "Generatorfunktion` oder einen :term:`asynchronen Generator-Iterator` " "verwendet. Die formalen Begriffe :term:`asynchrone Generatorfunktion` und " ":term:`asynchroner Generator-Iterator` sind in der Praxis selten; " -"„asynchroner Generator“ allein reicht fast immer aus." +"\"asynchroner Generator\“ allein reicht fast immer aus." msgid "asynchronous generator function" msgstr "asynchrone Generatorfunktion" @@ -252,7 +251,7 @@ msgid "" "An asynchronous generator function may contain :keyword:`await` expressions " "as well as :keyword:`async for`, and :keyword:`async with` statements." msgstr "" -"Eine asynchrone Generatorfunktion kann sowohl : :keyword:`await` -Ausdrücke " +"Eine asynchrone Generatorfunktion kann sowohl :keyword:`await` -Ausdrücke " "als auch :keyword:`async for`- und :keyword:`async with`-Anweisungen " "enthalten." @@ -271,9 +270,9 @@ msgid "" "`yield` expression." msgstr "" "Dies ist ein :term:`asynchroner Iterator`, der beim Aufruf mit der Methode „" -" :meth:`~object.__anext__` “ ein „awaitable“-Objekt zurückgibt, das den " -"Körper der asynchronen Generatorfunktion bis zum nächsten „ :keyword:`yield`" -" “-Ausdruck ausführt." +" :meth:`~object.__anext__` ein „awaitable“-Objekt zurückgibt, das den " +"Körper der asynchronen Generatorfunktion bis zum nächsten :keyword:`yield`" +" -Ausdruck ausführt." msgid "" "Each :keyword:`yield` temporarily suspends processing, remembering the " @@ -282,11 +281,11 @@ msgid "" "awaitable returned by :meth:`~object.__anext__`, it picks up where it left " "off. See :pep:`492` and :pep:`525`." msgstr "" -"Jeder „ :keyword:`yield` “ unterbricht die Verarbeitung vorübergehend und " +"Jeder :keyword:`yield` unterbricht die Verarbeitung vorübergehend und " "speichert dabei den Ausführungsstatus (einschließlich lokaler Variablen und " -"ausstehender „try“-Anweisungen). Wenn der *asynchrone Generator-Iterator* " -"mit einem anderen von „ :meth:`~object.__anext__` “ zurückgegebenen " -"„awaitable“ effektiv fortgesetzt wird, setzt er die Ausführung an der Stelle" +"ausstehender \"try\“-Anweisungen). Wenn der *asynchrone Generator-Iterator* " +"mit einem anderen von :meth:`~object.__anext__` zurückgegebenen " +"\"awaitable\“ effektiv fortgesetzt wird, setzt er die Ausführung an der Stelle" " fort, an der er unterbrochen wurde. Siehe :pep:`492` und :pep:`525`." msgid "asynchronous iterable" @@ -311,10 +310,10 @@ msgid "" "an asynchronous iterator's :meth:`~object.__anext__` method until it raises " "a :exc:`StopAsyncIteration` exception. Introduced by :pep:`492`." msgstr "" -"Ein Objekt, das die Methoden ` :meth:`~object.__aiter__` ` und ` " -":meth:`~object.__anext__` ` implementiert. ` :meth:`~object.__anext__` ` " +"Ein Objekt, das die Methoden :meth:`~object.__aiter__` und " +":meth:`~object.__anext__` implementiert. :meth:`~object.__anext__` " "muss ein :term:`awaitable`-Objekt zurückgeben. :keyword:`async for` " -"verarbeitet die von der Methode ` :meth:`~object.__anext__` ` eines " +"verarbeitet die von der Methode :meth:`~object.__anext__` eines " "asynchronen Iterators zurückgegebenen `awaitables`, bis eine Ausnahme vom " "Typ ` :exc:`StopAsyncIteration` ` ausgelöst wird. Eingeführt durch " ":pep:`492`." @@ -334,7 +333,7 @@ msgstr "" "ausgeführt wird: Kein anderer Thread kann sie in einem unvollendeten Zustand" " beobachten, und ihre Auswirkungen werden auf einmal sichtbar. Python " "garantiert nicht, dass Anweisungen auf hoher Ebene atomar sind " -"(beispielsweise führt „ ``x += 1`` “ mehrere Bytecode-Operationen aus und " +"(beispielsweise führt ``x += 1`` mehrere Bytecode-Operationen aus und " "ist nicht atomar). Atomarität wird nur dort garantiert, wo dies " "ausdrücklich dokumentiert ist. Siehe auch :term:`Race Condition` und " ":term:`Data Race`." @@ -419,9 +418,9 @@ msgid "" "term:`coroutine` or an object with an :meth:`~object.__await__` method. See " "also :pep:`492`." msgstr "" -"Ein Objekt, das in einem Ausdruck vom Typ „ :keyword:`await` “ verwendet " +"Ein Objekt, das in einem Ausdruck vom Typ :keyword:`await` verwendet " "werden kann. Kann eine :term:`coroutine` oder ein Objekt mit einer Methode " -"vom Typ „ :meth:`~object.__await__` “ sein. Siehe auch :pep:`492`." +"vom Typ :meth:`~object.__await__` sein. Siehe auch :pep:`492`." msgid "BDFL" msgstr "BDFL" @@ -430,8 +429,8 @@ msgid "" "Benevolent Dictator For Life, a.k.a. `Guido van Rossum `_, Python's creator." msgstr "" -"„Wohltätiger Diktator auf Lebenszeit“, auch bekannt als „Guido van Rossum " -"`_ “, der Schöpfer von Python." +"Wohltätiger Diktator auf Lebenszeit, auch bekannt als Guido van Rossum +"`_ , der Schöpfer von Python." msgid "binary file" msgstr "Binärdatei" @@ -467,7 +466,7 @@ msgid "" msgstr "" "In der C-API von Python ist eine ausgeliehene Referenz eine Referenz auf ein" " Objekt, wobei der Code, der das Objekt verwendet, nicht Eigentümer der " -"Referenz ist. Sie wird zu einem „dangling pointer“, wenn das Objekt zerstört" +"Referenz ist. Sie wird zu einem dangling pointer, wenn das Objekt zerstört" " wird. Beispielsweise kann eine Garbage Collection die letzte :term:`starke " "Referenz` auf das Objekt entfernen und es so zerstören." @@ -478,11 +477,11 @@ msgid "" "func:`Py_NewRef` function can be used to create a new :term:`strong " "reference`." msgstr "" -"Es wird empfohlen, die Funktion ` :c:func:`Py_INCREF` ` auf die " +"Es wird empfohlen, die Funktion :c:func:`Py_INCREF` auf die " ":term:`geliehene Referenz` anzuwenden, um diese an Ort und Stelle in eine " ":term:`starke Referenz` umzuwandeln – es sei denn, das Objekt kann nicht vor" " der letzten Verwendung der geliehenen Referenz zerstört werden. Mit der " -"Funktion ` :c:func:`Py_NewRef` ` kann eine neue :term:`starke Referenz` " +"Funktion :c:func:`Py_NewRef` kann eine neue :term:`starke Referenz` " "erstellt werden." msgid "bytes-like object" @@ -496,11 +495,11 @@ msgid "" "with binary data; these include compression, saving to a binary file, and " "sending over a socket." msgstr "" -"Ein Objekt, das die Schnittstelle „ :ref:`bufferobjects` “ unterstützt und " +"Ein Objekt, das die Schnittstelle :ref:`bufferobjects` unterstützt und " "einen C-:term:`contiguous`-Puffer exportieren kann. Dazu gehören alle " -"Objekte vom Typ „ :class:`bytes` “, „ :class:`bytearray` “ und „ " -":class:`array.array` “ sowie viele gängige Objekte vom Typ „ " -":class:`memoryview` “. Bytes-ähnliche Objekte können für verschiedene " +"Objekte vom Typ :class:`bytes` , :class:`bytearray` und " +":class:`array.array` sowie viele gängige Objekte vom Typ " +":class:`memoryview` . Bytes-ähnliche Objekte können für verschiedene " "Operationen verwendet werden, die mit Binärdaten arbeiten; dazu gehören " "Komprimierung, das Speichern in einer Binärdatei und das Senden über einen " "Socket." @@ -514,13 +513,13 @@ msgid "" "include :class:`bytes` and a :class:`memoryview` of a :class:`bytes` object." msgstr "" "Bei einigen Operationen müssen die Binärdaten veränderbar sein. In der " -"Dokumentation werden diese häufig als „les- und schreibbare byteähnliche " -"Objekte“ bezeichnet. Beispiele für veränderbare Pufferobjekte sind „ " -":class:`bytearray` “ und ein „ :class:`memoryview` “ eines „ " -":class:`bytearray` “-Objekts. Andere Operationen erfordern, dass die " -"Binärdaten in unveränderbaren Objekten („read-only bytes-like objects“) " -"gespeichert werden; Beispiele hierfür sind „ :class:`bytes` “ und ein „ " -":class:`memoryview` “ eines „ :class:`bytes` “-Objekts." +"Dokumentation werden diese häufig als \"les- und schreibbare byteähnliche " +"Objekte\" bezeichnet. Beispiele für veränderbare Pufferobjekte sind " +":class:`bytearray` und ein :class:`memoryview` eines " +":class:`bytearray` -Objekts. Andere Operationen erfordern, dass die " +"Binärdaten in unveränderbaren Objekten (read-only bytes-like objects) " +"gespeichert werden; Beispiele hierfür sind :class:`bytes` und ein " +":class:`memoryview` eines :class:`bytes` -Objekts." msgid "bytecode" msgstr "Bytecode" @@ -536,10 +535,10 @@ msgid "" "between Python releases." msgstr "" "Python-Quellcode wird zu Bytecode kompiliert, der internen Darstellung eines" -" Python-Programms im CPython-Interpreter. Der Bytecode wird zudem in „ " -"``.pyc`` “-Dateien zwischengespeichert, sodass die Ausführung derselben " +" Python-Programms im CPython-Interpreter. Der Bytecode wird zudem in " +"``.pyc`` -Dateien zwischengespeichert, sodass die Ausführung derselben " "Datei beim zweiten Mal schneller erfolgt (eine Neukompilierung vom Quellcode" -" zum Bytecode kann vermieden werden). Diese „Zwischensprache“ läuft auf " +" zum Bytecode kann vermieden werden). Diese \"Zwischensprache\“ läuft auf " "einer :term:`virtuellen Maschine`, die den jedem Bytecode entsprechenden " "Maschinencode ausführt. Beachten Sie jedoch, dass Bytecodes nicht unbedingt " "zwischen verschiedenen virtuellen Python-Maschinen funktionieren und auch " @@ -572,8 +571,8 @@ msgid "" "also a callable." msgstr "" "Eine :term:`Funktion` und im weiteren Sinne auch eine :term:`Methode` ist " -"ein aufrufbares Objekt. Eine Instanz einer Klasse, die die Methode ` " -":meth:`~object.__call__` ` implementiert, ist ebenfalls ein aufrufbares " +"ein aufrufbares Objekt. Eine Instanz einer Klasse, die die Methode " +":meth:`~object.__call__` implementiert, ist ebenfalls ein aufrufbares " "Objekt." msgid "callback" @@ -621,7 +620,7 @@ msgstr "" "Gültigkeitsbereich` verwiesen wird und die in einem äußeren " "Gültigkeitsbereich definiert ist, anstatt zur Laufzeit aus den globalen oder" " integrierten Namensräumen aufgelöst zu werden. Sie kann explizit mit dem " -"Schlüsselwort „ :keyword:`nonlocal` “ definiert werden, um Schreibzugriff zu" +"Schlüsselwort :keyword:`nonlocal` definiert werden, um Schreibzugriff zu" " ermöglichen, oder implizit definiert werden, wenn die Variable nur gelesen " "wird." @@ -630,7 +629,7 @@ msgid "" "``print`` are :term:`free variables `, but only ``x`` is a " "*closure variable*::" msgstr "" -"Beispielsweise sind in der Funktion „ ``inner`` “ im folgenden Code sowohl " +"Beispielsweise sind in der Funktion ``inner`` im folgenden Code sowohl " "``x`` als auch ``print``:term:`freie Variablen `, aber nur " "``x`` ist eine *Closure-Variable*::" @@ -658,7 +657,7 @@ msgid "" "sometimes used even when the intended meaning is to refer specifically to " "closure variables." msgstr "" -"Aufgrund des Attributs „ :attr:`codeobject.co_freevars` “ (das trotz seines " +"Aufgrund des Attributs :attr:`codeobject.co_freevars` (das trotz seines " "Namens lediglich die Namen von Closure-Variablen enthält, anstatt alle " "referenzierten freien Variablen aufzulisten) wird der allgemeinere Begriff " ":term:`freie Variable` manchmal verwendet, selbst wenn eigentlich speziell " @@ -684,9 +683,9 @@ msgstr "" "Quadratwurzel von ``-1``), die in der Mathematik häufig als ``i`` und im " "Ingenieurwesen als ``j`` geschrieben werden. Python bietet integrierte " "Unterstützung für komplexe Zahlen, die in der letztgenannten Notation " -"geschrieben werden; der Imaginärteil wird mit dem Suffix „ ``j`` “ " +"geschrieben werden; der Imaginärteil wird mit dem Suffix ``j`` " "angegeben, z. B. „ ``3+1j`` “. Um auf die komplexen Entsprechungen des " -"Moduls „ :mod:`math` “ zuzugreifen, verwenden Sie „ :mod:`cmath` “. Die " +"Moduls :mod:`math` zuzugreifen, verwenden Sie :mod:`cmath` . Die " "Verwendung komplexer Zahlen ist eine recht fortgeschrittene mathematische " "Funktion. Wenn Sie keinen Bedarf dafür sehen, können Sie diese Funktionen " "mit ziemlicher Sicherheit getrost ignorieren." @@ -705,10 +704,10 @@ msgid "" msgstr "" "Die Fähigkeit eines Computerprogramms, mehrere Aufgaben gleichzeitig " "auszuführen. Python bietet Bibliotheken zum Schreiben von Programmen, die " -"verschiedene Formen der Parallelität nutzen. „ :mod:`asyncio` “ ist eine " -"Bibliothek für den Umgang mit asynchronen Aufgaben und Coroutinen. „ " -":mod:`threading` “ bietet Zugriff auf Betriebssystem-Threads und „ " -":mod:`multiprocessing` “ auf Betriebssystem-Prozesse. Multi-Core-Prozessoren" +"verschiedene Formen der Parallelität nutzen. :mod:`asyncio` ist eine " +"Bibliothek für den Umgang mit asynchronen Aufgaben und Coroutinen. " +":mod:`threading` bietet Zugriff auf Betriebssystem-Threads und " +":mod:`multiprocessing` auf Betriebssystem-Prozesse. Multi-Core-Prozessoren" " können Threads und Prozesse gleichzeitig auf verschiedenen CPU-Kernen " "ausführen (siehe :term:`Parallelität`)." @@ -742,7 +741,7 @@ msgid "" "via a :keyword:`with` statement." msgstr "" "Der temporäre Zustand oder die Umgebung, die von einem :term:`Context " -"Manager` über eine ` :keyword:`with` `-Anweisung eingerichtet wird." +"Manager` über eine :keyword:`with` -Anweisung eingerichtet wird." msgid "" "The collection of key­value bindings associated with a particular " @@ -758,7 +757,7 @@ msgstr "" msgid "" "A :class:`contextvars.Context` object. Also see :term:`current context`." msgstr "" -"Ein ` :class:`contextvars.Context` `-Objekt. Siehe auch: :term:`aktueller " +"Ein :class:`contextvars.Context` -Objekt. Siehe auch: :term:`aktueller " "Kontext`." msgid "context management protocol" @@ -768,8 +767,8 @@ msgid "" "The :meth:`~object.__enter__` and :meth:`~object.__exit__` methods called by" " the :keyword:`with` statement. See :pep:`343`." msgstr "" -"Die Methoden „ :meth:`~object.__enter__` “ und „ :meth:`~object.__exit__` “," -" die von der Anweisung „ :keyword:`with` “ aufgerufen werden. Siehe " +"Die Methoden :meth:`~object.__enter__` und :meth:`~object.__exit__` ," +" die von der Anweisung :keyword:`with` aufgerufen werden. Siehe " ":pep:`343`." msgid "context manager" @@ -795,7 +794,7 @@ msgid "" msgstr "" "Eine Variable, deren Wert davon abhängt, welcher Kontext gerade aktiv ist, " "wird als :term:`aktueller Kontext` bezeichnet. Der Zugriff auf die Werte " -"erfolgt über Objekte vom Typ „ :class:`contextvars.ContextVar` “. " +"erfolgt über Objekte vom Typ :class:`contextvars.ContextVar` . " "Kontextvariablen werden in erster Linie dazu verwendet, den Zustand zwischen" " parallel laufenden asynchronen Aufgaben zu isolieren." @@ -958,7 +957,7 @@ msgid "" "decorators are :deco:`classmethod` and :deco:`staticmethod`." msgstr "" "Eine Funktion, die eine andere Funktion zurückgibt und in der Regel als " -"Funktionstransformation mithilfe der Syntax „ ``@wrapper`` “ angewendet " +"Funktionstransformation mithilfe der Syntax ``@wrapper`` angewendet " "wird. Gängige Beispiele für Dekoratoren sind :deco:`classmethod` und " ":deco:`staticmethod`." @@ -1010,8 +1009,8 @@ msgid "" "basis for many features including functions, methods, properties, class " "methods, static methods, and reference to super classes." msgstr "" -"Jedes Objekt, das die Methoden „ :meth:`~object.__get__` “, „ " -":meth:`~object.__set__` “ oder „ :meth:`~object.__delete__` “ definiert. " +"Jedes Objekt, das die Methoden :meth:`~object.__get__` , " +":meth:`~object.__set__` oder :meth:`~object.__delete__` definiert. " "Wenn ein Klassenattribut ein Deskriptor ist, wird sein spezielles " "Bindungsverhalten bei der Attributsuche ausgelöst. Normalerweise wird bei " "der Verwendung von *a.b* zum Abrufen, Setzen oder Löschen eines Attributs " @@ -1038,8 +1037,8 @@ msgid "" "methods. Called a hash in Perl." msgstr "" "Ein assoziatives Array, bei dem beliebige Schlüssel Werten zugeordnet " -"werden. Die Schlüssel können beliebige Objekte sein, die über die Methoden „" -" :meth:`~object.__hash__` “ und „ :meth:`~object.__eq__` “ verfügen. In Perl" +"werden. Die Schlüssel können beliebige Objekte sein, die über die Methoden " +" :meth:`~object.__hash__` und :meth:`~object.__eq__` verfügen. In Perl" " wird dies als „Hash“ bezeichnet." msgid "dictionary comprehension" @@ -1053,7 +1052,7 @@ msgid "" msgstr "" "Eine kompakte Möglichkeit, alle oder einen Teil der Elemente eines " "iterierbaren Objekts zu verarbeiten und ein Wörterbuch mit den Ergebnissen " -"zurückzugeben. ` ``results = {n: n ** 2 for n in range(10)}`` ` generiert " +"zurückzugeben. ``results = {n: n ** 2 for n in range(10)}`` generiert " "ein Wörterbuch, das Schlüssel- ``n`` enthält, die den Wert- ``n ** 2`` " "zugeordnet sind. Siehe :ref:`comprehensions`." @@ -1067,13 +1066,13 @@ msgid "" "the view reflects these changes. To force the dictionary view to become a " "full list use ``list(dictview)``. See :ref:`dict-views`." msgstr "" -"Die Objekte, die von den Methoden „ :meth:`dict.keys` “, „ " -":meth:`dict.values` “ und „ :meth:`dict.items` “ zurückgegeben werden, " +"Die Objekte, die von den Methoden :meth:`dict.keys` , " +":meth:`dict.values` und :meth:`dict.items` zurückgegeben werden, " "werden als „Dictionary-Ansichten“ bezeichnet. Sie bieten eine dynamische " "Ansicht der Einträge im Dictionary, was bedeutet, dass sich Änderungen am " "Dictionary unmittelbar in der Ansicht widerspiegeln. Um die Dictionary-" -"Ansicht zwangsweise in eine vollständige Liste umzuwandeln, verwenden Sie „ " -"``list(dictview)`` “. Siehe :ref:`dict-views`." +"Ansicht zwangsweise in eine vollständige Liste umzuwandeln, verwenden Sie " +"``list(dictview)`` . Siehe :ref:`dict-views`." msgid "docstring" msgstr "docstring" @@ -1087,8 +1086,8 @@ msgid "" msgstr "" "Ein String-Literal, das als erster Ausdruck in einer Klasse, Funktion oder " "einem Modul erscheint. Es wird zwar bei der Ausführung der Testsuite " -"ignoriert, jedoch vom Compiler erkannt und in das Attribut „ " -":attr:`~definition.__doc__` “ der umschließenden Klasse, Funktion oder des " +"ignoriert, jedoch vom Compiler erkannt und in das Attribut " +":attr:`~definition.__doc__` der umschließenden Klasse, Funktion oder des " "Moduls übernommen. Da es über Introspektion verfügbar ist, stellt es den " "kanonischen Ort für die Dokumentation des Objekts dar." @@ -1108,14 +1107,14 @@ msgid "" msgstr "" "Ein Programmierstil, bei dem nicht der Typ eines Objekts herangezogen wird, " "um festzustellen, ob es über die richtige Schnittstelle verfügt; stattdessen" -" wird die Methode oder das Attribut einfach aufgerufen bzw. verwendet („Wenn" +" wird die Methode oder das Attribut einfach aufgerufen bzw. verwendet (\"Wenn" " es wie eine Ente aussieht und wie eine Ente quakt, muss es eine Ente " -"sein.“) Durch die Betonung von Schnittstellen anstelle spezifischer Typen " +"sein.\“) Durch die Betonung von Schnittstellen anstelle spezifischer Typen " "verbessert gut gestalteter Code seine Flexibilität, indem er polymorphe " -"Substitution ermöglicht. Duck-Typing vermeidet Tests mit „ :func:`type` “ " -"oder „ :func:`isinstance` “. (Beachten Sie jedoch, dass Duck-Typing durch " +"Substitution ermöglicht. Duck-Typing vermeidet Tests mit :func:`type` " +"oder :func:`isinstance` . (Beachten Sie jedoch, dass Duck-Typing durch " ":term:`abstrakte Basisklassen ` ergänzt werden kann.) " -"Stattdessen werden typischerweise „ :func:`hasattr` “-Tests oder " +"Stattdessen werden typischerweise :func:`hasattr` -Tests oder " ":term:`EAFP`-Programmierung eingesetzt." msgid "dunder" @@ -1126,9 +1125,9 @@ msgid "" ":term:`special method`. For example, ``__init__`` is often pronounced " "\"dunder init\"." msgstr "" -"Eine umgangssprachliche Abkürzung für „doppelter Unterstrich“, die verwendet" +"Eine umgangssprachliche Abkürzung für \"doppelter Unterstrich\“, die verwendet" " wird, wenn von einer :term:`speziellen Methode` die Rede ist. So wird " -"beispielsweise „ ``__init__`` “ oft als „dunder init“ ausgesprochen." +"beispielsweise ``__init__`` oft als \"dunder init\“ ausgesprochen." msgid "EAFP" msgstr "EAFP" @@ -1159,7 +1158,7 @@ msgid "" msgstr "" "Eine Funktion, die aufgerufen werden kann, um ein verzögert ausgewertetes " "Attribut eines Objekts zu berechnen, beispielsweise den Wert von Typaliasen," -" die mit der Anweisung „ :keyword:`type` “ erstellt wurden." +" die mit der Anweisung :keyword:`type` erstellt wurden." msgid "expression" msgstr "Ausdruck" @@ -1202,8 +1201,8 @@ msgid "" "\"f-strings\" which is short for :ref:`formatted string literals " "`. See also :pep:`498`." msgstr "" -"Zeichenfolgenliterale, denen „ ``f`` “ oder „ ``F`` “ vorangestellt ist, " -"werden gemeinhin als „f-Strings“ bezeichnet, was die Abkürzung für " +"Zeichenfolgenliterale, denen ``f`` oder ``F`` vorangestellt ist, " +"werden gemeinhin als „\"f-Strings\“ bezeichnet, was die Abkürzung für " ":ref:`formatierte Zeichenfolgenliterale ` ist. Siehe auch " ":pep:`498`." @@ -1218,8 +1217,8 @@ msgid "" "input/output, in-memory buffers, sockets, pipes, etc.). File objects are " "also called :dfn:`file-like objects` or :dfn:`streams`." msgstr "" -"Ein Objekt, das eine dateiorientierte API (mit Methoden wie „ :meth:`!read` " -"“ oder „ :meth:`!write` “) für eine zugrunde liegende Ressource " +"Ein Objekt, das eine dateiorientierte API (mit Methoden wie :meth:`!read` " +" oder :meth:`!write` ) für eine zugrunde liegende Ressource " "bereitstellt. Je nach Art seiner Erstellung kann ein Dateiobjekt den " "Zugriff auf eine echte Datei auf der Festplatte oder auf eine andere Art von" " Speicher- oder Kommunikationsgerät vermitteln (z. B. " @@ -1237,8 +1236,8 @@ msgstr "" "Es gibt insgesamt drei Kategorien von Dateiobjekten: rohe " ":term:`Binärdateien `, gepufferte :term:`Binärdateien ` und :term:`Textdateien `. Ihre Schnittstellen sind im " -"Modul „ :mod:`io` “ definiert. Die übliche Vorgehensweise zum Erstellen " -"eines Dateiobjekts ist die Verwendung der Funktion „ :func:`open` “." +"Modul :mod:`io` definiert. Die übliche Vorgehensweise zum Erstellen " +"eines Dateiobjekts ist die Verwendung der Funktion :func:`open` ." msgid "file-like object" msgstr "dateiähnliches Objekt" @@ -1264,8 +1263,8 @@ msgid "" msgstr "" "Die Dateisystemkodierung muss gewährleisten, dass alle Bytes unter 128 " "erfolgreich dekodiert werden. Wenn die Dateisystemkodierung diese Garantie " -"nicht bieten kann, können API-Funktionen die Ausnahme „ :exc:`UnicodeError` " -"“ auslösen." +"nicht bieten kann, können API-Funktionen die Ausnahme :exc:`UnicodeError` " +" auslösen." msgid "" "The :func:`sys.getfilesystemencoding` and " @@ -1355,7 +1354,7 @@ msgid "" "using the :option:`--disable-gil` option before compilation." msgstr "" "Eine Version von :term:`CPython`, die :term:`Free Threading` unterstützt und" -" vor der Kompilierung mit der Option „ :option:`--disable-gil` “ " +" vor der Kompilierung mit der Option :option:`--disable-gil` " "konfiguriert wurde." msgid "See :ref:`freethreading-python-howto`." @@ -1376,7 +1375,7 @@ msgstr "" "`, eine freie Variable jede Variable, die in einem Namensraum " "verwendet wird und keine lokale Variable in diesem Namensraum ist. Ein " "Beispiel finden Sie unter :term:`Closure-Variable`. In der Praxis wird der " -"Begriff aufgrund des Namens des Attributs „ :attr:`codeobject.co_freevars` “" +"Begriff aufgrund des Namens des Attributs :attr:`codeobject.co_freevars` " " manchmal auch als Synonym für :term:`Closure-Variable` verwendet." msgid "function" @@ -1391,7 +1390,7 @@ msgstr "" "Eine Anweisungsfolge, die einen Wert an den Aufrufer zurückgibt. Ihr können " "zudem null oder mehr :term:`Argumente ` übergeben werden, die bei " "der Ausführung des Hauptteils verwendet werden können. Siehe auch " -":term:`Parameter`, :term:`Methode` sowie den Abschnitt „ :ref:`function` “." +":term:`Parameter`, :term:`Methode` sowie den Abschnitt :ref:`function` ." msgid "function annotation" msgstr "Funktionsanmerkung" @@ -1419,7 +1418,7 @@ msgstr "" msgid "Function annotation syntax is explained in section :ref:`function`." msgstr "" -"Die Syntax für Funktionsannotationen wird im Abschnitt „ :ref:`function` “ " +"Die Syntax für Funktionsannotationen wird im Abschnitt :ref:`function` " "erläutert." msgid "" @@ -1446,7 +1445,7 @@ msgstr "" "Eine :ref:`Future-Anweisung `, ``from __future__ import ``," " weist den Compiler an, das aktuelle Modul unter Verwendung einer Syntax " "oder Semantik zu kompilieren, die in einer zukünftigen Version von Python " -"zum Standard werden wird. Das Modul „ :mod:`__future__` “ dokumentiert die " +"zum Standard werden wird. Das Modul :mod:`__future__` dokumentiert die " "möglichen Werte von *feature*. Durch Importieren dieses Moduls und Auswerten" " seiner Variablen können Sie sehen, wann eine neue Funktion erstmals in die " "Sprache aufgenommen wurde und wann sie zur Standardeinstellung wird (oder " @@ -1473,7 +1472,7 @@ msgstr "" "Der Vorgang, bei dem Speicher freigegeben wird, wenn er nicht mehr benötigt " "wird. Python führt die Speicherbereinigung mithilfe der Referenzzählung und " "eines zyklischen Garbage Collectors durch, der Referenzzyklen erkennen und " -"auflösen kann. Der Garbage Collector lässt sich über das Modul „ :mod:`gc` “" +"auflösen kann. Der Garbage Collector lässt sich über das Modul :mod:`gc` " " steuern." msgid "generator" @@ -1488,7 +1487,7 @@ msgstr "" "Wird umgangssprachlich je nach Kontext entweder für eine " ":term:`Generatorfunktion` oder einen :term:`Generator-Iterator` verwendet. " "Die formalen Begriffe :term:`Generatorfunktion` und :term:`Generator-" -"Iterator` sind in der Praxis selten; der Begriff „Generator“ allein reicht " +"Iterator` sind in der Praxis selten; der Begriff \"Generator\“ allein reicht " "fast immer aus." msgid "generator function" @@ -1502,8 +1501,8 @@ msgid "" ":ref:`yieldexpr`." msgstr "" "Eine Funktion, die ein :term:`generator`-Objekt zurückgibt. Sie sieht wie " -"eine normale Funktion aus, enthält jedoch Ausdrücke vom Typ „ " -":keyword:`yield` “, um eine Reihe von Werten zu erzeugen, die in einer " +"eine normale Funktion aus, enthält jedoch Ausdrücke vom Typ " +":keyword:`yield` , um eine Reihe von Werten zu erzeugen, die in einer " ":keyword:`for`\\-Schleife verwendet oder mit der Funktion :func:`next` " "einzeln abgerufen werden können. Siehe :ref:`yieldexpr`." @@ -1523,9 +1522,9 @@ msgid "" " the *generator iterator* resumes, it picks up where it left off (in " "contrast to functions which start fresh on every invocation)." msgstr "" -"Jeder „ :keyword:`yield` “ unterbricht die Verarbeitung vorübergehend und " +"Jeder :keyword:`yield` unterbricht die Verarbeitung vorübergehend und " "speichert dabei den Ausführungszustand (einschließlich lokaler Variablen und" -" ausstehender „try“-Anweisungen). Wenn der *Generator-Iterator* fortgesetzt " +" ausstehender try-Anweisungen). Wenn der *Generator-Iterator* fortgesetzt " "wird, setzt er dort fort, wo er aufgehört hat (im Gegensatz zu Funktionen, " "die bei jedem Aufruf von vorne beginnen)." @@ -1535,9 +1534,9 @@ msgid "" "method to raise an exception at the point where the generator was paused. " "See :ref:`generator-methods`." msgstr "" -"Generator-Iteratoren implementieren außerdem die Methode „ " -":meth:`~generator.send` “, um einen Wert an den angehaltenen Generator zu " -"übergeben, sowie die Methode „ :meth:`~generator.throw` “, um an der Stelle," +"Generator-Iteratoren implementieren außerdem die Methode " +":meth:`~generator.send` , um einen Wert an den angehaltenen Generator zu " +"übergeben, sowie die Methode :meth:`~generator.throw` , um an der Stelle," " an der der Generator angehalten wurde, eine Ausnahme auszulösen. Siehe " ":ref:`generator-methods`." @@ -1601,8 +1600,8 @@ msgid "" ":pep:`483`, :pep:`484`, :pep:`585`, and the :mod:`typing` module." msgstr "" "Weitere Informationen finden Sie unter :ref:`generische Alias-Typen`, :pep:`483`, :pep:`484`, :pep:`585` sowie im Modul „ " -":mod:`typing` “." +"genericalias>`, :pep:`483`, :pep:`484`, :pep:`585` sowie im Modul " +":mod:`typing` ." msgid "GIL" msgstr "GIL" @@ -1650,8 +1649,8 @@ msgid "" "performance for multi-threaded applications and makes it easier to use " "multi-core CPUs efficiently. For more details, see :pep:`703`." msgstr "" -"Ab Python 3.13 kann der GIL mithilfe der Build-Konfiguration „ " -":option:`--disable-gil` “ deaktiviert werden. Nach dem Kompilieren von " +"Ab Python 3.13 kann der GIL mithilfe der Build-Konfiguration " +":option:`--disable-gil` deaktiviert werden. Nach dem Kompilieren von " "Python mit dieser Option muss der Code mit der Option :option:`-X gil=0 " "<-X>` ` ausgeführt werden oder nachdem die Umgebungsvariable " ":envvar:`PYTHON_GIL=0 ` ` gesetzt wurde. Diese Funktion " @@ -1734,7 +1733,7 @@ msgstr "" "unveränderliche Container (wie Tupel und FrozenSets) sind nur dann hashbar, " "wenn ihre Elemente hashbar sind. Objekte, die Instanzen benutzerdefinierter" " Klassen sind, sind standardmäßig hashbar. Sie sind alle ungleich (außer mit" -" sich selbst), und ihr Hash-Wert wird aus ihrem „ :func:`id` “ abgeleitet." +" sich selbst), und ihr Hash-Wert wird aus ihrem :func:`id` abgeleitet." msgid "IDLE" msgstr "LEERLAUF" @@ -1744,7 +1743,7 @@ msgid "" "is a basic editor and interpreter environment which ships with the standard " "distribution of Python." msgstr "" -"Eine integrierte Entwicklungs- und Lernumgebung für Python. „ :ref:`idle` “ " +"Eine integrierte Entwicklungs- und Lernumgebung für Python. :ref:`idle` " "ist eine einfache Editor- und Interpreter-Umgebung, die im Lieferumfang der " "Standarddistribution von Python enthalten ist." @@ -1765,8 +1764,8 @@ msgid "" msgstr "" "Ist ein Objekt unsterblich, wird seine :term:`Referenzanzahl` niemals " "geändert, sodass es während der Laufzeit des Interpreters niemals " -"freigegeben wird. Beispielsweise sind „ :const:`True` “ und „ :const:`None` " -"“ in CPython unsterblich." +"freigegeben wird. Beispielsweise sind :const:`True` und :const:`None` " +" in CPython unsterblich." msgid "" "Immortal objects can be identified via :func:`sys._is_immortal`, or via " @@ -1846,8 +1845,8 @@ msgid "" "In Python, indexing starts at zero. For example, ``things[0]`` names the " "*first* element of ``things``; ``things[1]`` names the second one." msgstr "" -"In Python beginnt die Indizierung bei Null. So bezeichnet beispielsweise „ " -"``things[0]`` “ das *erste* Element von „ ``things`` “; „ ``things[1]`` “ " +"In Python beginnt die Indizierung bei Null. So bezeichnet beispielsweise " +"``things[0]`` das *erste* Element von ``things`` ; ``things[1]`` " "bezeichnet das zweite Element." msgid "" @@ -1875,7 +1874,7 @@ msgstr "" "Python verfügt über einen interaktiven Interpreter, d. h., Sie können " "Anweisungen und Ausdrücke an der Interpreter-Eingabeaufforderung eingeben, " "diese sofort ausführen und die Ergebnisse anzeigen lassen. Starten Sie " -"einfach „ ``python`` “ ohne Argumente (z. B. über das Hauptmenü Ihres " +"einfach ``python`` ohne Argumente (z. B. über das Hauptmenü Ihres " "Computers). Dies ist eine sehr leistungsstarke Methode, um neue Ideen " "auszuprobieren oder Module und Pakete zu untersuchen (siehe auch " "``help(x)``). Weitere Informationen zum interaktiven Modus finden Sie unter " @@ -1929,8 +1928,8 @@ msgid "" "The main reason for interpreter shutdown is that the ``__main__`` module or " "the script being run has finished executing." msgstr "" -"Der Hauptgrund für das Beenden des Interpreters ist, dass das Modul „ " -"``__main__`` “ oder das ausgeführte Skript die Ausführung abgeschlossen hat." +"Der Hauptgrund für das Beenden des Interpreters ist, dass das Modul " +"``__main__`` oder das ausgeführte Skript die Ausführung abgeschlossen hat." msgid "iterable" msgstr "iterierbar" @@ -1963,10 +1962,10 @@ msgid "" "temporary unnamed variable to hold the iterator for the duration of the " "loop. See also :term:`iterator`, :term:`sequence`, and :term:`generator`." msgstr "" -"Iterables können in einer „ :keyword:`for` “-Schleife und an vielen anderen " +"Iterables können in einer :keyword:`for` -Schleife und an vielen anderen " "Stellen verwendet werden, an denen eine Sequenz benötigt wird (:func:`zip`, " ":func:`map`, …). Wenn ein iterierbares Objekt als Argument an die " -"integrierte Funktion „ :func:`iter` “ übergeben wird, gibt diese einen " +"integrierte Funktion :func:`iter` übergeben wird, gibt diese einen " "Iterator für das Objekt zurück. Dieser Iterator reicht für einen Durchlauf " "durch die Wertemenge aus. Bei der Verwendung von Iterables ist es in der " "Regel nicht notwendig, ` :func:`iter` ` aufzurufen oder sich selbst um " @@ -1995,10 +1994,10 @@ msgid "" " the previous iteration pass, making it appear like an empty container." msgstr "" "Ein Objekt, das einen Datenstrom darstellt. Wiederholte Aufrufe der Methode " -"„ :meth:`~iterator.__next__` “ des Iterators (oder die Übergabe an die " -"integrierte Funktion „ :func:`next` “) geben aufeinanderfolgende Elemente " +" :meth:`~iterator.__next__` des Iterators (oder die Übergabe an die " +"integrierte Funktion :func:`next` ) geben aufeinanderfolgende Elemente " "des Datenstroms zurück. Sind keine Daten mehr verfügbar, wird stattdessen " -"die Ausnahme „ :exc:`StopIteration` “ ausgelöst. Zu diesem Zeitpunkt ist " +"die Ausnahme :exc:`StopIteration` ausgelöst. Zu diesem Zeitpunkt ist " "das Iterator-Objekt erschöpft, und weitere Aufrufe seiner Methode ` " ":meth:`!__next__` ` lösen lediglich erneut eine ` :exc:`StopIteration` " "`-Ausnahme aus. Iteratoren müssen über eine Methode ` " @@ -2048,7 +2047,7 @@ msgid "" msgstr "" "Eine Schlüsselfunktion oder Sortierfunktion ist ein aufrufbares Objekt, das " "einen Wert zurückgibt, der zum Sortieren oder Ordnen verwendet wird. " -"Beispielsweise wird „ :func:`locale.strxfrm` “ verwendet, um einen " +"Beispielsweise wird :func:`locale.strxfrm` verwendet, um einen " "Sortierschlüssel zu erzeugen, der die lokalspezifischen Sortierkonventionen " "berücksichtigt." @@ -2060,9 +2059,9 @@ msgid "" msgstr "" "Eine Reihe von Tools in Python unterstützt Schlüssel-Funktionen, mit denen " "sich die Anordnung oder Gruppierung von Elementen steuern lässt. Dazu " -"gehören „ :func:`min` “, „ :func:`max` “, „ :func:`sorted` “, „ " -":meth:`list.sort` “, „ :func:`heapq.merge` “, „ :func:`heapq.nsmallest` “, „" -" :func:`heapq.nlargest` “ und „ :func:`itertools.groupby` “." +"gehören :func:`min` , :func:`max` , :func:`sorted` , " +":meth:`list.sort` , :func:`heapq.merge` , :func:`heapq.nsmallest` , " +" :func:`heapq.nlargest` und :func:`itertools.groupby` ." msgid "" "There are several ways to create a key function. For example. the " @@ -2075,10 +2074,10 @@ msgid "" "key functions." msgstr "" "Es gibt verschiedene Möglichkeiten, eine Schlüsselfunktion zu erstellen. " -"Beispielsweise kann die Methode „ :meth:`str.casefold` “ als " +"Beispielsweise kann die Methode :meth:`str.casefold` als " "Schlüsselfunktion für die Sortierung ohne Berücksichtigung der " "Groß-/Kleinschreibung dienen. Alternativ kann eine Schlüsselfunktion aus " -"einem Ausdruck vom Typ „ :keyword:`lambda` “ erstellt werden, wie " +"einem Ausdruck vom Typ :keyword:`lambda` erstellt werden, wie " "beispielsweise ``lambda r: (r[0], r[2])``. Außerdem sind " ":func:`operator.attrgetter`, :func:`operator.itemgetter` und " ":func:`operator.methodcaller` drei Konstruktoren für Schlüsselfunktionen. " @@ -2127,9 +2126,9 @@ msgid "" ":term:`EAFP` approach. See also :term:`thread-safe`." msgstr "" "In einer Multithread-Umgebung besteht bei dem LBYL-Ansatz die Gefahr, dass " -"eine :term:`Race Condition` zwischen dem „Nachschlagen“ und dem „Springen“ " -"entsteht. Beispielsweise kann der Code „ ``if key in mapping: return " -"mapping[key]`` “ fehlschlagen, wenn ein anderer Thread *key* nach dem Test, " +"eine :term:`Race Condition` zwischen dem \"Nachschlagen\“ und dem \"Springen\“ " +"entsteht. Beispielsweise kann der Code ``if key in mapping: return " +"mapping[key]`` fehlschlagen, wenn ein anderer Thread *key* nach dem Test, " "aber vor der Suche aus *mapping* entfernt. Dieses Problem lässt sich mit " ":term:`Locks ` oder durch Verwendung des :term:`EAFP`-Ansatzes lösen. " "Siehe auch :term:`thread-safe`." @@ -2163,11 +2162,11 @@ msgid "" "optional. If omitted, all elements in ``range(256)`` are processed." msgstr "" "Eine kompakte Möglichkeit, alle oder einen Teil der Elemente einer Sequenz " -"zu verarbeiten und eine Liste mit den Ergebnissen zurückzugeben. „ ``result" -" = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0]`` “ generiert " +"zu verarbeiten und eine Liste mit den Ergebnissen zurückzugeben. ``result" +" = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0]`` generiert " "eine Liste von Zeichenketten, die gerade Hexadezimalzahlen (0x..) im Bereich" -" von 0 bis 255 enthalten. Die Klausel „ :keyword:`if` “ ist optional. Wird " -"sie weggelassen, werden alle Elemente in „ ``range(256)`` “ verarbeitet." +" von 0 bis 255 enthalten. Die Klausel :keyword:`if` ist optional. Wird " +"sie weggelassen, werden alle Elemente in ``range(256)`` verarbeitet." msgid "lock" msgstr "Schloss" @@ -2190,9 +2189,9 @@ msgstr "" " vor dem Zugriff auf die geschützte Ressource eine Sperre erwerben und diese" " anschließend wieder freigeben. Versucht ein Thread, eine Sperre zu " "erwerben, die bereits von einem anderen Thread gehalten wird, wird er " -"blockiert, bis die Sperre verfügbar wird. Das Python-Modul „ " -":mod:`threading` “ stellt „ :class:`~threading.Lock` “ (eine einfache " -"Sperre) und „ :class:`~threading.RLock` “ (eine :term:`reentrante` Sperre) " +"blockiert, bis die Sperre verfügbar wird. Das Python-Modul " +":mod:`threading` stellt :class:`~threading.Lock` (eine einfache " +"Sperre) und :class:`~threading.RLock` (eine :term:`reentrante` Sperre) " "bereit. Sperren werden verwendet, um :term:`Race-Conditions ` zu verhindern und einen :term:`thread-safe` Zugriff auf " "gemeinsam genutzte Daten zu gewährleisten. Es gibt alternative " @@ -2261,7 +2260,7 @@ msgstr "Unter Windows ist dies die ANSI-Codepage (z. B.: ``\"cp1252\"``)." msgid "On Android and VxWorks, Python uses ``\"utf-8\"`` as the locale encoding." msgstr "" -"Unter Android und VxWorks verwendet Python „ ``\"utf-8\"`` “ als Locale-" +"Unter Android und VxWorks verwendet Python ``\"utf-8\"`` als Locale-" "Kodierung." msgid ":func:`locale.getencoding` can be used to get the locale encoding." @@ -2357,8 +2356,8 @@ msgid "" msgstr "" "Eine Funktion, die innerhalb des Klassenkörpers definiert ist. Wird sie als " "Attribut einer Instanz dieser Klasse aufgerufen, erhält die Methode das " -"Instanzobjekt als erstes :term:`Argument` (das üblicherweise als „ ``self`` " -"“ bezeichnet wird). Siehe :term:`function` und :term:`nested scope`." +"Instanzobjekt als erstes :term:`Argument` (das üblicherweise als ``self`` " +" bezeichnet wird). Siehe :term:`function` und :term:`nested scope`." msgid "method resolution order" msgstr "Reihenfolge der Methodenauflösung" @@ -2433,8 +2432,8 @@ msgid "" "tuple and whose indexable elements are also accessible using named " "attributes. The type or class may have other features as well." msgstr "" -"Der Begriff „benanntes Tupel“ bezieht sich auf jeden Typ oder jede Klasse, " -"die von „Tupel“ erbt und deren indizierbare Elemente auch über benannte " +"Der Begriff „\"benanntes Tupel\“ bezieht sich auf jeden Typ oder jede Klasse, " +"die von \"Tupel\“ erbt und deren indizierbare Elemente auch über benannte " "Attribute zugänglich sind. Der Typ oder die Klasse kann darüber hinaus noch " "weitere Merkmale aufweisen." @@ -2520,7 +2519,7 @@ msgstr "" "Ein :term:`Paket`, das ausschließlich als Container für Unterpakete dient. " "Namespace-Pakete haben möglicherweise keine physische Darstellung und " "unterscheiden sich insbesondere von einem :term:`normalen Paket`, da sie " -"keine Datei „ ``__init__.py`` “ enthalten." +"keine Datei ``__init__.py`` enthalten." msgid "" "Namespace packages allow several individually installable packages to have a" @@ -2552,8 +2551,8 @@ msgid "" msgstr "" "Code, der zu Maschinenbefehlen kompiliert wird und direkt auf dem Prozessor " "ausgeführt wird, im Gegensatz zu Code, der interpretiert wird oder in einer " -"virtuellen Maschine läuft. Im Zusammenhang mit Python bezieht sich „nativer" -" Code“ in der Regel auf C-, C++-, Rust- oder Fortran-Code in " +"virtuellen Maschine läuft. Im Zusammenhang mit Python bezieht sich \"nativer" +" Code\“ in der Regel auf C-, C++-, Rust- oder Fortran-Code in " ":term:`Erweiterungsmodulen `, der von Python aus " "aufgerufen werden kann. Siehe auch :term:`Erweiterungsmodul`." @@ -2574,8 +2573,8 @@ msgstr "" "Beachten Sie, dass verschachtelte Gültigkeitsbereiche standardmäßig nur für " "Verweise und nicht für Zuweisungen gelten. Lokale Variablen lesen und " "schreiben im innersten Gültigkeitsbereich. Ebenso lesen und schreiben " -"globale Variablen im globalen Namensraum. Die Anweisung „ " -":keyword:`nonlocal` “ ermöglicht das Schreiben in äußere " +"globale Variablen im globalen Namensraum. Die Anweisung " +":keyword:`nonlocal` ermöglicht das Schreiben in äußere " "Gültigkeitsbereiche." msgid "new-style class" @@ -2587,11 +2586,11 @@ msgid "" "versatile features like :attr:`~object.__slots__`, descriptors, properties, " ":meth:`~object.__getattribute__`, class methods, and static methods." msgstr "" -"Alte Bezeichnung für den „Flavor“ von Klassen, der nun für alle " +"Alte Bezeichnung für den \"Flavor\“ von Klassen, der nun für alle " "Klassenobjekte verwendet wird. In früheren Python-Versionen konnten nur " "Klassen des neuen Stils die neueren, vielseitigen Funktionen von Python " -"nutzen, wie beispielsweise „ :attr:`~object.__slots__` “, Deskriptoren, " -"Eigenschaften, „ :meth:`~object.__getattribute__` “, Klassenmethoden und " +"nutzen, wie beispielsweise :attr:`~object.__slots__` , Deskriptoren, " +"Eigenschaften, :meth:`~object.__getattribute__` , Klassenmethoden und " "statische Methoden." msgid "non-deterministic" @@ -2677,7 +2676,7 @@ msgid "" msgstr "" "Ein Python-:term:`Modul`, das Untermodule oder – rekursiv – Unterpakete " "enthalten kann. Technisch gesehen ist ein Paket ein Python-Modul mit einem " -"Attribut vom Typ „ ``__path__`` “." +"Attribut vom Typ ``__path__`` ." msgid "See also :term:`regular package` and :term:`namespace package`." msgstr "Siehe auch :term:`reguläres Paket` und :term:`Namensraum-Paket`." @@ -2739,7 +2738,7 @@ msgstr "" ":dfn:`positional-only`: Gibt ein Argument an, das nur über die Position " "übergeben werden kann. Parameter, die ausschließlich über die Position " "übergeben werden können, lassen sich definieren, indem man in der " -"Parameterliste der Funktionsdefinition hinter ihnen das Zeichen „ ``/`` “ " +"Parameterliste der Funktionsdefinition hinter ihnen das Zeichen ``/`` " "einfügt, zum Beispiel *posonly1* und *posonly2* im folgenden Beispiel::" msgid "def func(posonly1, posonly2, /, positional_or_keyword): ..." @@ -2772,8 +2771,8 @@ msgstr "" ":dfn:`var-positional`: Gibt an, dass eine beliebige Folge von " "Positionsargumenten angegeben werden kann (zusätzlich zu den " "Positionsargumenten, die bereits von anderen Parametern akzeptiert werden). " -"Ein solcher Parameter kann definiert werden, indem dem Parameternamen „ " -"``*`` “ vorangestellt wird, zum Beispiel *args* im folgenden Beispiel::" +"Ein solcher Parameter kann definiert werden, indem dem Parameternamen " +"``*`` vorangestellt wird, zum Beispiel *args* im folgenden Beispiel::" msgid "def func(*args, **kwargs): ..." msgstr "def func(*args, **kwargs): ..." @@ -2787,7 +2786,7 @@ msgstr "" ":dfn:`var-keyword`: Gibt an, dass beliebig viele Schlüsselwortargumente " "angegeben werden können (zusätzlich zu den Schlüsselwortargumenten, die " "bereits von anderen Parametern akzeptiert werden). Ein solcher Parameter " -"kann definiert werden, indem dem Parameternamen „ ``**`` “ vorangestellt " +"kann definiert werden, indem dem Parameternamen ``**`` vorangestellt " "wird, beispielsweise *kwargs* im obigen Beispiel." msgid "" @@ -2867,7 +2866,7 @@ msgid "" "entry finder` if it knows how to find modules on a specific :term:`path " "entry`." msgstr "" -"Eine auf der Liste „ :data:`sys.path_hooks` “ aufrufbare Funktion, die einen" +"Eine auf der Liste :data:`sys.path_hooks` aufrufbare Funktion, die einen" " :term:`Pfadeintrag-Finder` zurückgibt, sofern sie weiß, wie Module auf " "einem bestimmten :term:`Pfadeintrag` gefunden werden können." @@ -2895,14 +2894,14 @@ msgid "" ":pep:`519`." msgstr "" "Ein Objekt, das einen Dateisystempfad darstellt. Ein pfadähnliches Objekt " -"ist entweder ein „ :class:`str` “- oder ein „ :class:`bytes` “-Objekt, das " -"einen Pfad darstellt, oder ein Objekt, das das „ :class:`os.PathLike` " -"“-Protokoll implementiert. Ein Objekt, das das „ :class:`os.PathLike` " -"“-Protokoll unterstützt, kann durch Aufruf der Funktion „ :func:`os.fspath` " -"“ in einen „ :class:`str` “- oder „ :class:`bytes` “-Dateisystempfad " -"umgewandelt werden; mit „ :func:`os.fsdecode` “ bzw. „ :func:`os.fsencode` “" -" lässt sich stattdessen ein „ :class:`str` “- bzw. „ :class:`bytes` " -"“-Ergebnis gewährleisten. Eingeführt durch „ :pep:`519` “." +"ist entweder ein :class:`str` - oder ein :class:`bytes` -Objekt, das " +"einen Pfad darstellt, oder ein Objekt, das das :class:`os.PathLike` " +"-Protokoll implementiert. Ein Objekt, das das :class:`os.PathLike` " +"-Protokoll unterstützt, kann durch Aufruf der Funktion :func:`os.fspath` " +" in einen :class:`str` - oder :class:`bytes` -Dateisystempfad " +"umgewandelt werden; mit :func:`os.fsdecode` bzw. :func:`os.fsencode` " +" lässt sich stattdessen ein :class:`str` - bzw. :class:`bytes` " +"-Ergebnis gewährleisten. Eingeführt durch :pep:`519` ." msgid "PEP" msgstr "PEP" @@ -3006,7 +3005,7 @@ msgid "" msgstr "" "Spitzname für die Python-3.x-Versionsreihe (der vor langer Zeit geprägt " "wurde, als die Veröffentlichung von Version 3 noch in ferner Zukunft lag). " -"Er wird auch mit „Py3k“ abgekürzt." +"Er wird auch mit \"Py3k\“ abgekürzt." msgid "Pythonic" msgstr "Pythonesk" @@ -3024,7 +3023,7 @@ msgstr "" "Verwendung von Konzepten zu implementieren, die in anderen Sprachen üblich " "sind. Ein gängiges Beispiel in Python ist beispielsweise die " "Durchlaufschleife über alle Elemente eines iterierbaren Objekts mithilfe " -"einer „ :keyword:`for` “-Anweisung. Viele andere Sprachen verfügen nicht " +"einer :keyword:`for` -Anweisung. Viele andere Sprachen verfügen nicht " "über eine solche Konstruktion, sodass Personen, die mit Python nicht " "vertraut sind, manchmal stattdessen einen numerischen Zähler verwenden::" @@ -3036,13 +3035,13 @@ msgstr "" " print(food[i])" msgid "As opposed to the cleaner, Pythonic method::" -msgstr "Im Gegensatz zu der übersichtlicheren, „pythonesken“ Methode::" +msgstr "Im Gegensatz zu der übersichtlicheren, pythonesken Methode::" msgid "" "for piece in food:\n" " print(piece)" msgstr "" -"für „Stück“ in „Essen“:\n" +"für Stück in Essen:\n" " print(Stück)" msgid "qualified name" @@ -3054,7 +3053,7 @@ msgid "" "top-level functions and classes, the qualified name is the same as the " "object's name::" msgstr "" -"Ein gepunkteter Name, der den „Pfad“ vom globalen Gültigkeitsbereich eines " +"Ein gepunkteter Name, der den \"Pfad\“ vom globalen Gültigkeitsbereich eines " "Moduls zu einer in diesem Modul definierten Klasse, Funktion oder Methode " "angibt, wie in :pep:`3155` definiert. Bei Funktionen und Klassen der " "obersten Ebene entspricht der qualifizierte Name dem Namen des Objekts::" @@ -3203,10 +3202,10 @@ msgid "" "blocking. In contrast, :class:`threading.Lock` is not reentrant - " "attempting to acquire it twice from the same thread will cause a deadlock." msgstr "" -"Was Sperren betrifft, ist die Python-Sperre „ :class:`threading.RLock` “ " +"Was Sperren betrifft, ist die Python-Sperre :class:`threading.RLock` " "(Reentrant-Sperre) reentrant, was bedeutet, dass ein Thread, der die Sperre " "bereits hält, sie erneut erwerben kann, ohne zu blockieren. Im Gegensatz " -"dazu ist „ :class:`threading.Lock` “ nicht reentrant – der Versuch, sie " +"dazu ist :class:`threading.Lock` nicht reentrant – der Versuch, sie " "zweimal vom selben Thread aus zu erwerben, führt zu einem Deadlock." msgid "See also :term:`lock` and :term:`deadlock`." @@ -3219,7 +3218,7 @@ msgid "" "An acronym for the \"read–eval–print loop\", another name for the " ":term:`interactive` interpreter shell." msgstr "" -"Eine Abkürzung für „read–eval–print loop“ (Lesen–Auswerten–Ausgeben-" +"Eine Abkürzung für \"read–eval–print loop\“ (Lesen–Auswerten–Ausgeben-" "Schleife), eine andere Bezeichnung für die :term:`interaktive` Interpreter-" "Shell." @@ -3331,7 +3330,7 @@ msgid "" "already existing code to use it. The API remains documented and tested, but " "will not be enhanced further." msgstr "" -"Eine „soft deprecated“ API sollte in neuem Code nicht mehr verwendet werden," +"Eine soft deprecated API sollte in neuem Code nicht mehr verwendet werden," " bei bereits vorhandenem Code ist ihre Verwendung jedoch unbedenklich. Die " "API bleibt dokumentiert und wird weiterhin getestet, wird jedoch nicht mehr " "weiterentwickelt." @@ -3340,7 +3339,7 @@ msgid "" "Soft deprecation, unlike normal deprecation, does not plan on removing the " "API and will not emit warnings." msgstr "" -"Im Gegensatz zur normalen Veralterung ist bei einer „Soft Deprecation“ nicht" +"Im Gegensatz zur normalen Veralterung ist bei einer Soft Deprecation nicht" " vorgesehen, die API zu entfernen, und es werden keine Warnungen ausgegeben." msgid "" @@ -3396,10 +3395,10 @@ msgid "" " an :term:`expression` or one of several constructs with a keyword, such as " ":keyword:`if`, :keyword:`while` or :keyword:`for`." msgstr "" -"Eine Anweisung ist Teil einer Suite (eines „Code-Blocks“). Eine Anweisung " +"Eine Anweisung ist Teil einer Suite (eines \"Code-Blocks\“). Eine Anweisung " "ist entweder ein :term:`Ausdruck` oder eine von mehreren Konstrukten mit " -"einem Schlüsselwort, wie beispielsweise „ :keyword:`if` “, „ " -":keyword:`while` “ oder „ :keyword:`for` “." +"einem Schlüsselwort, wie beispielsweise :keyword:`if` , " +":keyword:`while` oder :keyword:`for` ." msgid "static type checker" msgstr "statischer Typprüfer" @@ -3411,7 +3410,7 @@ msgid "" msgstr "" "Ein externes Tool, das Python-Code ausliest und analysiert, um Probleme wie " "beispielsweise falsche Typen zu erkennen. Siehe auch :term:`Typangaben ` und das Modul „ :mod:`typing` “." +" hint>` und das Modul :mod:`typing` ." msgid "stdlib" msgstr "stdlib" @@ -3428,10 +3427,10 @@ msgid "" " reference after the call. Generally, functions that \"steal\" an argument " "do so even if they fail." msgstr "" -"In der C-API von Python bedeutet das „*Stehlen*“ eines Arguments, dass das " +"In der C-API von Python bedeutet das *Stehlen* eines Arguments, dass das " "Eigentumsrecht an dem Argument auf die aufgerufene Funktion übertragen wird." " Der Aufrufer darf diese Referenz nach dem Aufruf nicht mehr verwenden. Im " -"Allgemeinen tun Funktionen, die ein Argument „stehlen“, dies auch dann, wenn" +"Allgemeinen tun Funktionen, die ein Argument stehlen, dies auch dann, wenn" " sie fehlschlagen." msgid "See :ref:`api-refcountdetails` for a full explanation." @@ -3459,9 +3458,9 @@ msgid "" "strong reference before exiting the scope of the strong reference, to avoid " "leaking one reference." msgstr "" -"Mit der Funktion „ :c:func:`Py_NewRef` “ lässt sich eine starke Referenz auf" -" ein Objekt erstellen. In der Regel muss die Funktion „ :c:func:`Py_DECREF` " -"“ für die starke Referenz aufgerufen werden, bevor der Geltungsbereich der " +"Mit der Funktion :c:func:`Py_NewRef` lässt sich eine starke Referenz auf" +" ein Objekt erstellen. In der Regel muss die Funktion :c:func:`Py_DECREF` " +" für die starke Referenz aufgerufen werden, bevor der Geltungsbereich der " "starken Referenz verlassen wird, um ein Referenzleck zu vermeiden." msgid "See also :term:`borrowed reference`." @@ -3500,12 +3499,12 @@ msgid "" msgstr "" "Ein grundlegender Baustein zur Koordination (Synchronisation) der Ausführung" " mehrerer Threads, um einen :term:`thread-safe` Zugriff auf gemeinsam " -"genutzte Ressourcen zu gewährleisten. Das Python-Modul „ :mod:`threading` “ " -"stellt mehrere Synchronisationsprimitive bereit, darunter „ " -":class:`~threading.Lock` “, „ :class:`~threading.RLock` “, „ " -":class:`~threading.Semaphore` “, „ :class:`~threading.Condition` “, „ " -":class:`~threading.Event` “ und „ :class:`~threading.Barrier` “. Darüber " -"hinaus bietet das Modul „ :mod:`queue` “ Multi-Producer- und Multi-Consumer-" +"genutzte Ressourcen zu gewährleisten. Das Python-Modul :mod:`threading` " +"stellt mehrere Synchronisationsprimitive bereit, darunter " +":class:`~threading.Lock` , :class:`~threading.RLock` , " +":class:`~threading.Semaphore` , :class:`~threading.Condition` , " +":class:`~threading.Event` und :class:`~threading.Barrier` . Darüber " +"hinaus bietet das Modul :mod:`queue` Multi-Producer- und Multi-Consumer-" "Warteschlangen, die besonders in Multithread-Programmen nützlich sind. Diese" " Primitive tragen dazu bei, :term:`Race-Conditions ` zu " "verhindern und die Thread-Ausführung zu koordinieren. Siehe auch " @@ -3522,8 +3521,8 @@ msgid "" "\"t-strings\" which is short for :ref:`template string literals " "`." msgstr "" -"Zeichenfolgenliterale, denen „ ``t`` “ oder „ ``T`` “ vorangestellt ist, " -"werden gemeinhin als „t-Strings“ bezeichnet, was die Abkürzung für " +"Zeichenfolgenliterale, denen ``t`` oder ``T`` vorangestellt ist, " +"werden gemeinhin als t-Strings bezeichnet, was die Abkürzung für " ":ref:`Template-Zeichenfolgenliterale ` ist." msgid "text encoding" @@ -3542,9 +3541,9 @@ msgid "" "Serializing a string into a sequence of bytes is known as \"encoding\", and " "recreating the string from the sequence of bytes is known as \"decoding\"." msgstr "" -"Die Umwandlung einer Zeichenkette in eine Bytefolge wird als „Kodierung“ " +"Die Umwandlung einer Zeichenkette in eine Bytefolge wird als \"Kodierung\“ " "bezeichnet, und die Rekonstruktion der Zeichenkette aus der Bytefolge wird " -"als „Dekodierung“ bezeichnet." +"als \"Dekodierung\“ bezeichnet." msgid "" "There are a variety of different text serialization :ref:`codecs `, die zusammenfassend als " -"„Textkodierungen“ bezeichnet werden." +"\"Textkodierungen\“ bezeichnet werden." msgid "text file" msgstr "Textdatei" @@ -3832,8 +3831,8 @@ msgstr "Zähler: int = 0" msgid "Variable annotation syntax is explained in section :ref:`annassign`." msgstr "" -"Die Syntax für die Annotation von Variablen wird im Abschnitt „ " -":ref:`annassign` “ erläutert." +"Die Syntax für die Annotation von Variablen wird im Abschnitt " +":ref:`annassign` erläutert." msgid "" "See :term:`function annotation`, :pep:`484` and :pep:`526`, which describe " @@ -3893,7 +3892,7 @@ msgid "" msgstr "" "Eine Auflistung der Python-Entwurfsprinzipien und -Philosophien, die zum " "Verständnis und zur Anwendung der Sprache hilfreich sind. Die Auflistung " -"kann durch Eingabe von „``import this`` “ an der interaktiven " +"kann durch Eingabe von \"``import this`` \“ an der interaktiven " "Eingabeaufforderung aufgerufen werden." msgid "..." From df147473f27d230e8742d03db94fed687d409d86 Mon Sep 17 00:00:00 2001 From: JystBreisgau Date: Tue, 11 Aug 2026 11:46:05 +0200 Subject: [PATCH 06/13] Fix formatting and translation in glossary.po Corrected formatting and translation inconsistencies in glossary entries. --- glossary.po | 42 +++++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/glossary.po b/glossary.po index 39448ab..ef60fd9 100644 --- a/glossary.po +++ b/glossary.po @@ -80,13 +80,13 @@ msgstr "" "virtuelle Unterklassen ein – das sind Klassen, die nicht von einer Klasse " "erben, aber dennoch von :func:`isinstance` und :func:`issubclass` erkannt " "werden; siehe die Dokumentation zum Modul :mod:`abc`. Python enthält viele " -"integrierte ABCs für Datenstrukturen (im Modul „ :mod:`collections.abc` “), " -"Zahlen (im Modul :mod:`numbers` ), Streams (im Modul „ :mod:`io` “) sowie" -" Import-Finder und Loader (im Modul „ :mod:`importlib.abc` “). Mit dem Modul" +"integrierte ABCs für Datenstrukturen (im Modul :mod:`collections.abc` ), " +"Zahlen (im Modul :mod:`numbers` ), Streams (im Modul :mod:`io` ) sowie" +" Import-Finder und Loader (im Modul :mod:`importlib.abc` ). Mit dem Modul" " :mod:`abc` können Sie eigene ABCs erstellen." msgid "annotate function" -msgstr "Funktion „annotate“ +msgstr "Funktion annotate“ msgid "" "A function that can be called to retrieve the :term:`annotations " @@ -98,7 +98,7 @@ msgstr "" "Eine Callable-Funktion, die aufgerufen werden kann, um die " ":term:`Annotationen ` eines Objekts abzurufen. Annotate-" "Funktionen sind in der Regel :term:`Funktionen `, die automatisch " -"als Attribut „ :attr:`~object.__annotate__` “ von Funktionen, Klassen und " +"als Attribut :attr:`~object.__annotate__` von Funktionen, Klassen und " "Modulen generiert werden. Annotate-Funktionen sind eine Teilmenge der " ":term:`Evaluate-Funktionen `." @@ -269,8 +269,8 @@ msgid "" "the body of the asynchronous generator function until the next :keyword:" "`yield` expression." msgstr "" -"Dies ist ein :term:`asynchroner Iterator`, der beim Aufruf mit der Methode „" -" :meth:`~object.__anext__` ein „awaitable“-Objekt zurückgibt, das den " +"Dies ist ein :term:`asynchroner Iterator`, der beim Aufruf mit der Methode " +" :meth:`~object.__anext__` ein awaitable-Objekt zurückgibt, das den " "Körper der asynchronen Generatorfunktion bis zum nächsten :keyword:`yield`" " -Ausdruck ausführt." @@ -558,7 +558,7 @@ msgid "" "A callable is an object that can be called, possibly with a set of arguments " "(see :term:`argument`), with the following syntax::" msgstr "" -"Ein „Callable“ ist ein Objekt, das aufgerufen werden kann, gegebenenfalls " +"Ein Callable ist ein Objekt, das aufgerufen werden kann, gegebenenfalls " "mit einer Reihe von Argumenten (siehe :term:`argument`), und zwar mit " "folgender Syntax::" @@ -684,7 +684,7 @@ msgstr "" "Ingenieurwesen als ``j`` geschrieben werden. Python bietet integrierte " "Unterstützung für komplexe Zahlen, die in der letztgenannten Notation " "geschrieben werden; der Imaginärteil wird mit dem Suffix ``j`` " -"angegeben, z. B. „ ``3+1j`` “. Um auf die komplexen Entsprechungen des " +"angegeben, z. B. ``3+1j`` . Um auf die komplexen Entsprechungen des " "Moduls :mod:`math` zuzugreifen, verwenden Sie :mod:`cmath` . Die " "Verwendung komplexer Zahlen ist eine recht fortgeschrittene mathematische " "Funktion. Wenn Sie keinen Bedarf dafür sehen, können Sie diese Funktionen " @@ -860,7 +860,7 @@ msgid "" msgstr "" "Die kanonische Implementierung der Programmiersprache Python, wie sie auf " "`python.org `_ bereitgestellt wird. Der Begriff " -"„CPython“ wird bei Bedarf verwendet, um diese Implementierung von anderen " +"\"CPython\“ wird bei Bedarf verwendet, um diese Implementierung von anderen " "wie Jython oder IronPython zu unterscheiden." msgid "current context" @@ -943,7 +943,7 @@ msgstr "" "wartet, während Thread B die Sperre 2 hält und auf die Sperre 1 wartet, " "werden beide Threads auf unbestimmte Zeit warten. In Python entsteht dies " "häufig durch das Erlangen mehrerer Sperren in widersprüchlicher Reihenfolge " -"oder durch zirkuläre „join/await“-Abhängigkeiten. Deadlocks lassen sich " +"oder durch zirkuläre join/await-Abhängigkeiten. Deadlocks lassen sich " "vermeiden, indem mehrere :term:`Sperren ` stets in einer konsistenten " "Reihenfolge erworben werden. Siehe auch :term:`Sperre` und " ":term:`reentrant`." @@ -965,7 +965,7 @@ msgid "" "The decorator syntax is merely syntactic sugar, the following two function " "definitions are semantically equivalent::" msgstr "" -"Die Dekorator-Syntax ist lediglich „Syntactic Sugar“; die folgenden beiden " +"Die Dekorator-Syntax ist lediglich Syntactic Sugar; die folgenden beiden " "Funktionsdefinitionen sind semantisch gleichbedeutend::" msgid "" @@ -1039,7 +1039,7 @@ msgstr "" "Ein assoziatives Array, bei dem beliebige Schlüssel Werten zugeordnet " "werden. Die Schlüssel können beliebige Objekte sein, die über die Methoden " " :meth:`~object.__hash__` und :meth:`~object.__eq__` verfügen. In Perl" -" wird dies als „Hash“ bezeichnet." +" wird dies als Hash bezeichnet." msgid "dictionary comprehension" msgstr "Wörterbuchverständnis" @@ -1068,7 +1068,7 @@ msgid "" msgstr "" "Die Objekte, die von den Methoden :meth:`dict.keys` , " ":meth:`dict.values` und :meth:`dict.items` zurückgegeben werden, " -"werden als „Dictionary-Ansichten“ bezeichnet. Sie bieten eine dynamische " +"werden als Dictionary-Ansichten bezeichnet. Sie bieten eine dynamische " "Ansicht der Einträge im Dictionary, was bedeutet, dass sich Änderungen am " "Dictionary unmittelbar in der Ansicht widerspiegeln. Um die Dictionary-" "Ansicht zwangsweise in eine vollständige Liste umzuwandeln, verwenden Sie " @@ -1202,7 +1202,7 @@ msgid "" "`. See also :pep:`498`." msgstr "" "Zeichenfolgenliterale, denen ``f`` oder ``F`` vorangestellt ist, " -"werden gemeinhin als „\"f-Strings\“ bezeichnet, was die Abkürzung für " +"werden gemeinhin als \"f-Strings\“ bezeichnet, was die Abkürzung für " ":ref:`formatierte Zeichenfolgenliterale ` ist. Siehe auch " ":pep:`498`." @@ -2432,7 +2432,7 @@ msgid "" "tuple and whose indexable elements are also accessible using named " "attributes. The type or class may have other features as well." msgstr "" -"Der Begriff „\"benanntes Tupel\“ bezieht sich auf jeden Typ oder jede Klasse, " +"Der Begriff \"benanntes Tupel\“ bezieht sich auf jeden Typ oder jede Klasse, " "die von \"Tupel\“ erbt und deren indizierbare Elemente auch über benannte " "Attribute zugänglich sind. Der Typ oder die Klasse kann darüber hinaus noch " "weitere Merkmale aufweisen." @@ -2976,7 +2976,7 @@ msgid "" "backwards compatible resolution to any identified problems." msgstr "" "Selbst bei vorläufigen APIs gelten rückwärtsinkompatible Änderungen als " -"„letzter Ausweg“ – es wird weiterhin alles versucht, um für alle " +"\"letzter Ausweg\“ – es wird weiterhin alles versucht, um für alle " "festgestellten Probleme eine rückwärtskompatible Lösung zu finden." msgid "" @@ -3165,7 +3165,7 @@ msgid "" "``__init__.py`` file." msgstr "" "Ein herkömmliches :term:`Paket`, beispielsweise ein Verzeichnis, das eine " -"Datei vom Typ „ ``__init__.py`` “ enthält." +"Datei vom Typ ``__init__.py`` enthält." msgid "See also :term:`namespace package`." msgstr "Siehe auch: :term:`Namensraum-Paket`." @@ -3675,8 +3675,8 @@ msgid "" "The :mod:`tokenize` module exposes Python's lexical analyzer. The " ":mod:`token` module contains information on the various types of tokens." msgstr "" -"Das Modul „ :mod:`tokenize` “ stellt den lexikalischen Analysator von Python" -" bereit. Das Modul „ :mod:`token` “ enthält Informationen zu den " +"Das Modul :mod:`tokenize` stellt den lexikalischen Analysator von Python" +" bereit. Das Modul :mod:`token` enthält Informationen zu den " "verschiedenen Token-Typen." msgid "triple-quoted string" @@ -3780,7 +3780,7 @@ msgid "" "local variables, can be accessed using :func:`typing.get_type_hints`." msgstr "" "Typhinweise für globale Variablen, Klassenattribute und Funktionen, nicht " -"jedoch für lokale Variablen, können über „ :func:`typing.get_type_hints` “ " +"jedoch für lokale Variablen, können über :func:`typing.get_type_hints` " "abgerufen werden." msgid "universal newlines" From 0a79641f242f89a3072a98e5be4dcdb98eb2fe61 Mon Sep 17 00:00:00 2001 From: JystBreisgau Date: Tue, 11 Aug 2026 11:52:29 +0200 Subject: [PATCH 07/13] Fix formatting issues in glossary.po Corrected formatting issues in glossary.po by removing unnecessary backticks and ensuring consistent spacing in translations. --- glossary.po | 84 ++++++++++++++++++++++++++--------------------------- 1 file changed, 42 insertions(+), 42 deletions(-) diff --git a/glossary.po b/glossary.po index ef60fd9..6501092 100644 --- a/glossary.po +++ b/glossary.po @@ -315,7 +315,7 @@ msgstr "" "muss ein :term:`awaitable`-Objekt zurückgeben. :keyword:`async for` " "verarbeitet die von der Methode :meth:`~object.__anext__` eines " "asynchronen Iterators zurückgegebenen `awaitables`, bis eine Ausnahme vom " -"Typ ` :exc:`StopAsyncIteration` ` ausgelöst wird. Eingeführt durch " +"Typ :exc:`StopAsyncIteration` ausgelöst wird. Eingeführt durch " ":pep:`492`." msgid "atomic operation" @@ -452,8 +452,8 @@ msgid "" "See also :term:`text file` for a file object able to read and write :class:" "`str` objects." msgstr "" -"Siehe auch :term:`Textdatei` für ein Dateiobjekt, das Objekte vom Typ ` " -":class:`str` ` lesen und schreiben kann." +"Siehe auch :term:`Textdatei` für ein Dateiobjekt, das Objekte vom Typ " +":class:`str` lesen und schreiben kann." msgid "borrowed reference" msgstr "entlehnte Referenz" @@ -1271,8 +1271,8 @@ msgid "" ":func:`sys.getfilesystemencodeerrors` functions can be used to get the " "filesystem encoding and error handler." msgstr "" -"Mit den Funktionen ` :func:`sys.getfilesystemencoding` ` und ` " -":func:`sys.getfilesystemencodeerrors` ` lassen sich die Kodierung des " +"Mit den Funktionen :func:`sys.getfilesystemencoding` und " +":func:`sys.getfilesystemencodeerrors` lassen sich die Kodierung des " "Dateisystems und der Fehlerbehandler abrufen." msgid "" @@ -1282,7 +1282,7 @@ msgid "" ":c:member:`~PyConfig.filesystem_errors` members of :c:type:`PyConfig`." msgstr "" "Die :term:`Dateisystem-Kodierung und der Fehlerbehandler` werden beim Start " -"von Python über die Funktion ` :c:func:`PyConfig_Read` ` konfiguriert: siehe" +"von Python über die Funktion :c:func:`PyConfig_Read` konfiguriert: siehe" " :c:member:`~PyConfig.filesystem_encoding` und " ":c:member:`~PyConfig.filesystem_errors`, die zu :c:type:`PyConfig` gehören." @@ -1652,8 +1652,8 @@ msgstr "" "Ab Python 3.13 kann der GIL mithilfe der Build-Konfiguration " ":option:`--disable-gil` deaktiviert werden. Nach dem Kompilieren von " "Python mit dieser Option muss der Code mit der Option :option:`-X gil=0 " -"<-X>` ` ausgeführt werden oder nachdem die Umgebungsvariable " -":envvar:`PYTHON_GIL=0 ` ` gesetzt wurde. Diese Funktion " +"<-X>` ausgeführt werden oder nachdem die Umgebungsvariable " +":envvar:`PYTHON_GIL=0 ` gesetzt wurde. Diese Funktion " "ermöglicht eine verbesserte Leistung für Multithread-Anwendungen und " "erleichtert die effiziente Nutzung von Multi-Core-CPUs. Weitere Details " "finden Sie unter :pep:`703`." @@ -1707,9 +1707,9 @@ msgid "" "Hashable objects which compare equal must have the same hash value." msgstr "" "Ein Objekt ist *hashbar*, wenn es einen Hash-Wert besitzt, der sich während " -"seiner Lebensdauer nicht ändert (es benötigt eine ` :meth:`~object.__hash__`" +"seiner Lebensdauer nicht ändert (es benötigt eine :meth:`~object.__hash__`" " `-Methode), und wenn es mit anderen Objekten verglichen werden kann (es " -"benötigt eine ` :meth:`~object.__eq__` `-Methode). Hashbare Objekte, die als" +"benötigt eine :meth:`~object.__eq__` `-Methode). Hashbare Objekte, die als" " gleich verglichen werden, müssen denselben Hash-Wert haben." msgid "" @@ -1771,8 +1771,8 @@ msgid "" "Immortal objects can be identified via :func:`sys._is_immortal`, or via " ":c:func:`PyUnstable_IsImmortal` in the C API." msgstr "" -"Unsterbliche Objekte können über ` :func:`sys._is_immortal`` oder über ` " -":c:func:`PyUnstable_IsImmortal` ` in der C-API identifiziert werden." +"Unsterbliche Objekte können über :func:`sys._is_immortal` oder über " +":c:func:`PyUnstable_IsImmortal` in der C-API identifiziert werden." msgid "immutable" msgstr "unveränderlich" @@ -1968,8 +1968,8 @@ msgstr "" "integrierte Funktion :func:`iter` übergeben wird, gibt diese einen " "Iterator für das Objekt zurück. Dieser Iterator reicht für einen Durchlauf " "durch die Wertemenge aus. Bei der Verwendung von Iterables ist es in der " -"Regel nicht notwendig, ` :func:`iter` ` aufzurufen oder sich selbst um " -"Iterator-Objekte zu kümmern. Die Anweisung ` :keyword:`for` ` übernimmt dies" +"Regel nicht notwendig, :func:`iter` aufzurufen oder sich selbst um " +"Iterator-Objekte zu kümmern. Die Anweisung :keyword:`for` übernimmt dies" " automatisch für Sie und erstellt eine temporäre, unbenannte Variable, die " "den Iterator für die Dauer der Schleife enthält. Siehe auch " ":term:`iterator`, :term:`sequence` und :term:`generator`." @@ -1998,16 +1998,16 @@ msgstr "" "integrierte Funktion :func:`next` ) geben aufeinanderfolgende Elemente " "des Datenstroms zurück. Sind keine Daten mehr verfügbar, wird stattdessen " "die Ausnahme :exc:`StopIteration` ausgelöst. Zu diesem Zeitpunkt ist " -"das Iterator-Objekt erschöpft, und weitere Aufrufe seiner Methode ` " -":meth:`!__next__` ` lösen lediglich erneut eine ` :exc:`StopIteration` " -"`-Ausnahme aus. Iteratoren müssen über eine Methode ` " -":meth:`~iterator.__iter__` ` verfügen, die das Iterator-Objekt selbst " +"das Iterator-Objekt erschöpft, und weitere Aufrufe seiner Methode " +":meth:`!__next__` lösen lediglich erneut eine :exc:`StopIteration` " +"`-Ausnahme aus. Iteratoren müssen über eine Methode " +":meth:`~iterator.__iter__` verfügen, die das Iterator-Objekt selbst " "zurückgibt, sodass jeder Iterator auch iterierbar ist und an den meisten " "Stellen verwendet werden kann, an denen andere iterierbare Objekte " "akzeptiert werden. Eine bemerkenswerte Ausnahme bildet Code, der mehrere " "Iterationsdurchläufe versucht. Ein Containerobjekt (wie beispielsweise ein " "` :class:`list``) erzeugt jedes Mal einen neuen Iterator, wenn man es an die" -" Funktion ` :func:`iter` ` übergibt oder in einer ` :keyword:`for` " +" Funktion :func:`iter` übergibt oder in einer :keyword:`for` " "`-Schleife verwendet. Versucht man dies mit einem Iterator, wird lediglich " "dasselbe erschöpfte Iteratorobjekt zurückgegeben, das bereits im vorherigen " "Iterationsdurchlauf verwendet wurde, wodurch es so aussieht, als wäre der " @@ -2022,8 +2022,8 @@ msgid "" "` CPython does not guarantee :term:`thread-safe` behavior of" " iterator operations." msgstr "" -"CPython wendet die Anforderung, dass ein Iterator ` " -":meth:`~iterator.__iter__`` definieren muss, nicht konsequent an. Beachten " +"CPython wendet die Anforderung, dass ein Iterator " +":meth:`~iterator.__iter__` definieren muss, nicht konsequent an. Beachten " "Sie außerdem, dass :term:`free-threaded ` CPython kein " ":term:`thread-safe` Verhalten von Iterator-Operationen garantiert." @@ -2230,9 +2230,9 @@ msgid "" ":class:`~importlib.abc.Loader` interface. A loader is typically returned by " "a :term:`finder`. See also:" msgstr "" -"Ein Objekt, das ein Modul lädt. Es muss die Methoden ` :meth:`!exec_module` " -"` und ` :meth:`!create_module` ` definieren, um die Schnittstelle ` " -":class:`~importlib.abc.Loader` ` zu implementieren. Ein Loader wird in der " +"Ein Objekt, das ein Modul lädt. Es muss die Methoden :meth:`!exec_module` " +" und :meth:`!create_module` definieren, um die Schnittstelle " +":class:`~importlib.abc.Loader` zu implementieren. Ein Loader wird in der " "Regel von einem :term:`finder` zurückgegeben. Siehe auch:" msgid ":ref:`finders-and-loaders`" @@ -2395,8 +2395,8 @@ msgid "" " An instance of :class:`importlib.machinery.ModuleSpec`." msgstr "" "Ein Namespace, der die Import-bezogenen Informationen enthält, die zum Laden" -" eines Moduls verwendet werden. Eine Instanz von ` " -":class:`importlib.machinery.ModuleSpec``." +" eines Moduls verwendet werden. Eine Instanz von " +":class:`importlib.machinery.ModuleSpec`." msgid "See also :ref:`module-specs`." msgstr "Siehe auch :ref:`module-specs`." @@ -2443,8 +2443,8 @@ msgid "" ":data:`sys.float_info`::" msgstr "" "Mehrere integrierte Datentypen werden als Tupel bezeichnet, darunter die von" -" ` :func:`time.localtime` ` und ` :func:`os.stat`` zurückgegebenen Werte. " -"Ein weiteres Beispiel ist ` :data:`sys.float_info``: ::" +" :func:`time.localtime` und :func:`os.stat`` zurückgegebenen Werte. " +"Ein weiteres Beispiel ist :data:`sys.float_info``: ::" msgid "" ">>> sys.float_info[1] # indexed access\n" @@ -2472,9 +2472,9 @@ msgid "" msgstr "" "Einige benannte Tupel sind integrierte Typen (wie die obigen Beispiele). " "Alternativ kann ein benanntes Tupel aus einer regulären Klassendefinition " -"erstellt werden, die von ` :class:`tuple` ` erbt und benannte Felder " +"erstellt werden, die von :class:`tuple` erbt und benannte Felder " "definiert. Eine solche Klasse kann manuell geschrieben werden oder durch " -"Vererbung von ` :class:`typing.NamedTuple`` bzw. mit der Factory-Funktion ` " +"Vererbung von :class:`typing.NamedTuple`` bzw. mit der Factory-Funktion " ":func:`collections.namedtuple`` erstellt werden. Die letztgenannten " "Techniken fügen zudem einige zusätzliche Methoden hinzu, die in manuell " "geschriebenen oder integrierten benannten Tupeln möglicherweise nicht " @@ -3144,7 +3144,7 @@ msgstr "" " daher werden diese Objekte niemals freigegeben. Die Referenzzählung ist " "für Python-Code im Allgemeinen nicht sichtbar, stellt jedoch ein " "Schlüsselelement der :term:`CPython`-Implementierung dar. Programmierer " -"können die Funktion ` :func:`sys.getrefcount` ` aufrufen, um die " +"können die Funktion :func:`sys.getrefcount` aufrufen, um die " "Referenzanzahl für ein bestimmtes Objekt abzurufen." msgid "" @@ -3272,13 +3272,13 @@ msgid "" "documentation on sequence methods generally, see :ref:`Common Sequence " "Operations `." msgstr "" -"Die abstrakte Basisklasse ` :class:`collections.abc.Sequence` ` definiert " -"eine wesentlich umfangreichere Schnittstelle, die über die Methoden ` " -":meth:`~object.__getitem__` ` und ` :meth:`~object.__len__`` hinausgeht und " -"um die Methoden ` :meth:`~sequence.count``, ` :meth:`~sequence.index``, ` " -":meth:`~object.__contains__`` sowie ` :meth:`~object.__reversed__`` " +"Die abstrakte Basisklasse :class:`collections.abc.Sequence` definiert " +"eine wesentlich umfangreichere Schnittstelle, die über die Methoden " +":meth:`~object.__getitem__` und :meth:`~object.__len__` hinausgeht und " +"um die Methoden :meth:`~sequence.count`, :meth:`~sequence.index`, " +":meth:`~object.__contains__` sowie :meth:`~object.__reversed__` " "erweitert wird. Typen, die diese erweiterte Schnittstelle implementieren, " -"können explizit mit ` :func:`~abc.ABCMeta.register`` registriert werden. " +"können explizit mit :func:`~abc.ABCMeta.register` registriert werden. " "Weitere Informationen zu Sequenzmethoden im Allgemeinen finden Sie unter " ":ref:`Common Sequence Operations `." @@ -3293,8 +3293,8 @@ msgid "" msgstr "" "Eine kompakte Möglichkeit, alle oder einen Teil der Elemente einer " "iterierbaren Struktur zu verarbeiten und eine Menge mit den Ergebnissen " -"zurückzugeben. ` ``results = {c for c in 'abracadabra' if c not in 'abc'}`` " -"` erzeugt die Menge der Zeichenfolgen ` ``{'r', 'd'}```. Siehe " +"zurückzugeben. ``results = {c for c in 'abracadabra' if c not in 'abc'}`` " +" erzeugt die Menge der Zeichenfolgen ``{'r', 'd'}``. Siehe " ":ref:`comprehensions`." msgid "single dispatch" @@ -3448,8 +3448,8 @@ msgid "" msgstr "" "In der C-API von Python ist eine starke Referenz eine Referenz auf ein " "Objekt, das dem Code gehört, der die Referenz enthält. Die starke Referenz " -"wird durch den Aufruf von ` :c:func:`Py_INCREF` ` beim Erstellen der " -"Referenz hergestellt und durch den Aufruf von ` :c:func:`Py_DECREF` ` beim " +"wird durch den Aufruf von :c:func:`Py_INCREF` beim Erstellen der " +"Referenz hergestellt und durch den Aufruf von :c:func:`Py_DECREF` beim " "Löschen der Referenz freigegeben." msgid "" @@ -3710,7 +3710,7 @@ msgid "" msgstr "" "Der Typ eines Python-Objekts bestimmt, um welche Art von Objekt es sich " "handelt; jedes Objekt hat einen Typ. Der Typ eines Objekts ist über das " -"Attribut ` :attr:`~object.__class__` ` zugänglich oder kann mit ` " +"Attribut :attr:`~object.__class__` zugänglich oder kann mit " "``type(obj)``` abgerufen werden." msgid "type alias" From 285a0990f0198a1fdc92c78285c1f3656256d56d Mon Sep 17 00:00:00 2001 From: JystBreisgau Date: Tue, 11 Aug 2026 15:18:08 +0200 Subject: [PATCH 08/13] Translate floating-point documentation to German Translate floating-point arithmetic issues and limitations into German. --- tutorial/floatingpoint.po | 403 +++++++++++++++++++++++++++++++------- 1 file changed, 328 insertions(+), 75 deletions(-) diff --git a/tutorial/floatingpoint.po b/tutorial/floatingpoint.po index 96a0d27..986fae2 100644 --- a/tutorial/floatingpoint.po +++ b/tutorial/floatingpoint.po @@ -17,8 +17,9 @@ msgstr "" "Language: de\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" + msgid "Floating-Point Arithmetic: Issues and Limitations" -msgstr "" +msgstr "Gleitkommaarithmetik: Probleme und Einschränkungen" msgid "" "Floating-point numbers are represented in computer hardware as base 2 " @@ -28,6 +29,13 @@ msgid "" "values, the only real difference being that the first is written in base 10 " "fractional notation, and the second in base 2." msgstr "" +"Gleitkommazahlen werden in der Computerhardware als Brüche zur Basis 2 " +"(binär) dargestellt. Beispielsweise hat der **dezimale** Bruch ``0.625`` " +"den Wert 6/10 + 2/100 + 5/1000, und ebenso hat der **binäre** Bruch " +"``0.101`` den Wert 1/2 + 0/4 + 1/8. Diese beiden Brüche haben identische " +"Werte; der einzige wirkliche Unterschied besteht darin, dass der erste in " +"der Bruchschreibweise zur Basis 10 und der zweite in der zur Basis 2 " +"geschrieben ist." msgid "" "Unfortunately, most decimal fractions cannot be represented exactly as " @@ -35,47 +43,68 @@ msgid "" "point numbers you enter are only approximated by the binary floating-point " "numbers actually stored in the machine." msgstr "" +"Leider lassen sich die meisten Dezimalbrüche nicht exakt als Binärbrüche " +"darstellen. Dies hat zur Folge, dass die von Ihnen eingegebenen Dezimal-" +"Gleitkommazahlen im Allgemeinen nur annähernd durch die tatsächlich im " +"Rechner gespeicherten Binär-Gleitkommazahlen wiedergegeben werden." msgid "" "The problem is easier to understand at first in base 10. Consider the " "fraction 1/3. You can approximate that as a base 10 fraction::" msgstr "" +"Das Problem lässt sich zunächst im Dezimalsystem leichter verstehen. " +"Betrachten wir den Bruch 1/3. Man kann ihn als Bruch im Dezimalsystem " +"näherungsweise darstellen:" msgid "0.3" -msgstr "" +msgstr "0.3" msgid "or, better, ::" -msgstr "" +msgstr "oder besser noch: ::" msgid "0.33" -msgstr "" +msgstr "0.33" msgid "0.333" -msgstr "" +msgstr "0.333" msgid "" "and so on. No matter how many digits you're willing to write down, the " "result will never be exactly 1/3, but will be an increasingly better " "approximation of 1/3." msgstr "" +"und so weiter. Ganz gleich, wie viele Stellen man notieren möchte, das " +"Ergebnis wird niemals genau 1/3 sein, sondern eine immer bessere Annäherung " +"an 1/3 darstellen." msgid "" -"In the same way, no matter how many base 2 digits you're willing to use, the " -"decimal value 0.1 cannot be represented exactly as a base 2 fraction. In " +"In the same way, no matter how many base 2 digits you're willing to use, the" +" decimal value 0.1 cannot be represented exactly as a base 2 fraction. In " "base 2, 1/10 is the infinitely repeating fraction ::" msgstr "" +"Ebenso lässt sich der Dezimalwert 0,1 – ganz gleich, wie viele Ziffern im " +"Zweier-System man verwenden möchte – nicht exakt als Bruch im Zweier-System " +"darstellen. Im Zweier-System ist 1/10 der sich unendlich wiederholende Bruch" +" ::" msgid "0.0001100110011001100110011001100110011001100110011..." -msgstr "" +msgstr "0.0001100110011001100110011001100110011001100110011..." msgid "" "Stop at any finite number of bits, and you get an approximation. On most " "machines today, floats are approximated using a binary fraction with the " -"numerator using the first 53 bits starting with the most significant bit and " -"with the denominator as a power of two. In the case of 1/10, the binary " -"fraction is ``3602879701896397 / 2 ** 55`` which is close to but not exactly " -"equal to the true value of 1/10." +"numerator using the first 53 bits starting with the most significant bit and" +" with the denominator as a power of two. In the case of 1/10, the binary " +"fraction is ``3602879701896397 / 2 ** 55`` which is close to but not exactly" +" equal to the true value of 1/10." msgstr "" +"Hält man bei einer beliebigen endlichen Anzahl von Bits an, erhält man eine " +"Näherung. Auf den meisten heutigen Rechnern werden Gleitkommazahlen mithilfe" +" eines binären Bruchs approximiert, wobei der Zähler aus den ersten 53 Bits " +"(beginnend mit dem höchstwertigen Bit) besteht und der Nenner eine " +"Zweierpotenz ist. Im Fall von 1/10 lautet der Binärbruch ``3602879701896397" +" / 2 ** 55``, was nahe am tatsächlichen Wert von 1/10 liegt, diesem aber " +"nicht exakt entspricht." msgid "" "Many users are not aware of the approximation because of the way values are " @@ -84,26 +113,42 @@ msgid "" "if Python were to print the true decimal value of the binary approximation " "stored for 0.1, it would have to display::" msgstr "" +"Vielen Benutzern ist diese Annäherung aufgrund der Art und Weise, wie Werte " +"angezeigt werden, nicht bewusst. Python gibt lediglich eine dezimale " +"Annäherung an den tatsächlichen Dezimalwert der vom Rechner gespeicherten " +"binären Annäherung aus. Würde Python auf den meisten Rechnern den " +"tatsächlichen Dezimalwert der für 0,1 gespeicherten binären Annäherung " +"ausgeben, müsste es Folgendes anzeigen::" msgid "" ">>> 0.1\n" "0.1000000000000000055511151231257827021181583404541015625" msgstr "" +">>> 0.1\n" +"0.1000000000000000055511151231257827021181583404541015625" msgid "" -"That is more digits than most people find useful, so Python keeps the number " -"of digits manageable by displaying a rounded value instead:" +"That is more digits than most people find useful, so Python keeps the number" +" of digits manageable by displaying a rounded value instead:" msgstr "" +"Das sind mehr Stellen, als die meisten Menschen für sinnvoll halten. Deshalb" +" sorgt Python dafür, dass die Anzahl der Stellen überschaubar bleibt, indem " +"stattdessen ein gerundeter Wert angezeigt wird:" msgid "" ">>> 1 / 10\n" "0.1" msgstr "" +">>> 1 / 10\n" +"0.1" msgid "" "Just remember, even though the printed result looks like the exact value of " "1/10, the actual stored value is the nearest representable binary fraction." msgstr "" +"Denken Sie daran: Auch wenn das ausgegebene Ergebnis genau wie der Wert 1/10" +" aussieht, ist der tatsächlich gespeicherte Wert der nächstgelegene " +"darstellbare Binärbruch." msgid "" "Interestingly, there are many different decimal numbers that share the same " @@ -114,26 +159,47 @@ msgid "" "values share the same approximation, any one of them could be displayed " "while still preserving the invariant ``eval(repr(x)) == x``." msgstr "" +"Interessanterweise gibt es viele verschiedene Dezimalzahlen, die denselben " +"nächstliegenden binären Näherungsbruch haben. Beispielsweise werden die " +"Zahlen ``0.1``, ``0.10000000000000001`` und " +"``0.1000000000000000055511151231257827021181583404541015625`` alle durch " +"``3602879701896397 / 2 ** 55`` approximiert. Da alle diese Dezimalwerte " +"dieselbe Approximation haben, könnte jeder einzelne von ihnen angezeigt " +"werden, ohne dass die Invariante ``eval(repr(x)) == x`` verloren geht." msgid "" "Historically, the Python prompt and built-in :func:`repr` function would " "choose the one with 17 significant digits, ``0.10000000000000001``. " -"Starting with Python 3.1, Python (on most systems) is now able to choose the " -"shortest of these and simply display ``0.1``." +"Starting with Python 3.1, Python (on most systems) is now able to choose the" +" shortest of these and simply display ``0.1``." msgstr "" +"Früher wählten die Python-Eingabeaufforderung und die integrierte Funktion " +" :func:`repr` die Zahl mit 17 signifikanten Stellen aus: " +"``0.10000000000000001``. Ab Python 3.1 ist Python (auf den meisten Systemen)" +" nun in der Lage, die kürzeste dieser Zahlen auszuwählen und einfach ``0.1``" +" anzuzeigen." msgid "" -"Note that this is in the very nature of binary floating point: this is not a " -"bug in Python, and it is not a bug in your code either. You'll see the same " -"kind of thing in all languages that support your hardware's floating-point " -"arithmetic (although some languages may not *display* the difference by " -"default, or in all output modes)." +"Note that this is in the very nature of binary floating point: this is not a" +" bug in Python, and it is not a bug in your code either. You'll see the " +"same kind of thing in all languages that support your hardware's floating-" +"point arithmetic (although some languages may not *display* the difference " +"by default, or in all output modes)." msgstr "" +"Beachte, dass dies in der Natur der binären Gleitkommazahlen liegt: Es " +"handelt sich weder um einen Fehler in Python noch um einen Fehler in Ihrem " +"Code. Das gleiche Phänomen tritt in allen Sprachen auf, die die " +"Gleitkommaarithmetik Ihrer Hardware unterstützen (auch wenn manche Sprachen " +"den Unterschied standardmäßig oder in nicht allen Ausgabemodi möglicherweise" +" nicht *anzeigen*)." msgid "" -"For more pleasant output, you may wish to use string formatting to produce a " -"limited number of significant digits:" +"For more pleasant output, you may wish to use string formatting to produce a" +" limited number of significant digits:" msgstr "" +"Um die Ausgabe übersichtlicher zu gestalten, können Sie die " +"Zeichenfolgenformatierung verwenden, um eine begrenzte Anzahl signifikanter " +"Stellen auszugeben:" msgid "" ">>> format(math.pi, '.12g') # give 12 significant digits\n" @@ -145,63 +211,102 @@ msgid "" ">>> repr(math.pi)\n" "'3.141592653589793'" msgstr "" +">>> format(math.pi, '.12g') # gibt 12 signifikante Stellen an\n" +"'3.14159265359'\n" +"\n" +">>> format(math.pi, '.2f') # gibt 2 Stellen nach dem Komma an\n" +"'3.14'\n" +"\n" +">>> repr(math.pi)\n" +"'3.141592653589793'" msgid "" -"It's important to realize that this is, in a real sense, an illusion: you're " -"simply rounding the *display* of the true machine value." +"It's important to realize that this is, in a real sense, an illusion: you're" +" simply rounding the *display* of the true machine value." msgstr "" +"Man muss sich bewusst machen, dass es sich hierbei im wahrsten Sinne des " +"Wortes um eine Illusion handelt: Man rundet lediglich die *Anzeige* des " +"tatsächlichen Maschinenwerts." msgid "" -"One illusion may beget another. For example, since 0.1 is not exactly 1/10, " -"summing three values of 0.1 may not yield exactly 0.3, either:" +"One illusion may beget another. For example, since 0.1 is not exactly 1/10," +" summing three values of 0.1 may not yield exactly 0.3, either:" msgstr "" +"Eine Täuschung kann eine weitere nach sich ziehen. Da beispielsweise 0.1 " +"nicht genau 1/10 ist, ergibt die Summe von drei Werten von 0.1 " +"möglicherweise auch nicht genau 0.3:" msgid "" ">>> 0.1 + 0.1 + 0.1 == 0.3\n" "False" msgstr "" +">>> 0.1 + 0.1 + 0.1 == 0.3\n" +"Falsch" msgid "" -"Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3 " -"cannot get any closer to the exact value of 3/10, then pre-rounding with :" -"func:`round` function cannot help:" +"Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3" +" cannot get any closer to the exact value of 3/10, then pre-rounding with " +":func:`round` function cannot help:" msgstr "" +"Da sich die Zahl 0.1 dem exakten Wert von 1/10 nicht weiter annähern kann " +"und 0.3 sich dem exakten Wert von 3/10 nicht weiter annähern kann, hilft " +"auch eine Vorrundung mit der Funktion :func:`round` nicht weiter:" msgid "" ">>> round(0.1, 1) + round(0.1, 1) + round(0.1, 1) == round(0.3, 1)\n" "False" msgstr "" +">>> round(0.1, 1) + round(0.1, 1) + round(0.1, 1) == round(0.3, 1)\n" +"False" msgid "" -"Though the numbers cannot be made closer to their intended exact values, " -"the :func:`math.isclose` function can be useful for comparing inexact values:" +"Though the numbers cannot be made closer to their intended exact values, the" +" :func:`math.isclose` function can be useful for comparing inexact values:" msgstr "" +"Auch wenn die Zahlen nicht näher an ihre beabsichtigten exakten Werte " +"herangeführt werden können, kann die Funktion :func:`math.isclose` beim " +"Vergleich ungenauer Werte nützlich sein:" msgid "" ">>> math.isclose(0.1 + 0.1 + 0.1, 0.3)\n" "True" msgstr "" +">>> math.isclose(0.1 + 0.1 + 0.1, 0.3)\n" +"True" msgid "" "Alternatively, the :func:`round` function can be used to compare rough " "approximations:" msgstr "" +"Alternativ kann die Funktion :func:`round` verwendet werden, um grobe " +"Näherungswerte zu vergleichen:" msgid "" ">>> round(math.pi, ndigits=2) == round(22 / 7, ndigits=2)\n" "True" msgstr "" +">>> round(math.pi, ndigits=2) == round(22 / 7, ndigits=2)\n" +"True" msgid "" "Binary floating-point arithmetic holds many surprises like this. The " "problem with \"0.1\" is explained in precise detail below, in the " "\"Representation Error\" section. See `Examples of Floating Point Problems " -"`_ for " -"a pleasant summary of how binary floating point works and the kinds of " -"problems commonly encountered in practice. Also see `The Perils of Floating " -"Point `_ for a more complete " +"`_ for" +" a pleasant summary of how binary floating point works and the kinds of " +"problems commonly encountered in practice. Also see `The Perils of Floating" +" Point `_ for a more complete " "account of other common surprises." msgstr "" +"Die binäre Gleitkommaarithmetik birgt viele solcher Überraschungen. Das " +"Problem mit \"0,1\“ wird weiter unten im Abschnitt \"Darstellungsfehler\“ " +"ausführlich erläutert. Unter `Beispiele für Gleitkomma-Probleme " +"`_ " +"finden Sie eine anschauliche Zusammenfassung der Funktionsweise der binären " +"Gleitkommaarithmetik und der Arten von Problemen, die in der Praxis häufig " +"auftreten. Siehe auch `Die Tücken der Gleitkommazahlen " +"`_ für eine umfassendere " +"Darstellung weiterer häufiger Überraschungen." msgid "" "As that says near the end, \"there are no easy answers.\" Still, don't be " @@ -212,75 +317,121 @@ msgid "" "decimal arithmetic and that every float operation can suffer a new rounding " "error." msgstr "" +"Wie es gegen Ende heißt: \"Es gibt keine einfachen Antworten.\“ Dennoch " +"sollten Sie gegenüber Gleitkommazahlen nicht übermäßig misstrauisch sein! " +"Die Fehler bei Gleitkommaoperationen in Python stammen von der Gleitkomma-" +"Hardware und liegen auf den meisten Rechnern bei höchstens 1 Teil pro " +"2\\*\\*53 pro Operation. Das ist für die meisten Aufgaben mehr als " +"ausreichend, aber man muss bedenken, dass es sich nicht um Dezimalrechnen " +"handelt und dass bei jeder Gleitkommaoperation ein neuer Rundungsfehler " +"auftreten kann." msgid "" "While pathological cases do exist, for most casual use of floating-point " "arithmetic you'll see the result you expect in the end if you simply round " "the display of your final results to the number of decimal digits you " -"expect. :func:`str` usually suffices, and for finer control see the :meth:" -"`str.format` method's format specifiers in :ref:`formatstrings`." +"expect. :func:`str` usually suffices, and for finer control see the " +":meth:`str.format` method's format specifiers in :ref:`formatstrings`." msgstr "" +"Es gibt zwar Ausnahmefälle, doch bei den meisten alltäglichen " +"Anwendungen der Gleitkommaarithmetik erhalten Sie letztendlich das erwartete" +" Ergebnis, wenn Sie die Anzeige Ihrer Endergebnisse einfach auf die " +"gewünschte Anzahl von Dezimalstellen runden. :func:`str` reicht in der " +"Regel aus; für eine feinere Steuerung finden Sie die Formatbezeichner der " +"Methode :meth:`str.format` unter :ref:`formatstrings`." msgid "" -"For use cases which require exact decimal representation, try using the :mod:" -"`decimal` module which implements decimal arithmetic suitable for accounting " -"applications and high-precision applications." +"For use cases which require exact decimal representation, try using the " +":mod:`decimal` module which implements decimal arithmetic suitable for " +"accounting applications and high-precision applications." msgstr "" +"Für Anwendungsfälle, die eine exakte Dezimaldarstellung erfordern, sollten " +"Sie das Modul :mod:`decimal` verwenden, das eine Dezimalarithmetik " +"implementiert, die für Buchhaltungsanwendungen und Anwendungen mit hoher " +"Genauigkeit geeignet ist." msgid "" -"Another form of exact arithmetic is supported by the :mod:`fractions` module " -"which implements arithmetic based on rational numbers (so the numbers like " +"Another form of exact arithmetic is supported by the :mod:`fractions` module" +" which implements arithmetic based on rational numbers (so the numbers like " "1/3 can be represented exactly)." msgstr "" +"Eine weitere Form der exakten Arithmetik wird vom Modul :mod:`fractions` " +" unterstützt, das eine auf rationalen Zahlen basierende Arithmetik " +"implementiert (sodass Zahlen wie 1/3 exakt dargestellt werden können)." msgid "" "If you are a heavy user of floating-point operations you should take a look " "at the NumPy package and many other packages for mathematical and " -"statistical operations supplied by the SciPy project. See ." +"statistical operations supplied by the SciPy project. See " +"." msgstr "" +"Wenn Sie häufig mit Gleitkommaoperationen arbeiten, sollten Sie sich das " +"NumPy-Paket sowie viele andere Pakete für mathematische und statistische " +"Operationen ansehen, die vom SciPy-Projekt bereitgestellt werden. Siehe " +"." msgid "" "Python provides tools that may help on those rare occasions when you really " -"*do* want to know the exact value of a float. The :meth:`float." -"as_integer_ratio` method expresses the value of a float as a fraction:" +"*do* want to know the exact value of a float. The " +":meth:`float.as_integer_ratio` method expresses the value of a float as a " +"fraction:" msgstr "" +"Python bietet Werkzeuge, die in den seltenen Fällen hilfreich sein können, " +"in denen man den genauen Wert einer Gleitkommazahl wirklich *wissen* möchte." +" Die Methode :meth:`float.as_integer_ratio` gibt den Wert einer " +"Gleitkommazahl als Bruch an:" msgid "" ">>> x = 3.14159\n" ">>> x.as_integer_ratio()\n" "(3537115888337719, 1125899906842624)" msgstr "" +">>> x = 3.14159\n" +">>> x.as_integer_ratio()\n" +"(3537115888337719, 1125899906842624)" msgid "" -"Since the ratio is exact, it can be used to losslessly recreate the original " -"value:" +"Since the ratio is exact, it can be used to losslessly recreate the original" +" value:" msgstr "" +"Da das Verhältnis exakt ist, lässt sich damit der ursprüngliche Wert " +"verlustfrei wiederherstellen:" msgid "" ">>> x == 3537115888337719 / 1125899906842624\n" "True" msgstr "" +">>> x == 3537115888337719 / 1125899906842624\n" +"True" msgid "" "The :meth:`float.hex` method expresses a float in hexadecimal (base 16), " "again giving the exact value stored by your computer:" msgstr "" +"Die Methode :meth:`float.hex` gibt einen Float-Wert im Hexadezimalformat" +" (Basis 16) aus und liefert wiederum den exakten Wert, der auf Ihrem " +"Computer gespeichert ist:" msgid "" ">>> x.hex()\n" "'0x1.921f9f01b866ep+1'" msgstr "" +">>> x.hex()\n" +"'0x1.921f9f01b866ep+1'" msgid "" -"This precise hexadecimal representation can be used to reconstruct the float " -"value exactly:" +"This precise hexadecimal representation can be used to reconstruct the float" +" value exactly:" msgstr "" +"Anhand dieser exakten Hexadezimal-Darstellung lässt sich der Float-Wert " +"exakt rekonstruieren:" msgid "" ">>> x == float.fromhex('0x1.921f9f01b866ep+1')\n" "True" msgstr "" +">>> x == float.fromhex('0x1.921f9f01b866ep+1')\n" +"True" msgid "" "Since the representation is exact, it is useful for reliably porting values " @@ -288,6 +439,10 @@ msgid "" "data with other languages that support the same format (such as Java and " "C99)." msgstr "" +"Da die Darstellung exakt ist, eignet sie sich gut für die zuverlässige " +"Übertragung von Werten zwischen verschiedenen Python-Versionen " +"(Plattformunabhängigkeit) und den Datenaustausch mit anderen Sprachen, die " +"dasselbe Format unterstützen (wie beispielsweise Java und C99)." msgid "" "Another helpful tool is the :func:`sum` function which helps mitigate loss-" @@ -296,6 +451,12 @@ msgid "" "difference in overall accuracy so that the errors do not accumulate to the " "point where they affect the final total:" msgstr "" +"Ein weiteres nützliches Werkzeug ist die Funktion :func:`sum` , die dazu " +"beiträgt, Präzisionsverluste bei der Summierung zu minimieren. Sie nutzt " +"erweiterte Präzision für die Zwischenrunden, während Werte zur laufenden " +"Summe hinzugefügt werden. Dies kann sich auf die Gesamtgenauigkeit " +"auswirken, sodass sich die Fehler nicht so weit summieren, dass sie das " +"Endergebnis beeinflussen:" msgid "" ">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n" @@ -303,6 +464,10 @@ msgid "" ">>> sum([0.1] * 10) == 1.0\n" "True" msgstr "" +">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n" +"False\n" +">>> sum([0.1] * 10) == 1.0\n" +"True" msgid "" "The :func:`math.fsum` goes further and tracks all of the \"lost digits\" as " @@ -311,6 +476,12 @@ msgid "" "uncommon cases where large magnitude inputs mostly cancel each other out " "leaving a final sum near zero:" msgstr "" +"Die :func:`math.fsum` geht noch einen Schritt weiter und verfolgt alle " +"\"verlorenen Ziffern\“, während Werte zu einer laufenden Summe addiert werden," +" sodass das Ergebnis nur einmal gerundet wird. Dies ist langsamer als " +":func:`sum` , liefert jedoch in seltenen Fällen, in denen sich Eingaben " +"großer Größenordnungen weitgehend gegenseitig aufheben und eine Endsumme " +"nahe Null ergibt, genauere Ergebnisse:" msgid "" ">>> arr = [-0.10430216751806065, -266310978.67179024, 143401161448607.16,\n" @@ -319,27 +490,41 @@ msgid "" "8.042173697819788e-13\n" ">>> math.fsum(arr) # Single rounding\n" "8.042173697819788e-13\n" -">>> sum(arr) # Multiple roundings in extended " -"precision\n" +">>> sum(arr) # Multiple roundings in extended precision\n" "8.042178034628478e-13\n" ">>> total = 0.0\n" ">>> for x in arr:\n" -"... total += x # Multiple roundings in standard " -"precision\n" +"... total += x # Multiple roundings in standard precision\n" "...\n" -">>> total # Straight addition has no correct " -"digits!\n" +">>> total # Straight addition has no correct digits!\n" "-0.0051575902860057365" msgstr "" +">>> arr = [-0.10430216751806065, -266310978.67179024, 143401161448607.16,\n" +"... -143401161400469.7, 266262841.31058735, -0.003244936839808227]\n" +">>> float(sum(map(Fraction, arr))) # Exakte Summierung mit einmaliger Rundung\n" +"8.042173697819788e-13\n" +">>> math.fsum(arr) # Einmalige Rundung\n" +"8.042173697819788e-13\n" +">>> sum(arr) # Mehrfache Rundungen bei erweiterter Genauigkeit\n" +"8.0421778034628478e-13\n" +">>> total = 0.0\n" +">>> for x in arr:\n" +"... total += x # Mehrfache Rundungen in Standardgenauigkeit\n" +"...\n" +">>> total # Die einfache Addition liefert keine korrekten Ziffern!\n" +"-0.0051575902860057365" msgid "Representation Error" -msgstr "" +msgstr "Darstellungsfehler" msgid "" "This section explains the \"0.1\" example in detail, and shows how you can " "perform an exact analysis of cases like this yourself. Basic familiarity " "with binary floating-point representation is assumed." msgstr "" +"In diesem Abschnitt wird das Beispiel \"0.1\“ ausführlich erläutert und " +"gezeigt, wie Sie Fälle wie diesen selbst genau analysieren können. " +"Grundkenntnisse über die binäre Gleitkommadarstellung werden vorausgesetzt." msgid "" ":dfn:`Representation error` refers to the fact that some (most, actually) " @@ -348,113 +533,166 @@ msgid "" "Fortran, and many others) often won't display the exact decimal number you " "expect." msgstr "" +":dfn:`Darstellungsfehler` bezieht sich auf die Tatsache, dass " +"einige (eigentlich die meisten) Dezimalbrüche nicht exakt als Binärbrüche " +"(Basis 2) dargestellt werden können. Dies ist der Hauptgrund dafür, dass " +"Python (oder Perl, C, C++, Java, Fortran und viele andere) oft nicht genau " +"die Dezimalzahl anzeigen, die man erwartet." msgid "" -"Why is that? 1/10 is not exactly representable as a binary fraction. Since " -"at least 2000, almost all machines use IEEE 754 binary floating-point " +"Why is that? 1/10 is not exactly representable as a binary fraction. Since" +" at least 2000, almost all machines use IEEE 754 binary floating-point " "arithmetic, and almost all platforms map Python floats to IEEE 754 binary64 " "\"double precision\" values. IEEE 754 binary64 values contain 53 bits of " "precision, so on input the computer strives to convert 0.1 to the closest " -"fraction it can of the form *J*/2**\\ *N* where *J* is an integer containing " -"exactly 53 bits. Rewriting ::" -msgstr "" +"fraction it can of the form *J*/2**\\ *N* where *J* is an integer containing" +" exactly 53 bits. Rewriting ::" +msgstr "" +"Warum ist das so? 1/10 lässt sich nicht exakt als binärer Bruch darstellen." +" Seit mindestens dem Jahr 2000 verwenden fast alle Rechner die binäre " +"IEEE-754-Gleitkommaarithmetik, und fast alle Plattformen ordnen Python-" +"Float-Werte den IEEE-754-binary64-Werten mit \"doppelter Genauigkeit\“ zu. " +"IEEE-754-binary64-Werte enthalten 53 Bits an Genauigkeit, daher versucht der" +" Computer bei der Eingabe, 0,1 in den nächstgelegenen Bruch der Form " +"*J*/2**\\ *N* umzuwandeln, wobei *J* eine Ganzzahl mit genau 53 Bits ist. " +"Umformulierung ::" msgid "1 / 10 ~= J / (2**N)" -msgstr "" +msgstr "1 / 10 ~= J / (2**N)" msgid "as ::" -msgstr "" +msgstr "als ::" msgid "J ~= 2**N / 10" -msgstr "" +msgstr "J ~= 2**N / 10" msgid "" "and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< " "2**53``), the best value for *N* is 56:" msgstr "" +"und unter Berücksichtigung, dass J genau 53 Bits hat (d. h. >= 2**52, " +"aber < 2**53), ist der beste Wert für N gleich 56:" msgid "" ">>> 2**52 <= 2**56 // 10 < 2**53\n" "True" msgstr "" +">>> 2**52 <= 2**56 // 10 < 2**53\n" +"True" msgid "" -"That is, 56 is the only value for *N* that leaves *J* with exactly 53 bits. " -"The best possible value for *J* is then that quotient rounded:" +"That is, 56 is the only value for *N* that leaves *J* with exactly 53 bits." +" The best possible value for *J* is then that quotient rounded:" msgstr "" +"Das heißt, 56 ist der einzige Wert für *N*, bei dem *J* genau 53 Bits hat. " +"Der bestmögliche Wert für *J* ist dann dieser Quotient, gerundet:" msgid "" ">>> q, r = divmod(2**56, 10)\n" ">>> r\n" "6" msgstr "" +">>> q, r = divmod(2**56, 10)\n" +">>> r\n" +"6" msgid "" "Since the remainder is more than half of 10, the best approximation is " "obtained by rounding up:" msgstr "" +"Da der Rest mehr als die Hälfte von 10 beträgt, erhält man die beste " +"Annäherung durch Aufrunden:" msgid "" ">>> q+1\n" "7205759403792794" msgstr "" +">>> q+1\n" +"7205759403792794" msgid "" "Therefore the best possible approximation to 1/10 in IEEE 754 double " "precision is::" msgstr "" +"Daher lautet die bestmögliche Annäherung an 1/10 in IEEE " +"754-Doppelnauigkeit:" msgid "7205759403792794 / 2 ** 56" -msgstr "" +msgstr "7205759403792794 / 2 ** 56" msgid "" "Dividing both the numerator and denominator by two reduces the fraction to::" msgstr "" +"Durch Division von Zähler und Nenner durch zwei lässt sich der Bruch wie " +"folgt vereinfachen:" msgid "3602879701896397 / 2 ** 55" -msgstr "" +msgstr "3602879701896397 / 2 ** 55" msgid "" "Note that since we rounded up, this is actually a little bit larger than " "1/10; if we had not rounded up, the quotient would have been a little bit " "smaller than 1/10. But in no case can it be *exactly* 1/10!" msgstr "" +"Beachte, dass dieser Wert, da wir aufgerundet haben, tatsächlich etwas " +"größer als 1/10 ist; hätten wir nicht aufgerundet, wäre der Quotient etwas " +"kleiner als 1/10 gewesen. Aber auf keinen Fall kann er *genau* 1/10 " +"betragen!" msgid "" "So the computer never \"sees\" 1/10: what it sees is the exact fraction " "given above, the best IEEE 754 double approximation it can get:" msgstr "" +"Der Computer \"sieht\“ also niemals 1/10: Was er sieht, ist genau der oben " +"angegebene Bruch, die bestmögliche IEEE-754-Doppelgenauigkeits-Annäherung, " +"die er erzielen kann:" msgid "" ">>> 0.1 * 2 ** 55\n" "3602879701896397.0" msgstr "" +">>> 0.1 * 2 ** 55\n" +"3602879701896397.0" msgid "" "If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 " "decimal digits:" msgstr "" +"Wenn wir diesen Bruch mit 10\\*\\*55 multiplizieren, erhalten wir den Wert " +"mit 55 Dezimalstellen:" msgid "" ">>> 3602879701896397 * 10 ** 55 // 2 ** 55\n" "1000000000000000055511151231257827021181583404541015625" msgstr "" +">>> 3602879701896397 * 10 ** 55 // 2 ** 55\n" +"1000000000000000055511151231257827021181583404541015625" msgid "" -"meaning that the exact number stored in the computer is equal to the decimal " -"value 0.1000000000000000055511151231257827021181583404541015625. Instead of " -"displaying the full decimal value, many languages (including older versions " -"of Python), round the result to 17 significant digits:" +"meaning that the exact number stored in the computer is equal to the decimal" +" value 0.1000000000000000055511151231257827021181583404541015625. Instead of" +" displaying the full decimal value, many languages (including older versions" +" of Python), round the result to 17 significant digits:" msgstr "" +"Das bedeutet, dass die im Computer gespeicherte exakte Zahl dem Dezimalwert " +"0,1000000000000000055511151231257827021181583404541015625 entspricht. " +"Anstatt den vollständigen Dezimalwert anzuzeigen, runden viele Sprachen " +"(einschließlich älterer Python-Versionen) das Ergebnis auf 17 signifikante " +"Stellen:" msgid "" ">>> format(0.1, '.17f')\n" "'0.10000000000000001'" msgstr "" +">>> format(0.1, '.17f')\n" +"'0.10000000000000001'" msgid "" -"The :mod:`fractions` and :mod:`decimal` modules make these calculations easy:" +"The :mod:`fractions` and :mod:`decimal` modules make these calculations " +"easy:" msgstr "" +"Die Module :mod:`fractions` und :mod:`decimal` erleichtern diese " +"Berechnungen:" msgid "" ">>> from decimal import Decimal\n" @@ -472,3 +710,18 @@ msgid "" ">>> format(Decimal.from_float(0.1), '.17')\n" "'0.10000000000000001'" msgstr "" +">>> from decimal import Decimal\n" +">>> from fractions import Fraction\n" +"\n" +">>> Fraction.from_float(0.1)\n" +"Fraction(3602879701896397, 36028797018963968)\n" +"\n" +">>> (0.1).as_integer_ratio()\n" +"(3602879701896397, 36028797018963968)\n" +"\n" +">>> Decimal.from_float(0.1)\n" +"Decimal('0,1000000000000000055511151231257827021181583404541015625')\n" +"\n" +">>> format(Decimal.from_float(0.1), '.17')\n" +"'0.10000000000000001'" + From 481bad32506daf5187ab73090f46f4ef456b783a Mon Sep 17 00:00:00 2001 From: JystBreisgau Date: Wed, 12 Aug 2026 15:29:55 +0200 Subject: [PATCH 09/13] Update German translations for error messages --- tutorial/errors.po | 362 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 358 insertions(+), 4 deletions(-) diff --git a/tutorial/errors.po b/tutorial/errors.po index 51dc91f..111d8de 100644 --- a/tutorial/errors.po +++ b/tutorial/errors.po @@ -51,6 +51,11 @@ msgid "" " ^^^^^\n" "SyntaxError: invalid syntax" msgstr "" +">>> while True print('Hello world')\n" +" Datei \"\“, Zeile 1\n" +" while True print('Hello world')\n" +" ^^^^^\n" +"SyntaxError: ungültige Syntax" msgid "" "The parser repeats the offending line and displays little arrows pointing at " @@ -58,11 +63,19 @@ msgid "" "place that needs to be fixed. In the example, the error is detected at the " "function :func:`print`, since a colon (``':'``) is missing just before it." msgstr "" +"Der Parser wiederholt die fehlerhafte Zeile und zeigt kleine Pfeile an, die " +"auf die Stelle verweisen, an der der Fehler erkannt wurde. Beachten Sie, " +"dass dies nicht immer die Stelle ist, die korrigiert werden muss. Im " +"Beispiel wird der Fehler bei der Funktions :func:`print` erkannt, da " +"unmittelbar davor ein Doppelpunkt (``':'``) fehlt." msgid "" "The file name (```` in our example) and line number are printed so " "you know where to look in case the input came from a file." msgstr "" +"Der Dateiname (in unserem Beispiel ```` ) und die Zeilennummer " +"werden angezeigt, damit Sie wissen, wo Sie nachsehen müssen, falls die " +"Eingabe aus einer Datei stammt." msgid "Exceptions" msgstr "Ausnahmen" @@ -102,6 +115,24 @@ msgid "" " ~~~~^~~\n" "TypeError: can only concatenate str (not \"int\") to str" msgstr "" +">>> 10 * (1/0)\n" +"Traceback (letzter Aufruf zuletzt):\n" +" Datei \"\“, Zeile 1, in \n" +" 10 * (1/0)\n" +" ~^~\n" +"ZeroDivisionError: Division durch Null\n" +">>> 4 + spam*3\n" +"Traceback (letzter Aufruf zuletzt):\n" +" Datei \"\“, Zeile 1, in \n" +" 4 + spam*3\n" +" ^^^^\n" +"NameError: Der Name 'spam' ist nicht definiert\n" +">>> '2' + 2\n" +"Traceback (letzter Aufruf zuletzt):\n" +" Datei \"\“, Zeile 1, in \n" +" '2' + 2\n" +" ~~~~^~~\n" +"TypeError: Es können nur Zeichenketten (nicht \"int\“) mit Zeichenketten verkettet werden" msgid "" "The last line of the error message indicates what happened. Exceptions come " @@ -175,6 +206,13 @@ msgid "" "... print(\"Oops! That was no valid number. Try again...\")\n" "..." msgstr "" +">>> while True:\n" +"... try:\n" +"... x = int(input(\"Bitte gib eine Zahl ein: \"))\n" +"... break\n" +"... except ValueError:\n" +"... print(\"Hoppla! Das war keine gültige Zahl. Versuche es noch einmal...\")\n" +"..." msgid "The :keyword:`try` statement works as follows." msgstr "Die :keyword:`try` Anweisung funktioniert wie folgt." @@ -236,6 +274,8 @@ msgid "" "... except (RuntimeError, TypeError, NameError):\n" "... pass" msgstr "" +"... except (RuntimeError, TypeError, NameError):\n" +"... pass" msgid "" "A class in an :keyword:`except` clause matches exceptions which are " @@ -244,6 +284,12 @@ msgid "" "match instances of its base classes). For example, the following code will " "print B, C, D in that order::" msgstr "" +"Eine Klasse in einer :keyword:`except` -Klausel deckt Ausnahmen ab, bei " +"denen es sich um Instanzen dieser Klasse selbst oder einer ihrer " +"abgeleiteten Klassen handelt (jedoch nicht umgekehrt – eine " +"*except“-Klausel*, in der eine abgeleitete Klasse aufgeführt ist, deckt " +"keine Instanzen ihrer Basisklassen ab). Der folgende Code gibt " +"beispielsweise B, C und D in dieser Reihenfolge aus:" msgid "" "class B(Exception):\n" @@ -265,6 +311,24 @@ msgid "" " except B:\n" " print(\"B\")" msgstr "" +"class B(Exception):\n" +" pass\n" +"\n" +"class C(B):\n" +" pass\n" +"\n" +"class D(C):\n" +" pass\n" +"\n" +"for cls in [B, C, D]:\n" +" try:\n" +" raise cls()\n" +" except D:\n" +" print(\"D\")\n" +" except C:\n" +" print(\"C\")\n" +" except B:\n" +" print(\"B\")" msgid "" "Note that if the *except clauses* were reversed (with ``except B`` first), " @@ -377,6 +441,19 @@ msgid "" " print(f\"Unexpected {err=}, {type(err)=}\")\n" " raise" msgstr "" +"import sys\n" +"\n" +"try:\n" +" f = open('myfile.txt')\n" +" s = f.readline()\n" +" i = int(s.strip())\n" +"except OSError as err:\n" +" print(\"OS-Fehler:\", err)\n" +"except ValueError:\n" +" print(\"Daten konnten nicht in eine Ganzzahl konvertiert werden.\")\n" +"except Exception as err:\n" +" print(f\"Unerwarteter {err=}, {type(err)=}\")\n" +" raise" msgid "" "The :keyword:`try` ... :keyword:`except` statement has an optional *else " @@ -399,6 +476,14 @@ msgid "" " print(arg, 'has', len(f.readlines()), 'lines')\n" " f.close()" msgstr "" +"for arg in sys.argv[1:]:\n" +" try:\n" +" f = open(arg, 'r')\n" +" except OSError:\n" +" print('kann nicht geöffnet werden', arg)\n" +" else:\n" +" print(arg, 'hat', len(f.readlines()), 'Zeilen')\n" +" f.close()" msgid "" "The use of the :keyword:`!else` clause is better than adding additional code " @@ -433,6 +518,15 @@ msgid "" "...\n" "Handling run-time error: division by zero" msgstr "" +">>> def this_fails():\n" +"... x = 1/0\n" +"...\n" +">>> try:\n" +"... this_fails()\n" +"... except ZeroDivisionError as err:\n" +"... print('Behandlung eines Laufzeitfehlers:', err)\n" +"...\n" +"Behandlung eines Laufzeitfehlers: Division durch Null" msgid "Raising Exceptions" msgstr "Auslösen von Ausnahmen" @@ -451,6 +545,11 @@ msgid "" " raise NameError('HiThere')\n" "NameError: HiThere" msgstr "" +">>> raise NameError('HiThere')\n" +"Traceback (letzter Aufruf zuletzt):\n" +" Datei \"\“, Zeile 1, in \n" +" raise NameError('HiThere')\n" +"NameError: HiThere" msgid "" "The sole argument to :keyword:`raise` indicates the exception to be raised. " @@ -467,7 +566,7 @@ msgstr "" "ihr Konstruktor ohne Argumente aufgerufen wird::" msgid "raise ValueError # shorthand for 'raise ValueError()'" -msgstr "" +msgstr "raise ValueError # Kurzform für 'raise ValueError()'" msgid "" "If you need to determine whether an exception was raised but don't intend to " @@ -491,9 +590,20 @@ msgid "" " raise NameError('HiThere')\n" "NameError: HiThere" msgstr "" +">>> try:\n" +"... raise NameError('HiThere')\n" +"... except NameError:\n" +"... print('Eine Ausnahme ist aufgetreten!')\n" +"... raise\n" +"...\n" +"Eine Ausnahme ist aufgetreten!\n" +"Traceback (letzter Aufruf zuletzt):\n" +" Datei \"\“, Zeile 2, in \n" +" raise NameError('HiThere')\n" +"NameError: HiThere" msgid "Exception Chaining" -msgstr "Verkettung von Ausnah" +msgstr "Verkettung von Ausnahmen" msgid "" "If an unhandled exception occurs inside an :keyword:`except` section, it " @@ -523,6 +633,23 @@ msgid "" " raise RuntimeError(\"unable to handle error\")\n" "RuntimeError: unable to handle error" msgstr "" +">>> try:\n" +"... open(\"database.sqlite\")\n" +"... except OSError:\n" +"... raise RuntimeError(\"Fehler kann nicht behandelt werden\")\n" +"...\n" +"Traceback (letzter Aufruf zuletzt):\n" +" Datei \"\“, line 2, in \n" +" open(\"database.sqlite\")\n" +" ~~~~^^^^^^^^^^^^^^^^^^^\n" +"FileNotFoundError: [Errno 2] Keine solche Datei oder kein solches Verzeichnis: 'database.sqlite'\n" +"\n" +"Bei der Behandlung der oben genannten Ausnahme ist eine weitere Ausnahme aufgetreten:\n" +"\n" +"Traceback (letzter Aufruf zuletzt):\n" +" Datei \"\“, Zeile 4, in \n" +" raise RuntimeError(\"Fehler kann nicht behandelt werden\“)\n" +"RuntimeError: Fehler kann nicht behandelt werden" msgid "" "To indicate that an exception is a direct consequence of another, the :" @@ -536,6 +663,8 @@ msgid "" "# exc must be exception instance or None.\n" "raise RuntimeError from exc" msgstr "" +"# exc muss eine Ausnahminstanz oder None sein.\n" +"raise RuntimeError from exc" msgid "This can be useful when you are transforming exceptions. For example::" msgstr "" @@ -564,6 +693,28 @@ msgid "" " raise RuntimeError('Failed to open database') from exc\n" "RuntimeError: Failed to open database" msgstr "" +msgstr "" +">>> def func():\n" +"... raise ConnectionError\n" +"...\n" +">>> try:\n" +"... func()\n" +"... except ConnectionError as exc:\n" +"... raise RuntimeError('Datenbank konnte nicht geöffnet werden') from exc\n" +"...\n" +"Traceback (letzter Aufruf zuletzt):\n" +" Datei \"\“, Zeile 2, in \n" +" func()\n" +" ~~~~^^\n" +" Datei \"\“, Zeile 2, in func\n" +"ConnectionError\n" +"\n" +"Die oben genannte Ausnahme war die direkte Ursache für die folgende Ausnahme:\n" +"\n" +"Traceback (letzter Aufruf zuletzt):\n" +" Datei \"\“, Zeile 4, in \n" +" raise RuntimeError('Datenbank konnte nicht geöffnet werden') from exc\n" +"RuntimeError: Datenbank konnte nicht geöffnet werden" msgid "" "It also allows disabling automatic exception chaining using the ``from " @@ -583,11 +734,20 @@ msgid "" " raise RuntimeError from None\n" "RuntimeError" msgstr "" +">>> try:\n" +"... open('database.sqlite')\n" +"... except OSError:\n" +"... raise RuntimeError from None\n" +"...\n" +"Traceback (letzter Aufruf zuletzt):\n" +" Datei \"\“, Zeile 4, in \n" +" raise RuntimeError from None\n" +"RuntimeError" msgid "" "For more information about chaining mechanics, see :ref:`bltin-exceptions`." msgstr "" -"eitere Informationen zur Verkettungsmechanik finden Sie unter :ref:`bltin-" +"Weitere Informationen zur Verkettungsmechanik finden Sie unter :ref:`bltin-" "exceptions`." msgid "User-defined Exceptions" @@ -653,6 +813,16 @@ msgid "" " raise KeyboardInterrupt\n" "KeyboardInterrupt" msgstr "" +">>> try:\n" +"... raise KeyboardInterrupt\n" +"... finally:\n" +"... print('Auf Wiedersehen, Welt!')\n" +"...\n" +"Auf Wiedersehen, Welt!\n" +"Traceback (letzter Aufruf zuletzt):\n" +" Datei \"\“, Zeile 2, in \n" +" raise KeyboardInterrupt\n" +"KeyboardInterrupt" msgid "" "If a :keyword:`finally` clause is present, the :keyword:`!finally` clause " @@ -695,6 +865,11 @@ msgid "" "This can be confusing and is therefore discouraged. From version 3.14 the " "compiler emits a :exc:`SyntaxWarning` for it (see :pep:`765`)." msgstr "" +"Wenn die Klausel :keyword:`!finally` eine Anweisung vom Typ " +":keyword:`break` , :keyword:`continue` oder :keyword:`return` " +"ausführt, werden Ausnahmen nicht erneut ausgelöst. Dies kann verwirrend sein" +" und wird daher nicht empfohlen. Ab Version 3.14 gibt der Compiler hierfür " +"die Fehlermeldung :exc:`SyntaxWarning` aus (siehe :pep:`765`)." msgid "" "If the :keyword:`!try` statement reaches a :keyword:`break`, :keyword:" @@ -715,6 +890,13 @@ msgid "" "therefore discouraged. From version 3.14 the compiler emits a :exc:" "`SyntaxWarning` for it (see :pep:`765`)." msgstr "" +"Wenn eine :keyword:`!finally` -Klausel eine :keyword:`!return` " +"-Anweisung enthält, ist der zurückgegebene Wert derjenige aus der " +":keyword:`!return` -Anweisung der :keyword:`!finally` -Klausel und nicht" +" der Wert aus der :keyword:`!return` -Anweisung der :keyword:`!try` " +"-Klausel. Dies kann verwirrend sein und wird daher nicht empfohlen. Ab " +"Version 3.14 gibt der Compiler hierfür eine :exc:`SyntaxWarning` -Meldung" +" aus (siehe :pep:`765`)." msgid "For example::" msgstr "Zum Beispiel::" @@ -729,6 +911,14 @@ msgid "" ">>> bool_return()\n" "False" msgstr "" +">>> def bool_return():\n" +"... try:\n" +"... return True\n" +"... finally:\n" +"... return False\n" +"...\n" +">>> bool_return()\n" +"False" msgid "A more complicated example::" msgstr "Ein komplizierteres Beispiel::" @@ -761,6 +951,32 @@ msgid "" " ~~^~~\n" "TypeError: unsupported operand type(s) for /: 'str' and 'str'" msgstr "" +">>> def divide(x, y):\n" +"... try:\n" +"... result = x / y\n" +"... except ZeroDivisionError:\n" +"... print(\"Division durch Null!\")\n" +"... else:\n" +"... print(\"Ergebnis ist\", result)\n" +"... finally:\n" +"... print(\"Ausführung der finally-Klausel\")\n" +"...\n" +">>> divide(2, 1)\n" +"Ergebnis ist 2.0\n" +"Ausführung der finally-Klausel\n" +">>> divide(2, 0)\n" +"Division durch Null!\n" +"Ausführung der finally-Klausel\n" +">>> divide(\"2\", \"1\")\n" +"Ausführung der finally-Klausel\n" +"Traceback (letzter Aufruf zuletzt):\n" +" Datei \"\“, Zeile 1, in \n" +" divide(\"2\", \"1\")\n" +" ~~~~~~^^^^^^^^^^\n" +" Datei \"\“, Zeile 3, in divide\n" +" result = x / y\n" +" ~~^~~\n" +"TypeError: Nicht unterstützte Operandentypen für /: 'str' und 'str'" msgid "" "As you can see, the :keyword:`finally` clause is executed in any event. " @@ -801,6 +1017,8 @@ msgid "" "for line in open(\"myfile.txt\"):\n" " print(line, end=\"\")" msgstr "" +"for line in open(\"myfile.txt\"):\n" +" print(line, end=\"\")" msgid "" "The problem with this code is that it leaves the file open for an " @@ -822,6 +1040,9 @@ msgid "" " for line in f:\n" " print(line, end=\"\")" msgstr "" +"with open(\"myfile.txt\") as f:\n" +" for line in f:\n" +" print(line, end=\"\")" msgid "" "After the statement is executed, the file *f* is always closed, even if a " @@ -887,6 +1108,29 @@ msgid "" "caught : e\n" ">>>" msgstr "" +">>> def f():\n" +"... excs = [OSError('Fehler 1'), SystemError('Fehler 2')]\n" +"... raise ExceptionGroup('Es sind Probleme aufgetreten', excs)\n" +"...\n" +">>> f()\n" +" + Traceback der Ausnahmegruppe (letzter Aufruf zuletzt):\n" +" | Datei \"\“, Zeile 1, in \n" +" | f()\n" +" | ~^^\n" +" | Datei \"\“, Zeile 3, in f\n" +" | raise ExceptionGroup('es gab Probleme', excs)\n" +" | ExceptionGroup: es gab Probleme (2 Unterausnahmen)\n" +" +-+---------------- 1 ----------------\n" +" | OSError: Fehler 1\n" +" +---------------- 2 ----------------\n" +" | SystemError: Fehler 2\n" +" +------------------------------------\n" +">>> try:\n" +"... f()\n" +"... except Exception as e:\n" +"... print(f'{type(e)} abgefangen: {e}')\n" +"... abgefangen: Es gab Probleme (2 Unterausnahmen)\n" +">>>" msgid "" "By using ``except*`` instead of ``except``, we can selectively handle only " @@ -944,6 +1188,46 @@ msgid "" " +------------------------------------\n" ">>>" msgstr "" +">>> def f():\n" +"... raise ExceptionGroup(\n" +"... \"group1\",\n" +"... [\n" +"... OSError(1),\n" +"... SystemError(2),\n" +"... ExceptionGroup(\n" +"... group2,\n" +"... [\n" +"... OSError(3),\n" +"... RecursionError(4)\n" +"... ]\n" +"... )\n" +"... ]\n" +"... )\n" +"...\n" +">>> try:\n" +"... f()\n" +"... except* OSError as e:\n" +"... print(\"Es gab OSErrors\")\n" +"... except* SystemError as e:\n" +"... print(\"Es gab SystemErrors\")\n" +"...\n" +"Es sind OSErrors aufgetreten\n" +"Es sind SystemErrors aufgetreten\n" +" + Traceback der Ausnahmegruppe (letzter Aufruf zuletzt):\n" +" | Datei \"\“, Zeile 2, in \n" +" | f()\n" +" | ~^^\n" +" | Datei \"\“, Zeile 2, in f\n" +" | raise ExceptionGroup(\n" +" | ...<12 lines>...\n" +" | )\n" +" | ExceptionGroup: group1 (1 Unterausnahme)\n" +" +-+---------------- 1 ----------------\n" +" | ExceptionGroup: group2 (1 Unterausnahme)\n" +" +-+---------------- 1 ----------------\n" +" | RecursionError: 4\n" +" +------------------------------------\n" +">>>" msgid "" "Note that the exceptions nested in an exception group must be instances, not " @@ -951,7 +1235,7 @@ msgid "" "that have already been raised and caught by the program, along the following " "pattern::" msgstr "" -"Beachten Sie, dass die in einer Ausnahmegruppe verschachtelten Ausnahmen " +"Beachte, dass die in einer Ausnahmegruppe verschachtelten Ausnahmen " "Instanzen und keine Typen sein müssen. Dies liegt daran, dass es sich in der " "Praxis typischerweise um Ausnahmen handelt, die bereits vom Programm " "ausgelöst und abgefangen wurden, und zwar nach dem folgenden Muster:" @@ -968,6 +1252,16 @@ msgid "" "... raise ExceptionGroup(\"Test Failures\", excs)\n" "..." msgstr "" +">>> excs = []\n" +"... for test in tests:\n" +"... try:\n" +"... test.run()\n" +"... except Exception as e:\n" +"... excs.append(e)\n" +"...\n" +">>> if excs:\n" +"... raise ExceptionGroup(\"Testfehler\", excs)\n" +"..." msgid "Enriching Exceptions with Notes" msgstr "Anreicherung von Ausnahmen mit Notizen" @@ -1006,6 +1300,21 @@ msgid "" "Add some more information\n" ">>>" msgstr "" +msgstr "" +">>> try:\n" +"... raise TypeError('falscher Typ')\n" +"... except Exception as e:\n" +"... e.add_note('Einige Informationen hinzufügen')\n" +"... e.add_note('Weitere Informationen hinzufügen')\n" +"... raise\n" +"...\n" +"Traceback (letzter Aufruf zuletzt):\n" +" Datei \"\“, Zeile 2, in \n" +" raise TypeError('falscher Typ')\n" +"TypeError: falscher Typ\n" +"Füge einige Informationen hinzu\n" +"Füge noch mehr Informationen hinzu\n" +">>>" msgid "" "For example, when collecting exceptions into an exception group, we may want " @@ -1064,3 +1373,48 @@ msgid "" " +------------------------------------\n" ">>>" msgstr "" +">>> def f():\n" +"... raise OSError('Vorgang fehlgeschlagen')\n" +"...\n" +">>> excs = []\n" +">>> for i in range(3):\n" +"... try:\n" +"... f()\n" +"... except Exception as e:\n" +"... e.add_note(f'Aufgetreten in Iteration {i+1}')\n" +"... excs.append(e)\n" +"...\n" +">>> raise ExceptionGroup('Es sind einige Probleme aufgetreten', excs)\n" +" + Traceback der Ausnahmegruppe (letzter Aufruf zuletzt):\n" +" | Datei \"\“, Zeile 1, in \n" +" | raise ExceptionGroup('Wir haben einige Probleme', excs)\n" +" | ExceptionGroup: Wir haben einige Probleme (3 Unterausnahmen)\n" +" +-+---------------- 1 ----------------\n" +" | Traceback (letzter Aufruf zuletzt):\n" +" | Datei \"\“, Zeile 3, in \n" +" | f()\n" +" | ~^^\n" +" | Datei \"\“, Zeile 2, in f\n" +" | raise OSError('operation failed')\n" +" | OSError: operation failed\n" +" | Aufgetreten in Iteration 1\n" +" +---------------- 2 ----------------\n" +" | Traceback (letzter Aufruf zuletzt):\n" +" | Datei \"\“, Zeile 3, in \n" +" | f()\n" +" | ~^^\n" +" | Datei \"\“, Zeile 2, in f\n" +" | raise OSError('operation failed')\n" +" | OSError: operation failed\n" +" | Aufgetreten in Iteration 2\n" +" +---------------- 3 ----------------\n" +" | Traceback (letzter Aufruf zuletzt):\n" +" | Datei \"\“, Zeile 3, in \n" +" | f()\n" +" | ~^^\n" +" | Datei \"\“, Zeile 2, in f\n" +" | raise OSError('operation failed')\n" +" | OSError: operation failed\n" +" | Aufgetreten in Iteration 3\n" +" +------------------------------------\n" +">>>" From 92540d121175a647a660c8970a187c4776762679 Mon Sep 17 00:00:00 2001 From: JystBreisgau Date: Wed, 12 Aug 2026 15:32:58 +0200 Subject: [PATCH 10/13] Correct German translations for error messages --- tutorial/errors.po | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tutorial/errors.po b/tutorial/errors.po index 111d8de..1c134e3 100644 --- a/tutorial/errors.po +++ b/tutorial/errors.po @@ -64,7 +64,7 @@ msgid "" "function :func:`print`, since a colon (``':'``) is missing just before it." msgstr "" "Der Parser wiederholt die fehlerhafte Zeile und zeigt kleine Pfeile an, die " -"auf die Stelle verweisen, an der der Fehler erkannt wurde. Beachten Sie, " +"auf die Stelle verweisen, an der der Fehler erkannt wurde. Beachte, " "dass dies nicht immer die Stelle ist, die korrigiert werden muss. Im " "Beispiel wird der Fehler bei der Funktions :func:`print` erkannt, da " "unmittelbar davor ein Doppelpunkt (``':'``) fehlt." @@ -193,7 +193,7 @@ msgstr "" "Schauen Sie sich das folgende Beispiel an, das den Benutzer zur Eingabe " "auffordert, bis ein gültiger Integer eingegeben wurde, dem Benutzer aber " "erlaubt, das Programm zu unterbrechen (mit :kbd:`Control-C` oder was auch " -"immer das Betriebssystem unterstützt); beachten Sie, dass eine vom Benutzer " +"immer das Betriebssystem unterstützt); beachte, dass eine vom Benutzer " "erzeugte Unterbrechung durch das Auslösen der Ausnahme :exc:" "`KeyboardInterrupt` signalisiert wird. ::" @@ -335,7 +335,7 @@ msgid "" "it would have printed B, B, B --- the first matching *except clause* is " "triggered." msgstr "" -"Beachten Sie, dass, wenn die *Exception-Klauseln* umgekehrt wären (mit " +"Beachte, dass, wenn die *Exception-Klauseln* umgekehrt wären (mit " "``except B`` zuerst), B, B, B ausgegeben worden wäre --- die erste passende " "*Exception-Klausel* wird ausgelöst." From 4a081bd973204853481f1933b7416068af9406bb Mon Sep 17 00:00:00 2001 From: JystBreisgau Date: Wed, 12 Aug 2026 15:55:06 +0200 Subject: [PATCH 11/13] Translate appendix.po to German Translated various sections of the appendix from English to German, including terms like 'Appendix', 'Interactive Mode', and error handling descriptions. Updated interactive shell details and customization module explanations. --- tutorial/appendix.po | 190 ++++++++++++++++++++++++++++++++----------- 1 file changed, 142 insertions(+), 48 deletions(-) diff --git a/tutorial/appendix.po b/tutorial/appendix.po index d6503ac..eab04f5 100644 --- a/tutorial/appendix.po +++ b/tutorial/appendix.po @@ -22,89 +22,136 @@ msgstr "" "Plural-Forms: nplurals=2; plural=(n != 1);\n" msgid "Appendix" -msgstr "" +msgstr "Anhang" msgid "Interactive Mode" -msgstr "" +msgstr "Interaktiver Modus" msgid "" "There are two variants of the interactive :term:`REPL`. The classic basic " "interpreter is supported on all platforms with minimal line control " "capabilities." msgstr "" +"Es gibt zwei Varianten des interaktiven :term:`REPL`. Der klassische Basic-" +"Interpreter wird auf allen Plattformen mit minimalen " +"Zeilensteuerungsfunktionen unterstützt." msgid "" -"On Windows, or Unix-like systems with :mod:`curses` support, a new " -"interactive shell is used by default since Python 3.13. This one supports " -"color, multiline editing, history browsing, and paste mode. To disable " -"color, see :ref:`using-on-controlling-color` for details. Function keys " -"provide some additional functionality. :kbd:`F1` enters the interactive help " -"browser :mod:`pydoc`. :kbd:`F2` allows for browsing command-line history " -"with neither output nor the :term:`>>>` and :term:`...` prompts. :kbd:`F3` " -"enters \"paste mode\", which makes pasting larger blocks of code easier. " -"Press :kbd:`F3` to return to the regular prompt." +"Since Python 3.13, a new interactive shell is used by default. This one " +"supports color, multiline editing, history browsing, and paste mode. To " +"disable color, see :ref:`using-on-controlling-color` for details. Function " +"keys provide some additional functionality. :kbd:`F1` enters the interactive" +" help browser :mod:`pydoc`. :kbd:`F2` allows for browsing command-line " +"history with neither output nor the :term:`>>>` and :term:`...` prompts. " +":kbd:`F3` enters \"paste mode\", which makes pasting larger blocks of code " +"easier. Press :kbd:`F3` to return to the regular prompt." msgstr "" +"Seit Python 3.13 wird standardmäßig eine neue interaktive Shell verwendet. " +"Diese unterstützt Farbdarstellung, mehrzeilige Bearbeitung, das Durchsuchen " +"des Verlaufs und den Einfügemodus. Um die Farbdarstellung zu deaktivieren, " +"finden Sie weitere Informationen unter :ref:`using-on-controlling-color`. " +"Funktionstasten bieten einige zusätzliche Funktionen. Mit :kbd:`F1` " +"rufen Sie den interaktiven Hilfe-Browser auf: :mod:`pydoc`. Mit :kbd:`F2` " +" können Sie den Befehlsverlauf durchsuchen, ohne dass eine Ausgabe oder die" +" Eingabeaufforderungen :term:`>>>` und :term:`...` angezeigt werden. Mit " +":kbd:`F3` rufen Sie den \"Einfügemodus\“ auf, der das Einfügen größerer " +"Codeblöcke erleichtert. Drücken Sie :kbd:`F3` , um zur normalen " +"Eingabeaufforderung zurückzukehren." msgid "" "When using the new interactive shell, exit the shell by typing :kbd:`exit` " -"or :kbd:`quit`. Adding call parentheses after those commands is not required." +"or :kbd:`quit`. Adding call parentheses after those commands is not " +"required." msgstr "" +"Wenn Sie die neue interaktive Shell verwenden, beenden Sie die Shell, indem " +"Sie :kbd:`exit` oder :kbd:`quit` eingeben. Das Hinzufügen von " +"Aufrufklammern nach diesen Befehlen ist nicht erforderlich." msgid "" -"If the new interactive shell is not desired, it can be disabled via the :" -"envvar:`PYTHON_BASIC_REPL` environment variable." +"If the new interactive shell is not desired, it can be disabled via the " +":envvar:`PYTHON_BASIC_REPL` environment variable." msgstr "" +"Falls die neue interaktive Shell nicht gewünscht ist, kann sie über die " +"Umgebungsvariable :envvar:`PYTHON_BASIC_REPL` deaktiviert werden." msgid "Error Handling" -msgstr "" +msgstr "Fehlerbehandlung" msgid "" "When an error occurs, the interpreter prints an error message and a stack " "trace. In interactive mode, it then returns to the primary prompt; when " "input came from a file, it exits with a nonzero exit status after printing " -"the stack trace. (Exceptions handled by an :keyword:`except` clause in a :" -"keyword:`try` statement are not errors in this context.) Some errors are " +"the stack trace. (Exceptions handled by an :keyword:`except` clause in a " +":keyword:`try` statement are not errors in this context.) Some errors are " "unconditionally fatal and cause an exit with a nonzero exit status; this " -"applies to internal inconsistencies and some cases of running out of " -"memory. All error messages are written to the standard error stream; normal " -"output from executed commands is written to standard output." +"applies to internal inconsistencies and some cases of running out of memory." +" All error messages are written to the standard error stream; normal output" +" from executed commands is written to standard output." msgstr "" +"Wenn ein Fehler auftritt, gibt der Interpreter eine Fehlermeldung und einen " +"Stack-Trace aus. Im interaktiven Modus kehrt er anschließend zur Hauptprompt" +" zurück; wenn die Eingabe aus einer Datei stammt, wird das Programm nach " +"Ausgabe des Stack-Trace mit einem Exit-Status ungleich Null beendet. " +"(Ausnahmen, die durch eine :keyword:`except` -Klausel in einer " +":keyword:`try` -Anweisung behandelt werden, gelten in diesem Zusammenhang " +"nicht als Fehler.) Einige Fehler sind bedingungslos schwerwiegend und " +"führen zu einem Abbruch mit einem Exit-Status ungleich Null; dies gilt für " +"interne Inkonsistenzen und bestimmte Fälle von Speichermangel. Alle " +"Fehlermeldungen werden in den Standard-Fehlerstrom geschrieben; die normale " +"Ausgabe der ausgeführten Befehle wird in die Standardausgabe geschrieben." msgid "" "Typing the interrupt character (usually :kbd:`Control-C` or :kbd:`Delete`) " "to the primary or secondary prompt cancels the input and returns to the " -"primary prompt. [#]_ Typing an interrupt while a command is executing raises " -"the :exc:`KeyboardInterrupt` exception, which may be handled by a :keyword:" -"`try` statement." +"primary prompt. [#]_ Typing an interrupt while a command is executing raises" +" the :exc:`KeyboardInterrupt` exception, which may be handled by a " +":keyword:`try` statement." msgstr "" +"Durch Eingabe des Unterbrechungszeichens (in der Regel :kbd:`Control-C` oder" +" :kbd:`Delete`) an der primären oder sekundären Eingabeaufforderung wird die" +" Eingabe abgebrochen und zur primären Eingabeaufforderung zurückgekehrt. " +"[#]_ Wird während der Ausführung eines Befehls ein Unterbrechungszeichen " +"eingegeben, wird die Ausnahme :exc:`KeyboardInterrupt` ausgelöst, die " +"durch eine :keyword:`try` -Anweisung abgefangen werden kann." msgid "Executable Python Scripts" -msgstr "" +msgstr "Ausführbare Python-Skripte" msgid "" "On BSD'ish Unix systems, Python scripts can be made directly executable, " "like shell scripts, by putting the line ::" msgstr "" +"Auf BSD-ähnlichen Unix-Systemen können Python-Skripte – ähnlich wie Shell-" +"Skripte – direkt ausführbar gemacht werden, indem man die Zeile ::" msgid "#!/usr/bin/env python3" -msgstr "" +msgstr "#!/usr/bin/env python3" msgid "" "(assuming that the interpreter is on the user's :envvar:`PATH`) at the " "beginning of the script and giving the file an executable mode. The ``#!`` " -"must be the first two characters of the file. On some platforms, this first " -"line must end with a Unix-style line ending (``'\\n'``), not a Windows " +"must be the first two characters of the file. On some platforms, this first" +" line must end with a Unix-style line ending (``'\\n'``), not a Windows " "(``'\\r\\n'``) line ending. Note that the hash, or pound, character, " "``'#'``, is used to start a comment in Python." msgstr "" +"(vorausgesetzt, der Interpreter befindet sich im Verzeichnis " +":envvar:`PATH` des Benutzers) am Anfang des Skripts einzufügen und der " +"Datei Ausführungsrechte zu erteilen. Die Zeichenfolge ``#!`` muss die " +"ersten beiden Zeichen der Datei bilden. Auf einigen Plattformen muss diese " +"erste Zeile mit einem Zeilenende im Unix-Stil (``'\\n'``) enden, nicht mit " +"einem Windows-Zeilenende (``'\\r\\n'``). Beachten Sie, dass das " +"Rautezeichen ( ``'#'``) in Python zum Einleiten eines Kommentars verwendet " +"wird." msgid "" -"The script can be given an executable mode, or permission, using the :" -"program:`chmod` command." -msgstr "" +"The script can be given an executable mode, or permission, using the " +":program:`chmod` command." +msgstr "" +"Dem Skript kann mithilfe des Befehls :program:`chmod` ein Ausführungsmodus bzw. eine "entsprechende Berechtigung zugewiesen werden." msgid "$ chmod +x myscript.py" -msgstr "" +msgstr "$ chmod +x myscript.py" msgid "" "On Windows systems, there is no notion of an \"executable mode\". The " @@ -113,9 +160,14 @@ msgid "" "extension can also be ``.pyw``, in that case, the console window that " "normally appears is suppressed." msgstr "" +"Unter Windows gibt es keinen \"Ausführungsmodus\“. Der Python-Installer ordnet" +" Dateien mit der Endung ``.py`` automatisch der Datei ``python.exe`` " +" zu, sodass ein Doppelklick auf eine Python-Datei diese als Skript ausführt." +" Die Dateiendung kann auch ``.pyw`` lauten; in diesem Fall wird das " +"normalerweise angezeigte Konsolenfenster unterdrückt." msgid "The Interactive Startup File" -msgstr "" +msgstr "Die interaktive Startdatei" msgid "" "When you use Python interactively, it is frequently handy to have some " @@ -124,24 +176,43 @@ msgid "" "the name of a file containing your start-up commands. This is similar to " "the :file:`.profile` feature of the Unix shells." msgstr "" +"Wenn Sie Python interaktiv nutzen, ist es oft praktisch, wenn beim Start des" +" Interpreters jedes Mal bestimmte Standardbefehle ausgeführt werden. Dazu " +"können Sie eine Umgebungsvariable namens :envvar:`PYTHONSTARTUP` auf den" +" Namen einer Datei setzen, die Ihre Startbefehle enthält. Dies entspricht " +"der Funktion :file:`.profile` der Unix-Shells." msgid "" "This file is only read in interactive sessions, not when Python reads " "commands from a script, and not when :file:`/dev/tty` is given as the " "explicit source of commands (which otherwise behaves like an interactive " "session). It is executed in the same namespace where interactive commands " -"are executed, so that objects that it defines or imports can be used without " -"qualification in the interactive session. You can also change the prompts " +"are executed, so that objects that it defines or imports can be used without" +" qualification in the interactive session. You can also change the prompts " "``sys.ps1`` and ``sys.ps2`` in this file." msgstr "" +"Diese Datei wird nur in interaktiven Sitzungen eingelesen, nicht jedoch, " +"wenn Python Befehle aus einem Skript ausführt, und auch nicht, wenn " +":file:`/dev/tty` als explizite Befehlsquelle angegeben wird (was sich " +"ansonsten wie eine interaktive Sitzung verhält). Sie wird im selben " +"Namensraum ausgeführt, in dem auch interaktive Befehle ausgeführt werden, " +"sodass Objekte, die darin definiert oder importiert werden, in der " +"interaktiven Sitzung ohne Qualifizierung verwendet werden können. Sie können" +" in dieser Datei auch die Eingabeaufforderungen ``sys.ps1`` und ``sys.ps2`` " +"ändern." msgid "" "If you want to read an additional start-up file from the current directory, " -"you can program this in the global start-up file using code like ``if os." -"path.isfile('.pythonrc.py'): exec(open('.pythonrc.py').read())``. If you " -"want to use the startup file in a script, you must do this explicitly in the " -"script::" +"you can program this in the global start-up file using code like ``if " +"os.path.isfile('.pythonrc.py'): exec(open('.pythonrc.py').read())``. If you " +"want to use the startup file in a script, you must do this explicitly in the" +" script::" msgstr "" +"Wenn Sie eine zusätzliche Startdatei aus dem aktuellen Verzeichnis einlesen " +"möchten, können Sie dies in der globalen Startdatei mit einem Code wie " +"``if os.path.isfile('.pythonrc.py'): exec(open('.pythonrc.py').read())`` " +"programmieren. Wenn Sie die Startdatei in einem Skript verwenden möchten, " +"müssen Sie dies explizit im Skript tun::" msgid "" "import os\n" @@ -151,39 +222,62 @@ msgid "" " startup_file = fobj.read()\n" " exec(startup_file)" msgstr "" +"import os\n" +"filename = os.environ.get('PYTHONSTARTUP')\n" +"if filename and os.path.isfile(filename):\n" +" with open(filename) as fobj:\n" +" startup_file = fobj.read()\n" +" exec(startup_file)" msgid "The Customization Modules" -msgstr "" +msgstr "Die Anpassungsmodule" msgid "" "Python provides two hooks to let you customize it: :index:`sitecustomize` " -"and :index:`usercustomize`. To see how it works, you need first to find the " -"location of your user site-packages directory. Start Python and run this " +"and :index:`usercustomize`. To see how it works, you need first to find the" +" location of your user site-packages directory. Start Python and run this " "code::" msgstr "" +"Python bietet zwei Hooks, mit denen Sie das Programm anpassen können: " +":index:`sitecustomize` und :index:`usercustomize` . Um zu sehen, wie " +"das funktioniert, müssen Sie zunächst den Speicherort Ihres " +"Benutzerverzeichnisses \"site-packages\“ ermitteln. Starten Sie Python und " +"führen Sie folgenden Code aus::" msgid "" ">>> import site\n" ">>> site.getusersitepackages()\n" "'/home/user/.local/lib/python3.x/site-packages'" msgstr "" +">>> import site\n" +">>> site.getusersitepackages()\n" +"'/home/user/.local/lib/python3.x/site-packages'" msgid "" "Now you can create a file named :file:`usercustomize.py` in that directory " -"and put anything you want in it. It will affect every invocation of Python, " -"unless it is started with the :option:`-s` option to disable the automatic " +"and put anything you want in it. It will affect every invocation of Python," +" unless it is started with the :option:`-s` option to disable the automatic " "import." msgstr "" +"Nun können Sie in diesem Verzeichnis eine Datei mit dem Namen " +":file:`usercustomize.py` erstellen und darin beliebige Inhalte ablegen. " +"Dies wirkt sich auf jeden Aufruf von Python aus, es sei denn, Python wird " +"mit der Option :option:`-s` gestartet, um den automatischen Import zu " +"deaktivieren." msgid "" -":index:`sitecustomize` works in the same way, but is typically created by an " -"administrator of the computer in the global site-packages directory, and is " -"imported before :index:`usercustomize`. See the documentation of the :mod:" -"`site` module for more details." +":index:`sitecustomize` works in the same way, but is typically created by an" +" administrator of the computer in the global site-packages directory, and is" +" imported before :index:`usercustomize`. See the documentation of the " +":mod:`site` module for more details." msgstr "" +":index:`sitecustomize` funktioniert auf dieselbe Weise, wird jedoch in der " +"Regel von einem Administrator des Computers im Verzeichnis \"global/site-" +"packages\“ angelegt und vor :index:`usercustomize` importiert. Weitere " +"Informationen finden Sie in der Dokumentation zum Modul :mod:`site` ." msgid "Footnotes" msgstr "Fußnoten" msgid "A problem with the GNU Readline package may prevent this." -msgstr "" +msgstr "Ein Problem mit dem GNU-Readline-Paket könnte dies verhindern." From ff6e8adf45a04276480443ca4442853c382810ab Mon Sep 17 00:00:00 2001 From: JystBreisgau Date: Wed, 12 Aug 2026 15:59:35 +0200 Subject: [PATCH 12/13] Improve German translations in whatnow.po Updated German translations for various tutorial sections. --- tutorial/whatnow.po | 103 +++++++++++++++++++++++++++++++++----------- 1 file changed, 79 insertions(+), 24 deletions(-) diff --git a/tutorial/whatnow.po b/tutorial/whatnow.po index d17eb62..4293744 100644 --- a/tutorial/whatnow.po +++ b/tutorial/whatnow.po @@ -22,53 +22,75 @@ msgstr "" "Plural-Forms: nplurals=2; plural=(n != 1);\n" msgid "What Now?" -msgstr "" +msgstr "Wie geht es nun weiter?" msgid "" "Reading this tutorial has probably reinforced your interest in using Python " -"--- you should be eager to apply Python to solving your real-world problems. " -"Where should you go to learn more?" +"--- you should be eager to apply Python to solving your real-world problems." +" Where should you go to learn more?" msgstr "" +"Das Lesen dieses Tutorials hat Ihr Interesse an der Nutzung von Python " +"wahrscheinlich noch verstärkt – Sie sollten nun darauf brennen, Python zur " +"Lösung Ihrer praktischen Probleme einzusetzen. Wo können Sie mehr darüber " +"erfahren?" msgid "" "This tutorial is part of Python's documentation set. Some other documents " "in the set are:" msgstr "" +"Dieses Tutorial ist Teil der Python-Dokumentation. Weitere Dokumente " +"dieser Reihe sind:" msgid ":ref:`library-index`:" -msgstr "" +msgstr ":ref:`library-index`:" msgid "" "You should browse through this manual, which gives complete (though terse) " "reference material about types, functions, and the modules in the standard " "library. The standard Python distribution includes a *lot* of additional " -"code. There are modules to read Unix mailboxes, retrieve documents via HTTP, " -"generate random numbers, parse command-line options, compress data, and many " -"other tasks. Skimming through the Library Reference will give you an idea of " -"what's available." -msgstr "" +"code. There are modules to read Unix mailboxes, retrieve documents via HTTP," +" generate random numbers, parse command-line options, compress data, and " +"many other tasks. Skimming through the Library Reference will give you an " +"idea of what's available." +msgstr "" +"Sie sollten dieses Handbuch durchblättern, das umfassendes (wenn auch knapp " +"gehaltenes) Referenzmaterial zu Typen, Funktionen und den Modulen der " +"Standardbibliothek enthält. Die Standard-Python-Distribution enthält *sehr " +"viel* zusätzlichen Code. Es gibt Module zum Auslesen von Unix-Mailboxen, zum" +" Abrufen von Dokumenten über HTTP, zum Generieren von Zufallszahlen, zum " +"Parsen von Befehlszeilenoptionen, zum Komprimieren von Daten und für viele " +"andere Aufgaben. Ein kurzer Blick in die Bibliotheksreferenz vermittelt " +"Ihnen einen Eindruck davon, was alles verfügbar ist." msgid "" ":ref:`installing-index` explains how to install additional modules written " "by other Python users." msgstr "" +":ref:`installing-index` erläutert, wie man zusätzliche Module installiert, " +"die von anderen Python-Anwendern geschrieben wurden." msgid "" ":ref:`reference-index`: A detailed explanation of Python's syntax and " "semantics. It's heavy reading, but is useful as a complete guide to the " "language itself." msgstr "" +":ref:`reference-index`: Eine ausführliche Erläuterung der Syntax und " +"Semantik von Python. Es ist zwar anspruchsvolle Lektüre, eignet sich aber " +"gut als umfassender Leitfaden zur Sprache selbst." msgid "More Python resources:" -msgstr "" +msgstr "Weitere Python-Ressourcen:" msgid "" -"https://www.python.org: The major Python web site. It contains code, " +"https://www.python.org: The major Python website. It contains code, " "documentation, and pointers to Python-related pages around the web." msgstr "" +"https://www.python.org: Die wichtigste Python-Website. Sie enthält Code, " +"Dokumentation und Verweise auf Python-bezogene Seiten im Internet." msgid "https://docs.python.org: Fast access to Python's documentation." msgstr "" +"https://docs.python.org: Schneller Zugriff auf die Python-Dokumentation." msgid "" "https://pypi.org: The Python Package Index, previously also nicknamed the " @@ -76,47 +98,80 @@ msgid "" "available for download. Once you begin releasing code, you can register it " "here so that others can find it." msgstr "" +"https://pypi.org: Der Python Package Index, früher auch unter dem Spitznamen" +" \"Cheese Shop\“ bekannt ( [#]_), ist ein Verzeichnis von benutzerdefinierten " +"Python-Modulen, die zum Download bereitstehen. Sobald Sie Code " +"veröffentlichen, können Sie ihn hier registrieren, damit andere ihn finden " +"können." msgid "" -"https://code.activestate.com/recipes/langs/python/: The Python Cookbook is a " -"sizable collection of code examples, larger modules, and useful scripts. " +"https://code.activestate.com/recipes/langs/python/: The Python Cookbook is a" +" sizable collection of code examples, larger modules, and useful scripts. " "Particularly notable contributions are collected in a book also titled " "Python Cookbook (O'Reilly & Associates, ISBN 0-596-00797-3.)" msgstr "" +"https://code.activestate.com/recipes/langs/python/: Das \"Python Cookbook\“ " +"ist eine umfangreiche Sammlung von Code-Beispielen, größeren Modulen und " +"nützlichen Skripten. Besonders bemerkenswerte Beiträge sind in einem Buch " +"zusammengefasst, das ebenfalls den Titel \"Python Cookbook\“ trägt (O'Reilly &" +" Associates, ISBN 0-596-00797-3)." msgid "" -"https://pyvideo.org collects links to Python-related videos from conferences " -"and user-group meetings." +"https://pyvideo.org collects links to Python-related videos from conferences" +" and user-group meetings." msgstr "" +"https://pyvideo.org sammelt Links zu Python-bezogenen Videos von " +"Konferenzen und Treffen von Benutzergruppen." msgid "" "https://scipy.org: The Scientific Python project includes modules for fast " -"array computations and manipulations plus a host of packages for such things " -"as linear algebra, Fourier transforms, non-linear solvers, random number " +"array computations and manipulations plus a host of packages for such things" +" as linear algebra, Fourier transforms, non-linear solvers, random number " "distributions, statistical analysis and the like." msgstr "" +"https://scipy.org: Das \"Scientific Python\“-Projekt umfasst Module für " +"schnelle Berechnungen und Bearbeitungen mit Arrays sowie eine Vielzahl von " +"Paketen für Bereiche wie lineare Algebra, Fourier-Transformationen, " +"nichtlineare Löser, Zufallsverteilungen, statistische Analysen und " +"Ähnliches." msgid "" "For Python-related questions and problem reports, you can post to the " -"newsgroup :newsgroup:`comp.lang.python`, or send them to the mailing list at " -"python-list@python.org. The newsgroup and mailing list are gatewayed, so " +"newsgroup :newsgroup:`comp.lang.python`, or send them to the mailing list at" +" python-list@python.org. The newsgroup and mailing list are gatewayed, so " "messages posted to one will automatically be forwarded to the other. There " -"are hundreds of postings a day, asking (and answering) questions, suggesting " -"new features, and announcing new modules. Mailing list archives are " +"are hundreds of postings a day, asking (and answering) questions, suggesting" +" new features, and announcing new modules. Mailing list archives are " "available at https://mail.python.org/pipermail/." msgstr "" +"Bei Fragen zu Python und zur Meldung von Problemen können Sie Beiträge in " +"der Newsgroup :newsgroup:`comp.lang.python` veröffentlichen oder diese an " +"die Mailingliste unter python-list@python.org senden. Die Newsgroup und die" +" Mailingliste sind miteinander verbunden, sodass Nachrichten, die in der " +"einen gepostet werden, automatisch an die andere weitergeleitet werden. " +"Täglich gibt es Hunderte von Beiträgen, in denen Fragen gestellt (und " +"beantwortet) werden, neue Funktionen vorgeschlagen und neue Module " +"angekündigt werden. Die Archive der Mailingliste sind unter " +"https://mail.python.org/pipermail/ verfügbar." msgid "" "Before posting, be sure to check the list of :ref:`Frequently Asked " "Questions ` (also called the FAQ). The FAQ answers many of the " -"questions that come up again and again, and may already contain the solution " -"for your problem." +"questions that come up again and again, and may already contain the solution" +" for your problem." msgstr "" +"Bevor Sie einen Beitrag verfassen, sollten Sie unbedingt die Liste der " +":ref:`Häufig gestellten Fragen ` (auch FAQ genannt) durchsehen. " +"Die FAQ beantwortet viele der immer wieder auftauchenden Fragen und enthält " +"möglicherweise bereits die Lösung für Ihr Problem." msgid "Footnotes" msgstr "Fußnoten" msgid "" -"\"Cheese Shop\" is a Monty Python's sketch: a customer enters a cheese shop, " +"\"Cheese Shop\" is a Monty Python sketch: a customer enters a cheese shop, " "but whatever cheese he asks for, the clerk says it's missing." msgstr "" +"\"Cheese Shop\“ ist ein Sketch von Monty Python: Ein Kunde betritt einen " +"Käseladen, doch egal, nach welchem Käse er fragt, der Verkäufer sagt immer, " +"dieser sei nicht vorrätig." From d6e1b6c9a60689f412b2e77ef5165beb7ba0c816 Mon Sep 17 00:00:00 2001 From: JystBreisgau Date: Wed, 12 Aug 2026 16:01:44 +0200 Subject: [PATCH 13/13] Fix German translation for chmod command explanation --- tutorial/appendix.po | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tutorial/appendix.po b/tutorial/appendix.po index eab04f5..814e5e3 100644 --- a/tutorial/appendix.po +++ b/tutorial/appendix.po @@ -148,7 +148,8 @@ msgid "" "The script can be given an executable mode, or permission, using the " ":program:`chmod` command." msgstr "" -"Dem Skript kann mithilfe des Befehls :program:`chmod` ein Ausführungsmodus bzw. eine "entsprechende Berechtigung zugewiesen werden." +"Dem Skript kann mithilfe des Befehls :program:`chmod` ein Ausführungsmodus bzw. " +"eine "entsprechende Berechtigung zugewiesen werden." msgid "$ chmod +x myscript.py" msgstr "$ chmod +x myscript.py"