# SOME DESCRIPTIVE TITLE. # Copyright (C) 2001 Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # msgid "" msgstr "" "Project-Id-Version: Python 3.14\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2026-09-05 16:53+0200\n" "PO-Revision-Date: 2025-09-16 00:02+0000\n" "Last-Translator: Swen Bachmann <[email protected]>\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/inputoutput.rst:5 msgid "Input and Output" msgstr "Eingabe und Ausgabe" #: ../../tutorial/inputoutput.rst:7 msgid "" "There are several ways to present the output of a program; data can be " "printed in a human-readable form, or written to a file for future use. This " "chapter will discuss some of the possibilities." msgstr "" "Es gibt verschiedene Möglichkeiten, die Ausgabe eines Programms " "darzustellen; Daten können in einer für Menschen lesbaren Form ausgegeben " "oder zur späteren Verwendung in eine Datei geschrieben werden. In diesem " "Kapitel werden einige dieser Möglichkeiten behandelt." #: ../../tutorial/inputoutput.rst:15 msgid "Fancier Output Formatting" msgstr "Erweiterte Formatierungsmöglichkeiten für die Ausgabe" #: ../../tutorial/inputoutput.rst:17 msgid "" "So far we've encountered two ways of writing values: *expression statements* " "and the :func:`print` function. (A third way is using the :meth:`~io." "TextIOBase.write` method of file objects; the standard output file can be " "referenced as ``sys.stdout``. See the Library Reference for more information " "on this.)" msgstr "" "Bisher haben wir zwei Möglichkeiten kennengelernt, Werte zu schreiben: " "*Ausdrucksanweisungen* und die Funktion :func:`print`. (Eine dritte " "Möglichkeit ist die Verwendung der Methode :meth:`~io.TextIOBase.write` von " "Datei-Objekten. Auf die Standardausgabedatei kann als ``sys.stdout`` " "verwiesen werden. Weitere Informationen hierzu findest du in der " "Bibliotheksreferenz.)" #: ../../tutorial/inputoutput.rst:22 msgid "" "Often you'll want more control over the formatting of your output than " "simply printing space-separated values. There are several ways to format " "output." msgstr "" "Oftmals möchtest du mehr Kontrolle über die Formatierung deiner Ausgabe " "haben, als nur durch Leerzeichen getrennte Werte auszugeben. Es gibt " "verschiedene Möglichkeiten, die Ausgabe zu formatieren." #: ../../tutorial/inputoutput.rst:25 msgid "" "To use :ref:`formatted string literals `, begin a string with " "``f`` or ``F`` before the opening quotation mark or triple quotation mark. " "Inside this string, you can write a Python expression between ``{`` and ``}" "`` characters that can refer to variables or literal values." msgstr "" "Um :ref:`formatierte Zeichenfolgenliterale ` zu verwenden, " "beginne eine Zeichenfolge mit ``f`` oder ``F`` vor dem öffnenden " "Anführungszeichen oder dem dreifachen Anführungszeichen. Innerhalb dieser " "Zeichenfolge kannst du einen Python-Ausdruck zwischen den Zeichen ``{`` und " "``}`` schreiben, der sich auf Variablen oder Literalwerte beziehen kann." #: ../../tutorial/inputoutput.rst:32 msgid "" ">>> year = 2016\n" ">>> event = 'Referendum'\n" ">>> f'Results of the {year} {event}'\n" "'Results of the 2016 Referendum'" msgstr "" ">>> year = 2016\n" ">>> event = 'Referendum'\n" ">>> f'Results of the {year} {event}'\n" "'Results of the 2016 Referendum'" #: ../../tutorial/inputoutput.rst:37 msgid "" "The :meth:`str.format` method of strings requires more manual effort. " "You'll still use ``{`` and ``}`` to mark where a variable will be " "substituted and can provide detailed formatting directives, but you'll also " "need to provide the information to be formatted. In the following code block " "there are two examples of how to format variables:" msgstr "" "Die Methode :meth:`str.format` von Zeichenketten erfordert mehr manuellen " "Aufwand. Du markierst nach wie vor mit ``{`` und ``}``, wo eine Variable " "ersetzt wird, und kannst detaillierte Formatierungsanweisungen angeben, " "musst aber zusätzlich die zu formatierenden Informationen selbst " "bereitstellen. Im folgenden Codeblock findest du zwei Beispiele, wie " "Variablen formatiert werden können:" #: ../../tutorial/inputoutput.rst:46 msgid "" ">>> yes_votes = 42_572_654\n" ">>> total_votes = 85_705_149\n" ">>> percentage = yes_votes / total_votes\n" ">>> '{:-9} YES votes {:2.2%}'.format(yes_votes, percentage)\n" "' 42572654 YES votes 49.67%'" msgstr "" ">>> yes_votes = 42_572_654\n" ">>> total_votes = 85_705_149\n" ">>> percentage = yes_votes / total_votes\n" ">>> '{:-9} YES votes {:2.2%}'.format(yes_votes, percentage)\n" "' 42572654 YES votes 49.67%'" #: ../../tutorial/inputoutput.rst:52 msgid "" "Notice how the ``yes_votes`` are padded with spaces and a negative sign only " "for negative numbers. The example also prints ``percentage`` multiplied by " "100, with 2 decimal places and followed by a percent sign (see :ref:" "`formatspec` for details)." msgstr "" "Beachte, dass die ``yes_votes`` nur bei negativen Zahlen mit Leerzeichen " "und einem Minuszeichen aufgefüllt werden. Das Beispiel gibt außerdem " "``percentage`` multipliziert mit 100 aus, mit zwei Dezimalstellen und einem " "Prozentzeichen am Ende (weitere Informationen findest du unter :ref:" "`formatspec` )." #: ../../tutorial/inputoutput.rst:57 msgid "" "Finally, you can do all the string handling yourself by using string slicing " "and concatenation operations to create any layout you can imagine. The " "string type has some methods that perform useful operations for padding " "strings to a given column width." msgstr "" "Schließlich kannst du die gesamte Zeichenfolgenbearbeitung selbst " "übernehmen, indem du Zeichenfolgenausschnitte und Verkettungsoperationen " "nutzt, um jedes erdenkliche Layout zu erstellen. Der Typ \"Zeichenfolge\" " "verfügt über einige Methoden, mit denen sich Zeichenfolgen auf eine " "bestimmte Spaltenbreite auffüllen lassen." #: ../../tutorial/inputoutput.rst:62 msgid "" "When you don't need fancy output but just want a quick display of some " "variables for debugging purposes, you can convert any value to a string with " "the :func:`repr` or :func:`str` functions." msgstr "" "Wenn du keine aufwendige Ausgabe benötigst, sondern lediglich eine schnelle " "Anzeige einiger Variablen zu Debugging-Zwecken wünschst, kannst du jeden " "Wert mit den Funktionen :func:`repr` oder :func:`str` in eine Zeichenkette " "umwandeln." #: ../../tutorial/inputoutput.rst:66 msgid "" "The :func:`str` function is meant to return representations of values which " "are fairly human-readable, while :func:`repr` is meant to generate " "representations which can be read by the interpreter (or will force a :exc:" "`SyntaxError` if there is no equivalent syntax). For objects which don't " "have a particular representation for human consumption, :func:`str` will " "return the same value as :func:`repr`. Many values, such as numbers or " "structures like lists and dictionaries, have the same representation using " "either function. Strings, in particular, have two distinct representations." msgstr "" "Die Funktion :func:`str` soll Darstellungen von Werten zurückgeben, die für " "Menschen gut lesbar sind, während :func:`repr` dazu dient, Darstellungen zu " "generieren, die vom Interpreter gelesen werden können (oder einen :exc:" "`SyntaxError` auslösen, falls keine entsprechende Syntax vorhanden ist). " "Bei Objekten, für die es keine spezielle Darstellung für Menschen gibt, " "gibt :func:`str` denselben Wert zurück wie :func:`repr`. Viele Werte, wie " "beispielsweise Zahlen oder Strukturen wie Listen und Wörterbücher, werden " "von beiden Funktionen auf dieselbe Weise dargestellt. Insbesondere " "Zeichenketten haben zwei unterschiedliche Darstellungen." #: ../../tutorial/inputoutput.rst:75 msgid "Some examples::" msgstr "Einige Beispiele:" #: ../../tutorial/inputoutput.rst:77 msgid "" ">>> s = 'Hello, world.'\n" ">>> str(s)\n" "'Hello, world.'\n" ">>> repr(s)\n" "\"'Hello, world.'\"\n" ">>> str(1/7)\n" "'0.14285714285714285'\n" ">>> x = 10 * 3.25\n" ">>> y = 200 * 200\n" ">>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'\n" ">>> print(s)\n" "The value of x is 32.5, and y is 40000...\n" ">>> # The repr() of a string adds string quotes and backslashes:\n" ">>> hello = 'hello, world\\n'\n" ">>> hellos = repr(hello)\n" ">>> print(hellos)\n" "'hello, world\\n'\n" ">>> # The argument to repr() may be any Python object:\n" ">>> repr((x, y, ('spam', 'eggs')))\n" "\"(32.5, 40000, ('spam', 'eggs'))\"" msgstr "" ">>> s = 'Hello, world.'\n" ">>> str(s)\n" "'Hello, world.'\n" ">>> repr(s)\n" "\"'Hello, world.'\"\n" ">>> str(1/7)\n" "'0.14285714285714285'\n" ">>> x = 10 * 3.25\n" ">>> y = 200 * 200\n" ">>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'\n" ">>> print(s)\n" "The value of x is 32.5, and y is 40000...\n" ">>> # Die Funktion repr() fügt bei einer Zeichenkette Anführungszeichen und " "Backslashes hinzu:\n" ">>> hello = 'hello, world\\n'\n" ">>> hellos = repr(hello)\n" ">>> print(hellos)\n" "'hello, world\\n'\n" ">>> # Das Argument für repr() kann ein beliebiges Python-Objekt sein:\n" ">>> repr((x, y, ('spam', 'eggs')))\n" "\"(32.5, 40000, ('spam', 'eggs'))\"" #: ../../tutorial/inputoutput.rst:98 msgid "" "The :mod:`string` module contains support for a simple templating approach " "based upon regular expressions, via :class:`string.Template`. This offers " "yet another way to substitute values into strings, using placeholders like " "``$x`` and replacing them with values from a dictionary. This syntax is easy " "to use, although it offers much less control for formatting." msgstr "" "Das Modul :mod:`string` bietet Unterstützung für einen einfachen Template-" "Ansatz auf Basis regulärer Ausdrücke über :class:`string.Template`. Dies " "bietet eine weitere Möglichkeit, Werte in Zeichenfolgen einzufügen, indem " "Platzhalter wie ``$x`` verwendet und durch Werte aus einem Wörterbuch " "ersetzt werden. Diese Syntax ist einfach zu verwenden, bietet jedoch " "deutlich weniger Kontrolle über die Formatierung." #: ../../tutorial/inputoutput.rst:115 msgid "Formatted String Literals" msgstr "Formatierte Zeichenfolgenliterale" #: ../../tutorial/inputoutput.rst:117 msgid "" ":ref:`Formatted string literals ` (also called f-strings for " "short) let you include the value of Python expressions inside a string by " "prefixing the string with ``f`` or ``F`` and writing expressions as " "``{expression}``." msgstr "" ":ref:`Mit formatierten String-Literalen ` (kurz auch als f-" "Strings bezeichnet) kannst du den Wert von Python-Ausdrücken in einen String " "einfügen, indem du dem String die Präfixe ``f`` oder ``F`` voranstellen und " "Ausdrücke in der Form ``{expression}`` schreibst." #: ../../tutorial/inputoutput.rst:122 msgid "" "An optional format specifier can follow the expression. This allows greater " "control over how the value is formatted. The following example rounds pi to " "three places after the decimal::" msgstr "" "Dem Ausdruck kann ein optionaler Formatbezeichner folgen. Dies ermöglicht " "eine genauere Steuerung der Formatierung des Werts. Im folgenden Beispiel " "wird Pi auf drei Stellen nach dem Komma gerundet::" #: ../../tutorial/inputoutput.rst:126 msgid "" ">>> import math\n" ">>> print(f'The value of pi is approximately {math.pi:.3f}.')\n" "The value of pi is approximately 3.142." msgstr "" ">>> import math\n" ">>> print(f'The value of pi is approximately {math.pi:.3f}.')\n" "The value of pi is approximately 3.142." #: ../../tutorial/inputoutput.rst:130 msgid "" "Passing an integer after the ``':'`` will cause that field to be a minimum " "number of characters wide. This is useful for making columns line up. ::" msgstr "" "Wird nach dem Befehl ``':'`` eine Ganzzahl übergeben, wird die Breite " "dieses Feldes auf die angegebene Mindestanzahl an Zeichen festgelegt. Dies " "ist nützlich, um Spalten auszurichten. ::" #: ../../tutorial/inputoutput.rst:133 msgid "" ">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}\n" ">>> for name, phone in table.items():\n" "... print(f'{name:10} ==> {phone:10d}')\n" "...\n" "Sjoerd ==> 4127\n" "Jack ==> 4098\n" "Dcab ==> 7678" msgstr "" ">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}\n" ">>> for name, phone in table.items():\n" "... print(f'{name:10} ==> {phone:10d}')\n" "...\n" "Sjoerd ==> 4127\n" "Jack ==> 4098\n" "Dcab ==> 7678" #: ../../tutorial/inputoutput.rst:141 msgid "" "Other modifiers can be used to convert the value before it is formatted. ``'!" "a'`` applies :func:`ascii`, ``'!s'`` applies :func:`str`, and ``'!r'`` " "applies :func:`repr`::" msgstr "" "Es können weitere Modifikatoren verwendet werden, um den Wert vor der " "Formatierung umzuwandeln. ``'!a'`` wendet :func:`ascii` an, ``'!s'`` " "wendet :func:`str` an und ``'!r'`` wendet :func:`repr` an ::" #: ../../tutorial/inputoutput.rst:145 msgid "" ">>> animals = 'eels'\n" ">>> print(f'My hovercraft is full of {animals}.')\n" "My hovercraft is full of eels.\n" ">>> print(f'My hovercraft is full of {animals!r}.')\n" "My hovercraft is full of 'eels'." msgstr "" ">>> animals = 'eels'\n" ">>> print(f'My hovercraft is full of {animals}.')\n" "My hovercraft is full of eels.\n" ">>> print(f'My hovercraft is full of {animals!r}.')\n" "My hovercraft is full of 'eels'." #: ../../tutorial/inputoutput.rst:151 msgid "" "The ``=`` specifier can be used to expand an expression to the text of the " "expression, an equal sign, then the representation of the evaluated " "expression:" msgstr "" "Mit dem Bezeichner ``=`` lässt sich ein Ausdruck so erweitern, dass er " "zunächst den Text des Ausdrucks, dann ein Gleichheitszeichen und " "anschließend die Darstellung des ausgewerteten Ausdrucks enthält:" #: ../../tutorial/inputoutput.rst:160 msgid "" "See :ref:`self-documenting expressions ` for more " "information on the ``=`` specifier. For a reference on these format " "specifications, see the reference guide for the :ref:`formatspec`." msgstr "" "Weitere Informationen zum Spezifizierer ``=`` findest du unter :ref:" "`selbstdokumentierende Ausdrücke `. Eine Ãœbersicht über " "diese Formatvorgaben findest du im Referenzhandbuch unter :ref:`formatspec`." #: ../../tutorial/inputoutput.rst:167 msgid "The String format() Method" msgstr "Die String-Methode format()" #: ../../tutorial/inputoutput.rst:169 msgid "Basic usage of the :meth:`str.format` method looks like this::" msgstr "" "Die grundlegende Verwendung der Methode :meth:`str.format` sieht wie folgt " "aus::" #: ../../tutorial/inputoutput.rst:171 msgid "" ">>> print('We are the {} who say \"{}!\"'.format('knights', 'Ni'))\n" "We are the knights who say \"Ni!\"" msgstr "" ">>> print('We are the {} who say \"{}!\"'.format('knights', 'Ni'))\n" "We are the knights who say \"Ni!\"" #: ../../tutorial/inputoutput.rst:174 msgid "" "The brackets and characters within them (called format fields) are replaced " "with the objects passed into the :meth:`str.format` method. A number in the " "brackets can be used to refer to the position of the object passed into the :" "meth:`str.format` method. ::" msgstr "" "Die Klammern und die darin enthaltenen Zeichen (sogenannte Formatfelder) " "werden durch die an die Methode :meth:`str.format` übergebenen Objekte " "ersetzt. Eine Zahl in den Klammern kann verwendet werden, um auf die " "Position des an die Methode :meth:`str.format` übergebenen Objekts zu " "verweisen. ::" #: ../../tutorial/inputoutput.rst:179 msgid "" ">>> print('{0} and {1}'.format('spam', 'eggs'))\n" "spam and eggs\n" ">>> print('{1} and {0}'.format('spam', 'eggs'))\n" "eggs and spam" msgstr "" ">>> print('{0} and {1}'.format('spam', 'eggs'))\n" "spam and eggs\n" ">>> print('{1} and {0}'.format('spam', 'eggs'))\n" "eggs and spam" #: ../../tutorial/inputoutput.rst:184 msgid "" "If keyword arguments are used in the :meth:`str.format` method, their values " "are referred to by using the name of the argument. ::" msgstr "" "Werden in der Methode :meth:`str.format` Schlüsselwortargumente verwendet, " "wird auf deren Werte über den Namen des Arguments verwiesen. ::" #: ../../tutorial/inputoutput.rst:187 msgid "" ">>> print('This {food} is {adjective}.'.format(\n" "... food='spam', adjective='absolutely horrible'))\n" "This spam is absolutely horrible." msgstr "" ">>> print('This {food} is {adjective}.'.format(\n" "... food='spam', adjective='absolutely horrible'))\n" "This spam is absolutely horrible." #: ../../tutorial/inputoutput.rst:191 msgid "Positional and keyword arguments can be arbitrarily combined::" msgstr "" "Positions- und Schlüsselwortargumente können beliebig kombiniert werden::" #: ../../tutorial/inputoutput.rst:193 msgid "" ">>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',\n" "... other='Georg'))\n" "The story of Bill, Manfred, and Georg." msgstr "" ">>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',\n" "... other='Georg'))\n" "The story of Bill, Manfred, and Georg." #: ../../tutorial/inputoutput.rst:197 msgid "" "If you have a really long format string that you don't want to split up, it " "would be nice if you could reference the variables to be formatted by name " "instead of by position. This can be done by simply passing the dict and " "using square brackets ``'[]'`` to access the keys. ::" msgstr "" "Wenn du eine wirklich lange Formatzeichenfolge hast, die du nicht aufteilen " "möchtest, wäre es praktisch, wenn du die zu formatierenden Variablen nicht " "anhand ihrer Position, sondern anhand ihres Namens referenzieren könntest. " "Dies lässt sich erreichen, indem du einfach das Wörterbuch übergibst und " "eckige Klammern ``'[]'`` verwendest, um auf die Schlüssel zuzugreifen. ::" #: ../../tutorial/inputoutput.rst:202 msgid "" ">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n" ">>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '\n" "... 'Dcab: {0[Dcab]:d}'.format(table))\n" "Jack: 4098; Sjoerd: 4127; Dcab: 8637678" msgstr "" ">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n" ">>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '\n" "... 'Dcab: {0[Dcab]:d}'.format(table))\n" "Jack: 4098; Sjoerd: 4127; Dcab: 8637678" #: ../../tutorial/inputoutput.rst:207 msgid "" "This could also be done by passing the ``table`` dictionary as keyword " "arguments with the ``**`` notation. ::" msgstr "" "Dies könnte auch erreicht werden, indem das Wörterbuch ``table`` als " "Schlüsselwortargumente mit der Notation ``**`` übergeben wird. ::" #: ../../tutorial/inputoutput.rst:210 msgid "" ">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n" ">>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'." "format(**table))\n" "Jack: 4098; Sjoerd: 4127; Dcab: 8637678" msgstr "" ">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n" ">>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'." "format(**table))\n" "Jack: 4098; Sjoerd: 4127; Dcab: 8637678" #: ../../tutorial/inputoutput.rst:214 msgid "" "This is particularly useful in combination with the built-in function :func:" "`vars`, which returns a dictionary containing all local variables::" msgstr "" "Dies ist besonders nützlich in Kombination mit der integrierten Funktion :" "func:`vars`, die ein Wörterbuch zurückgibt, das alle lokalen Variablen " "enthält::" #: ../../tutorial/inputoutput.rst:217 msgid "" ">>> table = {k: str(v) for k, v in vars().items()}\n" ">>> message = \" \".join([f'{k}: ' + '{' + k +'};' for k in table.keys()])\n" ">>> print(message.format(**table))\n" "__name__: __main__; __doc__: None; __package__: None; __loader__: ..." msgstr "" ">>> table = {k: str(v) for k, v in vars().items()}\n" ">>> message = \" \".join([f'{k}: ' + '{' + k +'};' for k in table.keys()])\n" ">>> print(message.format(**table))\n" "__name__: __main__; __doc__: None; __package__: None; __loader__: ..." #: ../../tutorial/inputoutput.rst:222 msgid "" "As an example, the following lines produce a tidily aligned set of columns " "giving integers and their squares and cubes::" msgstr "" "Die folgenden Zeilen erzeugen beispielsweise eine übersichtlich " "ausgerichtete Spaltenreihe, in der Ganzzahlen sowie deren Quadrate und " "Kubikzahlen aufgeführt sind::" #: ../../tutorial/inputoutput.rst:225 msgid "" ">>> for x in range(1, 11):\n" "... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))\n" "...\n" " 1 1 1\n" " 2 4 8\n" " 3 9 27\n" " 4 16 64\n" " 5 25 125\n" " 6 36 216\n" " 7 49 343\n" " 8 64 512\n" " 9 81 729\n" "10 100 1000" msgstr "" ">>> for x in range(1, 11):\n" "... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))\n" "...\n" " 1 1 1\n" " 2 4 8\n" " 3 9 27\n" " 4 16 64\n" " 5 25 125\n" " 6 36 216\n" " 7 49 343\n" " 8 64 512\n" " 9 81 729\n" "10 100 1000" #: ../../tutorial/inputoutput.rst:239 msgid "" "For a complete overview of string formatting with :meth:`str.format`, see :" "ref:`formatstrings`." msgstr "" "Einen vollständigen Ãœberblick über die Zeichenfolgenformatierung mit :meth:" "`str.format` findest du unter :ref:`formatstrings`." #: ../../tutorial/inputoutput.rst:244 msgid "Manual String Formatting" msgstr "Manuelle Formatierung von Zeichenfolgen" #: ../../tutorial/inputoutput.rst:246 msgid "Here's the same table of squares and cubes, formatted manually::" msgstr "" "Hier ist dieselbe Tabelle mit Quadraten und Würfeln, die manuell formatiert " "wurde::" #: ../../tutorial/inputoutput.rst:248 msgid "" ">>> for x in range(1, 11):\n" "... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')\n" "... # Note use of 'end' on previous line\n" "... print(repr(x*x*x).rjust(4))\n" "...\n" " 1 1 1\n" " 2 4 8\n" " 3 9 27\n" " 4 16 64\n" " 5 25 125\n" " 6 36 216\n" " 7 49 343\n" " 8 64 512\n" " 9 81 729\n" "10 100 1000" msgstr "" ">>> for x in range(1, 11):\n" "... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')\n" "... # Beachte die Verwendung von 'end' in der vorherigen Zeile\n" "... print(repr(x*x*x).rjust(4))\n" "...\n" " 1 1 1\n" " 2 4 8\n" " 3 9 27\n" " 4 16 64\n" " 5 25 125\n" " 6 36 216\n" " 7 49 343\n" " 8 64 512\n" " 9 81 729\n" "10 100 1000" #: ../../tutorial/inputoutput.rst:264 msgid "" "(Note that the one space between each column was added by the way :func:" "`print` works: it always adds spaces between its arguments.)" msgstr "" "(Beachte, dass das einzelne Leerzeichen zwischen den einzelnen Spalten durch " "die Funktionsweise von :func:`print` hinzugefügt wurde: Diese Funktion fügt " "immer Leerzeichen zwischen ihren Argumenten ein.)" #: ../../tutorial/inputoutput.rst:267 msgid "" "The :meth:`str.rjust` method of string objects right-justifies a string in a " "field of a given width by padding it with spaces on the left. There are " "similar methods :meth:`str.ljust` and :meth:`str.center`. These methods do " "not write anything, they just return a new string. If the input string is " "too long, they don't truncate it, but return it unchanged; this will mess up " "your column lay-out but that's usually better than the alternative, which " "would be lying about a value. (If you really want truncation you can always " "add a slice operation, as in ``x.ljust(n)[:n]``.)" msgstr "" "Die Methode :meth:`str.rjust` von String-Objekten richtet eine Zeichenkette " "in einem Feld mit einer bestimmten Breite rechtsbündig aus, indem sie links " "mit Leerzeichen aufgefüllt wird. Es gibt ähnliche Methoden: :meth:`str." "ljust` und :meth:`str.center`. Diese Methoden schreiben nichts, sondern " "geben lediglich eine neue Zeichenkette zurück. Ist die Eingabezeichenkette " "zu lang, wird sie nicht gekürzt, sondern unverändert zurückgegeben; dies " "bringt zwar das Spaltenlayout durcheinander, ist aber in der Regel besser " "als die Alternative, bei der ein Wert falsch dargestellt würde. (Wenn du " "wirklich eine Kürzung wünschst, kannst du jederzeit eine Slice-Operation " "hinzufügen, wie in ``x.ljust(n)[:n]`` beschrieben.)" #: ../../tutorial/inputoutput.rst:276 msgid "" "There is another method, :meth:`str.zfill`, which pads a numeric string on " "the left with zeros. It understands about plus and minus signs::" msgstr "" "Es gibt noch eine weitere Methode, :meth:`str.zfill`, die eine numerische " "Zeichenkette links mit Nullen auffüllt. Sie erkennt Plus- und Minuszeichen::" #: ../../tutorial/inputoutput.rst:279 msgid "" ">>> '12'.zfill(5)\n" "'00012'\n" ">>> '-3.14'.zfill(7)\n" "'-003.14'\n" ">>> '3.14159265359'.zfill(5)\n" "'3.14159265359'" msgstr "" ">>> '12'.zfill(5)\n" "'00012'\n" ">>> '-3.14'.zfill(7)\n" "'-003.14'\n" ">>> '3.14159265359'.zfill(5)\n" "'3.14159265359'" #: ../../tutorial/inputoutput.rst:288 msgid "Old string formatting" msgstr "Alte Zeichenfolgenformatierung" #: ../../tutorial/inputoutput.rst:290 msgid "" "The % operator (modulo) can also be used for string formatting. Given " "``format % values`` (where *format* is a string), ``%`` conversion " "specifications in *format* are replaced with zero or more elements of " "*values*. This operation is commonly known as string interpolation. For " "example::" msgstr "" "Der %-Operator (Modulo) kann auch zur Formatierung von Zeichenketten " "verwendet werden. Bei der Angabe von ``format % values`` (wobei *format* " "eine Zeichenkette ist) werden die Konvertierungsspezifikationen ``%`` in " "*format* durch null oder mehr Elemente aus *values* ersetzt. Dieser Vorgang " "wird allgemein als Zeichenketteninterpolation bezeichnet. Zum Beispiel::" #: ../../tutorial/inputoutput.rst:297 msgid "" ">>> import math\n" ">>> print('The value of pi is approximately %5.3f.' % math.pi)\n" "The value of pi is approximately 3.142." msgstr "" ">>> import math\n" ">>> print('The value of pi is approximately %5.3f.' % math.pi)\n" "The value of pi is approximately 3.142." #: ../../tutorial/inputoutput.rst:301 msgid "" "More information can be found in the :ref:`old-string-formatting` section." msgstr "" "Weitere Informationen findest du im Abschnitt :ref:`old-string-formatting`." #: ../../tutorial/inputoutput.rst:307 msgid "Reading and Writing Files" msgstr "Dateien lesen und schreiben" #: ../../tutorial/inputoutput.rst:313 msgid "" ":func:`open` returns a :term:`file object`, and is most commonly used with " "two positional arguments and one keyword argument: ``open(filename, mode, " "encoding=None)``" msgstr "" ":func:`open` gibt ein :term:`Dateiobjekt ` zurück und wird " "meist mit zwei Positionsargumenten und einem Schlüsselwortargument " "verwendet: ``open(filename, mode, encoding=None)``" #: ../../tutorial/inputoutput.rst:319 msgid ">>> f = open('workfile', 'w', encoding=\"utf-8\")" msgstr ">>> f = open('workfile', 'w', encoding=\"utf-8\")" #: ../../tutorial/inputoutput.rst:326 msgid "" "The first argument is a string containing the filename. The second argument " "is another string containing a few characters describing the way in which " "the file will be used. *mode* can be ``'r'`` when the file will only be " "read, ``'w'`` for only writing (an existing file with the same name will be " "erased), and ``'a'`` opens the file for appending; any data written to the " "file is automatically added to the end. ``'r+'`` opens the file for both " "reading and writing. The *mode* argument is optional; ``'r'`` will be " "assumed if it's omitted." msgstr "" "Das erste Argument ist eine Zeichenkette, die den Dateinamen enthält. Das " "zweite Argument ist eine weitere Zeichenkette, die einige Zeichen enthält, " "die beschreiben, wie die Datei verwendet wird. *mode* kann ``'r'`` lauten, " "wenn die Datei nur gelesen wird, ``'w'`` für das reine Schreiben (eine " "bereits vorhandene Datei mit demselben Namen wird dabei gelöscht) und " "``'a'`` öffnet die Datei zum Anhängen; alle in die Datei geschriebenen Daten " "werden automatisch am Ende angehängt. ``'r+'`` öffnet die Datei sowohl zum " "Lesen als auch zum Schreiben. Das Argument *mode* ist optional; wird es " "weggelassen, wird ``'r'`` angenommen." #: ../../tutorial/inputoutput.rst:335 msgid "" "Normally, files are opened in :dfn:`text mode`, that means, you read and " "write strings from and to the file, which are encoded in a specific " "*encoding*. If *encoding* is not specified, the default is platform " "dependent (see :func:`open`). Because UTF-8 is the modern de-facto standard, " "``encoding=\"utf-8\"`` is recommended unless you know that you need to use a " "different encoding. Appending a ``'b'`` to the mode opens the file in :dfn:" "`binary mode`. Binary mode data is read and written as :class:`bytes` " "objects. You can not specify *encoding* when opening file in binary mode." msgstr "" "Normalerweise werden Dateien im :dfn:`Textmodus` geöffnet, das heißt, du " "liest Zeichenketten aus der Datei aus und schreibst Zeichenketten in die " "Datei, die in einer bestimmten *Kodierung* kodiert sind. Wenn keine " "*Kodierung* angegeben ist, ist die Standardeinstellung plattformabhängig " "(siehe :func:`open`). Da UTF-8 der moderne De-facto-Standard ist, wird " "``encoding=\"utf-8\"`` empfohlen, es sei denn, du weisst, dass du eine " "andere Kodierung verwenden musst. Durch Hinzufügen eines ``'b'`` zum Modus " "wird die Datei im :dfn:`Binärmodus` geöffnet. Daten im Binärmodus werden " "als :class:`bytes`-Objekte gelesen und geschrieben. Beim Öffnen einer Datei " "im Binärmodus kannst du keine *Kodierung* angeben." #: ../../tutorial/inputoutput.rst:345 msgid "" "In text mode, the default when reading is to convert platform-specific line " "endings (``\\n`` on Unix, ``\\r\\n`` on Windows) to just ``\\n``. When " "writing in text mode, the default is to convert occurrences of ``\\n`` back " "to platform-specific line endings. This behind-the-scenes modification to " "file data is fine for text files, but will corrupt binary data like that in :" "file:`JPEG` or :file:`EXE` files. Be very careful to use binary mode when " "reading and writing such files." msgstr "" "Im Textmodus werden beim Lesen standardmäßig plattformspezifische " "Zeilenenden (``\\n`` unter Unix, ``\\r\\n`` unter Windows) in ``\\n`` " "umgewandelt. Beim Schreiben im Textmodus werden ``\\n`` standardmäßig wieder " "in plattformspezifische Zeilenenden umgewandelt. Diese im Hintergrund " "vorgenommene Änderung der Dateidaten ist für Textdateien unbedenklich, führt " "jedoch bei Binärdateien wie den in den Formaten :file:`JPEG` oder :file:" "`EXE` zu Datenverlusten. Achte daher unbedingt darauf, beim Lesen und " "Schreiben solcher Dateien den Binärmodus zu verwenden." #: ../../tutorial/inputoutput.rst:353 msgid "" "It is good practice to use the :keyword:`with` keyword when dealing with " "file objects. The advantage is that the file is properly closed after its " "suite finishes, even if an exception is raised at some point. Using :" "keyword:`!with` is also much shorter than writing equivalent :keyword:" "`try`\\ -\\ :keyword:`finally` blocks::" msgstr "" "Es hat sich bewährt, beim Umgang mit Datei-Objekten das Schlüsselwort :" "keyword:`with` zu verwenden. Der Vorteil besteht darin, dass die Datei nach " "Abschluss der Suite ordnungsgemäß geschlossen wird, selbst wenn an " "irgendeiner Stelle eine Ausnahme ausgelöst wird. Die Verwendung von :keyword:" "`!with` ist zudem wesentlich kürzer als das Schreiben der entsprechenden :" "keyword:`try`\\ -\\ :keyword:`finally`-Blöcke::" #: ../../tutorial/inputoutput.rst:359 msgid "" ">>> with open('workfile', encoding=\"utf-8\") as f:\n" "... read_data = f.read()\n" "\n" ">>> # We can check that the file has been automatically closed.\n" ">>> f.closed\n" "True" msgstr "" ">>> with open('workfile', encoding=\"utf-8\") as f:\n" "... read_data = f.read()\n" "\n" ">>> # Wir können überprüfen, ob die Datei automatisch geschlossen wurde.\n" ">>> f.closed\n" "True" #: ../../tutorial/inputoutput.rst:366 msgid "" "If you're not using the :keyword:`with` keyword, then you should call ``f." "close()`` to close the file and immediately free up any system resources " "used by it." msgstr "" "Wenn du das Schlüsselwort :keyword:`with` nicht verwendest, solltest du die " "Funktion ``f.close()`` aufrufen, um die Datei zu schließen und die von ihr " "belegten Systemressourcen sofort freizugeben." #: ../../tutorial/inputoutput.rst:371 msgid "" "Calling ``f.write()`` without using the :keyword:`!with` keyword or calling " "``f.close()`` **might** result in the arguments of ``f.write()`` not being " "completely written to the disk, even if the program exits successfully." msgstr "" "Der Aufruf von ``f.write()`` ohne das Schlüsselwort :keyword:`!with` oder " "der Aufruf von ``f.close()`` **kann** dazu führen, dass die Argumente von " "``f.write()`` nicht vollständig auf die Festplatte geschrieben werden, " "selbst wenn das Programm erfolgreich beendet wird." #: ../../tutorial/inputoutput.rst:379 msgid "" "After a file object is closed, either by a :keyword:`with` statement or by " "calling ``f.close()``, attempts to use the file object will automatically " "fail. ::" msgstr "" "Nachdem ein Dateiobjekt geschlossen wurde – entweder durch eine :keyword:" "`with`-Anweisung oder durch den Aufruf von ``f.close()``– schlagen alle " "Versuche, das Dateiobjekt zu verwenden, automatisch fehl. ::" #: ../../tutorial/inputoutput.rst:383 msgid "" ">>> f.close()\n" ">>> f.read()\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "ValueError: I/O operation on closed file." msgstr "" ">>> f.close()\n" ">>> f.read()\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "ValueError: I/O operation on closed file." #: ../../tutorial/inputoutput.rst:393 msgid "Methods of File Objects" msgstr "Methoden von Datei-Objekten" #: ../../tutorial/inputoutput.rst:395 msgid "" "The rest of the examples in this section will assume that a file object " "called ``f`` has already been created." msgstr "" "In den übrigen Beispielen dieses Abschnitts wird davon ausgegangen, dass " "bereits ein Dateiobjekt namens ``f`` angelegt wurde." #: ../../tutorial/inputoutput.rst:398 msgid "" "To read a file's contents, call ``f.read(size)``, which reads some quantity " "of data and returns it as a string (in text mode) or bytes object (in binary " "mode). *size* is an optional numeric argument. When *size* is omitted or " "negative, the entire contents of the file will be read and returned; it's " "your problem if the file is twice as large as your machine's memory. " "Otherwise, at most *size* characters (in text mode) or *size* bytes (in " "binary mode) are read and returned. If the end of the file has been reached, " "``f.read()`` will return an empty string (``''``). ::" msgstr "" "Um den Inhalt einer Datei zu lesen, rufe ``f.read(size)`` auf. Diese " "Funktion liest eine bestimmte Datenmenge ein und gibt sie als Zeichenkette " "(im Textmodus) oder als Byte-Objekt (im Binärmodus) zurück. *size* ist ein " "optionales numerisches Argument. Wenn *size* weggelassen wird oder negativ " "ist, wird der gesamte Inhalt der Datei gelesen und zurückgegeben; es ist Ihr " "Problem, wenn die Datei doppelt so groß ist wie der Arbeitsspeicher deines " "Rechners. Andernfalls werden höchstens *size* Zeichen (im Textmodus) oder " "*size* Bytes (im Binärmodus) gelesen und zurückgegeben. Wenn das Ende der " "Datei erreicht wurde, gibt ``f.read()`` eine leere Zeichenkette zurück " "(``''``). ::" #: ../../tutorial/inputoutput.rst:407 msgid "" ">>> f.read()\n" "'This is the entire file.\\n'\n" ">>> f.read()\n" "''" msgstr "" ">>> f.read()\n" "'This is the entire file.\\n'\n" ">>> f.read()\n" "''" #: ../../tutorial/inputoutput.rst:412 msgid "" "``f.readline()`` reads a single line from the file; a newline character " "(``\\n``) is left at the end of the string, and is only omitted on the last " "line of the file if the file doesn't end in a newline. This makes the " "return value unambiguous; if ``f.readline()`` returns an empty string, the " "end of the file has been reached, while a blank line is represented by " "``'\\n'``, a string containing only a single newline. ::" msgstr "" "``f.readline()`` Liest eine einzelne Zeile aus der Datei; am Ende der " "Zeichenkette wird ein Zeilenumbruchzeichen (``\\n``) belassen, das nur in " "der letzten Zeile der Datei weggelassen wird, wenn die Datei nicht mit einem " "Zeilenumbruch endet. Dadurch ist der Rückgabewert eindeutig: Wenn ``f." "readline()`` eine leere Zeichenkette zurückgibt, ist das Ende der Datei " "erreicht, während eine Leerzeile durch ``'\\n'`` dargestellt wird, eine " "Zeichenkette, die nur ein einziges Zeilenendezeichen enthält. ::" #: ../../tutorial/inputoutput.rst:419 msgid "" ">>> f.readline()\n" "'This is the first line of the file.\\n'\n" ">>> f.readline()\n" "'Second line of the file\\n'\n" ">>> f.readline()\n" "''" msgstr "" ">>> f.readline()\n" "'This is the first line of the file.\\n'\n" ">>> f.readline()\n" "'Second line of the file\\n'\n" ">>> f.readline()\n" "''" #: ../../tutorial/inputoutput.rst:426 msgid "" "For reading lines from a file, you can loop over the file object. This is " "memory efficient, fast, and leads to simple code::" msgstr "" "Um Zeilen aus einer Datei zu lesen, kannst du das Dateiobjekt in einer " "Schleife durchlaufen. Dies ist speichereffizient, schnell und führt zu " "einfachem Code::" #: ../../tutorial/inputoutput.rst:429 msgid "" ">>> for line in f:\n" "... print(line, end='')\n" "...\n" "This is the first line of the file.\n" "Second line of the file" msgstr "" ">>> for line in f:\n" "... print(line, end='')\n" "...\n" "This is the first line of the file.\n" "Second line of the file" #: ../../tutorial/inputoutput.rst:435 msgid "" "If you want to read all the lines of a file in a list you can also use " "``list(f)`` or ``f.readlines()``." msgstr "" "Wenn du alle Zeilen einer Datei in eine Liste einlesen möchtest, kannst du " "auch ``list(f)`` oder ``f.readlines()`` verwenden." #: ../../tutorial/inputoutput.rst:438 msgid "" "``f.write(string)`` writes the contents of *string* to the file, returning " "the number of characters written. ::" msgstr "" "``f.write(string)`` Schreibt den Inhalt von *string* in die Datei und gibt " "die Anzahl der geschriebenen Zeichen zurück. ::" #: ../../tutorial/inputoutput.rst:441 msgid "" ">>> f.write('This is a test\\n')\n" "15" msgstr "" ">>> f.write('This is a test\\n')\n" "15" #: ../../tutorial/inputoutput.rst:444 msgid "" "Other types of objects need to be converted -- either to a string (in text " "mode) or a bytes object (in binary mode) -- before writing them::" msgstr "" "Andere Objekttypen müssen vor dem Schreiben konvertiert werden – entweder in " "eine Zeichenkette (im Textmodus) oder in ein Byte-Objekt (im Binärmodus):" #: ../../tutorial/inputoutput.rst:447 msgid "" ">>> value = ('the answer', 42)\n" ">>> s = str(value) # convert the tuple to string\n" ">>> f.write(s)\n" "18" msgstr "" ">>> value = ('the answer', 42)\n" ">>> s = str(value) # das Tupel in eine Zeichenkette umwandeln\n" ">>> f.write(s)\n" "18" #: ../../tutorial/inputoutput.rst:452 msgid "" "``f.tell()`` returns an integer giving the file object's current position in " "the file represented as number of bytes from the beginning of the file when " "in binary mode and an opaque number when in text mode." msgstr "" "``f.tell()`` Gibt eine Ganzzahl zurück, die die aktuelle Position des " "Dateiobjekts in der Datei angibt – im Binärmodus als Anzahl der Bytes ab dem " "Dateianfang und im Textmodus als undurchsichtige Zahl." #: ../../tutorial/inputoutput.rst:456 msgid "" "To change the file object's position, use ``f.seek(offset, whence)``. The " "position is computed from adding *offset* to a reference point; the " "reference point is selected by the *whence* argument. A *whence* value of 0 " "measures from the beginning of the file, 1 uses the current file position, " "and 2 uses the end of the file as the reference point. *whence* can be " "omitted and defaults to 0, using the beginning of the file as the reference " "point. ::" msgstr "" "Um die Position des Dateiobjekts zu ändern, verwende ``f.seek(offset, " "whence)``. Die Position wird berechnet, indem *offset* zu einem " "Referenzpunkt addiert wird; der Referenzpunkt wird durch das Argument " "*whence* festgelegt. Ein *whence*-Wert von 0 misst vom Anfang der Datei " "aus, 1 verwendet die aktuelle Dateiposition und 2 verwendet das Ende der " "Datei als Bezugspunkt. *whence* kann weggelassen werden und ist " "standardmäßig auf 0 gesetzt, wobei der Anfang der Datei als Bezugspunkt " "verwendet wird. ::" #: ../../tutorial/inputoutput.rst:463 msgid "" ">>> f = open('workfile', 'rb+')\n" ">>> f.write(b'0123456789abcdef')\n" "16\n" ">>> f.seek(5) # Go to the 6th byte in the file\n" "5\n" ">>> f.read(1)\n" "b'5'\n" ">>> f.seek(-3, 2) # Go to the 3rd byte before the end\n" "13\n" ">>> f.read(1)\n" "b'd'" msgstr "" ">>> f = open('workfile', 'rb+')\n" ">>> f.write(b'0123456789abcdef')\n" "16\n" ">>> f.seek(5) # Zum 6. Byte in der Datei springen\n" "5\n" ">>> f.read(1)\n" "b'5'\n" ">>> f.seek(-3, 2) # Zum dritten Byte vor dem Ende springen\n" "13\n" ">>> f.read(1)\n" "b'd'" #: ../../tutorial/inputoutput.rst:475 msgid "" "In text files (those opened without a ``b`` in the mode string), only seeks " "relative to the beginning of the file are allowed (the exception being " "seeking to the very file end with ``seek(0, 2)``) and the only valid " "*offset* values are those returned from the ``f.tell()``, or zero. Any other " "*offset* value produces undefined behaviour." msgstr "" "In Textdateien (die ohne ``b`` in der Moduszeichenfolge geöffnet wurden) " "sind nur relative Sprünge zum Dateianfang zulässig (mit Ausnahme des Sprungs " "zum Dateiende mit ``seek(0, 2)``), und die einzigen gültigen *offset*-Werte " "sind diejenigen, die von ``f.tell()`` zurückgegeben werden, oder Null. Jeder " "andere *offset*-Wert führt zu undefiniertem Verhalten." #: ../../tutorial/inputoutput.rst:481 msgid "" "File objects have some additional methods, such as :meth:`~io.IOBase.isatty` " "and :meth:`~io.IOBase.truncate` which are less frequently used; consult the " "Library Reference for a complete guide to file objects." msgstr "" "Dateiobjekte verfügen über einige zusätzliche Methoden, wie beispielsweise :" "meth:`~io.IOBase.isatty` und :meth:`~io.IOBase.truncate`, die jedoch " "seltener verwendet werden; eine vollständige Anleitung zu Dateiobjekten " "findest du in der Bibliotheksreferenz." #: ../../tutorial/inputoutput.rst:489 msgid "Saving structured data with :mod:`json`" msgstr "Strukturierte Daten speichern mit :mod:`json`" #: ../../tutorial/inputoutput.rst:493 msgid "" "Strings can easily be written to and read from a file. Numbers take a bit " "more effort, since the :meth:`~io.TextIOBase.read` method only returns " "strings, which will have to be passed to a function like :func:`int`, which " "takes a string like ``'123'`` and returns its numeric value 123. When you " "want to save more complex data types like nested lists and dictionaries, " "parsing and serializing by hand becomes complicated." msgstr "" "Zeichenketten lassen sich problemlos in eine Datei schreiben und aus einer " "Datei lesen. Bei Zahlen ist der Aufwand etwas größer, da die Methode :meth:" "`~io.TextIOBase.read` nur Zeichenketten zurückgibt, die an eine Funktion " "wie :func:`int` übergeben werden müssen, die eine Zeichenkette wie ``'123'`` " "entgegennimmt und deren numerischen Wert 123 zurückgibt. Wenn du komplexere " "Datentypen wie verschachtelte Listen und Wörterbücher speichern möchtest, " "wird das manuelle Parsen und Serialisieren kompliziert." #: ../../tutorial/inputoutput.rst:500 msgid "" "Rather than having users constantly writing and debugging code to save " "complicated data types to files, Python allows you to use the popular data " "interchange format called `JSON (JavaScript Object Notation) `_. The standard module called :mod:`json` can take Python data " "hierarchies, and convert them to string representations; this process is " "called :dfn:`serializing`. Reconstructing the data from the string " "representation is called :dfn:`deserializing`. Between serializing and " "deserializing, the string representing the object may have been stored in a " "file or data, or sent over a network connection to some distant machine." msgstr "" "Anstatt dass Benutzer ständig Code schreiben und debuggen müssen, um " "komplizierte Datentypen in Dateien zu speichern, ermöglicht Python die " "Verwendung des beliebten Datenaustauschformats namens `JSON (JavaScript " "Object Notation) `_. Das Standardmodul namens :mod:`json` " "kann Python-Datenhierarchien übernehmen und in Zeichenfolgen-Darstellungen " "umwandeln; dieser Vorgang wird als :dfn:`Serialisierung` bezeichnet. Das " "Rekonstruieren der Daten aus der Zeichenfolgenrepräsentation wird als :dfn:" "`Deserialisierung` bezeichnet. Zwischen der Serialisierung und der " "Deserialisierung kann die das Objekt repräsentierende Zeichenfolge in einer " "Datei oder einem Datenspeicher abgelegt oder über eine Netzwerkverbindung an " "einen entfernten Rechner gesendet worden sein." #: ../../tutorial/inputoutput.rst:511 msgid "" "The JSON format is commonly used by modern applications to allow for data " "exchange. Many programmers are already familiar with it, which makes it a " "good choice for interoperability." msgstr "" "Das JSON-Format wird häufig von modernen Anwendungen für den Datenaustausch " "verwendet. Viele Programmierer sind bereits damit vertraut, was es zu einer " "guten Wahl für die Interoperabilität macht." #: ../../tutorial/inputoutput.rst:515 msgid "" "If you have an object ``x``, you can view its JSON string representation " "with a simple line of code::" msgstr "" "Wenn du ein Objekt vom Typ ``x`` hast, kannst du dessen JSON-" "Zeichenkettendarstellung mit einer einzigen Codezeile anzeigen::" #: ../../tutorial/inputoutput.rst:518 msgid "" ">>> import json\n" ">>> x = [1, 'simple', 'list']\n" ">>> json.dumps(x)\n" "'[1, \"simple\", \"list\"]'" msgstr "" ">>> import json\n" ">>> x = [1, 'simple', 'list']\n" ">>> json.dumps(x)\n" "'[1, \"simple\", \"list\"]'" #: ../../tutorial/inputoutput.rst:523 msgid "" "Another variant of the :func:`~json.dumps` function, called :func:`~json." "dump`, simply serializes the object to a :term:`text file`. So if ``f`` is " "a :term:`text file` object opened for writing, we can do this::" msgstr "" "Eine weitere Variante der Funktion :func:`~json.dumps`, die den Namen :func:" "`~json.dump` trägt, serialisiert das Objekt einfach in eine :term:`Textdatei " "`. Wenn also ``f`` ein zum Schreiben geöffnetes :term:`Textdatei " "`-Objekt ist, können wir Folgendes tun::" #: ../../tutorial/inputoutput.rst:527 msgid "json.dump(x, f)" msgstr "json.dump(x, f)" #: ../../tutorial/inputoutput.rst:529 msgid "" "To decode the object again, if ``f`` is a :term:`binary file` or :term:`text " "file` object which has been opened for reading::" msgstr "" "Um das Objekt erneut zu dekodieren, wenn ``f`` ein :term:`Binärdatei `- oder :term:`Textdatei `-Objekt ist, das zum Lesen " "geöffnet wurde::" #: ../../tutorial/inputoutput.rst:532 msgid "x = json.load(f)" msgstr "x = json.load(f)" #: ../../tutorial/inputoutput.rst:535 msgid "" "JSON files must be encoded in UTF-8. Use ``encoding=\"utf-8\"`` when opening " "JSON file as a :term:`text file` for both of reading and writing." msgstr "" "JSON-Dateien müssen in UTF-8 kodiert sein. Verwende die Option " "``encoding=\"utf-8\"``, wenn du eine JSON-Datei als :term:`Textdatei ` öffnest, sowohl beim Lesen als auch beim Schreiben." #: ../../tutorial/inputoutput.rst:538 msgid "" "This simple serialization technique can handle lists and dictionaries, but " "serializing arbitrary class instances in JSON requires a bit of extra " "effort. The reference for the :mod:`json` module contains an explanation of " "this." msgstr "" "Diese einfache Serialisierungstechnik eignet sich für Listen und " "Wörterbücher, doch die Serialisierung beliebiger Klasseninstanzen in JSON " "erfordert etwas mehr Aufwand. Die Dokumentation zum Modul :mod:`json` " "enthält eine Erläuterung dazu." #: ../../tutorial/inputoutput.rst:544 msgid ":mod:`pickle` - the pickle module" msgstr ":mod:`pickle` - das Pickle-Modul" #: ../../tutorial/inputoutput.rst:546 msgid "" "Contrary to :ref:`JSON `, *pickle* is a protocol which allows the " "serialization of arbitrarily complex Python objects. As such, it is " "specific to Python and cannot be used to communicate with applications " "written in other languages. It is also insecure by default: deserializing " "pickle data coming from an untrusted source can execute arbitrary code, if " "the data was crafted by a skilled attacker." msgstr "" "Im Gegensatz zu :ref:`JSON ` ist *pickle* ein Protokoll, das die " "Serialisierung beliebig komplexer Python-Objekte ermöglicht. Als solches " "ist es Python-spezifisch und kann nicht zur Kommunikation mit Anwendungen " "verwendet werden, die in anderen Sprachen geschrieben sind. Außerdem ist es " "standardmäßig unsicher: Die Deserialisierung von *pickle*-Daten aus einer " "nicht vertrauenswürdigen Quelle kann zur Ausführung von beliebigem Code " "führen, wenn die Daten von einem erfahrenen Angreifer manipuliert wurden." #: ../../tutorial/inputoutput.rst:104 msgid "formatted string literal" msgstr "formatiertes String-Literal" #: ../../tutorial/inputoutput.rst:104 msgid "interpolated string literal" msgstr "interpoliertes Zeichenfolgenliteral" #: ../../tutorial/inputoutput.rst:104 msgid "string" msgstr "Zeichenkette" #: ../../tutorial/inputoutput.rst:104 msgid "formatted literal" msgstr "formatiertes Literal" #: ../../tutorial/inputoutput.rst:104 msgid "interpolated literal" msgstr "interpoliertes Literal" #: ../../tutorial/inputoutput.rst:104 msgid "f-string" msgstr "f-String" #: ../../tutorial/inputoutput.rst:104 msgid "fstring" msgstr "fstring" #: ../../tutorial/inputoutput.rst:309 msgid "built-in function" msgstr "built-in function" #: ../../tutorial/inputoutput.rst:309 msgid "open" msgstr "open" #: ../../tutorial/inputoutput.rst:309 msgid "object" msgstr "object" #: ../../tutorial/inputoutput.rst:309 msgid "file" msgstr "file" #: ../../tutorial/inputoutput.rst:491 msgid "module" msgstr "module" #: ../../tutorial/inputoutput.rst:491 msgid "json" msgstr "json"