FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[View Raw Code]
[Original HTTPS Page]
python-docs-zh-tw/library/decimal.po at library/string · python/python-docs-zh-tw · GitHub
python
python-docs-zh-tw
Repository navigation
Code
Issues
33
(33)
Pull requests
12
(12)
Discussions
Actions
Wiki
Security and quality
Insights
Expand file tree
Breadcrumbs
python-docs-zh-tw
/
library
/
decimal.po
Copy path
More file actions
More file actions
Latest commit
History
History
History
2080 lines (1742 loc) · 69.7 KB
Breadcrumbs
python-docs-zh-tw
/
library
/
decimal.po
Copy path
File metadata and controls
2080 lines (1742 loc) · 69.7 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
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
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#
SOME DESCRIPTIVE TITLE.
#
Copyright (C) 2001-2022, Python Software Foundation
#
This file is distributed under the same license as the Python package.
#
#
Translators:
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
:
2018-05-23 14:43+0000\n
"
"
Last-Translator
:
Adrian Liaw <adrianliaw2000@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
"
#:
../../library/decimal.rst:2
msgid
":mod:`decimal` --- Decimal fixed point and floating point arithmetic"
msgstr
""
#:
../../library/decimal.rst:15
msgid
"**Source code:** :source:`Lib/decimal.py`"
msgstr
"**原始碼：**
\\
:source:`Lib/decimal.py`"
#:
../../library/decimal.rst:33
msgid
""
"The :mod:`decimal` module provides support for fast correctly rounded "
"decimal floating point arithmetic. It offers several advantages over the :"
"class:`float` datatype:"
msgstr
""
#:
../../library/decimal.rst:37
msgid
""
"Decimal
\"
is based on a floating-point model which was designed with people "
"in mind, and necessarily has a paramount guiding principle -- computers must "
"provide an arithmetic that works in the same way as the arithmetic that "
"people learn at school.
\"
-- excerpt from the decimal arithmetic "
"specification."
msgstr
""
#:
../../library/decimal.rst:42
msgid
""
"Decimal numbers can be represented exactly. In contrast, numbers like "
"``1.1`` and ``2.2`` do not have exact representations in binary floating "
"point. End users typically would not expect ``1.1 + 2.2`` to display as "
"``3.3000000000000003`` as it does with binary floating point."
msgstr
""
#:
../../library/decimal.rst:47
msgid
""
"The exactness carries over into arithmetic. In decimal floating point, "
"``0.1 + 0.1 + 0.1 - 0.3`` is exactly equal to zero. In binary floating "
"point, the result is ``5.5511151231257827e-017``. While near to zero, the "
"differences prevent reliable equality testing and differences can "
"accumulate. For this reason, decimal is preferred in accounting applications "
"which have strict equality invariants."
msgstr
""
#:
../../library/decimal.rst:54
msgid
""
"The decimal module incorporates a notion of significant places so that "
"``1.30 + 1.20`` is ``2.50``. The trailing zero is kept to indicate "
"significance. This is the customary presentation for monetary applications. "
"For multiplication, the
\"
schoolbook
\"
approach uses all the figures in the "
"multiplicands. For instance, ``1.3 * 1.2`` gives ``1.56`` while ``1.30 * "
"1.20`` gives ``1.5600``."
msgstr
""
#:
../../library/decimal.rst:61
msgid
""
"Unlike hardware based binary floating point, the decimal module has a user "
"alterable precision (defaulting to 28 places) which can be as large as "
"needed for a given problem:"
msgstr
""
#:
../../library/decimal.rst:73
msgid
""
"Both binary and decimal floating point are implemented in terms of published "
"standards. While the built-in float type exposes only a modest portion of "
"its capabilities, the decimal module exposes all required parts of the "
"standard. When needed, the programmer has full control over rounding and "
"signal handling. This includes an option to enforce exact arithmetic by "
"using exceptions to block any inexact operations."
msgstr
""
#:
../../library/decimal.rst:80
msgid
""
"The decimal module was designed to support
\"
without prejudice, both exact "
"unrounded decimal arithmetic (sometimes called fixed-point arithmetic) and "
"rounded floating-point arithmetic.
\"
-- excerpt from the decimal arithmetic "
"specification."
msgstr
""
#:
../../library/decimal.rst:85
msgid
""
"The module design is centered around three concepts: the decimal number, "
"the context for arithmetic, and signals."
msgstr
""
#:
../../library/decimal.rst:88
msgid
""
"A decimal number is immutable. It has a sign, coefficient digits, and an "
"exponent. To preserve significance, the coefficient digits do not truncate "
"trailing zeros. Decimals also include special values such as ``Infinity``, "
"``-Infinity``, and ``NaN``. The standard also differentiates ``-0`` from "
"``+0``."
msgstr
""
#:
../../library/decimal.rst:94
msgid
""
"The context for arithmetic is an environment specifying precision, rounding "
"rules, limits on exponents, flags indicating the results of operations, and "
"trap enablers which determine whether signals are treated as exceptions. "
"Rounding options include :const:`ROUND_CEILING`, :const:`ROUND_DOWN`, :const:"
"`ROUND_FLOOR`, :const:`ROUND_HALF_DOWN`, :const:`ROUND_HALF_EVEN`, :const:"
"`ROUND_HALF_UP`, :const:`ROUND_UP`, and :const:`ROUND_05UP`."
msgstr
""
#:
../../library/decimal.rst:101
msgid
""
"Signals are groups of exceptional conditions arising during the course of "
"computation. Depending on the needs of the application, signals may be "
"ignored, considered as informational, or treated as exceptions. The signals "
"in the decimal module are: :const:`Clamped`, :const:`InvalidOperation`, :"
"const:`DivisionByZero`, :const:`Inexact`, :const:`Rounded`, :const:"
"`Subnormal`, :const:`Overflow`, :const:`Underflow` and :const:"
"`FloatOperation`."
msgstr
""
#:
../../library/decimal.rst:108
msgid
""
"For each signal there is a flag and a trap enabler. When a signal is "
"encountered, its flag is set to one, then, if the trap enabler is set to "
"one, an exception is raised. Flags are sticky, so the user needs to reset "
"them before monitoring a calculation."
msgstr
""
#:
../../library/decimal.rst:116
msgid
""
"IBM's General Decimal Arithmetic Specification, `The General Decimal "
"Arithmetic Specification <https://speleotrove.com/decimal/decarith.html>`_."
msgstr
""
#:
../../library/decimal.rst:125
msgid
"Quick-start Tutorial"
msgstr
""
#:
../../library/decimal.rst:127
msgid
""
"The usual start to using decimals is importing the module, viewing the "
"current context with :func:`getcontext` and, if necessary, setting new "
"values for precision, rounding, or enabled traps::"
msgstr
""
#:
../../library/decimal.rst:139
msgid
""
"Decimal instances can be constructed from integers, strings, floats, or "
"tuples. Construction from an integer or a float performs an exact conversion "
"of the value of that integer or float. Decimal numbers include special "
"values such as ``NaN`` which stands for
\"
Not a number
\"
, positive and "
"negative ``Infinity``, and ``-0``::"
msgstr
""
#:
../../library/decimal.rst:163
msgid
""
"If the :exc:`FloatOperation` signal is trapped, accidental mixing of "
"decimals and floats in constructors or ordering comparisons raises an "
"exception::"
msgstr
""
#:
../../library/decimal.rst:182
msgid
""
"The significance of a new Decimal is determined solely by the number of "
"digits input. Context precision and rounding only come into play during "
"arithmetic operations."
msgstr
""
#:
../../library/decimal.rst:199
msgid
""
"If the internal limits of the C version are exceeded, constructing a decimal "
"raises :class:`InvalidOperation`::"
msgstr
""
#:
../../library/decimal.rst:209
msgid
""
"Decimals interact well with much of the rest of Python. Here is a small "
"decimal floating point flying circus:"
msgstr
""
#:
../../library/decimal.rst:241
msgid
"And some mathematical functions are also available to Decimal:"
msgstr
""
#:
../../library/decimal.rst:253
msgid
""
"The :meth:`~Decimal.quantize` method rounds a number to a fixed exponent. "
"This method is useful for monetary applications that often round results to "
"a fixed number of places:"
msgstr
""
#:
../../library/decimal.rst:262
msgid
""
"As shown above, the :func:`getcontext` function accesses the current context "
"and allows the settings to be changed. This approach meets the needs of "
"most applications."
msgstr
""
#:
../../library/decimal.rst:266
msgid
""
"For more advanced work, it may be useful to create alternate contexts using "
"the Context() constructor. To make an alternate active, use the :func:"
"`setcontext` function."
msgstr
""
#:
../../library/decimal.rst:270
msgid
""
"In accordance with the standard, the :mod:`decimal` module provides two "
"ready to use standard contexts, :const:`BasicContext` and :const:"
"`ExtendedContext`. The former is especially useful for debugging because "
"many of the traps are enabled:"
msgstr
""
#:
../../library/decimal.rst:299
msgid
""
"Contexts also have signal flags for monitoring exceptional conditions "
"encountered during computations. The flags remain set until explicitly "
"cleared, so it is best to clear the flags before each set of monitored "
"computations by using the :meth:`~Context.clear_flags` method. ::"
msgstr
""
#:
../../library/decimal.rst:312
msgid
""
"The *flags* entry shows that the rational approximation to pi was rounded "
"(digits beyond the context precision were thrown away) and that the result "
"is inexact (some of the discarded digits were non-zero)."
msgstr
""
#:
../../library/decimal.rst:316
msgid
""
"Individual traps are set using the dictionary in the :attr:`~Context.traps` "
"attribute of a context:"
msgstr
""
#:
../../library/decimal.rst:331
msgid
""
"Most programs adjust the current context only once, at the beginning of the "
"program. And, in many applications, data is converted to :class:`Decimal` "
"with a single cast inside a loop. With context set and decimals created, "
"the bulk of the program manipulates the data no differently than with other "
"Python numeric types."
msgstr
""
#:
../../library/decimal.rst:343
msgid
"Decimal objects"
msgstr
""
#:
../../library/decimal.rst:348
msgid
"Construct a new :class:`Decimal` object based from *value*."
msgstr
""
#:
../../library/decimal.rst:350
msgid
""
"*value* can be an integer, string, tuple, :class:`float`, or another :class:"
"`Decimal` object. If no *value* is given, returns ``Decimal('0')``. If "
"*value* is a string, it should conform to the decimal numeric string syntax "
"after leading and trailing whitespace characters, as well as underscores "
"throughout, are removed::"
msgstr
""
#:
../../library/decimal.rst:366
msgid
""
"Other Unicode decimal digits are also permitted where ``digit`` appears "
"above. These include decimal digits from various other alphabets (for "
"example, Arabic-Indic and Devanāgarī digits) along with the fullwidth digits "
"``'
\\
uff10'`` through ``'
\\
uff19'``."
msgstr
""
#:
../../library/decimal.rst:371
msgid
""
"If *value* is a :class:`tuple`, it should have three components, a sign "
"(``0`` for positive or ``1`` for negative), a :class:`tuple` of digits, and "
"an integer exponent. For example, ``Decimal((0, (1, 4, 1, 4), -3))`` returns "
"``Decimal('1.414')``."
msgstr
""
#:
../../library/decimal.rst:376
msgid
""
"If *value* is a :class:`float`, the binary floating point value is "
"losslessly converted to its exact decimal equivalent. This conversion can "
"often require 53 or more digits of precision. For example, "
"``Decimal(float('1.1'))`` converts to "
"``Decimal('1.100000000000000088817841970012523233890533447265625')``."
msgstr
""
#:
../../library/decimal.rst:382
msgid
""
"The *context* precision does not affect how many digits are stored. That is "
"determined exclusively by the number of digits in *value*. For example, "
"``Decimal('3.00000')`` records all five zeros even if the context precision "
"is only three."
msgstr
""
#:
../../library/decimal.rst:387
msgid
""
"The purpose of the *context* argument is determining what to do if *value* "
"is a malformed string. If the context traps :const:`InvalidOperation`, an "
"exception is raised; otherwise, the constructor returns a new Decimal with "
"the value of ``NaN``."
msgstr
""
#:
../../library/decimal.rst:392
msgid
"Once constructed, :class:`Decimal` objects are immutable."
msgstr
""
#:
../../library/decimal.rst:394
msgid
""
"The argument to the constructor is now permitted to be a :class:`float` "
"instance."
msgstr
""
#:
../../library/decimal.rst:398
msgid
""
":class:`float` arguments raise an exception if the :exc:`FloatOperation` "
"trap is set. By default the trap is off."
msgstr
""
#:
../../library/decimal.rst:402
msgid
""
"Underscores are allowed for grouping, as with integral and floating-point "
"literals in code."
msgstr
""
#:
../../library/decimal.rst:406
msgid
""
"Decimal floating point objects share many properties with the other built-in "
"numeric types such as :class:`float` and :class:`int`. All of the usual "
"math operations and special methods apply. Likewise, decimal objects can be "
"copied, pickled, printed, used as dictionary keys, used as set elements, "
"compared, sorted, and coerced to another type (such as :class:`float` or :"
"class:`int`)."
msgstr
""
#:
../../library/decimal.rst:413
msgid
""
"There are some small differences between arithmetic on Decimal objects and "
"arithmetic on integers and floats. When the remainder operator ``%`` is "
"applied to Decimal objects, the sign of the result is the sign of the "
"*dividend* rather than the sign of the divisor::"
msgstr
""
#:
../../library/decimal.rst:423
msgid
""
"The integer division operator ``//`` behaves analogously, returning the "
"integer part of the true quotient (truncating towards zero) rather than its "
"floor, so as to preserve the usual identity ``x == (x // y) * y + x % y``::"
msgstr
""
#:
../../library/decimal.rst:432
msgid
""
"The ``%`` and ``//`` operators implement the ``remainder`` and ``divide-"
"integer`` operations (respectively) as described in the specification."
msgstr
""
#:
../../library/decimal.rst:436
msgid
""
"Decimal objects cannot generally be combined with floats or instances of :"
"class:`fractions.Fraction` in arithmetic operations: an attempt to add a :"
"class:`Decimal` to a :class:`float`, for example, will raise a :exc:"
"`TypeError`. However, it is possible to use Python's comparison operators "
"to compare a :class:`Decimal` instance ``x`` with another number ``y``. "
"This avoids confusing results when doing equality comparisons between "
"numbers of different types."
msgstr
""
#:
../../library/decimal.rst:444
msgid
""
"Mixed-type comparisons between :class:`Decimal` instances and other numeric "
"types are now fully supported."
msgstr
""
#:
../../library/decimal.rst:448
msgid
""
"In addition to the standard numeric properties, decimal floating point "
"objects also have a number of specialized methods:"
msgstr
""
#:
../../library/decimal.rst:454
msgid
""
"Return the adjusted exponent after shifting out the coefficient's rightmost "
"digits until only the lead digit remains: ``Decimal('321e+5').adjusted()`` "
"returns seven. Used for determining the position of the most significant "
"digit with respect to the decimal point."
msgstr
""
#:
../../library/decimal.rst:461
msgid
""
"Return a pair ``(n, d)`` of integers that represent the given :class:"
"`Decimal` instance as a fraction, in lowest terms and with a positive "
"denominator::"
msgstr
""
#:
../../library/decimal.rst:468
msgid
""
"The conversion is exact. Raise OverflowError on infinities and ValueError "
"on NaNs."
msgstr
""
#:
../../library/decimal.rst:475
msgid
""
"Return a :term:`named tuple` representation of the number: "
"``DecimalTuple(sign, digits, exponent)``."
msgstr
""
#:
../../library/decimal.rst:481
msgid
""
"Return the canonical encoding of the argument. Currently, the encoding of "
"a :class:`Decimal` instance is always canonical, so this operation returns "
"its argument unchanged."
msgstr
""
#:
../../library/decimal.rst:487
msgid
""
"Compare the values of two Decimal instances. :meth:`compare` returns a "
"Decimal instance, and if either operand is a NaN then the result is a NaN::"
msgstr
""
#:
../../library/decimal.rst:498
msgid
""
"This operation is identical to the :meth:`compare` method, except that all "
"NaNs signal. That is, if neither operand is a signaling NaN then any quiet "
"NaN operand is treated as though it were a signaling NaN."
msgstr
""
#:
../../library/decimal.rst:504
msgid
""
"Compare two operands using their abstract representation rather than their "
"numerical value. Similar to the :meth:`compare` method, but the result "
"gives a total ordering on :class:`Decimal` instances. Two :class:`Decimal` "
"instances with the same numeric value but different representations compare "
"unequal in this ordering:"
msgstr
""
#:
../../library/decimal.rst:513
msgid
""
"Quiet and signaling NaNs are also included in the total ordering. The "
"result of this function is ``Decimal('0')`` if both operands have the same "
"representation, ``Decimal('-1')`` if the first operand is lower in the total "
"order than the second, and ``Decimal('1')`` if the first operand is higher "
"in the total order than the second operand. See the specification for "
"details of the total order."
msgstr
""
#:
../../library/decimal.rst:520
../../library/decimal.rst:531
#:
../../library/decimal.rst:559
../../library/decimal.rst:846
msgid
""
"This operation is unaffected by context and is quiet: no flags are changed "
"and no rounding is performed. As an exception, the C version may raise "
"InvalidOperation if the second operand cannot be converted exactly."
msgstr
""
#:
../../library/decimal.rst:526
msgid
""
"Compare two operands using their abstract representation rather than their "
"value as in :meth:`compare_total`, but ignoring the sign of each operand. "
"``x.compare_total_mag(y)`` is equivalent to ``x.copy_abs().compare_total(y."
"copy_abs())``."
msgstr
""
#:
../../library/decimal.rst:537
msgid
""
"Just returns self, this method is only to comply with the Decimal "
"Specification."
msgstr
""
#:
../../library/decimal.rst:542
msgid
""
"Return the absolute value of the argument. This operation is unaffected by "
"the context and is quiet: no flags are changed and no rounding is performed."
msgstr
""
#:
../../library/decimal.rst:548
msgid
""
"Return the negation of the argument. This operation is unaffected by the "
"context and is quiet: no flags are changed and no rounding is performed."
msgstr
""
#:
../../library/decimal.rst:553
msgid
""
"Return a copy of the first operand with the sign set to be the same as the "
"sign of the second operand. For example:"
msgstr
""
#:
../../library/decimal.rst:565
msgid
""
"Return the value of the (natural) exponential function ``e**x`` at the given "
"number. The result is correctly rounded using the :const:`ROUND_HALF_EVEN` "
"rounding mode."
msgstr
""
#:
../../library/decimal.rst:576
msgid
""
"Alternative constructor that only accepts instances of :class:`float` or :"
"class:`int`."
msgstr
""
#:
../../library/decimal.rst:579
msgid
""
"Note ``Decimal.from_float(0.1)`` is not the same as ``Decimal('0.1')``. "
"Since 0.1 is not exactly representable in binary floating point, the value "
"is stored as the nearest representable value which is "
"``0x1.999999999999ap-4``. That equivalent value in decimal is "
"``0.1000000000000000055511151231257827021181583404541015625``."
msgstr
""
#:
../../library/decimal.rst:585
msgid
""
"From Python 3.2 onwards, a :class:`Decimal` instance can also be constructed "
"directly from a :class:`float`."
msgstr
""
#:
../../library/decimal.rst:603
msgid
""
"Fused multiply-add. Return self*other+third with no rounding of the "
"intermediate product self*other."
msgstr
""
#:
../../library/decimal.rst:611
msgid
""
"Return :const:`True` if the argument is canonical and :const:`False` "
"otherwise. Currently, a :class:`Decimal` instance is always canonical, so "
"this operation always returns :const:`True`."
msgstr
""
#:
../../library/decimal.rst:617
msgid
""
"Return :const:`True` if the argument is a finite number, and :const:`False` "
"if the argument is an infinity or a NaN."
msgstr
""
#:
../../library/decimal.rst:622
msgid
""
"Return :const:`True` if the argument is either positive or negative infinity "
"and :const:`False` otherwise."
msgstr
""
#:
../../library/decimal.rst:627
msgid
""
"Return :const:`True` if the argument is a (quiet or signaling) NaN and :"
"const:`False` otherwise."
msgstr
""
#:
../../library/decimal.rst:632
msgid
""
"Return :const:`True` if the argument is a *normal* finite number. Return :"
"const:`False` if the argument is zero, subnormal, infinite or a NaN."
msgstr
""
#:
../../library/decimal.rst:637
msgid
""
"Return :const:`True` if the argument is a quiet NaN, and :const:`False` "
"otherwise."
msgstr
""
#:
../../library/decimal.rst:642
msgid
""
"Return :const:`True` if the argument has a negative sign and :const:`False` "
"otherwise. Note that zeros and NaNs can both carry signs."
msgstr
""
#:
../../library/decimal.rst:647
msgid
""
"Return :const:`True` if the argument is a signaling NaN and :const:`False` "
"otherwise."
msgstr
""
#:
../../library/decimal.rst:652
msgid
""
"Return :const:`True` if the argument is subnormal, and :const:`False` "
"otherwise."
msgstr
""
#:
../../library/decimal.rst:657
msgid
""
"Return :const:`True` if the argument is a (positive or negative) zero and :"
"const:`False` otherwise."
msgstr
""
#:
../../library/decimal.rst:662
msgid
""
"Return the natural (base e) logarithm of the operand. The result is "
"correctly rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
msgstr
""
#:
../../library/decimal.rst:667
msgid
""
"Return the base ten logarithm of the operand. The result is correctly "
"rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
msgstr
""
#:
../../library/decimal.rst:672
msgid
""
"For a nonzero number, return the adjusted exponent of its operand as a :"
"class:`Decimal` instance. If the operand is a zero then ``Decimal('-"
"Infinity')`` is returned and the :const:`DivisionByZero` flag is raised. If "
"the operand is an infinity then ``Decimal('Infinity')`` is returned."
msgstr
""
#:
../../library/decimal.rst:680
msgid
""
":meth:`logical_and` is a logical operation which takes two *logical "
"operands* (see :ref:`logical_operands_label`). The result is the digit-wise "
"``and`` of the two operands."
msgstr
""
#:
../../library/decimal.rst:686
msgid
""
":meth:`logical_invert` is a logical operation. The result is the digit-wise "
"inversion of the operand."
msgstr
""
#:
../../library/decimal.rst:691
msgid
""
":meth:`logical_or` is a logical operation which takes two *logical operands* "
"(see :ref:`logical_operands_label`). The result is the digit-wise ``or`` of "
"the two operands."
msgstr
""
#:
../../library/decimal.rst:697
msgid
""
":meth:`logical_xor` is a logical operation which takes two *logical "
"operands* (see :ref:`logical_operands_label`). The result is the digit-wise "
"exclusive or of the two operands."
msgstr
""
#:
../../library/decimal.rst:703
msgid
""
"Like ``max(self, other)`` except that the context rounding rule is applied "
"before returning and that ``NaN`` values are either signaled or ignored "
"(depending on the context and whether they are signaling or quiet)."
msgstr
""
#:
../../library/decimal.rst:710
msgid
""
"Similar to the :meth:`.max` method, but the comparison is done using the "
"absolute values of the operands."
msgstr
""
#:
../../library/decimal.rst:715
msgid
""
"Like ``min(self, other)`` except that the context rounding rule is applied "
"before returning and that ``NaN`` values are either signaled or ignored "
"(depending on the context and whether they are signaling or quiet)."
msgstr
""
#:
../../library/decimal.rst:722
msgid
""
"Similar to the :meth:`.min` method, but the comparison is done using the "
"absolute values of the operands."
msgstr
""
#:
../../library/decimal.rst:727
msgid
""
"Return the largest number representable in the given context (or in the "
"current thread's context if no context is given) that is smaller than the "
"given operand."
msgstr
""
#:
../../library/decimal.rst:733
msgid
""
"Return the smallest number representable in the given context (or in the "
"current thread's context if no context is given) that is larger than the "
"given operand."
msgstr
""
#:
../../library/decimal.rst:739
msgid
""
"If the two operands are unequal, return the number closest to the first "
"operand in the direction of the second operand. If both operands are "
"numerically equal, return a copy of the first operand with the sign set to "
"be the same as the sign of the second operand."
msgstr
""
#:
../../library/decimal.rst:746
msgid
""
"Used for producing canonical values of an equivalence class within either "
"the current context or the specified context."
msgstr
""
#:
../../library/decimal.rst:749
msgid
""
"This has the same semantics as the unary plus operation, except that if the "
"final result is finite it is reduced to its simplest form, with all trailing "
"zeros removed and its sign preserved. That is, while the coefficient is non-"
"zero and a multiple of ten the coefficient is divided by ten and the "
"exponent is incremented by 1. Otherwise (the coefficient is zero) the "
"exponent is set to 0. In all cases the sign is unchanged."
msgstr
""
#:
../../library/decimal.rst:756
msgid
""
"For example, ``Decimal('32.100')`` and ``Decimal('0.321000e+2')`` both "
"normalize to the equivalent value ``Decimal('32.1')``."
msgstr
""
#:
../../library/decimal.rst:759
msgid
"Note that rounding is applied *before* reducing to simplest form."
msgstr
""
#:
../../library/decimal.rst:761
msgid
""
"In the latest versions of the specification, this operation is also known as "
"``reduce``."
msgstr
""
#:
../../library/decimal.rst:766
msgid
""
"Return a string describing the *class* of the operand. The returned value "
"is one of the following ten strings."
msgstr
""
#:
../../library/decimal.rst:769
msgid
"``
\"
-Infinity
\"
``, indicating that the operand is negative infinity."
msgstr
""
#:
../../library/decimal.rst:770
msgid
""
"``
\"
-Normal
\"
``, indicating that the operand is a negative normal number."
msgstr
""
#:
../../library/decimal.rst:771
msgid
""
"``
\"
-Subnormal
\"
``, indicating that the operand is negative and subnormal."
msgstr
""
#:
../../library/decimal.rst:772
msgid
"``
\"
-Zero
\"
``, indicating that the operand is a negative zero."
msgstr
""
#:
../../library/decimal.rst:773
msgid
"``
\"
+Zero
\"
``, indicating that the operand is a positive zero."
msgstr
""
#:
../../library/decimal.rst:774
msgid
""
"``
\"
+Subnormal
\"
``, indicating that the operand is positive and subnormal."
msgstr
""
#:
../../library/decimal.rst:775
msgid
""
"``
\"
+Normal
\"
``, indicating that the operand is a positive normal number."
msgstr
""
#:
../../library/decimal.rst:776
msgid
"``
\"
+Infinity
\"
``, indicating that the operand is positive infinity."
msgstr
""
#:
../../library/decimal.rst:777
msgid
"``
\"
NaN
\"
``, indicating that the operand is a quiet NaN (Not a Number)."
msgstr
""
#:
../../library/decimal.rst:778
msgid
"``
\"
sNaN
\"
``, indicating that the operand is a signaling NaN."
msgstr
""
#:
../../library/decimal.rst:782
msgid
""
"Return a value equal to the first operand after rounding and having the "
"exponent of the second operand."
msgstr
""
#:
../../library/decimal.rst:788
msgid
""
"Unlike other operations, if the length of the coefficient after the quantize "
"operation would be greater than precision, then an :const:`InvalidOperation` "
"is signaled. This guarantees that, unless there is an error condition, the "
"quantized exponent is always equal to that of the right-hand operand."
msgstr
""
#:
../../library/decimal.rst:794
msgid
""
"Also unlike other operations, quantize never signals Underflow, even if the "
"result is subnormal and inexact."
msgstr
""
#:
../../library/decimal.rst:797
msgid
""
"If the exponent of the second operand is larger than that of the first then "
"rounding may be necessary. In this case, the rounding mode is determined by "
"the ``rounding`` argument if given, else by the given ``context`` argument; "
"if neither argument is given the rounding mode of the current thread's "
"context is used."
msgstr
""
#:
../../library/decimal.rst:803
msgid
""
"An error is returned whenever the resulting exponent is greater than :attr:"
"`~Context.Emax` or less than :meth:`~Context.Etiny`."
msgstr
""
#:
../../library/decimal.rst:808
msgid
""
"Return ``Decimal(10)``, the radix (base) in which the :class:`Decimal` class "
"does all its arithmetic. Included for compatibility with the specification."
msgstr
""
#:
../../library/decimal.rst:814
msgid
""
"Return the remainder from dividing *self* by *other*. This differs from "
"``self % other`` in that the sign of the remainder is chosen so as to "
"minimize its absolute value. More precisely, the return value is ``self - n "
"* other`` where ``n`` is the integer nearest to the exact value of ``self / "
"other``, and if two integers are equally near then the even one is chosen."
msgstr
""
#:
../../library/decimal.rst:821
msgid
"If the result is zero then its sign will be the sign of *self*."
msgstr
""
#:
../../library/decimal.rst:832
msgid
""
"Return the result of rotating the digits of the first operand by an amount "
"specified by the second operand. The second operand must be an integer in "
"the range -precision through precision. The absolute value of the second "
"operand gives the number of places to rotate. If the second operand is "
"positive then rotation is to the left; otherwise rotation is to the right. "
"The coefficient of the first operand is padded on the left with zeros to "
"length precision if necessary. The sign and exponent of the first operand "
"are unchanged."
msgstr
""
#:
../../library/decimal.rst:843
msgid
""
"Test whether self and other have the same exponent or whether both are "
"``NaN``."
msgstr
""
#:
../../library/decimal.rst:852
msgid
""
"Return the first operand with exponent adjusted by the second. Equivalently, "
"return the first operand multiplied by ``10**other``. The second operand "
"must be an integer."
msgstr
""
#:
../../library/decimal.rst:858
msgid
""
"Return the result of shifting the digits of the first operand by an amount "
"specified by the second operand. The second operand must be an integer in "
"the range -precision through precision. The absolute value of the second "
"operand gives the number of places to shift. If the second operand is "
"positive then the shift is to the left; otherwise the shift is to the "
"right. Digits shifted into the coefficient are zeros. The sign and "
"exponent of the first operand are unchanged."
msgstr
""
#:
../../library/decimal.rst:868
msgid
"Return the square root of the argument to full precision."
msgstr
""
#:
../../library/decimal.rst:873
../../library/decimal.rst:1468
msgid
""
"Convert to a string, using engineering notation if an exponent is needed."
msgstr
""
#:
../../library/decimal.rst:875
../../library/decimal.rst:1470
msgid
""
"Engineering notation has an exponent which is a multiple of 3. This can "
"leave up to 3 digits to the left of the decimal place and may require the "
"addition of either one or two trailing zeros."
msgstr
""
#:
../../library/decimal.rst:879
msgid
""
"For example, this converts ``Decimal('123E+1')`` to ``Decimal('1.23E+3')``."
msgstr
""
#:
../../library/decimal.rst:883
msgid
""
"Identical to the :meth:`to_integral_value` method. The ``to_integral`` name "
"has been kept for compatibility with older versions."
msgstr
""
#:
../../library/decimal.rst:888
msgid
""
"Round to the nearest integer, signaling :const:`Inexact` or :const:`Rounded` "
"as appropriate if rounding occurs. The rounding mode is determined by the "
"``rounding`` parameter if given, else by the given ``context``. If neither "
"parameter is given then the rounding mode of the current context is used."
msgstr
""
#:
../../library/decimal.rst:896
msgid
""
"Round to the nearest integer without signaling :const:`Inexact` or :const:"
"`Rounded`. If given, applies *rounding*; otherwise, uses the rounding "
"method in either the supplied *context* or the current context."
msgstr
""
#:
../../library/decimal.rst:904
msgid
"Logical operands"
msgstr
""
#:
../../library/decimal.rst:906
msgid
""
"The :meth:`~Decimal.logical_and`, :meth:`~Decimal.logical_invert`, :meth:"
"`~Decimal.logical_or`, and :meth:`~Decimal.logical_xor` methods expect their "
"arguments to be *logical operands*. A *logical operand* is a :class:"
"`Decimal` instance whose exponent and sign are both zero, and whose digits "
"are all either ``0`` or ``1``."
msgstr
""
#:
../../library/decimal.rst:918
msgid
"Context objects"
msgstr
""
#:
../../library/decimal.rst:920
msgid
""
"Contexts are environments for arithmetic operations. They govern precision, "
"set rules for rounding, determine which signals are treated as exceptions, "
"and limit the range for exponents."
msgstr
""
#:
../../library/decimal.rst:924
msgid
""
"Each thread has its own current context which is accessed or changed using "
"the :func:`getcontext` and :func:`setcontext` functions:"
msgstr
""
#:
../../library/decimal.rst:930
msgid
"Return the current context for the active thread."
msgstr
""
#:
../../library/decimal.rst:935
msgid
"Set the current context for the active thread to *c*."
msgstr
""
#:
../../library/decimal.rst:937
msgid
""
"You can also use the :keyword:`with` statement and the :func:`localcontext` "
"function to temporarily change the active context."
msgstr
""
#:
../../library/decimal.rst:942
msgid
""
"Return a context manager that will set the current context for the active "
"thread to a copy of *ctx* on entry to the with-statement and restore the "
"previous context when exiting the with-statement. If no context is "
"specified, a copy of the current context is used. The *kwargs* argument is "
"used to set the attributes of the new context."
msgstr
""
#:
../../library/decimal.rst:948
msgid
""
"For example, the following code sets the current decimal precision to 42 "
"places, performs a calculation, and then automatically restores the previous "
"context::"
msgstr
""
#:
../../library/decimal.rst:958
msgid
"Using keyword arguments, the code would be the following::"
msgstr
""
#:
../../library/decimal.rst:966
msgid
""
"Raises :exc:`TypeError` if *kwargs* supplies an attribute that :class:"
"`Context` doesn't support. Raises either :exc:`TypeError` or :exc:"
"`ValueError` if *kwargs* supplies an invalid value for an attribute."
msgstr
""
#:
../../library/decimal.rst:970
msgid
""
":meth:`localcontext` now supports setting context attributes through the use "
"of keyword arguments."
msgstr
""
#:
../../library/decimal.rst:973
msgid
""
"New contexts can also be created using the :class:`Context` constructor "
"described below. In addition, the module provides three pre-made contexts:"
msgstr
""
#:
../../library/decimal.rst:979
msgid
""
"This is a standard context defined by the General Decimal Arithmetic "
"Specification. Precision is set to nine. Rounding is set to :const:"
"`ROUND_HALF_UP`. All flags are cleared. All traps are enabled (treated as "
"exceptions) except :const:`Inexact`, :const:`Rounded`, and :const:"
"`Subnormal`."
msgstr
""
#:
../../library/decimal.rst:985
msgid
""
"Because many of the traps are enabled, this context is useful for debugging."
msgstr
""
#:
../../library/decimal.rst:990
msgid
""
"This is a standard context defined by the General Decimal Arithmetic "
View remainder of file in raw view
Back
|
FazBrowse Home
|
New Git URL