Repository navigation
Expand file tree
/
Copy pathfloatingpoint.po
More file actions
495 lines (447 loc) · 23.3 KB
/
Copy pathfloatingpoint.po
File metadata and controls
495 lines (447 loc) · 23.3 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2022, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# yichung279, 2018
# cypevan, 2018
# Adrian Liaw <adrianliaw2000@gmail.com>, 2018
# Steven Hsu <hsuhaochun@gmail.com>, 2021
msgid ""
msgstr ""
"Project-Id-Version: Python 3.12\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-07-17 17:39+0800\n"
"PO-Revision-Date: 2023-06-22 14:43+0800\n"
"Last-Translator: Matt Wang <mattwang44@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Generator: Poedit 3.3.1\n"
#: ../../tutorial/floatingpoint.rst:10
msgid "Floating Point Arithmetic: Issues and Limitations"
msgstr "浮點數運算：問題與限制"
#: ../../tutorial/floatingpoint.rst:16
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 ""
"在計算機架構中，浮點數 (floating-point number) 是以基數為 2（二進位）的小數表"
"示。例如說，在\\ **十進位**\\ 小數中 ``0.625`` 可被分為 6/10 + 2/100 + "
"5/1000，同樣的道理，\\ **二進位**\\ 小數 ``0.101`` 可被分為 1/2 + 0/4 + 1/8。"
"這兩個小數有相同的數值，而唯一真正的不同在於前者以十進位表示，後者以二進位表"
"示。"
#: ../../tutorial/floatingpoint.rst:23
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 ""
"不幸的是，大多數十進位小數無法精準地以二進位小數表示。一般的結果為，你輸入的"
"十進位浮點數只能由實際儲存在計算機中的二進位浮點數近似。"
#: ../../tutorial/floatingpoint.rst:28
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 ""
"在十進位中，這個問題更容易被理解。以分數 1/3 為例，你可以將其近似為十進位小"
"數：\n"
"\n"
"::"
#: ../../tutorial/floatingpoint.rst:33 ../../tutorial/floatingpoint.rst:37
msgid "or, better, ::"
msgstr ""
"或者，更好的近似：\n"
"\n"
"::"
#: ../../tutorial/floatingpoint.rst:41
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 ""
"依此類推，不論你使用多少位數表示小數，最後的結果都無法精準地表示 1/3，但你還"
"是能越來越精準地表示 1/3。"
#: ../../tutorial/floatingpoint.rst:45
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 ""
"同樣的道理，不論你願意以多少位數表示二進位小數，十進位小數 0.1 都無法被二進位"
"小數精準地表達。在二進位小數中，1/10 會是一個無限循環小數：\n"
"\n"
"::"
#: ../../tutorial/floatingpoint.rst:51
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 ""
"只要你停在任何有限的位數，你就只會得到近似值。而現在大多數的計算機中，浮點數"
"是透過二進位分數近似的，其中分子是從最高有效位元開始，用 53 個位元表示，分母"
"則是以二為底的指數。在 1/10 的例子中，二進位分數為 ``3602879701896397 / 2 ** "
"55``，而這樣的表示十分地接近，但不完全等同於 1/10 的真正數值。"
#: ../../tutorial/floatingpoint.rst:58
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 ""
"由於數值顯示的方式，很多使用者並沒有發現數值是個近似值。Python 只會印出一個十"
"進位近似值，其近似了儲存在計算機中的二進位近似值的真正十進位數值。在大多數的"
"計算機中，如果 Python 真的會印出完整的十進位數值，其表示儲存在計算機中的 0.1 "
"的二進位近似值，它將顯示為：\n"
"\n"
"::"
#: ../../tutorial/floatingpoint.rst:67
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 ""
"這比一般人感到有用的位數還多，所以 Python 將位數保持在可以接受的範圍，只顯示"
"捨入後的數值："
#: ../../tutorial/floatingpoint.rst:75
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 ""
"一定要記住，雖然印出的數字看起來是精準的 1/10，但真正儲存的數值是能表示的二進"
"位分數中，最接近精準數值的數。"
#: ../../tutorial/floatingpoint.rst:78
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 ""
"有趣的是，有許多不同的十進位數，共用同一個最接近的二進位近似分數。例如說：數"
"字 ``0.1`` 和 ``0.10000000000000001`` 和 "
"``0.1000000000000000055511151231257827021181583404541015625``，都由 "
"``3602879701896397 / 2 ** 55`` 近似。由於這三個十進位數值共用同一個近似值，任"
"何一個數值都可以被顯示，同時保持 ``eval(repr(x)) == x``。"
#: ../../tutorial/floatingpoint.rst:86
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 ""
"歷史上，Python 的提示字元 (prompt) 與內建的 :func:`repr` 函式會選擇上段說明中"
"有 17 個有效位元的數：``0.10000000000000001``。從 Python 3.1 版開始，Python"
"（在大部分的系統上）現在能選擇其中最短的數並簡單地顯示為 ``0.1``。"
#: ../../tutorial/floatingpoint.rst:91
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 ""
"注意，這是二進位浮點數理所當然的特性，並不是 Python 的錯誤 (bug)，更不是你程"
"式碼的錯誤。只要程式語言有支援硬體的浮點數運算，你將會看到同樣的事情出現在其"
"中（雖然有些程式語言預設不會\\ *顯示*\\ 該差異，有些甚至是在所有的輸出模式中"
"都不會顯示。）"
#: ../../tutorial/floatingpoint.rst:97
msgid ""
"For more pleasant output, you may wish to use string formatting to produce a "
"limited number of significant digits:"
msgstr ""
"為求更優雅的輸出，你可能想要使用字串的格式化 (string formatting) 產生限定的有"
"效位數："
#: ../../tutorial/floatingpoint.rst:111
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 ""
"要了解一件很重要的事，在真正意義上，浮點數的表示是一種幻覺：你基本上在捨入真"
"正機器數值所\\ *展示的值*。"
#: ../../tutorial/floatingpoint.rst:114
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 ""
"這種幻覺可能會產生下一個幻覺。舉例來說，因為 0.1 不是真正的 1/10，把三個 0.1 "
"的值相加，也不會產生精準的 0.3："
#: ../../tutorial/floatingpoint.rst:122
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 ""
"同時，因為 0.1 不能再更接近精準的 1/10，還有 0.3 不能再更接近精準的 3/10，預"
"先用 :func:`round` 函式捨入並不會有幫助："
#: ../../tutorial/floatingpoint.rst:131
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 ""
"雖然數字不會再更接近他們的精準數值，但 :func:`math.isclose` 函式可以用來比較"
"不精確的值：\n"
"\n"
"::"
#: ../../tutorial/floatingpoint.rst:139
msgid ""
"Alternatively, the :func:`round` function can be used to compare rough "
"approximations::"
msgstr "或者，可以使用 :func:`round` 函式來比較粗略的近似值： ::"
#: ../../tutorial/floatingpoint.rst:147
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 "
"<https://jvns.ca/blog/2023/01/13/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 <https://www.lahey.com/float.htm>`_ for a more complete account of "
"other common surprises."
msgstr ""
"二進位浮點數架構下還有很多這樣的意外。底下的「表示法誤差 (Representation "
"Error)」章節，詳細地解釋了「0.1」的問題。`Examples of Floating Point Problems"
"（浮點數問題範例） <https://jvns.ca/blog/2023/01/13/examples-of-floating-"
"point-problems/>`_\\ 一文提供了二進位浮點數的作用方式與現實中這類常見問題的摘"
"錄。如果想要其他常見問題的更完整描述，可以參考 `The Perils of Floating Point"
"（浮點數的風險） <https://www.lahey.com/float.htm>`_。"
#: ../../tutorial/floatingpoint.rst:156
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 ""
"如同上文的末段所述，「這個問題並沒有簡單的答案。」不過，也不必對浮點過度擔"
"心！Python 的 float（浮點數）運算中的誤差，是從浮點硬體繼承而來，而在大多數的"
"計算機上，每次運算的誤差範圍不會大於 2\\*\\*53 分之 1。這對大多數的任務來說已"
"經相當足夠，但你需要記住，它並非十進位運算，且每一次 float 運算都可能會承受新"
"的捨入誤差。"
#: ../../tutorial/floatingpoint.rst:163
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 ""
"雖然浮點運算確實存在一些問題，但在一般情況下，如果你只是把最終結果的顯示值，"
"以十進位方式捨入至預期的位數，那麼仍會得到你預期的結果。:func:`str` 通常就能"
"滿足要求，而若想要更細緻的控制，可參閱\\ :ref:`formatstrings`\\ 中關於 :meth:"
"`str.format` method（方法）的格式規範。"
#: ../../tutorial/floatingpoint.rst:169
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 ""
"對於需要精準十進位表示法的用例，可以試著用 :mod:`decimal` 模組，它可實作適用"
"於會計應用程式與高精確度應用程式的十進位運算。"
#: ../../tutorial/floatingpoint.rst:173
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 ""
"另一種支援精準運算的格式為 :mod:`fractions` 模組，該模組基於有理數來實作運算"
"（因此可以精確表示像 1/3 這樣的數字）。"
#: ../../tutorial/floatingpoint.rst:177
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 <https://scipy."
"org>."
msgstr ""
"如果你是浮點運算的重度使用者，你應該看一下 NumPy 套件，以及由 SciPy 專案提供"
"的許多用於數學和統計學運算的其他套件。請參閱 <https://scipy.org>。"
#: ../../tutorial/floatingpoint.rst:181
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 ""
"在罕見情況下，當你\\ *真的*\\ 想知道一個 float 的精準值，Python 提供的工具可"
"協助達成。:meth:`float.as_integer_ratio` method 可將一個 float 的值表示為分"
"數："
#: ../../tutorial/floatingpoint.rst:192
msgid ""
"Since the ratio is exact, it can be used to losslessly recreate the original "
"value:"
msgstr "由於該比率是精準的，它可無損地再現該原始值："
#: ../../tutorial/floatingpoint.rst:200
msgid ""
"The :meth:`float.hex` method expresses a float in hexadecimal (base 16), "
"again giving the exact value stored by your computer:"
msgstr ""
":meth:`float.hex` method 以十六進位（基數為 16）表示 float，一樣可以給出你的"
"電腦所儲存的精準值："
#: ../../tutorial/floatingpoint.rst:208
msgid ""
"This precise hexadecimal representation can be used to reconstruct the float "
"value exactly:"
msgstr "這種精確的十六進位表示法可用於精準地重建 float 值："
#: ../../tutorial/floatingpoint.rst:216
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 ""
"由於該表示法是精準的，因此適用於在不同版本的 Python 之間可靠地傳送數值（獨立"
"於系統平台），並與支援相同格式的其他語言（如 JAVA 和 C99）交換資料。"
#: ../../tutorial/floatingpoint.rst:220
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 ""
"另一個有用的工具是 :func:`sum` 函式，能在計算總和時幫忙減少精確度的損失。當數"
"值被加到運行中的總計值時，它會追蹤「失去的位數 (lost digits)」。這可以明顯改"
"善總體準確度 (overall accuracy)，使得誤差不至於累積到影響最終總計值的程度："
#: ../../tutorial/floatingpoint.rst:233
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 ""
":func:`math.fsum()` 更進一步將數值被加到運行總計中的總計時追蹤所有「失去的位"
"數」，以便結果僅有一次捨入。這比 :func:`sum` 慢，但在不常見的情況下會更準確，"
"在這種情況下，大量輸入大多相互抵消，最終的總和會接近於零："
#: ../../tutorial/floatingpoint.rst:260
msgid "Representation Error"
msgstr "表示法誤差 (Representation Error)"
#: ../../tutorial/floatingpoint.rst:262
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 ""
"本節將會詳細解釋「0.1」的例子，並說明你自己要如何對類似案例執行精準的分析。 "
"以下假設你對二進位浮點表示法已有基本程度的熟悉。"
#: ../../tutorial/floatingpoint.rst:266
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:`Representation error`\\ （表示法誤差）是指在真實情況中，有些（實際上是"
"大多數）十進位小數並不能精準地以二進位（基數為 2）小數表示。這是 Python（或 "
"Perl、C、C++、JAVA、Fortran 和其他許多）通常不會顯示你期望的精準十進位數字的"
"主要原因。"
#: ../../tutorial/floatingpoint.rst:271
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 ""
"為什麼呢？因為 1/10 無法精準地以一個二進位小數來表示。至少自從 2000 年以來，"
"幾乎所有的計算機皆使用 IEEE-754 浮點數運算標準，並且幾乎所有的平台都以 IEEE "
"754 binary64 標準中的「雙精度 (double precision)」來作為 Python 的 float。"
"IEEE 754 binary64 的值包含 53 位元的精度，所以在輸入時，電腦會努力把 0.1 轉換"
"到最接近的分數，以 *J*/2**\\ *N* 的形式表示，此處 *J* 是一個正好包含 53 位元"
"的整數。可以將：\n"
"\n"
"::"
#: ../../tutorial/floatingpoint.rst:282
msgid "as ::"
msgstr ""
"重寫為：\n"
"\n"
"::"
#: ../../tutorial/floatingpoint.rst:286
msgid ""
"and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< "
"2**53``), the best value for *N* is 56:"
msgstr ""
"而前面提到 *J* 有精準的 53 位元（即 ``>= 2**52`` 但 ``< 2**53``），所以 *N* "
"的最佳數值是 56："
#: ../../tutorial/floatingpoint.rst:294
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 ""
"意即，要使 *J* 正好有 53 位元，則 56 會是 *N* 的唯一值。而 *J* 最有可能的數值"
"就是經過捨入後的該商數："
#: ../../tutorial/floatingpoint.rst:303
msgid ""
"Since the remainder is more than half of 10, the best approximation is "
"obtained by rounding up:"
msgstr "由於餘數超過 10 的一半，所以最佳的近似值是透過進位而得："
#: ../../tutorial/floatingpoint.rst:313
msgid ""
"Therefore the best possible approximation to 1/10 in IEEE 754 double "
"precision is::"
msgstr ""
"所以，在 IEEE 754 雙精度下，1/10 的最佳近似值是：\n"
"\n"
"::"
#: ../../tutorial/floatingpoint.rst:318
msgid ""
"Dividing both the numerator and denominator by two reduces the fraction to::"
msgstr ""
"將分子和分母同除以二，會約分為：\n"
"\n"
"::"
#: ../../tutorial/floatingpoint.rst:322
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 ""
"請注意，由於我們有進位，所以這實際上比 1/10 大了一點；如果我們沒有進位，商數"
"將會有點小於 1/10。但在任何情況下都不可能是\\ *精準的* 1/10！"
#: ../../tutorial/floatingpoint.rst:326
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 ""
"所以電腦從來沒有「看到」1/10：它看到的是上述的精準分數，也就是它能得到的 "
"IEEE 754 double 最佳近似值：\n"
"\n"
"::"
#: ../../tutorial/floatingpoint.rst:334
msgid ""
"If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "
"decimal digits:"
msgstr "如果將該分數乘以 10\\*\\*55，則可以看到該值以 55 個十進位數字顯示："
#: ../../tutorial/floatingpoint.rst:342
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 ""
"這表示儲存在電腦中的精準數值等於十進位值 "
"0.1000000000000000055511151231257827021181583404541015625。與其顯示完整的十進"
"位數值，許多語言（包括 Python 的舊版本）選擇將結果捨入至 17 個有效位數："
#: ../../tutorial/floatingpoint.rst:352
msgid ""
"The :mod:`fractions` and :mod:`decimal` modules make these calculations easy:"
msgstr ":mod:`fractions` 與 :mod:`decimal` 模組能使這些計算變得容易："