# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3.14\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-08-22 12:07+0200\n"

"PO-Revision-Date: 2025-09-16 00:02+0000\n"

"Last-Translator: \n"

"Language-Team: German (https://app.transifex.com/python-doc/teams/5390/de/)\n"

"Language: de\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: ../../tutorial/stdlib2.rst:5

msgid "Brief tour of the standard library --- part II"

msgstr "Ein kurzer Überblick über die Standardbibliothek – Teil II"

#: ../../tutorial/stdlib2.rst:7

msgid ""

"This second tour covers more advanced modules that support professional "

"programming needs. These modules rarely occur in small scripts."

msgstr ""

"Dieser zweite Durchgang behandelt fortgeschrittenere Module, die den "

"Anforderungen professioneller Programmierer gerecht werden. Diese Module "

"kommen in kleinen Skripten nur selten vor."

#: ../../tutorial/stdlib2.rst:14

msgid "Output formatting"

msgstr "Ausgabeformatierung"

#: ../../tutorial/stdlib2.rst:16

msgid ""

"The :mod:`reprlib` module provides a version of :func:`repr` customized for "

"abbreviated displays of large or deeply nested containers::"

msgstr ""

"Das Modul :mod:`reprlib` stellt eine für die verkürzte Darstellung großer "

"oder tief verschachtelter Container angepasste Version von :func:`repr` "

"bereit::"

#: ../../tutorial/stdlib2.rst:19

msgid ""

">>> import reprlib\n"

">>> reprlib.repr(set('supercalifragilisticexpialidocious'))\n"

"\"{'a', 'c', 'd', 'e', 'f', 'g', ...}\""

msgstr ""

">>> import reprlib\n"

">>> reprlib.repr(set('supercalifragilisticexpialidocious'))\n"

"\"{'a', 'c', 'd', 'e', 'f', 'g', ...}\""

#: ../../tutorial/stdlib2.rst:23

msgid ""

"The :mod:`pprint` module offers more sophisticated control over printing "

"both built-in and user defined objects in a way that is readable by the "

"interpreter. When the result is longer than one line, the \"pretty printer\" "

"adds line breaks and indentation to more clearly reveal data structure::"

msgstr ""

"Das Modul :mod:`pprint` bietet eine ausgefeiltere Steuerung beim Ausgeben "

"sowohl integrierter als auch benutzerdefinierter Objekte in einer für den "

"Interpreter lesbaren Form. Wenn das Ergebnis länger als eine Zeile ist, fügt "

"der „Pretty Printer“ Zeilenumbrüche und Einrückungen hinzu, um die "

"Datenstruktur übersichtlicher darzustellen::"

#: ../../tutorial/stdlib2.rst:28

msgid ""

">>> import pprint\n"

">>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',\n"

"... 'yellow'], 'blue']]]\n"

"...\n"

">>> pprint.pprint(t, width=30)\n"

"[[[['black', 'cyan'],\n"

" 'white',\n"

" ['green', 'red']],\n"

" [['magenta', 'yellow'],\n"

" 'blue']]]"

msgstr ""

">>> import pprint\n"

">>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',\n"

"... 'yellow'], 'blue']]]\n"

"...\n"

">>> pprint.pprint(t, width=30)\n"

"[[[['black', 'cyan'],\n"

" 'white',\n"

" ['green', 'red']],\n"

" [['magenta', 'yellow'],\n"

" 'blue']]]"

#: ../../tutorial/stdlib2.rst:39

msgid ""

"The :mod:`textwrap` module formats paragraphs of text to fit a given screen "

"width::"

msgstr ""

"Das Modul :mod:`textwrap` passt Textabsätze an eine bestimmte "

"Bildschirmbreite an::"

#: ../../tutorial/stdlib2.rst:42

msgid ""

">>> import textwrap\n"

">>> doc = \"\"\"The wrap() method is just like fill() except that it "

"returns\n"

"... a list of strings instead of one big string with newlines to separate\n"

"... the wrapped lines.\"\"\"\n"

"...\n"

">>> print(textwrap.fill(doc, width=40))\n"

"The wrap() method is just like fill()\n"

"except that it returns a list of strings\n"

"instead of one big string with newlines\n"

"to separate the wrapped lines."

msgstr ""

">>> import textwrap\n"

">>> doc = \"\"\"The wrap() method is just like fill() except that it "

"returns\n"

"... a list of strings instead of one big string with newlines to separate\n"

"... the wrapped lines.\"\"\"\n"

"...\n"

">>> print(textwrap.fill(doc, width=40))\n"

"The wrap() method is just like fill()\n"

"except that it returns a list of strings\n"

"instead of one big string with newlines\n"

"to separate the wrapped lines."

#: ../../tutorial/stdlib2.rst:53

msgid ""

"The :mod:`locale` module accesses a database of culture specific data "

"formats. The grouping attribute of locale's format function provides a "

"direct way of formatting numbers with group separators::"

msgstr ""

"Das Modul :mod:`locale` greift auf eine Datenbank mit kulturspezifischen "

"Datenformaten zu. Das Gruppierungsattribut der Formatierungsfunktion von "

"\"locale“ bietet eine direkte Möglichkeit, Zahlen mit Gruppentrennzeichen zu "

"formatieren::"

#: ../../tutorial/stdlib2.rst:57

msgid ""

">>> import locale\n"

">>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')\n"

"'English_United States.1252'\n"

">>> conv = locale.localeconv() # get a mapping of conventions\n"

">>> x = 1234567.8\n"

">>> locale.format_string(\"%d\", x, grouping=True)\n"

"'1,234,567'\n"

">>> locale.format_string(\"%s%.*f\", (conv['currency_symbol'],\n"

"... conv['frac_digits'], x), grouping=True)\n"

"'$1,234,567.80'"

msgstr ""

">>> import locale\n"

">>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')\n"

"'English_United States.1252'\n"

">>> conv = locale.localeconv() # get a mapping of conventions\n"

">>> x = 1234567.8\n"

">>> locale.format_string(\"%d\", x, grouping=True)\n"

"'1,234,567'\n"

">>> locale.format_string(\"%s%.*f\", (conv['currency_symbol'],\n"

"... conv['frac_digits'], x), grouping=True)\n"

"'$1,234,567.80'"

#: ../../tutorial/stdlib2.rst:72

msgid "Templating"

msgstr "Vorlagen"

#: ../../tutorial/stdlib2.rst:74

msgid ""

"The :mod:`string` module includes a versatile :class:`~string.Template` "

"class with a simplified syntax suitable for editing by end-users. This "

"allows users to customize their applications without having to alter the "

"application."

msgstr ""

"Das Modul :mod:`string` enthält eine vielseitige Klasse :class:`~string."

"Template` mit einer vereinfachten Syntax, die sich für die Bearbeitung durch "

"Endbenutzer eignet. Dadurch können Benutzer ihre Anwendungen anpassen, ohne "

"den Anwendungscode ändern zu müssen."

#: ../../tutorial/stdlib2.rst:78

msgid ""

"The format uses placeholder names formed by ``$`` with valid Python "

"identifiers (alphanumeric characters and underscores). Surrounding the "

"placeholder with braces allows it to be followed by more alphanumeric "

"letters with no intervening spaces. Writing ``$$`` creates a single escaped "

"``$``::"

msgstr ""

"Das Format verwendet Platzhalternamen, die aus ``$`` in Kombination mit "

"gültigen Python-Bezeichnern (alphanumerische Zeichen und Unterstriche) "

"gebildet werden. Durch die Einfassung des Platzhalters in geschweifte "

"Klammern können weitere alphanumerische Zeichen ohne dazwischenliegende "

"Leerzeichen folgen. Durch die Schreibweise ``$$`` wird ein einzelner Escape-"

"Platzhalter ``$`` erzeugt ::"

#: ../../tutorial/stdlib2.rst:83

msgid ""

">>> from string import Template\n"

">>> t = Template('${village}folk send $$10 to $cause.')\n"

">>> t.substitute(village='Nottingham', cause='the ditch fund')\n"

"'Nottinghamfolk send $10 to the ditch fund.'"

msgstr ""

">>> from string import Template\n"

">>> t = Template('${village}folk send $$10 to $cause.')\n"

">>> t.substitute(village='Nottingham', cause='the ditch fund')\n"

"'Nottinghamfolk send $10 to the ditch fund.'"

#: ../../tutorial/stdlib2.rst:88

msgid ""

"The :meth:`~string.Template.substitute` method raises a :exc:`KeyError` when "

"a placeholder is not supplied in a dictionary or a keyword argument. For "

"mail-merge style applications, user supplied data may be incomplete and the :"

"meth:`~string.Template.safe_substitute` method may be more appropriate --- "

"it will leave placeholders unchanged if data is missing::"

msgstr ""

"Die Methode :meth:`~string.Template.substitute` löst einen :exc:`KeyError` "

"aus, wenn in einem Wörterbuch oder einem Schlüsselwortargument kein "

"Platzhalter angegeben wurde. Bei Anwendungen im Stil einer "

"Seriendruckfunktion können die vom Benutzer bereitgestellten Daten "

"unvollständig sein, sodass die Methode :meth:`~string.Template."

"safe_substitute` möglicherweise besser geeignet ist – sie lässt Platzhalter "

"unverändert, wenn Daten fehlen::"

#: ../../tutorial/stdlib2.rst:94

msgid ""

">>> t = Template('Return the $item to $owner.')\n"

">>> d = dict(item='unladen swallow')\n"

">>> t.substitute(d)\n"

"Traceback (most recent call last):\n"

" ...\n"

"KeyError: 'owner'\n"

">>> t.safe_substitute(d)\n"

"'Return the unladen swallow to $owner.'"

msgstr ""

">>> t = Template('Return the $item to $owner.')\n"

">>> d = dict(item='unladen swallow')\n"

">>> t.substitute(d)\n"

"Traceback (most recent call last):\n"

" ...\n"

"KeyError: 'owner'\n"

">>> t.safe_substitute(d)\n"

"'Return the unladen swallow to $owner.'"

#: ../../tutorial/stdlib2.rst:103

msgid ""

"Template subclasses can specify a custom delimiter. For example, a batch "

"renaming utility for a photo browser may elect to use percent signs for "

"placeholders such as the current date, image sequence number, or file "

"format::"

msgstr ""

"Unterklassen von Vorlagen können ein benutzerdefiniertes Trennzeichen "

"festlegen. Beispielsweise könnte ein Dienstprogramm zur Stapelumbenennung "

"für einen Foto-Browser Prozentzeichen für Platzhalter wie das aktuelle "

"Datum, die Bildnummer oder das Dateiformat verwenden::"

#: ../../tutorial/stdlib2.rst:107

msgid ""

">>> import time, os.path\n"

">>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']\n"

">>> class BatchRename(Template):\n"

"... delimiter = '%'\n"

"...\n"

">>> fmt = input('Enter rename style (%d-date %n-seqnum %f-format): ')\n"

"Enter rename style (%d-date %n-seqnum %f-format): Ashley_%n%f\n"

"\n"

">>> t = BatchRename(fmt)\n"

">>> date = time.strftime('%d%b%y')\n"

">>> for i, filename in enumerate(photofiles):\n"

"... base, ext = os.path.splitext(filename)\n"

"... newname = t.substitute(d=date, n=i, f=ext)\n"

"... print('{0} --> {1}'.format(filename, newname))\n"

"\n"

"img_1074.jpg --> Ashley_0.jpg\n"

"img_1076.jpg --> Ashley_1.jpg\n"

"img_1077.jpg --> Ashley_2.jpg"

msgstr ""

">>> import time, os.path\n"

">>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']\n"

">>> class BatchRename(Template):\n"

"... delimiter = '%'\n"

"...\n"

">>> fmt = input('Enter rename style (%d-date %n-seqnum %f-format): ')\n"

"Enter rename style (%d-date %n-seqnum %f-format): Ashley_%n%f\n"

"\n"

">>> t = BatchRename(fmt)\n"

">>> date = time.strftime('%d%b%y')\n"

">>> for i, filename in enumerate(photofiles):\n"

"... base, ext = os.path.splitext(filename)\n"

"... newname = t.substitute(d=date, n=i, f=ext)\n"

"... print('{0} --> {1}'.format(filename, newname))\n"

"\n"

"img_1074.jpg --> Ashley_0.jpg\n"

"img_1076.jpg --> Ashley_1.jpg\n"

"img_1077.jpg --> Ashley_2.jpg"

#: ../../tutorial/stdlib2.rst:126

msgid ""

"Another application for templating is separating program logic from the "

"details of multiple output formats. This makes it possible to substitute "

"custom templates for XML files, plain text reports, and HTML web reports."

msgstr ""

"Eine weitere Anwendungsmöglichkeit für Templates ist die Trennung der "

"Programmlogik von den Details verschiedener Ausgabeformate. Dadurch lassen "

"sich XML-Dateien, Berichte im Klartext und HTML-Webberichte durch "

"benutzerdefinierte Templates ersetzen."

#: ../../tutorial/stdlib2.rst:134

msgid "Working with binary data record layouts"

msgstr "Arbeiten mit Layouts für binäre Datensätze"

#: ../../tutorial/stdlib2.rst:136

msgid ""

"The :mod:`struct` module provides :func:`~struct.pack` and :func:`~struct."

"unpack` functions for working with variable length binary record formats. "

"The following example shows how to loop through header information in a ZIP "

"file without using the :mod:`zipfile` module. Pack codes ``\"H\"`` and "

"``\"I\"`` represent two and four byte unsigned numbers respectively. The "

"``\"<\"`` indicates that they are standard size and in little-endian byte "

"order::"

msgstr ""

"Das Modul :mod:`struct` stellt die Funktionen :func:`~struct.pack` und :func:"

"`~struct.unpack` für die Arbeit mit binären Datensatzformaten variabler "

"Länge bereit. Das folgende Beispiel zeigt, wie man die Header-Informationen "

"einer ZIP-Datei durchlaufen kann, ohne das Modul :mod:`zipfile` zu "

"verwenden. Die Pack-Codes ``\"H\"`` und ``\"I\"`` stehen für vorzeichenlose "

"Zahlen mit zwei bzw. vier Bytes. Der ``\"<\"`` gibt an, dass es sich um "

"Standardgrößen in Little-Endian-Byte-Reihenfolge handelt::"

#: ../../tutorial/stdlib2.rst:144

msgid ""

"import struct\n"

"\n"

"with open('myfile.zip', 'rb') as f:\n"

" data = f.read()\n"

"\n"

"start = 0\n"

"for i in range(3): # show the first 3 file headers\n"

" start += 14\n"

" fields = struct.unpack('<IIIHH', data[start:start+16])\n"

" crc32, comp_size, uncomp_size, filenamesize, extra_size = fields\n"

"\n"

" start += 16\n"

" filename = data[start:start+filenamesize]\n"

" start += filenamesize\n"

" extra = data[start:start+extra_size]\n"

" print(filename, hex(crc32), comp_size, uncomp_size)\n"

"\n"

" start += extra_size + comp_size # skip to the next header"

msgstr ""

"import struct\n"

"\n"

"with open('myfile.zip', 'rb') as f:\n"

" data = f.read()\n"

"\n"

"start = 0\n"

"for i in range(3): # show the first 3 file headers\n"

" start += 14\n"

" fields = struct.unpack('<IIIHH', data[start:start+16])\n"

" crc32, comp_size, uncomp_size, filenamesize, extra_size = fields\n"

"\n"

" start += 16\n"

" filename = data[start:start+filenamesize]\n"

" start += filenamesize\n"

" extra = data[start:start+extra_size]\n"

" print(filename, hex(crc32), comp_size, uncomp_size)\n"

"\n"

" start += extra_size + comp_size # skip to the next header"

#: ../../tutorial/stdlib2.rst:167

msgid "Multi-threading"

msgstr "Multithreading"

#: ../../tutorial/stdlib2.rst:169

msgid ""

"Threading is a technique for decoupling tasks which are not sequentially "

"dependent. Threads can be used to improve the responsiveness of "

"applications that accept user input while other tasks run in the "

"background. A related use case is running I/O in parallel with computations "

"in another thread."

msgstr ""

"Threading ist eine Technik zur Entkopplung von Aufgaben, die nicht "

"sequenziell voneinander abhängig sind. Threads können eingesetzt werden, um "

"die Reaktionsfähigkeit von Anwendungen zu verbessern, die Benutzereingaben "

"entgegennehmen, während andere Aufgaben im Hintergrund ausgeführt werden. "

"Ein damit verbundener Anwendungsfall ist die parallele Ausführung von E/A-"

"Vorgängen und Berechnungen in einem anderen Thread."

#: ../../tutorial/stdlib2.rst:174

msgid ""

"The following code shows how the high level :mod:`threading` module can run "

"tasks in background while the main program continues to run::"

msgstr ""

"Der folgende Code zeigt, wie das High-Level- :mod:`threading` -Modul "

"Aufgaben im Hintergrund ausführen kann, während das Hauptprogramm "

"weiterläuft::"

#: ../../tutorial/stdlib2.rst:177

msgid ""

"import threading, zipfile\n"

"\n"

"class AsyncZip(threading.Thread):\n"

" def __init__(self, infile, outfile):\n"

" super().__init__()\n"

" self.infile = infile\n"

" self.outfile = outfile\n"

"\n"

" def run(self):\n"

" with zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED) as f:\n"

" f.write(self.infile)\n"

" print('Finished background zip of:', self.infile)\n"

"\n"

"background = AsyncZip('mydata.txt', 'myarchive.zip')\n"

"background.start()\n"

"print('The main program continues to run in foreground.')\n"

"\n"

"background.join() # Wait for the background task to finish\n"

"print('Main program waited until background was done.')"

msgstr ""

"import threading, zipfile\n"

"\n"

"class AsyncZip(threading.Thread):\n"

" def __init__(self, infile, outfile):\n"

" super().__init__()\n"

" self.infile = infile\n"

" self.outfile = outfile\n"

"\n"

" def run(self):\n"

" with zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED) as f:\n"

" f.write(self.infile)\n"

" print('Finished background zip of:', self.infile)\n"

"\n"

"background = AsyncZip('mydata.txt', 'myarchive.zip')\n"

"background.start()\n"

"print('The main program continues to run in foreground.')\n"

"\n"

"background.join() # Wait for the background task to finish\n"

"print('Main program waited until background was done.')"

#: ../../tutorial/stdlib2.rst:197

msgid ""

"The principal challenge of multi-threaded applications is coordinating "

"threads that share data or other resources. To that end, the threading "

"module provides a number of synchronization primitives including locks, "

"events, condition variables, and semaphores."

msgstr ""

"Die größte Herausforderung bei Multithread-Anwendungen besteht darin, "

"Threads zu koordinieren, die Daten oder andere Ressourcen gemeinsam nutzen. "

"Zu diesem Zweck stellt das Threading-Modul eine Reihe von "

"Synchronisationsprimitiven bereit, darunter Sperren, Ereignisse, "

"Bedingungsvariablen und Semaphoren."

#: ../../tutorial/stdlib2.rst:202

msgid ""

"While those tools are powerful, minor design errors can result in problems "

"that are difficult to reproduce. So, the preferred approach to task "

"coordination is to concentrate all access to a resource in a single thread "

"and then use the :mod:`queue` module to feed that thread with requests from "

"other threads. Applications using :class:`~queue.Queue` objects for inter-"

"thread communication and coordination are easier to design, more readable, "

"and more reliable."

msgstr ""

"Obwohl diese Werkzeuge leistungsstark sind, können bereits kleine "

"Designfehler zu Problemen führen, die sich nur schwer reproduzieren lassen. "

"Daher besteht der bevorzugte Ansatz zur Aufgabenkoordination darin, den "

"gesamten Zugriff auf eine Ressource in einem einzigen Thread zu bündeln und "

"diesen Thread dann mithilfe des Moduls :mod:`queue` mit Anfragen aus anderen "

"Threads zu versorgen. Anwendungen, die :class:`~queue.Queue` “-Objekte für "

"die Kommunikation und Koordination zwischen Threads nutzen, sind einfacher "

"zu entwerfen, besser lesbar und zuverlässiger."

#: ../../tutorial/stdlib2.rst:213

msgid "Logging"

msgstr "Protokollierung"

#: ../../tutorial/stdlib2.rst:215

msgid ""

"The :mod:`logging` module offers a full featured and flexible logging "

"system. At its simplest, log messages are sent to a file or to ``sys."

"stderr``::"

msgstr ""

"Das Modul :mod:`logging` bietet ein funktionsreiches und flexibles "

"Protokollierungssystem. Im einfachsten Fall werden Protokollmeldungen an "

"eine Datei oder an ``sys.stderr`` gesendet ::"

#: ../../tutorial/stdlib2.rst:218

msgid ""

"import logging\n"

"logging.debug('Debugging information')\n"

"logging.info('Informational message')\n"

"logging.warning('Warning:config file %s not found', 'server.conf')\n"

"logging.error('Error occurred')\n"

"logging.critical('Critical error -- shutting down')"

msgstr ""

"import logging\n"

"logging.debug('Informationen zur Fehlersuche')\n"

"logging.info('Informative Meldung')\n"

"logging.warning('Warnung: Konfigurationsdatei %s nicht gefunden', 'server."

"conf')\n"

"logging.error('Fehler aufgetreten')\n"

"logging.critical('Kritischer Fehler -- Programm wird beendet')"

#: ../../tutorial/stdlib2.rst:225

msgid "This produces the following output:"

msgstr "Dies führt zu folgender Ausgabe:"

#: ../../tutorial/stdlib2.rst:227

msgid ""

"WARNING:root:Warning:config file server.conf not found\n"

"ERROR:root:Error occurred\n"

"CRITICAL:root:Critical error -- shutting down"

msgstr ""

"WARNUNG:root:Warnung: Konfigurationsdatei „server.conf“ nicht gefunden\n"

"FEHLER:root:Es ist ein Fehler aufgetreten\n"

"KRITISCH:root:Kritischer Fehler – System wird heruntergefahren"

#: ../../tutorial/stdlib2.rst:233

msgid ""

"By default, informational and debugging messages are suppressed and the "

"output is sent to standard error. Other output options include routing "

"messages through email, datagrams, sockets, or to an HTTP Server. New "

"filters can select different routing based on message priority: :const:"

"`~logging.DEBUG`, :const:`~logging.INFO`, :const:`~logging.WARNING`, :const:"

"`~logging.ERROR`, and :const:`~logging.CRITICAL`."

msgstr ""

"Standardmäßig werden Informations- und Debugging-Meldungen unterdrückt und "

"die Ausgabe an die Standardfehlerausgabe weitergeleitet. Zu den weiteren "

"Ausgabeoptionen gehört die Weiterleitung von Meldungen per E-Mail, über "

"Datagramme, Sockets oder an einen HTTP-Server. Mit neuen Filtern lassen sich "

"je nach Priorität der Meldungen unterschiedliche Weiterleitungswege "

"auswählen: :const:`~logging.DEBUG`, :const:`~logging.INFO`, :const:`~logging."

"WARNING`, :const:`~logging.ERROR` und :const:`~logging.CRITICAL`."

#: ../../tutorial/stdlib2.rst:240

msgid ""

"The logging system can be configured directly from Python or can be loaded "

"from a user editable configuration file for customized logging without "

"altering the application."

msgstr ""

"Das Protokollierungssystem kann direkt über Python konfiguriert oder aus "

"einer vom Benutzer bearbeitbaren Konfigurationsdatei geladen werden, um eine "

"individuelle Protokollierung zu ermöglichen, ohne die Anwendung zu verändern."

#: ../../tutorial/stdlib2.rst:248

msgid "Weak references"

msgstr "Schwache Referenzen"

#: ../../tutorial/stdlib2.rst:250

msgid ""

"Python does automatic memory management (reference counting for most objects "

"and :term:`garbage collection` to eliminate cycles). The memory is freed "

"shortly after the last reference to it has been eliminated."

msgstr ""

"Python verfügt über eine automatische Speicherverwaltung (Referenzzählung "

"für die meisten Objekte und :term:`Garbage Collection <garbage collection>` "

"zur Beseitigung von Zyklen). Der Speicher wird kurz nach dem Wegfall der "

"letzten Referenz darauf freigegeben."

#: ../../tutorial/stdlib2.rst:254

msgid ""

"This approach works fine for most applications but occasionally there is a "

"need to track objects only as long as they are being used by something else. "

"Unfortunately, just tracking them creates a reference that makes them "

"permanent. The :mod:`weakref` module provides tools for tracking objects "

"without creating a reference. When the object is no longer needed, it is "

"automatically removed from a weakref table and a callback is triggered for "

"weakref objects. Typical applications include caching objects that are "

"expensive to create::"

msgstr ""

"Dieser Ansatz funktioniert bei den meisten Anwendungen gut, doch "

"gelegentlich besteht die Notwendigkeit, Objekte nur so lange zu verfolgen, "

"wie sie von etwas anderem verwendet werden. Leider wird allein durch das "

"Verfolgen einer Referenz erstellt, die das Objekt dauerhaft macht. Das "

"Modul :mod:`weakref` bietet Werkzeuge, um Objekte zu verfolgen, ohne eine "

"Referenz zu erstellen. Wenn das Objekt nicht mehr benötigt wird, wird es "

"automatisch aus einer „weakref“-Tabelle entfernt und ein Callback für "

"„weakref“-Objekte ausgelöst. Zu den typischen Anwendungsfällen gehört das "

"Zwischenspeichern von Objekten, deren Erstellung ressourcenintensiv ist::"

#: ../../tutorial/stdlib2.rst:262

msgid ""

">>> import weakref, gc\n"

">>> class A:\n"

"... def __init__(self, value):\n"

"... self.value = value\n"

"... def __repr__(self):\n"

"... return str(self.value)\n"

"...\n"

">>> a = A(10) # create a reference\n"

">>> d = weakref.WeakValueDictionary()\n"

">>> d['primary'] = a # does not create a reference\n"

">>> d['primary'] # fetch the object if it is still alive\n"

"10\n"

">>> del a # remove the one reference\n"

">>> gc.collect() # run garbage collection right away\n"

"0\n"

">>> d['primary'] # entry was automatically removed\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" d['primary'] # entry was automatically removed\n"

" File \"C:/python315/lib/weakref.py\", line 46, in __getitem__\n"

" o = self.data[key]()\n"

"KeyError: 'primary'"

msgstr ""

">>> import weakref, gc\n"

">>> class A:\n"

"... def __init__(self, value):\n"

"... self.value = value\n"

"... def __repr__(self):\n"

"... return str(self.value)\n"

"...\n"

">>> a = A(10) # erstellt eine Referenz\n"

">>> d = weakref.WeakValueDictionary()\n"

">>> d['primary'] = a # erstellt keine Referenz\n"

">>> d['primary'] # ruft das Objekt ab, falls es noch "

"existiert\n"

"10\n"

">>> del a # entfernt die einzige Referenz\n"

">>> gc.collect() # führt die Garbage Collection sofort aus\n"

"0\n"

">>> d['primary'] # Eintrag wurde automatisch entfernt\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" d['primary'] # Eintrag wurde automatisch entfernt\n"

" File \"C:/python315/lib/weakref.py\", line 46, in __getitem__\n"

" o = self.data[key]()\n"

"KeyError: 'primary'"

#: ../../tutorial/stdlib2.rst:289

msgid "Tools for working with lists"

msgstr "Werkzeuge zur Arbeit mit Listen"

#: ../../tutorial/stdlib2.rst:291

msgid ""

"Many data structure needs can be met with the built-in list type. However, "

"sometimes there is a need for alternative implementations with different "

"performance trade-offs."

msgstr ""

"Viele Anforderungen an Datenstrukturen lassen sich mit dem integrierten "

"Listentyp erfüllen. Manchmal besteht jedoch Bedarf an alternativen "

"Implementierungen mit unterschiedlichen Kompromissen hinsichtlich der "

"Leistung."

#: ../../tutorial/stdlib2.rst:295

msgid ""

"The :mod:`array` module provides an :class:`~array.array` object that is "

"like a list that stores only homogeneous data and stores it more compactly. "

"The following example shows an array of numbers stored as two byte unsigned "

"binary numbers (typecode ``\"H\"``) rather than the usual 16 bytes per entry "

"for regular lists of Python int objects::"

msgstr ""

"Das Modul :mod:`array` stellt ein :class:`~array.array` “-Objekt bereit, das "

"einer Liste ähnelt, jedoch ausschließlich homogene Daten enthält und diese "

"kompakter speichert. Das folgende Beispiel zeigt ein Array von Zahlen, die "

"als vorzeichenlose Binärzahlen mit zwei Bytes (Typcode ``\"H\"`` “) "

"gespeichert sind, anstatt der üblichen 16 Bytes pro Eintrag bei regulären "

"Listen von Python-int-Objekten::"

#: ../../tutorial/stdlib2.rst:301

msgid ""

">>> from array import array\n"

">>> a = array('H', [4000, 10, 700, 22222])\n"

">>> sum(a)\n"

"26932\n"

">>> a[1:3]\n"

"array('H', [10, 700])"

msgstr ""

">>> from array import array\n"

">>> a = array('H', [4000, 10, 700, 22222])\n"

">>> sum(a)\n"

"26932\n"

">>> a[1:3]\n"

"array('H', [10, 700])"

#: ../../tutorial/stdlib2.rst:308

msgid ""

"The :mod:`collections` module provides a :class:`~collections.deque` object "

"that is like a list with faster appends and pops from the left side but "

"slower lookups in the middle. These objects are well suited for implementing "

"queues and breadth first tree searches::"

msgstr ""

"Das Modul :mod:`collections` stellt ein :class:`~collections.deque` “-Objekt "

"bereit, das einer Liste ähnelt: Das Hinzufügen und Entfernen von Elementen "

"auf der linken Seite erfolgt schneller, das Suchen in der Mitte hingegen "

"langsamer. Diese Objekte eignen sich gut für die Implementierung von "

"Warteschlangen und für die Breitensuche in Bäumen::"

#: ../../tutorial/stdlib2.rst:313

msgid ""

">>> from collections import deque\n"

">>> d = deque([\"task1\", \"task2\", \"task3\"])\n"

">>> d.append(\"task4\")\n"

">>> print(\"Handling\", d.popleft())\n"

"Handling task1"

msgstr ""

">>> from collections import deque\n"

">>> d = deque([\"task1\", \"task2\", \"task3\"])\n"

">>> d.append(\"task4\")\n"

">>> print(\"Handling\", d.popleft())\n"

"Handling task1"

#: ../../tutorial/stdlib2.rst:321

msgid ""

"unsearched = deque([starting_node])\n"

"def breadth_first_search(unsearched):\n"

" node = unsearched.popleft()\n"

" for m in gen_moves(node):\n"

" if is_goal(m):\n"

" return m\n"

" unsearched.append(m)"

msgstr ""

"unsearched = deque([starting_node])\n"

"def breadth_first_search(unsearched):\n"

" node = unsearched.popleft()\n"

" for m in gen_moves(node):\n"

" if is_goal(m):\n"

" return m\n"

" unsearched.append(m)"

#: ../../tutorial/stdlib2.rst:329

msgid ""

"In addition to alternative list implementations, the library also offers "

"other tools such as the :mod:`bisect` module with functions for manipulating "

"sorted lists::"

msgstr ""

"Neben alternativen Listenimplementierungen bietet die Bibliothek auch "

"weitere Werkzeuge wie das Modul :mod:`bisect` mit Funktionen zur Bearbeitung "

"sortierter Listen::"

#: ../../tutorial/stdlib2.rst:333

msgid ""

">>> import bisect\n"

">>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]\n"

">>> bisect.insort(scores, (300, 'ruby'))\n"

">>> scores\n"

"[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]"

msgstr ""

">>> import bisect\n"

">>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]\n"

">>> bisect.insort(scores, (300, 'ruby'))\n"

">>> scores\n"

"[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]"

#: ../../tutorial/stdlib2.rst:339

msgid ""

"The :mod:`heapq` module provides functions for implementing heaps based on "

"regular lists. The lowest valued entry is always kept at position zero. "

"This is useful for applications which repeatedly access the smallest element "

"but do not want to run a full list sort::"

msgstr ""

"Das Modul :mod:`heapq` bietet Funktionen zur Implementierung von Heaps auf "

"der Grundlage regulärer Listen. Der Eintrag mit dem niedrigsten Wert wird "

"stets an Position Null gespeichert. Dies ist nützlich für Anwendungen, die "

"wiederholt auf das kleinste Element zugreifen, aber keine vollständige "

"Sortierung der Liste durchführen möchten::"

#: ../../tutorial/stdlib2.rst:344

msgid ""

">>> from heapq import heapify, heappop, heappush\n"

">>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]\n"

">>> heapify(data) # rearrange the list into heap order\n"

">>> heappush(data, -5) # add a new entry\n"

">>> [heappop(data) for i in range(3)] # fetch the three smallest entries\n"

"[-5, 0, 1]"

msgstr ""

">>> from heapq import heapify, heappop, heappush\n"

">>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]\n"

">>> heapify(data) # rearrange the list into heap order\n"

">>> heappush(data, -5) # add a new entry\n"

">>> [heappop(data) for i in range(3)] # fetch the three smallest entries\n"

"[-5, 0, 1]"

#: ../../tutorial/stdlib2.rst:355

msgid "Decimal floating-point arithmetic"

msgstr "Dezimale Gleitkommaarithmetik"

#: ../../tutorial/stdlib2.rst:357

msgid ""

"The :mod:`decimal` module offers a :class:`~decimal.Decimal` datatype for "

"decimal floating-point arithmetic. Compared to the built-in :class:`float` "

"implementation of binary floating point, the class is especially helpful for"

msgstr ""

"Das Modul :mod:`decimal` bietet den Datentyp :class:`~decimal.Decimal` für "

"die dezimale Gleitkommaarithmetik. Im Vergleich zur integrierten :class:"

"`float` “-Implementierung der binären Gleitkommaarithmetik ist diese Klasse "

"besonders hilfreich für"

#: ../../tutorial/stdlib2.rst:361

msgid ""

"financial applications and other uses which require exact decimal "

"representation,"

msgstr ""

"Finanzanwendungen und andere Anwendungsbereiche, die eine exakte "

"Dezimaldarstellung erfordern,"

#: ../../tutorial/stdlib2.rst:363

msgid "control over precision,"

msgstr "Kontrolle über die Präzision,"

#: ../../tutorial/stdlib2.rst:364

msgid "control over rounding to meet legal or regulatory requirements,"

msgstr ""

"Kontrolle über die Rundung zur Erfüllung gesetzlicher oder behördlicher "

"Anforderungen,"

#: ../../tutorial/stdlib2.rst:365

msgid "tracking of significant decimal places, or"

msgstr "Verfolgung der signifikanten Dezimalstellen oder"

#: ../../tutorial/stdlib2.rst:366

msgid ""

"applications where the user expects the results to match calculations done "

"by hand."

msgstr ""

"Anwendungen, bei denen der Benutzer erwartet, dass die Ergebnisse mit den "

"von Hand durchgeführten Berechnungen übereinstimmen."

#: ../../tutorial/stdlib2.rst:369

msgid ""

"For example, calculating a 5% tax on a 70 cent phone charge gives different "

"results in decimal floating point and binary floating point. The difference "

"becomes significant if the results are rounded to the nearest cent::"

msgstr ""

"Beispielsweise führt die Berechnung einer Steuer von 5 % auf eine "

"Telefongebühr von 70 Cent bei der dezimalen Gleitkommadarstellung und der "

"binären Gleitkommadarstellung zu unterschiedlichen Ergebnissen. Der "

"Unterschied wird erheblich, wenn die Ergebnisse auf den nächsten Cent "

"gerundet werden::"

#: ../../tutorial/stdlib2.rst:373

msgid ""

">>> from decimal import *\n"

">>> round(Decimal('0.70') * Decimal('1.05'), 2)\n"

"Decimal('0.74')\n"

">>> round(.70 * 1.05, 2)\n"

"0.73"

msgstr ""

">>> from decimal import *\n"

">>> round(Decimal('0.70') * Decimal('1.05'), 2)\n"

"Decimal('0.74')\n"

">>> round(.70 * 1.05, 2)\n"

"0.73"

#: ../../tutorial/stdlib2.rst:379

msgid ""

"The :class:`~decimal.Decimal` result keeps a trailing zero, automatically "

"inferring four place significance from multiplicands with two place "

"significance. Decimal reproduces mathematics as done by hand and avoids "

"issues that can arise when binary floating point cannot exactly represent "

"decimal quantities."

msgstr ""

"Das Ergebnis von :class:`~decimal.Decimal` behält eine nachgestellte Null "

"bei und leitet daraus automatisch eine Signifikanz von vier Stellen aus "

"Multiplikanden mit einer Signifikanz von zwei Stellen ab. \"Decimal“ bildet "

"mathematische Berechnungen so ab, wie sie von Hand durchgeführt werden, und "

"vermeidet Probleme, die auftreten können, wenn binäre Gleitkommazahlen "

"dezimale Größen nicht exakt darstellen können."

#: ../../tutorial/stdlib2.rst:385

msgid ""

"Exact representation enables the :class:`~decimal.Decimal` class to perform "

"modulo calculations and equality tests that are unsuitable for binary "

"floating point::"

msgstr ""

"Dank der exakten Darstellung kann die Klasse :class:`~decimal.Decimal` "

"Modulo-Berechnungen und Gleichheitsprüfungen durchführen, die für binäre "

"Gleitkommazahlen ungeeignet sind::"

#: ../../tutorial/stdlib2.rst:389

msgid ""

">>> Decimal('1.00') % Decimal('.10')\n"

"Decimal('0.00')\n"

">>> 1.00 % 0.10\n"

"0.09999999999999995\n"

"\n"

">>> sum([Decimal('0.1')]*10) == Decimal('1.0')\n"

"True\n"

">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"

"False"

msgstr ""

">>> Decimal('1.00') % Decimal('.10')\n"

"Decimal('0.00')\n"

">>> 1.00 % 0.10\n"

"0.09999999999999995\n"

"\n"

">>> sum([Decimal('0.1')]*10) == Decimal('1.0')\n"

"True\n"

">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"

"False"

#: ../../tutorial/stdlib2.rst:399

msgid ""

"The :mod:`decimal` module provides arithmetic with as much precision as "

"needed::"

msgstr ""

"Das Modul :mod:`decimal` ermöglicht arithmetische Berechnungen mit beliebig "

"hoher Genauigkeit::"

#: ../../tutorial/stdlib2.rst:401

msgid ""

">>> getcontext().prec = 36\n"

">>> Decimal(1) / Decimal(7)\n"

"Decimal('0.142857142857142857142857142857142857')"

msgstr ""

">>> getcontext().prec = 36\n"

">>> Decimal(1) / Decimal(7)\n"

"Decimal('0.142857142857142857142857142857142857')"