# 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.15\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: 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/floatingpoint.rst:10
msgid "Floating-Point Arithmetic: Issues and Limitations"
msgstr "Gleitkommaarithmetik: Probleme und Einschränkungen"
#: ../../tutorial/floatingpoint.rst:12
msgid ""
"Floating-point numbers are represented in computer hardware as base 2 "
"(binary) fractions. For example, the **decimal** fraction ``0.625`` has "
"value 6/10 + 2/100 + 5/1000, and in the same way the **binary** fraction "
"``0.101`` has value 1/2 + 0/4 + 1/8. These two fractions have identical "
"values, the only real difference being that the first is written in base 10 "
"fractional notation, and the second in base 2."
msgstr ""
"Gleitkommazahlen werden in der Computerhardware als Brüche zur Basis 2 "
"(binär) dargestellt. Beispielsweise hat der **dezimale** Bruch ``0.625`` "
"den Wert 6/10 + 2/100 + 5/1000, und ebenso hat der **binäre** Bruch "
"``0.101`` den Wert 1/2 + 0/4 + 1/8. Diese beiden Brüche haben identische "
"Werte; der einzige wirkliche Unterschied besteht darin, dass der erste in "
"der Bruchschreibweise zur Basis 10 und der zweite in der zur Basis 2 "
"geschrieben ist."
#: ../../tutorial/floatingpoint.rst:19
msgid ""
"Unfortunately, most decimal fractions cannot be represented exactly as "
"binary fractions. A consequence is that, in general, the decimal floating-"
"point numbers you enter are only approximated by the binary floating-point "
"numbers actually stored in the machine."
msgstr ""
"Leider lassen sich die meisten Dezimalbrüche nicht exakt als Binärbrüche "
"darstellen. Dies hat zur Folge, dass die von dir eingegebenen Dezimal-"
"Gleitkommazahlen im Allgemeinen nur annähernd durch die tatsächlich im "
"Rechner gespeicherten Binär-Gleitkommazahlen wiedergegeben werden."
#: ../../tutorial/floatingpoint.rst:24
msgid ""
"The problem is easier to understand at first in base 10. Consider the "
"fraction 1/3. You can approximate that as a base 10 fraction::"
msgstr ""
"Das Problem lässt sich zunächst im Dezimalsystem leichter verstehen. "
"Betrachten wir den Bruch 1/3. Man kann ihn als Bruch im Dezimalsystem "
"näherungsweise darstellen:"
#: ../../tutorial/floatingpoint.rst:27
msgid "0.3"
msgstr "0.3"
#: ../../tutorial/floatingpoint.rst:29 ../../tutorial/floatingpoint.rst:33
msgid "or, better, ::"
msgstr "oder besser noch: ::"
#: ../../tutorial/floatingpoint.rst:31
msgid "0.33"
msgstr "0.33"
#: ../../tutorial/floatingpoint.rst:35
msgid "0.333"
msgstr "0.333"
#: ../../tutorial/floatingpoint.rst:37
msgid ""
"and so on. No matter how many digits you're willing to write down, the "
"result will never be exactly 1/3, but will be an increasingly better "
"approximation of 1/3."
msgstr ""
"und so weiter. Ganz gleich, wie viele Stellen man notieren möchte, das "
"Ergebnis wird niemals genau 1/3 sein, sondern eine immer bessere Annäherung "
"an 1/3 darstellen."
#: ../../tutorial/floatingpoint.rst:41
msgid ""
"In the same way, no matter how many base 2 digits you're willing to use, the "
"decimal value 0.1 cannot be represented exactly as a base 2 fraction. In "
"base 2, 1/10 is the infinitely repeating fraction ::"
msgstr ""
"Ebenso lässt sich der Dezimalwert 0,1 – ganz gleich, wie viele Ziffern im "
"Zweier-System man verwenden möchte – nicht exakt als Bruch im Zweier-System "
"darstellen. Im Zweier-System ist 1/10 der sich unendlich wiederholende "
"Bruch ::"
#: ../../tutorial/floatingpoint.rst:45
msgid "0.0001100110011001100110011001100110011001100110011..."
msgstr "0.0001100110011001100110011001100110011001100110011..."
#: ../../tutorial/floatingpoint.rst:47
msgid ""
"Stop at any finite number of bits, and you get an approximation. On most "
"machines today, floats are approximated using a binary fraction with the "
"numerator using the first 53 bits starting with the most significant bit and "
"with the denominator as a power of two. In the case of 1/10, the binary "
"fraction is ``3602879701896397 / 2 ** 55`` which is close to but not exactly "
"equal to the true value of 1/10."
msgstr ""
"Hält man bei einer beliebigen endlichen Anzahl von Bits an, erhält man eine "
"Näherung. Auf den meisten heutigen Rechnern werden Gleitkommazahlen mithilfe "
"eines binären Bruchs approximiert, wobei der Zähler aus den ersten 53 Bits "
"(beginnend mit dem höchstwertigen Bit) besteht und der Nenner eine "
"Zweierpotenz ist. Im Fall von 1/10 lautet der Binärbruch "
"``3602879701896397 / 2 ** 55``, was nahe am tatsächlichen Wert von 1/10 "
"liegt, diesem aber nicht exakt entspricht."
#: ../../tutorial/floatingpoint.rst:54
msgid ""
"Many users are not aware of the approximation because of the way values are "
"displayed. Python only prints a decimal approximation to the true decimal "
"value of the binary approximation stored by the machine. On most machines, "
"if Python were to print the true decimal value of the binary approximation "
"stored for 0.1, it would have to display::"
msgstr ""
"Vielen Benutzern ist diese Annäherung aufgrund der Art und Weise, wie Werte "
"angezeigt werden, nicht bewusst. Python gibt lediglich eine dezimale "
"Annäherung an den tatsächlichen Dezimalwert der vom Rechner gespeicherten "
"binären Annäherung aus. Würde Python auf den meisten Rechnern den "
"tatsächlichen Dezimalwert der für 0,1 gespeicherten binären Annäherung "
"ausgeben, müsste es Folgendes anzeigen::"
#: ../../tutorial/floatingpoint.rst:60
msgid ""
">>> 0.1\n"
"0.1000000000000000055511151231257827021181583404541015625"
msgstr ""
">>> 0.1\n"
"0.1000000000000000055511151231257827021181583404541015625"
#: ../../tutorial/floatingpoint.rst:63
msgid ""
"That is more digits than most people find useful, so Python keeps the number "
"of digits manageable by displaying a rounded value instead:"
msgstr ""
"Das sind mehr Stellen, als die meisten Menschen für sinnvoll halten. Deshalb "
"sorgt Python dafür, dass die Anzahl der Stellen überschaubar bleibt, indem "
"stattdessen ein gerundeter Wert angezeigt wird:"
#: ../../tutorial/floatingpoint.rst:66
msgid ""
">>> 1 / 10\n"
"0.1"
msgstr ""
">>> 1 / 10\n"
"0.1"
#: ../../tutorial/floatingpoint.rst:71
msgid ""
"Just remember, even though the printed result looks like the exact value of "
"1/10, the actual stored value is the nearest representable binary fraction."
msgstr ""
"Denke daran: Auch wenn das ausgegebene Ergebnis genau wie der Wert 1/10 "
"aussieht, ist der tatsächlich gespeicherte Wert der nächstgelegene "
"darstellbare Binärbruch."
#: ../../tutorial/floatingpoint.rst:74
msgid ""
"Interestingly, there are many different decimal numbers that share the same "
"nearest approximate binary fraction. For example, the numbers ``0.1`` and "
"``0.10000000000000001`` and "
"``0.1000000000000000055511151231257827021181583404541015625`` are all "
"approximated by ``3602879701896397 / 2 ** 55``. Since all of these decimal "
"values share the same approximation, any one of them could be displayed "
"while still preserving the invariant ``eval(repr(x)) == x``."
msgstr ""
"Interessanterweise gibt es viele verschiedene Dezimalzahlen, die denselben "
"nächstliegenden binären Näherungsbruch haben. Beispielsweise werden die "
"Zahlen ``0.1``, ``0.10000000000000001`` und "
"``0.1000000000000000055511151231257827021181583404541015625`` alle durch "
"``3602879701896397 / 2 ** 55`` approximiert. Da alle diese Dezimalwerte "
"dieselbe Approximation haben, könnte jeder einzelne von ihnen angezeigt "
"werden, ohne dass die Invariante ``eval(repr(x)) == x`` verloren geht."
#: ../../tutorial/floatingpoint.rst:82
msgid ""
"Historically, the Python prompt and built-in :func:`repr` function would "
"choose the one with 17 significant digits, ``0.10000000000000001``. "
"Starting with Python 3.1, Python (on most systems) is now able to choose the "
"shortest of these and simply display ``0.1``."
msgstr ""
"Früher wählten die Python-Eingabeaufforderung und die integrierte Funktion :"
"func:`repr` die Zahl mit 17 signifikanten Stellen aus: "
"``0.10000000000000001``. Ab Python 3.1 ist Python (auf den meisten Systemen) "
"nun in der Lage, die kürzeste dieser Zahlen auszuwählen und einfach ``0.1`` "
"anzuzeigen."
#: ../../tutorial/floatingpoint.rst:87
msgid ""
"Note that this is in the very nature of binary floating point: this is not a "
"bug in Python, and it is not a bug in your code either. You'll see the same "
"kind of thing in all languages that support your hardware's floating-point "
"arithmetic (although some languages may not *display* the difference by "
"default, or in all output modes)."
msgstr ""
"Beachte, dass dies in der Natur der binären Gleitkommazahlen liegt: Es "
"handelt sich weder um einen Fehler in Python noch um einen Fehler in deinem "
"Code. Das gleiche Phänomen tritt in allen Sprachen auf, die die "
"Gleitkommaarithmetik deiner Hardware unterstützen (auch wenn manche Sprachen "
"den Unterschied standardmäßig oder in nicht allen Ausgabemodi möglicherweise "
"nicht *anzeigen*)."
#: ../../tutorial/floatingpoint.rst:93
msgid ""
"For more pleasant output, you may wish to use string formatting to produce a "
"limited number of significant digits:"
msgstr ""
"Um die Ausgabe übersichtlicher zu gestalten, kannst du die "
"Zeichenfolgenformatierung verwenden, um eine begrenzte Anzahl signifikanter "
"Stellen auszugeben:"
#: ../../tutorial/floatingpoint.rst:96
msgid ""
">>> format(math.pi, '.12g') # give 12 significant digits\n"
"'3.14159265359'\n"
"\n"
">>> format(math.pi, '.2f') # give 2 digits after the point\n"
"'3.14'\n"
"\n"
">>> repr(math.pi)\n"
"'3.141592653589793'"
msgstr ""
">>> format(math.pi, '.12g') # gibt 12 signifikante Stellen an\n"
"'3.14159265359'\n"
"\n"
">>> format(math.pi, '.2f') # gibt 2 Stellen nach dem Komma an\n"
"'3.14'\n"
"\n"
">>> repr(math.pi)\n"
"'3.141592653589793'"
#: ../../tutorial/floatingpoint.rst:107
msgid ""
"It's important to realize that this is, in a real sense, an illusion: you're "
"simply rounding the *display* of the true machine value."
msgstr ""
"Man muss sich bewusst machen, dass es sich hierbei im wahrsten Sinne des "
"Wortes um eine Illusion handelt: Man rundet lediglich die *Anzeige* des "
"tatsächlichen Maschinenwerts."
#: ../../tutorial/floatingpoint.rst:110
msgid ""
"One illusion may beget another. For example, since 0.1 is not exactly 1/10, "
"summing three values of 0.1 may not yield exactly 0.3, either:"
msgstr ""
"Eine Täuschung kann eine weitere nach sich ziehen. Da beispielsweise 0.1 "
"nicht genau 1/10 ist, ergibt die Summe von drei Werten von 0.1 "
"möglicherweise auch nicht genau 0.3:"
#: ../../tutorial/floatingpoint.rst:113
msgid ""
">>> 0.1 + 0.1 + 0.1 == 0.3\n"
"False"
msgstr ""
">>> 0.1 + 0.1 + 0.1 == 0.3\n"
"False"
#: ../../tutorial/floatingpoint.rst:118
msgid ""
"Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3 "
"cannot get any closer to the exact value of 3/10, then pre-rounding with :"
"func:`round` function cannot help:"
msgstr ""
"Da sich die Zahl 0.1 dem exakten Wert von 1/10 nicht weiter annähern kann "
"und 0.3 sich dem exakten Wert von 3/10 nicht weiter annähern kann, hilft "
"auch eine Vorrundung mit der Funktion :func:`round` nicht weiter:"
#: ../../tutorial/floatingpoint.rst:122
msgid ""
">>> round(0.1, 1) + round(0.1, 1) + round(0.1, 1) == round(0.3, 1)\n"
"False"
msgstr ""
">>> round(0.1, 1) + round(0.1, 1) + round(0.1, 1) == round(0.3, 1)\n"
"False"
#: ../../tutorial/floatingpoint.rst:127
msgid ""
"Though the numbers cannot be made closer to their intended exact values, "
"the :func:`math.isclose` function can be useful for comparing inexact values:"
msgstr ""
"Auch wenn die Zahlen nicht näher an ihre beabsichtigten exakten Werte "
"herangeführt werden können, kann die Funktion :func:`math.isclose` beim "
"Vergleich ungenauer Werte nützlich sein:"
#: ../../tutorial/floatingpoint.rst:130
msgid ""
">>> math.isclose(0.1 + 0.1 + 0.1, 0.3)\n"
"True"
msgstr ""
">>> math.isclose(0.1 + 0.1 + 0.1, 0.3)\n"
"True"
#: ../../tutorial/floatingpoint.rst:135
msgid ""
"Alternatively, the :func:`round` function can be used to compare rough "
"approximations:"
msgstr ""
"Alternativ kann die Funktion :func:`round` verwendet werden, um grobe "
"Näherungswerte zu vergleichen:"
#: ../../tutorial/floatingpoint.rst:138
msgid ""
">>> round(math.pi, ndigits=2) == round(22 / 7, ndigits=2)\n"
"True"
msgstr ""
">>> round(math.pi, ndigits=2) == round(22 / 7, ndigits=2)\n"
"True"
#: ../../tutorial/floatingpoint.rst:143
msgid ""
"Binary floating-point arithmetic holds many surprises like this. The "
"problem with \"0.1\" is explained in precise detail below, in the "
"\"Representation Error\" section. See `Examples of Floating Point Problems "
"`_ for "
"a pleasant summary of how binary floating point works and the kinds of "
"problems commonly encountered in practice. Also see `The Perils of Floating "
"Point `_ for a more complete "
"account of other common surprises."
msgstr ""
"Die binäre Gleitkommaarithmetik birgt viele solcher Überraschungen. Das "
"Problem mit \"0,1\" wird weiter unten im Abschnitt \"Darstellungsfehler\" "
"ausführlich erläutert. Unter `Beispiele für Gleitkomma-Probleme `_ findest du "
"eine anschauliche Zusammenfassung der Funktionsweise der binären "
"Gleitkommaarithmetik und der Arten von Problemen, die in der Praxis häufig "
"auftreten. Siehe auch `Die Tücken der Gleitkommazahlen `_ für eine umfassendere Darstellung "
"weiterer häufiger Überraschungen."
#: ../../tutorial/floatingpoint.rst:152
msgid ""
"As that says near the end, \"there are no easy answers.\" Still, don't be "
"unduly wary of floating point! The errors in Python float operations are "
"inherited from the floating-point hardware, and on most machines are on the "
"order of no more than 1 part in 2\\*\\*53 per operation. That's more than "
"adequate for most tasks, but you do need to keep in mind that it's not "
"decimal arithmetic and that every float operation can suffer a new rounding "
"error."
msgstr ""
"Wie es gegen Ende heißt: \"Es gibt keine einfachen Antworten.\" Dennoch "
"solltest du gegenüber Gleitkommazahlen nicht übermäßig misstrauisch sein! "
"Die Fehler bei Gleitkommaoperationen in Python stammen von der Gleitkomma-"
"Hardware und liegen auf den meisten Rechnern bei höchstens 1 Teil pro "
"2\\*\\*53 pro Operation. Das ist für die meisten Aufgaben mehr als "
"ausreichend, aber man muss bedenken, dass es sich nicht um Dezimalrechnen "
"handelt und dass bei jeder Gleitkommaoperation ein neuer Rundungsfehler "
"auftreten kann."
#: ../../tutorial/floatingpoint.rst:159
msgid ""
"While pathological cases do exist, for most casual use of floating-point "
"arithmetic you'll see the result you expect in the end if you simply round "
"the display of your final results to the number of decimal digits you "
"expect. :func:`str` usually suffices, and for finer control see the :meth:"
"`str.format` method's format specifiers in :ref:`formatstrings`."
msgstr ""
"Es gibt zwar Ausnahmefälle, doch bei den meisten alltäglichen Anwendungen "
"der Gleitkommaarithmetik erhältst du letztendlich das erwartete Ergebnis, "
"wenn du die Anzeige deiner Endergebnisse einfach auf die gewünschte Anzahl "
"von Dezimalstellen rundest. :func:`str` reicht in der Regel aus; für eine "
"feinere Steuerung findest du die Formatbezeichner der Methode :meth:`str."
"format` unter :ref:`formatstrings`."
#: ../../tutorial/floatingpoint.rst:165
msgid ""
"For use cases which require exact decimal representation, try using the :mod:"
"`decimal` module which implements decimal arithmetic suitable for accounting "
"applications and high-precision applications."
msgstr ""
"Für Anwendungsfälle, die eine exakte Dezimaldarstellung erfordern, solltest "
"du das Modul :mod:`decimal` verwenden, das eine Dezimalarithmetik "
"implementiert, die für Buchhaltungsanwendungen und Anwendungen mit hoher "
"Genauigkeit geeignet ist."
#: ../../tutorial/floatingpoint.rst:169
msgid ""
"Another form of exact arithmetic is supported by the :mod:`fractions` module "
"which implements arithmetic based on rational numbers (so the numbers like "
"1/3 can be represented exactly)."
msgstr ""
"Eine weitere Form der exakten Arithmetik wird vom Modul :mod:`fractions` "
"unterstützt, das eine auf rationalen Zahlen basierende Arithmetik "
"implementiert (sodass Zahlen wie 1/3 exakt dargestellt werden können)."
#: ../../tutorial/floatingpoint.rst:173
msgid ""
"If you are a heavy user of floating-point operations you should take a look "
"at the NumPy package and many other packages for mathematical and "
"statistical operations supplied by the SciPy project. See ."
msgstr ""
"Wenn du häufig mit Gleitkommaoperationen arbeitest, solltest du das NumPy-"
"Paket sowie viele andere Pakete für mathematische und statistische "
"Operationen ansehen, die vom SciPy-Projekt bereitgestellt werden. Siehe "
"."
#: ../../tutorial/floatingpoint.rst:177
msgid ""
"Python provides tools that may help on those rare occasions when you really "
"*do* want to know the exact value of a float. The :meth:`float."
"as_integer_ratio` method expresses the value of a float as a fraction:"
msgstr ""
"Python bietet Werkzeuge, die in den seltenen Fällen hilfreich sein können, "
"in denen man den genauen Wert einer Gleitkommazahl wirklich *wissen* möchte. "
"Die Methode :meth:`float.as_integer_ratio` gibt den Wert einer "
"Gleitkommazahl als Bruch an:"
#: ../../tutorial/floatingpoint.rst:182
msgid ""
">>> x = 3.14159\n"
">>> x.as_integer_ratio()\n"
"(3537115888337719, 1125899906842624)"
msgstr ""
">>> x = 3.14159\n"
">>> x.as_integer_ratio()\n"
"(3537115888337719, 1125899906842624)"
#: ../../tutorial/floatingpoint.rst:188
msgid ""
"Since the ratio is exact, it can be used to losslessly recreate the original "
"value:"
msgstr ""
"Da das Verhältnis exakt ist, lässt sich damit der ursprüngliche Wert "
"verlustfrei wiederherstellen:"
#: ../../tutorial/floatingpoint.rst:191
msgid ""
">>> x == 3537115888337719 / 1125899906842624\n"
"True"
msgstr ""
">>> x == 3537115888337719 / 1125899906842624\n"
"True"
#: ../../tutorial/floatingpoint.rst:196
msgid ""
"The :meth:`float.hex` method expresses a float in hexadecimal (base 16), "
"again giving the exact value stored by your computer:"
msgstr ""
"Die Methode :meth:`float.hex` gibt einen Float-Wert im Hexadezimalformat "
"(Basis 16) aus und liefert wiederum den exakten Wert, der auf deinem "
"Computer gespeichert ist:"
#: ../../tutorial/floatingpoint.rst:199
msgid ""
">>> x.hex()\n"
"'0x1.921f9f01b866ep+1'"
msgstr ""
">>> x.hex()\n"
"'0x1.921f9f01b866ep+1'"
#: ../../tutorial/floatingpoint.rst:204
msgid ""
"This precise hexadecimal representation can be used to reconstruct the float "
"value exactly:"
msgstr ""
"Anhand dieser exakten Hexadezimal-Darstellung lässt sich der Float-Wert "
"exakt rekonstruieren:"
#: ../../tutorial/floatingpoint.rst:207
msgid ""
">>> x == float.fromhex('0x1.921f9f01b866ep+1')\n"
"True"
msgstr ""
">>> x == float.fromhex('0x1.921f9f01b866ep+1')\n"
"True"
#: ../../tutorial/floatingpoint.rst:212
msgid ""
"Since the representation is exact, it is useful for reliably porting values "
"across different versions of Python (platform independence) and exchanging "
"data with other languages that support the same format (such as Java and "
"C99)."
msgstr ""
"Da die Darstellung exakt ist, eignet sie sich gut für die zuverlässige "
"Ãœbertragung von Werten zwischen verschiedenen Python-Versionen "
"(Plattformunabhängigkeit) und den Datenaustausch mit anderen Sprachen, die "
"dasselbe Format unterstützen (wie beispielsweise Java und C99)."
#: ../../tutorial/floatingpoint.rst:216
msgid ""
"Another helpful tool is the :func:`sum` function which helps mitigate loss-"
"of-precision during summation. It uses extended precision for intermediate "
"rounding steps as values are added onto a running total. That can make a "
"difference in overall accuracy so that the errors do not accumulate to the "
"point where they affect the final total:"
msgstr ""
"Ein weiteres nützliches Werkzeug ist die Funktion :func:`sum` , die dazu "
"beiträgt, Präzisionsverluste bei der Summierung zu minimieren. Sie nutzt "
"erweiterte Präzision für die Zwischenrunden, während Werte zur laufenden "
"Summe hinzugefügt werden. Dies kann sich auf die Gesamtgenauigkeit "
"auswirken, sodass sich die Fehler nicht so weit summieren, dass sie das "
"Endergebnis beeinflussen:"
#: ../../tutorial/floatingpoint.rst:222
msgid ""
">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"
"False\n"
">>> sum([0.1] * 10) == 1.0\n"
"True"
msgstr ""
">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"
"False\n"
">>> sum([0.1] * 10) == 1.0\n"
"True"
#: ../../tutorial/floatingpoint.rst:229
msgid ""
"The :func:`math.fsum` goes further and tracks all of the \"lost digits\" as "
"values are added onto a running total so that the result has only a single "
"rounding. This is slower than :func:`sum` but will be more accurate in "
"uncommon cases where large magnitude inputs mostly cancel each other out "
"leaving a final sum near zero:"
msgstr ""
"Die :func:`math.fsum` geht noch einen Schritt weiter und verfolgt alle "
"\"verlorenen Ziffern\", während Werte zu einer laufenden Summe addiert "
"werden, sodass das Ergebnis nur einmal gerundet wird. Dies ist langsamer "
"als :func:`sum` , liefert jedoch in seltenen Fällen, in denen sich Eingaben "
"großer Größenordnungen weitgehend gegenseitig aufheben und eine Endsumme "
"nahe Null ergibt, genauere Ergebnisse:"
#: ../../tutorial/floatingpoint.rst:235
msgid ""
">>> arr = [-0.10430216751806065, -266310978.67179024, 143401161448607.16,\n"
"... -143401161400469.7, 266262841.31058735, -0.003244936839808227]\n"
">>> float(sum(map(Fraction, arr))) # Exact summation with single rounding\n"
"8.042173697819788e-13\n"
">>> math.fsum(arr) # Single rounding\n"
"8.042173697819788e-13\n"
">>> sum(arr) # Multiple roundings in extended "
"precision\n"
"8.042178034628478e-13\n"
">>> total = 0.0\n"
">>> for x in arr:\n"
"... total += x # Multiple roundings in standard "
"precision\n"
"...\n"
">>> total # Straight addition has no correct "
"digits!\n"
"-0.0051575902860057365"
msgstr ""
">>> arr = [-0.10430216751806065, -266310978.67179024, 143401161448607.16,\n"
"... -143401161400469.7, 266262841.31058735, -0.003244936839808227]\n"
">>> float(sum(map(Fraction, arr))) # Exakte Summierung mit einmaliger "
"Rundung\n"
"8.042173697819788e-13\n"
">>> math.fsum(arr) # Einmalige Rundung\n"
"8.042173697819788e-13\n"
">>> sum(arr) # Mehrfache Rundungen bei erweiterter "
"Genauigkeit\n"
"8.042178034628478e-13\n"
">>> total = 0.0\n"
">>> for x in arr:\n"
"... total += x # Mehrfache Rundungen in "
"Standardgenauigkeit\n"
"...\n"
">>> total # Die einfache Addition liefert keine "
"korrekten Ziffern!\n"
"-0.0051575902860057365"
#: ../../tutorial/floatingpoint.rst:256
msgid "Representation Error"
msgstr "Darstellungsfehler"
#: ../../tutorial/floatingpoint.rst:258
msgid ""
"This section explains the \"0.1\" example in detail, and shows how you can "
"perform an exact analysis of cases like this yourself. Basic familiarity "
"with binary floating-point representation is assumed."
msgstr ""
"In diesem Abschnitt wird das Beispiel \"0.1\" ausführlich erläutert und "
"gezeigt, wie du Fälle wie diesen selbst genau analysieren kannst. "
"Grundkenntnisse über die binäre Gleitkommadarstellung werden vorausgesetzt."
#: ../../tutorial/floatingpoint.rst:262
msgid ""
":dfn:`Representation error` refers to the fact that some (most, actually) "
"decimal fractions cannot be represented exactly as binary (base 2) "
"fractions. This is the chief reason why Python (or Perl, C, C++, Java, "
"Fortran, and many others) often won't display the exact decimal number you "
"expect."
msgstr ""
":dfn:`Darstellungsfehler` bezieht sich auf die Tatsache, dass einige "
"(eigentlich die meisten) Dezimalbrüche nicht exakt als Binärbrüche (Basis 2) "
"dargestellt werden können. Dies ist der Hauptgrund dafür, dass Python (oder "
"Perl, C, C++, Java, Fortran und viele andere) oft nicht genau die "
"Dezimalzahl anzeigen, die man erwartet."
#: ../../tutorial/floatingpoint.rst:267
msgid ""
"Why is that? 1/10 is not exactly representable as a binary fraction. Since "
"at least 2000, almost all machines use IEEE 754 binary floating-point "
"arithmetic, and almost all platforms map Python floats to IEEE 754 binary64 "
"\"double precision\" values. IEEE 754 binary64 values contain 53 bits of "
"precision, so on input the computer strives to convert 0.1 to the closest "
"fraction it can of the form *J*/2**\\ *N* where *J* is an integer containing "
"exactly 53 bits. Rewriting ::"
msgstr ""
"Warum ist das so? 1/10 lässt sich nicht exakt als binärer Bruch "
"darstellen. Seit mindestens dem Jahr 2000 verwenden fast alle Rechner die "
"binäre IEEE-754-Gleitkommaarithmetik, und fast alle Plattformen ordnen "
"Python-Float-Werte den IEEE-754-binary64-Werten mit \"doppelter "
"Genauigkeit\" zu. IEEE-754-binary64-Werte enthalten 53 Bits an Genauigkeit, "
"daher versucht der Computer bei der Eingabe, 0,1 in den nächstgelegenen "
"Bruch der Form *J*/2**\\ *N* umzuwandeln, wobei *J* eine Ganzzahl mit genau "
"53 Bits ist. Umformulierung ::"
#: ../../tutorial/floatingpoint.rst:276
msgid "1 / 10 ~= J / (2**N)"
msgstr "1 / 10 ~= J / (2**N)"
#: ../../tutorial/floatingpoint.rst:278
msgid "as ::"
msgstr "als ::"
#: ../../tutorial/floatingpoint.rst:280
msgid "J ~= 2**N / 10"
msgstr "J ~= 2**N / 10"
#: ../../tutorial/floatingpoint.rst:282
msgid ""
"and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< "
"2**53``), the best value for *N* is 56:"
msgstr ""
"und unter Berücksichtigung, dass *J* genau 53 Bits hat (also ``>= 2**52``, "
"aber ``< 2**53``), ist der beste Wert für *N* gleich 56:"
#: ../../tutorial/floatingpoint.rst:285
msgid ""
">>> 2**52 <= 2**56 // 10 < 2**53\n"
"True"
msgstr ""
">>> 2**52 <= 2**56 // 10 < 2**53\n"
"True"
#: ../../tutorial/floatingpoint.rst:290
msgid ""
"That is, 56 is the only value for *N* that leaves *J* with exactly 53 bits. "
"The best possible value for *J* is then that quotient rounded:"
msgstr ""
"Das heißt, 56 ist der einzige Wert für *N*, bei dem *J* genau 53 Bits hat. "
"Der bestmögliche Wert für *J* ist dann dieser Quotient, gerundet:"
#: ../../tutorial/floatingpoint.rst:293
msgid ""
">>> q, r = divmod(2**56, 10)\n"
">>> r\n"
"6"
msgstr ""
">>> q, r = divmod(2**56, 10)\n"
">>> r\n"
"6"
#: ../../tutorial/floatingpoint.rst:299
msgid ""
"Since the remainder is more than half of 10, the best approximation is "
"obtained by rounding up:"
msgstr ""
"Da der Rest mehr als die Hälfte von 10 beträgt, erhält man die beste "
"Annäherung durch Aufrunden:"
#: ../../tutorial/floatingpoint.rst:302
msgid ""
">>> q+1\n"
"7205759403792794"
msgstr ""
">>> q+1\n"
"7205759403792794"
#: ../../tutorial/floatingpoint.rst:309
msgid ""
"Therefore the best possible approximation to 1/10 in IEEE 754 double "
"precision is::"
msgstr ""
"Daher lautet die bestmögliche Annäherung an 1/10 in IEEE 754-Doppelnauigkeit:"
#: ../../tutorial/floatingpoint.rst:312
msgid "7205759403792794 / 2 ** 56"
msgstr "7205759403792794 / 2 ** 56"
#: ../../tutorial/floatingpoint.rst:314
msgid ""
"Dividing both the numerator and denominator by two reduces the fraction to::"
msgstr ""
"Durch Division von Zähler und Nenner durch zwei lässt sich der Bruch wie "
"folgt vereinfachen:"
#: ../../tutorial/floatingpoint.rst:316
msgid "3602879701896397 / 2 ** 55"
msgstr "3602879701896397 / 2 ** 55"
#: ../../tutorial/floatingpoint.rst:318
msgid ""
"Note that since we rounded up, this is actually a little bit larger than "
"1/10; if we had not rounded up, the quotient would have been a little bit "
"smaller than 1/10. But in no case can it be *exactly* 1/10!"
msgstr ""
"Beachte, dass dieser Wert, da wir aufgerundet haben, tatsächlich etwas "
"größer als 1/10 ist; hätten wir nicht aufgerundet, wäre der Quotient etwas "
"kleiner als 1/10 gewesen. Aber auf keinen Fall kann er *genau* 1/10 betragen!"
#: ../../tutorial/floatingpoint.rst:322
msgid ""
"So the computer never \"sees\" 1/10: what it sees is the exact fraction "
"given above, the best IEEE 754 double approximation it can get:"
msgstr ""
"Der Computer \"sieht\" also niemals 1/10: Was er sieht, ist genau der oben "
"angegebene Bruch, die bestmögliche IEEE-754-Doppelgenauigkeits-Annäherung, "
"die er erzielen kann:"
#: ../../tutorial/floatingpoint.rst:325
msgid ""
">>> 0.1 * 2 ** 55\n"
"3602879701896397.0"
msgstr ""
">>> 0.1 * 2 ** 55\n"
"3602879701896397.0"
#: ../../tutorial/floatingpoint.rst:330
msgid ""
"If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "
"decimal digits:"
msgstr ""
"Wenn wir diesen Bruch mit 10\\*\\*55 multiplizieren, erhalten wir den Wert "
"mit 55 Dezimalstellen:"
#: ../../tutorial/floatingpoint.rst:333
msgid ""
">>> 3602879701896397 * 10 ** 55 // 2 ** 55\n"
"1000000000000000055511151231257827021181583404541015625"
msgstr ""
">>> 3602879701896397 * 10 ** 55 // 2 ** 55\n"
"1000000000000000055511151231257827021181583404541015625"
#: ../../tutorial/floatingpoint.rst:338
msgid ""
"meaning that the exact number stored in the computer is equal to the decimal "
"value 0.1000000000000000055511151231257827021181583404541015625. Instead of "
"displaying the full decimal value, many languages (including older versions "
"of Python), round the result to 17 significant digits:"
msgstr ""
"Das bedeutet, dass die im Computer gespeicherte exakte Zahl dem Dezimalwert "
"0,1000000000000000055511151231257827021181583404541015625 entspricht. "
"Anstatt den vollständigen Dezimalwert anzuzeigen, runden viele Sprachen "
"(einschließlich älterer Python-Versionen) das Ergebnis auf 17 signifikante "
"Stellen:"
#: ../../tutorial/floatingpoint.rst:343
msgid ""
">>> format(0.1, '.17f')\n"
"'0.10000000000000001'"
msgstr ""
">>> format(0.1, '.17f')\n"
"'0.10000000000000001'"
#: ../../tutorial/floatingpoint.rst:348
msgid ""
"The :mod:`fractions` and :mod:`decimal` modules make these calculations easy:"
msgstr ""
"Die Module :mod:`fractions` und :mod:`decimal` erleichtern diese "
"Berechnungen:"
#: ../../tutorial/floatingpoint.rst:351
msgid ""
">>> from decimal import Decimal\n"
">>> from fractions import Fraction\n"
"\n"
">>> Fraction.from_float(0.1)\n"
"Fraction(3602879701896397, 36028797018963968)\n"
"\n"
">>> (0.1).as_integer_ratio()\n"
"(3602879701896397, 36028797018963968)\n"
"\n"
">>> Decimal.from_float(0.1)\n"
"Decimal('0.1000000000000000055511151231257827021181583404541015625')\n"
"\n"
">>> format(Decimal.from_float(0.1), '.17')\n"
"'0.10000000000000001'"
msgstr ""
">>> from decimal import Decimal\n"
">>> from fractions import Fraction\n"
"\n"
">>> Fraction.from_float(0.1)\n"
"Fraction(3602879701896397, 36028797018963968)\n"
"\n"
">>> (0.1).as_integer_ratio()\n"
"(3602879701896397, 36028797018963968)\n"
"\n"
">>> Decimal.from_float(0.1)\n"
"Decimal('0.1000000000000000055511151231257827021181583404541015625')\n"
"\n"
">>> format(Decimal.from_float(0.1), '.17')\n"
"'0.10000000000000001'"