# 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.

#

# Translators:

# python-doc bot, 2025

# Swen Bachmann, 2026

#

msgid ""

msgstr ""

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

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

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

"PO-Revision-Date: 2026-08-30 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 <tut-f-strings>`, 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 <tut-f-strings>` 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'Ergebnisse des {year} {event} '\n"

"'Ergebnisse des Referendums von 2016'"

#: ../../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"

">>> prozent = Ja-Stimmen / Gesamtstimmen\n"

">>> '{:-9} Ja-Stimmen {:2,2 %}'.format(Ja-Stimmen, prozent)\n"

"' 42.572.654 Ja-Stimmen 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 = 'Hallo, Welt.'\n"

">>> str(s)\n"

"'Hallo, Welt.'\n"

">>> repr(s)\n"

"\"'Hallo, Welt.'\"\n"

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

"'0,14285714285714285'\n"

">>> x = 10 * 3,25\n"

">>> y = 200 * 200\n"

">>> s = 'Der Wert von x ist ' + repr(x) + ', und y ist ' + repr(y) + '...'\n"

">>> print(s)\n"

"Der Wert von x ist 32,5 und der von y ist 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 <f-strings>` (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 <f-strings>` (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'Der Wert von Pi beträgt ungefähr {math.pi:.3f}.')\n"

"Der Wert von Pi beträgt ungefähr 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 = 'Aale'\n"

">>> print(f'Mein Luftkissenfahrzeug ist voll mit {animals}.')\n"

"Mein Luftkissenfahrzeug ist voll mit Aalen.\n"

">>> print(f'Mein Luftkissenfahrzeug ist voll mit {animals!r}.')\n"

"Mein Luftkissenfahrzeug ist voll mit 'Aalen'."

#: ../../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 <bpo-36817-whatsnew>` 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 <bpo-36817-whatsnew>`. 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('Wir sind die {}, die \"{}!\" sagen'.format('Ritter', 'Ni'))\n"

"Wir sind die Ritter, die \"Ni!\" sagen"

#: ../../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} und {1}'.format('Spam', 'Eier'))\n"

"Spam und Eier\n"

">>> print('{1} und {0}'.format('Spam', 'Eier'))\n"

"Eier und 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('Diese {food} lautet {adjective}.'.format(\n"

"... food='Spam', adjective='absolut schrecklich'))\n"

"Dieser Spam ist absolut schrecklich."

#: ../../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('Die Geschichte von {0}, {1} und {other}.'.format('Bill', "

"'Manfred',\n"

"... other='Georg'))\n"

"Die Geschichte von Bill, Manfred und 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('Der Wert von Pi beträgt ungefähr %5.3f.' % math.pi)\n"

"Der Wert von Pi beträgt ungefähr 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 <file object>` 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 \"<stdin>\", line 1, in <module>\n"

"ValueError: I/O operation on closed file."

msgstr ""

">>> f.close()\n"

">>> f.read()\n"

"Traceback (letzter Aufruf zuletzt):\n"

" Datei \"<stdin>\", Zeile 1, in <module>\n"

"ValueError: E/A-Vorgang an einer geschlossenen Datei."

#: ../../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"

"'Das ist der gesamte Inhalt der Datei.\\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"

"'Dies ist die erste Zeile der Datei.\\n'\n"

">>> f.readline()\n"

"'Zweite Zeile der Datei\\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"

"Dies ist die erste Zeile der Datei.\n"

"Zweite Zeile der Datei"

#: ../../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('Das ist ein 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 = ('die Antwort', 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 "