Python float bulat ke 4 desimal

Modul ini menyediakan dukungan untuk aritmatika floating point desimal yang dibulatkan dengan benar dengan cepat. Ini menawarkan beberapa keunggulan dibandingkan tipe data

Nội dung chính Show

Tutorial memulai cepat
Objek desimal
Operan logis
Objek konteks
Rounding modes
Catatan Titik Mengambang
Memitigasi kesalahan pembulatan dengan peningkatan presisi
Nilai-nilai khusus
Bekerja dengan benang
FAQ desimal
Bagaimana Anda membulatkan pelampung ke 4 tempat desimal dengan Python?
Bagaimana Anda membulatkan float ke sejumlah desimal dengan Python?
Bagaimana Anda mencetak ke 4 tempat desimal dengan Python?

Desimal “didasarkan pada model floating-point yang dirancang dengan mempertimbangkan manusia, dan tentu saja memiliki prinsip panduan terpenting – komputer harus menyediakan aritmatika yang bekerja dengan cara yang sama seperti aritmatika yang dipelajari orang di sekolah. ” – kutipan dari spesifikasi aritmatika desimal

Angka desimal dapat direpresentasikan dengan tepat. Sebaliknya, angka seperti

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []

7 dan

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []

8 tidak memiliki representasi yang tepat dalam floating point biner. Pengguna akhir biasanya tidak mengharapkan

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []

9 untuk ditampilkan sebagai

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

0 seperti halnya dengan floating point biner

Ketepatan terbawa ke dalam aritmatika. Dalam floating point desimal,

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

_1 persis sama dengan nol. Dalam floating point biner, hasilnya adalah

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

2. Meskipun mendekati nol, perbedaan mencegah pengujian kesetaraan yang andal dan perbedaan dapat terakumulasi. Untuk alasan ini, desimal lebih disukai dalam aplikasi akuntansi yang memiliki persamaan invarian yang ketat

Modul desimal menggabungkan gagasan tempat signifikan sehingga

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

3 adalah

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

4. Trailing zero disimpan untuk menunjukkan signifikansi. Ini adalah presentasi umum untuk aplikasi moneter. Untuk perkalian, pendekatan “buku sekolah” menggunakan semua angka dalam perkalian. Misalnya,

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

_5 memberikan

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

6 sementara

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

7 memberikan

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

Tidak seperti floating point biner berbasis perangkat keras, modul desimal memiliki presisi yang dapat diubah pengguna (default ke 28 tempat) yang dapat sebesar yang diperlukan untuk masalah yang diberikan

>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')

Titik mengambang biner dan desimal diimplementasikan dalam standar yang dipublikasikan. Sementara tipe float built-in hanya memperlihatkan sebagian kecil dari kemampuannya, modul desimal memperlihatkan semua bagian yang diperlukan dari standar. Saat dibutuhkan, pemrogram memiliki kendali penuh atas pembulatan dan penanganan sinyal. Ini termasuk opsi untuk menerapkan aritmatika yang tepat dengan menggunakan pengecualian untuk memblokir operasi yang tidak tepat
Modul desimal dirancang untuk mendukung “tanpa prasangka, baik aritmatika desimal tak bulat eksak (terkadang disebut aritmatika titik tetap) dan aritmatika titik mengambang bulat. ” – kutipan dari spesifikasi aritmatika desimal

Desain modul berpusat di sekitar tiga konsep. angka desimal, konteks untuk aritmatika, dan sinyal

Angka desimal tidak dapat diubah. Ini memiliki tanda, digit koefisien, dan eksponen. Untuk menjaga signifikansi, digit koefisien tidak memotong angka nol yang tertinggal. Desimal juga menyertakan nilai khusus seperti

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

0, dan

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1. Standar ini juga membedakan

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

_2 dari

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

Konteks untuk aritmatika adalah lingkungan yang menentukan presisi, aturan pembulatan, batas eksponen, bendera yang menunjukkan hasil operasi, dan pemungkin perangkap yang menentukan apakah sinyal diperlakukan sebagai pengecualian. Opsi pembulatan meliputi , , , , , , , dan

Sinyal adalah kelompok kondisi luar biasa yang muncul selama perhitungan. Bergantung pada kebutuhan aplikasi, sinyal dapat diabaikan, dianggap sebagai informasi, atau diperlakukan sebagai pengecualian. Sinyal dalam modul desimal adalah. , , , , , , , Dan

Untuk setiap sinyal ada sebuah flag dan sebuah trap enabler. Ketika sebuah sinyal ditemukan, benderanya disetel ke satu, kemudian, jika pengaktif perangkap disetel ke satu, pengecualian dimunculkan. Bendera melekat, sehingga pengguna perlu menyetel ulang sebelum memantau perhitungan

Lihat juga

Spesifikasi Aritmatika Desimal Umum IBM, Spesifikasi Aritmatika Desimal Umum

Tutorial memulai cepat

Awal penggunaan desimal yang biasa adalah mengimpor modul, melihat konteks saat ini dengan dan, jika perlu, menyetel nilai baru untuk presisi, pembulatan, atau perangkap yang diaktifkan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

Contoh desimal dapat dibangun dari bilangan bulat, string, float, atau tupel. Konstruksi dari integer atau float melakukan konversi yang tepat dari nilai integer atau float tersebut. Angka desimal mencakup nilai khusus seperti

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 yang merupakan singkatan dari “Bukan angka”, positif dan negatif

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

9, dan

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

Jika sinyal terjebak, pencampuran desimal dan float yang tidak disengaja dalam konstruktor atau perbandingan urutan akan menimbulkan pengecualian

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

Baru di versi 3. 3

Signifikansi Desimal baru ditentukan semata-mata oleh jumlah digit input. Ketepatan konteks dan pembulatan hanya berperan selama operasi aritmatika

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

Jika batas internal versi C terlampaui, membuat kenaikan desimal

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []

Berubah di versi 3. 3

Desimal berinteraksi dengan baik dengan sebagian besar Python lainnya. Ini adalah sirkus terbang floating point desimal kecil

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

Dan beberapa fungsi matematika juga tersedia untuk Desimal

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

Metode

>>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)
>>> setcontext(myothercontext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857142857142857142857142857')

>>> ExtendedContext
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[])
>>> setcontext(ExtendedContext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857143')
>>> Decimal(42) / Decimal(0)
Decimal('Infinity')

>>> setcontext(BasicContext)
>>> Decimal(42) / Decimal(0)
Traceback (most recent call last):
  File "", line 1, in -toplevel-
    Decimal(42) / Decimal(0)
DivisionByZero: x / 0

_7 membulatkan angka menjadi eksponen tetap. Metode ini berguna untuk aplikasi moneter yang sering membulatkan hasil ke jumlah tempat yang tetap

>>> Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)
Decimal('7.32')
>>> Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP)
Decimal('8')

Seperti yang ditunjukkan di atas, fungsi mengakses konteks saat ini dan memungkinkan pengaturan diubah. Pendekatan ini memenuhi kebutuhan sebagian besar aplikasi

Untuk pekerjaan yang lebih lanjut, mungkin berguna untuk membuat konteks alternatif menggunakan konstruktor Context(). Untuk mengaktifkan alternatif, gunakan fungsi

Sesuai dengan standar, modul menyediakan dua konteks standar siap pakai, dan. Yang pertama sangat berguna untuk debugging karena banyak jebakan diaktifkan

>>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)
>>> setcontext(myothercontext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857142857142857142857142857')

>>> ExtendedContext
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[])
>>> setcontext(ExtendedContext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857143')
>>> Decimal(42) / Decimal(0)
Decimal('Infinity')

>>> setcontext(BasicContext)
>>> Decimal(42) / Decimal(0)
Traceback (most recent call last):
  File "", line 1, in -toplevel-
    Decimal(42) / Decimal(0)
DivisionByZero: x / 0

Konteks juga memiliki tanda sinyal untuk memantau kondisi luar biasa yang ditemui selama perhitungan. Bendera tetap disetel hingga dibersihkan secara eksplisit, jadi yang terbaik adalah menghapus bendera sebelum setiap rangkaian perhitungan yang dipantau dengan menggunakan metode

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

Entri flag menunjukkan bahwa perkiraan rasional untuk

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

04 dibulatkan (digit di luar presisi konteks dibuang) dan hasilnya tidak eksak (beberapa digit yang dibuang bukan nol)

Jebakan individu diatur menggunakan kamus di bidang

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

05 dari suatu konteks

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

Sebagian besar program menyesuaikan konteks saat ini hanya sekali, di awal program. Dan, di banyak aplikasi, data dikonversi dengan satu pemeran di dalam satu lingkaran. Dengan set konteks dan desimal dibuat, sebagian besar program memanipulasi data tidak berbeda dengan tipe numerik Python lainnya

Objek desimal

kelas desimal. Desimal(nilai=', context=None)

Bangun objek baru berdasarkan nilai

nilai dapat berupa bilangan bulat, string, tupel, , atau objek lain. Jika tidak ada nilai yang diberikan, kembalikan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

10. Jika nilai adalah string, itu harus sesuai dengan sintaks string numerik desimal setelah karakter spasi putih di depan dan di belakang, serta garis bawah seluruhnya, dihapus

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

Digit desimal Unicode lainnya juga diizinkan jika

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

11 muncul di atas. Ini termasuk angka desimal dari berbagai abjad lainnya (misalnya, angka Arab-India dan Devanāgarī) bersama dengan angka lebar penuh

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

12 hingga

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

Jika nilainya a , ia harus memiliki tiga komponen, tanda (

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

15 untuk positif atau

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

16 untuk negatif), a digit, dan eksponen bilangan bulat. Misalnya,

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_18 mengembalikan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

Jika nilainya adalah a , nilai floating point biner tanpa rugi dikonversi ke persamaan desimal persisnya. Konversi ini seringkali membutuhkan 53 digit atau lebih presisi. Misalnya,

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_21 diubah menjadi

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

Ketepatan konteks tidak memengaruhi jumlah digit yang disimpan. Itu ditentukan secara eksklusif oleh jumlah digit nilainya. Misalnya,

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

23 merekam semua lima angka nol meskipun ketepatan konteksnya hanya tiga

Tujuan dari argumen konteks adalah menentukan apa yang harus dilakukan jika nilai adalah string yang salah bentuk. Jika konteks menjebak , pengecualian dimunculkan;

Setelah dibangun, objek tidak dapat diubah

Berubah di versi 3. 2. Argumen ke konstruktor sekarang diizinkan menjadi instance.

Berubah di versi 3. 3. argumen memunculkan pengecualian jika jebakan disetel. Secara default, jebakan tidak aktif.

Berubah di versi 3. 6. Underscore diperbolehkan untuk pengelompokan, seperti literal integral dan floating-point dalam kode.

Objek floating point desimal berbagi banyak properti dengan tipe numerik bawaan lainnya seperti dan. Semua operasi matematika biasa dan metode khusus berlaku. Demikian pula, objek desimal dapat disalin, diasamkan, dicetak, digunakan sebagai kunci kamus, digunakan sebagai elemen set, dibandingkan, diurutkan, dan dipaksakan ke jenis lain (seperti atau )

Ada beberapa perbedaan kecil antara aritmatika pada objek Desimal dan aritmatika pada bilangan bulat dan pelampung. Ketika operator sisa

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

34 diterapkan pada objek Desimal, tanda hasilnya adalah tanda pembagi dan bukan tanda pembagi

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

Operator pembagian bilangan bulat

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

35 berperilaku analogi, mengembalikan bagian bilangan bulat dari hasil bagi yang sebenarnya (memotong menuju nol) daripada lantainya, untuk mempertahankan identitas yang biasa

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

Operator

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_34 dan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

35 menerapkan operasi

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

39 dan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

40 (masing-masing) seperti yang dijelaskan dalam spesifikasi

Objek desimal umumnya tidak dapat digabungkan dengan float atau contoh dalam operasi aritmatika. upaya untuk menambahkan a ke a , misalnya, akan memunculkan a. Namun, dimungkinkan untuk menggunakan operator perbandingan Python untuk membandingkan contoh

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

46 dengan nomor lain

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

47. Hal ini untuk menghindari hasil yang membingungkan ketika melakukan perbandingan kesetaraan antara jumlah dari jenis yang berbeda

Berubah di versi 3. 2. Perbandingan tipe campuran antara instans dan tipe numerik lainnya kini didukung sepenuhnya.

Selain properti numerik standar, objek floating point desimal juga memiliki sejumlah metode khusus

disesuaikan()

Kembalikan eksponen yang telah disesuaikan setelah menggeser digit paling kanan koefisien hingga hanya digit awal yang tersisa.

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_49 mengembalikan tujuh. Digunakan untuk menentukan posisi digit paling signifikan sehubungan dengan titik desimal

as_integer_ratio()

Mengembalikan sepasang

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

50 bilangan bulat yang mewakili contoh yang diberikan sebagai pecahan, dalam suku terendah dan dengan penyebut positif

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

Konversinya tepat. Tingkatkan OverflowError pada infinitas dan ValueError pada NaN

Baru di versi 3. 6

as_tuple()

Mengembalikan representasi nomor.

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_52

kanonis()

Kembalikan pengkodean kanonis argumen. Saat ini, pengkodean suatu instance selalu bersifat kanonis, sehingga operasi ini mengembalikan argumennya tanpa perubahan

bandingkan(lainnya , konteks=None)

Bandingkan nilai dari dua contoh Desimal. mengembalikan instance Desimal, dan jika salah satu operan adalah NaN maka hasilnya adalah NaN

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

bandingkan_sinyal(lainnya , konteks=None)

Operasi ini identik dengan metode, kecuali bahwa semua sinyal NaN. Yaitu, jika tidak ada operan yang merupakan NaN pensinyalan, maka setiap operan NaN yang tenang diperlakukan seolah-olah itu adalah NaN pensinyalan

bandingkan_total(lainnya , konteks=None)

Bandingkan dua operan menggunakan representasi abstraknya daripada nilai numeriknya. Mirip dengan metode, tetapi hasilnya memberikan pengurutan total pada instans. Dua contoh dengan nilai numerik yang sama tetapi representasi berbeda membandingkan tidak sama dalam urutan ini

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

NaN yang tenang dan memberi sinyal juga termasuk dalam pemesanan total. Hasil dari fungsi ini adalah

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_10 jika kedua operan memiliki representasi yang sama,

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

60 jika urutan total operan pertama lebih rendah daripada operan kedua, dan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

61 jika urutan total operan pertama lebih tinggi daripada operan kedua. Lihat spesifikasi untuk detail total pesanan

Operasi ini tidak terpengaruh oleh konteks dan tenang. tidak ada bendera yang diubah dan tidak ada pembulatan yang dilakukan. Sebagai pengecualian, versi C dapat memunculkan InvalidOperation jika operan kedua tidak dapat dikonversi dengan tepat

bandingkan_total_mag(lainnya , konteks=None)

Bandingkan dua operan menggunakan representasi abstraknya daripada nilainya seperti pada , tetapi abaikan tanda setiap operan.

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_63 setara dengan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

konjugasi()

Hanya mengembalikan diri, metode ini hanya untuk memenuhi Spesifikasi Desimal

copy_abs()

Mengembalikan nilai absolut argumen. Operasi ini tidak terpengaruh oleh konteks dan tidak bersuara. tidak ada bendera yang diubah dan tidak ada pembulatan yang dilakukan

copy_negate()

Kembalikan negasi argumen. Operasi ini tidak terpengaruh oleh konteks dan tidak bersuara. tidak ada bendera yang diubah dan tidak ada pembulatan yang dilakukan

copy_sign(lainnya , konteks=None)

Kembalikan salinan operan pertama dengan tanda yang disetel sama dengan tanda operan kedua. Misalnya

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

exp(konteks=Tidak ada)

Kembalikan nilai fungsi eksponensial (alami)

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

65 pada nomor yang diberikan. Hasilnya dibulatkan dengan benar menggunakan mode pembulatan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

classmethod from_float(f)

Konstruktor alternatif yang hanya menerima instance dari or

Perhatikan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_69 tidak sama dengan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

70. Sejak 0. 1 tidak dapat direpresentasikan secara tepat dalam floating point biner, nilai disimpan sebagai nilai terdekat yang dapat direpresentasikan yaitu

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

71. Nilai yang setara dalam desimal adalah

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

Catatan

Dari Python 3. 2 dan seterusnya, sebuah instance juga dapat dibangun langsung dari a

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

Baru di versi 3. 1

fma(lainnya , ketiga, context=None)

Multiply-add menyatu. Mengembalikan diri*lain+ketiga tanpa pembulatan produk perantara diri*lainnya

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

is_canonical()

Kembalikan jika argumennya kanonik dan sebaliknya. Saat ini, sebuah instance selalu bersifat kanonis, sehingga operasi ini selalu kembali

terbatas()

Kembalikan jika argumennya adalah bilangan terbatas, dan jika argumennya adalah tak terhingga atau NaN

tidak terbatas()

Kembalikan jika argumennya positif atau negatif tak terhingga dan sebaliknya

is_nan()

Kembalikan jika argumennya adalah NaN (diam atau memberi sinyal) dan sebaliknya

normal(konteks=Tidak ada)

Kembalikan jika argumennya adalah bilangan terbatas normal. Kembalikan jika argumennya nol, subnormal, tak terbatas, atau NaN

is_qnan()

Kembalikan jika argumennya adalah NaN yang tenang, dan sebaliknya

ditandatangani()

Kembali jika argumen memiliki tanda negatif dan sebaliknya. Perhatikan bahwa nol dan NaN keduanya dapat membawa tanda

is_snan()

Kembalikan jika argumennya adalah sinyal NaN dan sebaliknya

is_subnormal(konteks=Tidak ada)

Kembalikan jika argumennya subnormal, dan sebaliknya

adalah_nol()

Kembalikan jika argumennya adalah nol (positif atau negatif) dan sebaliknya

ln(konteks=Tidak ada)

Mengembalikan logaritma natural (basis e) dari operan. Hasilnya dibulatkan dengan benar menggunakan mode pembulatan

log10(konteks=Tidak ada)

Mengembalikan logaritma basis sepuluh operan. Hasilnya dibulatkan dengan benar menggunakan mode pembulatan

logb(konteks=Tidak ada)

Untuk angka bukan nol, kembalikan eksponen yang disesuaikan dari operannya sebagai contoh. Jika operan adalah nol maka

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

00 dikembalikan dan bendera dinaikkan. Jika operan adalah tak terhingga maka

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

02 dikembalikan

logis_dan(lainnya , konteks=None)

adalah operasi logis yang membutuhkan dua operan logis (lihat ). Hasilnya adalah digit-bijaksana

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_04 dari dua operan

logical_invert(konteks=Tidak ada)

adalah operasi logika. Hasilnya adalah inversi operan digit-bijaksana

logis_atau(lainnya , konteks=None)

adalah operasi logis yang membutuhkan dua operan logis (lihat ). Hasilnya adalah digit-bijaksana

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_07 dari dua operan

logika_xor(lainnya , konteks=None)

adalah operasi logis yang membutuhkan dua operan logis (lihat ). Hasilnya adalah eksklusif digit atau dari dua operan

maks(lainnya , konteks=None)

Seperti

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_09 kecuali bahwa aturan pembulatan konteks diterapkan sebelum kembali dan bahwa nilai

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 ditandai atau diabaikan (bergantung pada konteks dan apakah memberi sinyal atau diam)

max_mag(lainnya , konteks=None)

Mirip dengan metode, tetapi perbandingan dilakukan dengan menggunakan nilai absolut dari operan

mnt(lainnya , konteks=None)

Seperti

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_12 kecuali bahwa aturan pembulatan konteks diterapkan sebelum kembali dan bahwa nilai

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 ditandai atau diabaikan (bergantung pada konteks dan apakah mereka memberi sinyal atau diam)

min_mag(lainnya , konteks=None)

Mirip dengan metode, tetapi perbandingan dilakukan dengan menggunakan nilai absolut dari operan

next_minus(konteks=Tidak ada)

Kembalikan angka terbesar yang dapat diwakili dalam konteks yang diberikan (atau dalam konteks utas saat ini jika tidak ada konteks yang diberikan) yang lebih kecil dari operan yang diberikan

next_plus(konteks=Tidak ada)

Kembalikan angka terkecil yang dapat diwakili dalam konteks yang diberikan (atau dalam konteks utas saat ini jika tidak ada konteks yang diberikan) yang lebih besar dari operan yang diberikan

selanjutnya(lainnya , konteks=None)

Jika kedua operan tidak sama, kembalikan angka yang paling dekat dengan operan pertama ke arah operan kedua. Jika kedua operan sama secara numerik, kembalikan salinan operan pertama dengan tanda yang disetel sama dengan tanda operan kedua

normalkan(konteks=Tidak ada)

Normalisasi angka dengan menghapus angka nol paling kanan dan mengonversi hasil apa pun yang sama dengan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

10 menjadi

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

16. Digunakan untuk menghasilkan nilai kanonik untuk atribut kelas kesetaraan. Misalnya,

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

17 dan

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

18 keduanya dinormalisasi ke nilai yang setara

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

number_class(konteks=Tidak ada)

Mengembalikan string yang menjelaskan kelas operan. Nilai yang dikembalikan adalah salah satu dari sepuluh string berikut

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_20, menunjukkan bahwa operan adalah infinity negatif

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_21, menunjukkan bahwa operan adalah bilangan normal negatif

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_22, menunjukkan bahwa operan negatif dan subnormal

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_23, menunjukkan bahwa operan adalah nol negatif

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_24, menunjukkan bahwa operan adalah nol positif

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_25, menunjukkan bahwa operan adalah positif dan subnormal

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_26, menunjukkan bahwa operan adalah bilangan normal positif

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_27, menunjukkan bahwa operan adalah infinity positif

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_28, menunjukkan bahwa operan adalah NaN yang tenang (Bukan Angka)

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_29, menunjukkan bahwa operan adalah NaN pensinyalan

kuantisasi(exp , pembulatan=None, context=None)

Mengembalikan nilai yang sama dengan operan pertama setelah pembulatan dan memiliki eksponen dari operan kedua

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

Tidak seperti operasi lainnya, jika panjang koefisien setelah operasi kuantisasi akan lebih besar dari presisi, maka sebuah diberi sinyal. Ini menjamin bahwa, kecuali ada kondisi kesalahan, eksponen terkuantisasi selalu sama dengan eksponen kanan

Juga tidak seperti operasi lainnya, quantize tidak pernah memberi sinyal Underflow, meskipun hasilnya di bawah normal dan tidak tepat

Jika eksponen operan kedua lebih besar dari yang pertama, maka pembulatan mungkin diperlukan. Dalam hal ini, mode pembulatan ditentukan oleh argumen

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

31 jika diberikan, selain itu dengan argumen

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

32 yang diberikan;

Kesalahan dikembalikan setiap kali eksponen yang dihasilkan lebih besar dari

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

33 atau kurang dari

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

radiks()

Kembalikan

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_35, radix (basis) di mana kelas melakukan semua aritmatika. Termasuk untuk kompatibilitas dengan spesifikasi

remainder_near(lainnya , konteks=None)

Kembalikan sisa dari pembagian diri dengan orang lain. Ini berbeda dari

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_37 di mana tanda sisa dipilih untuk meminimalkan nilai absolutnya. Lebih tepatnya, nilai yang dikembalikan adalah

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_38 di mana

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

39 adalah bilangan bulat terdekat dengan nilai pasti dari

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

40, dan jika dua bilangan bulat sama-sama dekat maka yang genap dipilih

Jika hasilnya nol maka tandanya adalah tanda diri

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

putar(lainnya , konteks=None)

Kembalikan hasil memutar digit operan pertama dengan jumlah yang ditentukan oleh operan kedua. Operan kedua harus berupa bilangan bulat dalam rentang -presisi hingga presisi. Nilai absolut dari operan kedua memberikan jumlah tempat untuk diputar. Jika operan kedua positif maka rotasi ke kiri; . Koefisien operan pertama diisi di sebelah kiri dengan presisi nol hingga panjang jika perlu. Tanda dan eksponen operan pertama tidak berubah

same_quantum(other , konteks=None)

Ujilah apakah self dan other memiliki eksponen yang sama atau apakah keduanya

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

skala(lainnya , konteks=None)

Kembalikan operan pertama dengan eksponen yang disesuaikan dengan yang kedua. Secara setara, kembalikan operan pertama dikalikan dengan

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

42. Operan kedua harus bilangan bulat

pergeseran(lainnya , konteks=None)

Kembalikan hasil menggeser digit operan pertama dengan jumlah yang ditentukan oleh operan kedua. Operan kedua harus berupa bilangan bulat dalam rentang -presisi hingga presisi. Nilai absolut dari operan kedua memberikan jumlah tempat untuk bergeser. Jika operan kedua positif maka pergeserannya ke kiri; . Digit yang digeser menjadi koefisien adalah nol. Tanda dan eksponen operan pertama tidak berubah

sqrt(konteks=Tidak ada)

Kembalikan akar kuadrat argumen ke presisi penuh

to_eng_string(konteks=Tidak ada)

Konversikan ke string, gunakan notasi teknik jika diperlukan eksponen

Notasi teknik memiliki eksponen yang merupakan kelipatan 3. Ini dapat menyisakan hingga 3 digit di sebelah kiri tempat desimal dan mungkin memerlukan penambahan satu atau dua angka nol di belakang

Misalnya, ini mengonversi

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_43 menjadi

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

to_integral(pembulatan=Tidak ada, context=None)

Identik dengan metode. Nama

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_46 telah disimpan untuk kompatibilitas dengan versi yang lebih lama

to_integral_exact(pembulatan=Tidak ada, context=None)

Membulatkan ke bilangan bulat terdekat, menandakan atau sesuai jika terjadi pembulatan. Mode pembulatan ditentukan oleh parameter

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

31 jika diberikan, selain itu dengan

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

32 yang diberikan. Jika tidak ada parameter yang diberikan maka mode pembulatan dari konteks saat ini akan digunakan

to_integral_value(pembulatan=Tidak ada, context=None)

Bulatkan ke bilangan bulat terdekat tanpa memberi isyarat atau. Jika diberikan, terapkan pembulatan;

Operan logis

Metode

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_03,

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

05,

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

06, dan

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

08 mengharapkan argumen mereka menjadi operan logis. Operan logis adalah turunan yang eksponen dan tandanya sama-sama nol, dan semua digitnya adalah

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

15 atau

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

Objek konteks

Konteks adalah lingkungan untuk operasi aritmatika. Mereka mengatur presisi, menetapkan aturan untuk pembulatan, menentukan sinyal mana yang diperlakukan sebagai pengecualian, dan membatasi rentang eksponen

Setiap utas memiliki konteksnya sendiri saat ini yang diakses atau diubah menggunakan fungsi dan

desimal. getcontext()

Kembalikan konteks saat ini untuk utas aktif

desimal. setcontext(c)

Tetapkan konteks saat ini untuk utas aktif ke c

Anda juga dapat menggunakan pernyataan dan fungsi untuk sementara mengubah konteks aktif

desimal. konteks lokal(ctx=Tidak ada , \*\*kwargs)

Kembalikan manajer konteks yang akan mengatur konteks saat ini untuk utas aktif ke salinan ctx saat masuk ke pernyataan-dengan dan mengembalikan konteks sebelumnya saat keluar dari pernyataan-dengan. Jika tidak ada konteks yang ditentukan, salinan konteks saat ini akan digunakan. Argumen kwargs digunakan untuk mengatur atribut konteks baru

Misalnya, kode berikut menyetel presisi desimal saat ini ke 42 tempat, melakukan penghitungan, lalu secara otomatis memulihkan konteks sebelumnya

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

Menggunakan argumen kata kunci, kodenya adalah sebagai berikut

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

Menaikkan jika kwarg menyediakan atribut yang tidak didukung. Menaikkan salah satu atau jika kwarg memberikan nilai atribut yang tidak valid

Berubah di versi 3. 11. sekarang mendukung pengaturan atribut konteks melalui penggunaan argumen kata kunci.

Konteks baru juga dapat dibuat menggunakan konstruktor yang dijelaskan di bawah ini. Selain itu, modul ini menyediakan tiga konteks yang telah dibuat sebelumnya

kelas desimal. BasicContext

Ini adalah konteks standar yang ditentukan oleh Spesifikasi Aritmatika Desimal Umum. Presisi diatur ke sembilan. Pembulatan diatur ke. Semua bendera dibersihkan. Semua jebakan diaktifkan (diperlakukan sebagai pengecualian) kecuali , , dan

Karena banyak jebakan diaktifkan, konteks ini berguna untuk debugging

kelas desimal. ExtendedContext

Ini adalah konteks standar yang ditentukan oleh Spesifikasi Aritmatika Desimal Umum. Presisi diatur ke sembilan. Pembulatan diatur ke. Semua bendera dibersihkan. Tidak ada jebakan yang diaktifkan (sehingga pengecualian tidak dimunculkan selama perhitungan)

Karena jebakan dinonaktifkan, konteks ini berguna untuk aplikasi yang lebih suka memiliki nilai hasil

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 atau

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

9 daripada memunculkan pengecualian. Ini memungkinkan aplikasi untuk menyelesaikan proses di hadapan kondisi yang jika tidak akan menghentikan program

kelas desimal. DefaultContext

Konteks ini digunakan oleh konstruktor sebagai prototipe untuk konteks baru. Mengubah bidang (presisi seperti itu) memiliki efek mengubah default untuk konteks baru yang dibuat oleh konstruktor

Konteks ini paling berguna di lingkungan multi-utas. Mengubah salah satu bidang sebelum utas dimulai memiliki efek menyetel default seluruh sistem. Mengubah bidang setelah utas dimulai tidak disarankan karena memerlukan sinkronisasi utas untuk mencegah kondisi balapan

Dalam lingkungan utas tunggal, sebaiknya tidak menggunakan konteks ini sama sekali. Sebagai gantinya, cukup buat konteks secara eksplisit seperti yang dijelaskan di bawah ini

Nilai defaultnya adalah

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

79=

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

80,

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

31=, dan jebakan yang diaktifkan untuk , , dan

Selain tiga konteks yang disediakan, konteks baru dapat dibuat dengan konstruktor

kelas desimal. Konteks(prec=Tidak ada, rounding=None, Emin=None, Emax=None, capitals=None, clamp=None, flags=None, traps=None)

Menciptakan konteks baru. Jika bidang tidak ditentukan atau , nilai default akan disalin dari. Jika bidang bendera tidak ditentukan atau , semua bendera dihapus

prec adalah bilangan bulat dalam rentang [

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_16, ] yang menetapkan presisi untuk operasi aritmatika dalam konteks

Opsi pembulatan adalah salah satu konstanta yang tercantum di bagian ini

Bidang jebakan dan bendera mencantumkan sinyal apa pun yang akan disetel. Umumnya, konteks baru seharusnya hanya mengatur jebakan dan membiarkan benderanya bersih

Bidang Emin dan Emax adalah bilangan bulat yang menentukan batas terluar yang diperbolehkan untuk eksponen. Emin harus berada dalam rentang [,

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

15], Emax dalam rentang [

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

15, ]

Kolom kapital adalah

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

15 atau

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

16 (default). Jika diatur ke

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

16, eksponen dicetak dengan huruf kapital

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

99; .

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

_01

Bidang penjepit adalah

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_15 (default) atau

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

16. Jika diatur ke

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

16, eksponen

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

00 dari instance yang dapat diwakili dalam konteks ini sangat terbatas pada rentang

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

07. Jika penjepit adalah

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_15 maka kondisi yang lebih lemah berlaku. eksponen yang disesuaikan dari instance paling banyak

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

33. Ketika penjepit adalah

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

16, bilangan normal yang besar akan, jika memungkinkan, dikurangi eksponennya dan sejumlah nol yang sesuai ditambahkan ke koefisiennya, agar sesuai dengan kendala eksponen; . Misalnya

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

Nilai penjepit

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

16 memungkinkan kompatibilitas dengan format pertukaran desimal lebar tetap yang ditentukan dalam IEEE 754

Kelas mendefinisikan beberapa metode tujuan umum serta sejumlah besar metode untuk melakukan aritmatika secara langsung dalam konteks tertentu. Selain itu, untuk setiap metode yang dijelaskan di atas (dengan pengecualian metode

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

15 dan

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

16) ada metode yang sesuai. Misalnya, untuk contoh

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

_19 dan contoh

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

46,

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

22 setara dengan

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

23. Setiap metode menerima integer Python (instance dari ) di mana saja instance Desimal diterima

clear_flags()

Setel ulang semua bendera ke

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

clear_traps()

Setel ulang semua jebakan ke

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

Baru di versi 3. 3

salin()

Kembalikan duplikat konteks

copy_decimal(num)

Kembalikan salinan num instance Desimal

buat_desimal(num)

Membuat instance Desimal baru dari num tetapi menggunakan diri sebagai konteks. Berbeda dengan konstruktor, presisi konteks, metode pembulatan, bendera, dan jebakan diterapkan pada konversi

Ini berguna karena konstanta sering diberikan dengan presisi yang lebih tinggi daripada yang dibutuhkan oleh aplikasi. Manfaat lainnya adalah pembulatan segera menghilangkan efek yang tidak diinginkan dari digit di luar presisi saat ini. Dalam contoh berikut, menggunakan input yang tidak dibulatkan berarti menambahkan nol ke jumlah dapat mengubah hasilnya

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

Metode ini mengimplementasikan operasi ke nomor dari spesifikasi IBM. Jika argumennya berupa string, tidak ada spasi atau garis bawah di depan atau di belakang yang diizinkan

buat_desimal_dari_float(f)

Membuat instance Desimal baru dari float f tetapi pembulatan menggunakan self sebagai konteksnya. Berbeda dengan metode kelas, presisi konteks, metode pembulatan, bendera, dan jebakan diterapkan pada konversi

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

Baru di versi 3. 1

Etiny()

Mengembalikan nilai yang sama dengan

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

30 yang merupakan nilai eksponen minimum untuk hasil di bawah normal. Ketika underflow terjadi, eksponen diatur ke

Etop()

Mengembalikan nilai yang sama dengan

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

Pendekatan biasa untuk bekerja dengan desimal adalah membuat instance dan kemudian menerapkan operasi aritmatika yang terjadi dalam konteks saat ini untuk utas aktif. Pendekatan alternatif adalah dengan menggunakan metode konteks untuk menghitung dalam konteks tertentu. Metodenya mirip dengan yang ada di kelas dan hanya diceritakan secara singkat di sini

abs(x)

Mengembalikan nilai absolut dari x

tambahkan(x , y)

Kembalikan jumlah x dan y

kanonis(x)

Mengembalikan objek Desimal yang sama x

bandingkan(x , y)

Membandingkan x dan y secara numerik

bandingkan_sinyal(x , y)

Membandingkan nilai dari dua operan secara numerik

bandingkan_total(x , y)

Membandingkan dua operan menggunakan representasi abstraknya

bandingkan_total_mag(x , y)

Membandingkan dua operan menggunakan representasi abstraknya, mengabaikan tanda

copy_abs(x)

Mengembalikan salinan x dengan tanda yang disetel ke 0

copy_negate(x)

Mengembalikan salinan x dengan tanda terbalik

copy_sign(x , y)

Salin tanda dari y ke x

bagi(x , y)

Kembalikan x dibagi dengan y

bagi_int(x , y)

Mengembalikan x dibagi y, dipotong menjadi bilangan bulat

divmod(x , y)

Membagi dua angka dan mengembalikan bagian bilangan bulat dari hasilnya

exp(x)

Mengembalikan

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

_35

fma(x , y, z)

Mengembalikan x dikalikan dengan y, ditambah z

is_canonical(x)

Mengembalikan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_75 jika x adalah kanonis;

is_finite(x)

Mengembalikan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_75 jika x terbatas;

is_infinite(x)

Mengembalikan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_75 jika x tidak terbatas;

is_nan(x)

Mengembalikan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

75 jika x adalah qNaN atau sNaN;

normal(x)

Mengembalikan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_75 jika x adalah angka normal;

is_qnan(x)

Mengembalikan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_75 jika x adalah NaN yang tenang;

ditandatangani(x)

Mengembalikan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_75 jika x negatif;

is_snan(x)

Returns

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

75 if x is a signaling NaN; otherwise returns

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

adalah_subnormal(x)

Mengembalikan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_75 jika x subnormal;

adalah_nol(x)

Mengembalikan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_75 jika x adalah nol;

ln(x)

Mengembalikan logaritma natural (basis e) dari x

log10(x)

Mengembalikan basis 10 logaritma dari x

logb(x)

Mengembalikan eksponen besaran MSD operan

logis_dan(x , y)

Menerapkan operasi logis dan di antara setiap digit operan

logika_balik(x)

Balikkan semua angka di x

logis_atau(x , y)

Menerapkan operasi logis atau di antara setiap digit operan

logical_xor(x , y)

Menerapkan operasi logis xor di antara setiap digit operan

maks(x , y)

Membandingkan dua nilai secara numerik dan mengembalikan maksimum

max_mag(x , y)

Membandingkan nilai secara numerik dengan tanda yang diabaikan

min(x , y)

Membandingkan dua nilai secara numerik dan mengembalikan minimum

min_mag(x , y)

Membandingkan nilai secara numerik dengan tanda yang diabaikan

minus(x)

Minus sesuai dengan operator minus awalan unary di Python

kalikan(x , y)

Kembalikan produk dari x dan y

minus_berikutnya(x)

Mengembalikan angka terwakili terbesar yang lebih kecil dari x

next_plus(x)

Mengembalikan angka terwakili terkecil yang lebih besar dari x

selanjutnya(x , y)

Mengembalikan angka yang paling dekat dengan x, dengan arah menuju y

normalkan(x)

Mengurangi x ke bentuk yang paling sederhana

kelas_angka(x)

Mengembalikan indikasi kelas x

ditambah(x)

Plus sesuai dengan awalan unary plus operator di Python. Operasi ini menerapkan presisi dan pembulatan konteks, jadi ini bukan operasi identitas

daya(x , y, modulo=None)

Kembalikan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_46 dengan pangkat

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

47, kurangi modulo

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

58 jika diberikan

Dengan dua argumen, hitung

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

59. Jika

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_46 negatif maka

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

47 harus integral. Hasilnya tidak akan eksak kecuali

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

47 adalah integral dan hasilnya berhingga dan dapat dinyatakan dengan tepat dalam digit 'presisi'. Mode pembulatan konteks digunakan. Hasil selalu dibulatkan dengan benar dalam versi Python

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

_63 menghasilkan

>>> Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)
Decimal('7.32')
>>> Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP)
Decimal('8')

3, dan jika

>>> Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)
Decimal('7.32')
>>> Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP)
Decimal('8')

3 tidak terjebak, maka menghasilkan

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

Berubah di versi 3. 3. Modul C menghitung dalam bentuk pembulatan dan fungsi yang benar. Hasilnya terdefinisi dengan baik tetapi hanya "hampir selalu dibulatkan dengan benar".

Dengan tiga argumen, hitung

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

70. Untuk tiga bentuk argumen, pembatasan argumen berikut berlaku

ketiga argumen harus integral

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_47 harus nonnegatif

setidaknya salah satu dari

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

46 atau

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

47 harus bukan nol

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

_58 harus bukan nol dan memiliki paling banyak digit 'presisi'

Nilai yang dihasilkan dari

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

75 sama dengan nilai yang akan diperoleh dengan menghitung

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

70 dengan presisi tak terbatas, tetapi dihitung lebih efisien. Eksponen hasilnya adalah nol, terlepas dari eksponen

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

46,

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

47 dan

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

58. Hasilnya selalu tepat

menghitung(x , y)

Mengembalikan nilai yang sama dengan x (dibulatkan), memiliki eksponen y

radiks()

Hanya mengembalikan 10, karena ini Desimal,. )

sisa(x , y)

Mengembalikan sisa dari pembagian bilangan bulat

Tanda hasilnya, jika bukan nol, sama dengan tanda pembagian awal

remainder_near(x , y)

Mengembalikan

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

_80, di mana n adalah bilangan bulat terdekat dengan nilai pasti dari

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

81 (jika hasilnya 0 maka tandanya akan menjadi tanda x)

putar(x , y)

Mengembalikan salinan yang diputar x, y kali

same_quantum(x , y)

Mengembalikan

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

_75 jika kedua operan memiliki eksponen yang sama

skala(x , y)

Mengembalikan operan pertama setelah menambahkan nilai kedua exp

pergeseran(x , y)

Mengembalikan salinan yang digeser dari x, y kali

sqrt(x)

Akar kuadrat dari angka non-negatif ke presisi konteks

kurangi(x , y)

Kembalikan perbedaan antara x dan y

to_eng_string(x)

Konversikan ke string, gunakan notasi teknik jika diperlukan eksponen

Notasi teknik memiliki eksponen yang merupakan kelipatan 3. Ini dapat menyisakan hingga 3 digit di sebelah kiri tempat desimal dan mungkin memerlukan penambahan satu atau dua angka nol di belakang

to_integral_exact(x)

Membulatkan ke bilangan bulat

to_sci_string(x)

Mengonversi angka menjadi string menggunakan notasi ilmiah

Konstanta

Konstanta di bagian ini hanya relevan untuk modul C. Mereka juga termasuk dalam versi Python murni untuk kompatibilitas

32-bit

64-bit

desimal. MAX_PREC

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

_83

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

decimal. MAX_EMAX

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

_83

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

decimal. MIN_EMIN

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

decimal. MIN_ETINY

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

decimal. HAVE_THREADS

The value is

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

75. Deprecated, because Python now always has threads

Deprecated since version 3. 9

decimal. HAVE_CONTEXTVAR

The default value is

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

75. If Python is , the C version uses a thread-local rather than a coroutine-local context and the value is

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

76. This is slightly faster in some nested context scenarios

New in version 3. 9. backported to 3. 7 and 3. 8.

Rounding modes

decimal. ROUND_CEILING

Round towards

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

decimal. ROUND_DOWN

Round towards zero

decimal. ROUND_FLOOR

Round towards

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

decimal. ROUND_HALF_DOWN

Putaran ke terdekat dengan ikatan mengarah ke nol

desimal. ROUND_HALF_EVEN

Bulatkan ke terdekat dengan ikatan ke bilangan bulat genap terdekat

desimal. ROUND_HALF_UP

Putaran ke terdekat dengan ikatan menjauh dari nol

desimal. ROUND_UP

Membulatkan jauh dari nol

desimal. ROUND_05UP

Membulatkan menjauhi nol jika angka terakhir setelah pembulatan menuju nol adalah 0 atau 5;

Sinyal

Sinyal mewakili kondisi yang muncul selama perhitungan. Masing-masing sesuai dengan satu bendera konteks dan satu pengaktif perangkap konteks

Bendera konteks disetel setiap kali kondisi ditemui. Setelah perhitungan, bendera dapat diperiksa untuk tujuan informasi (misalnya, untuk menentukan apakah perhitungan tepat). Setelah memeriksa flag, pastikan untuk menghapus semua flag sebelum memulai perhitungan berikutnya

If the context’s trap enabler is set for the signal, then the condition causes a Python exception to be raised. Misalnya, jika jebakan disetel, pengecualian akan dimunculkan saat menghadapi kondisi tersebut

kelas desimal. Dijepit

Mengubah eksponen agar sesuai dengan kendala representasi

Biasanya, penjepitan terjadi ketika eksponen berada di luar batas

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

99 dan

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

33 konteks. Jika memungkinkan, eksponen direduksi agar pas dengan menambahkan nol pada koefisien

kelas desimal. DecimalException

Kelas dasar untuk sinyal lain dan subkelas dari

kelas desimal. Pembagian Dengan Nol

Menandakan pembagian bilangan tak terhingga dengan nol

Dapat terjadi dengan pembagian, pembagian modulo, atau saat menaikkan angka ke pangkat negatif. Jika sinyal ini tidak terjebak, kembalikan

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

9 atau

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

0 dengan tanda yang ditentukan oleh input ke perhitungan

kelas desimal. Tidak Tepat

Menunjukkan bahwa pembulatan terjadi dan hasilnya tidak tepat

Sinyal ketika digit bukan nol dibuang selama pembulatan. Hasil bulat dikembalikan. Bendera sinyal atau jebakan digunakan untuk mendeteksi ketika hasilnya tidak tepat

kelas desimal. Operasi Tidak Valid

Operasi yang tidak valid dilakukan

Menunjukkan bahwa operasi diminta yang tidak masuk akal. Jika tidak terjebak, kembalikan

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1. Kemungkinan penyebabnya antara lain

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

kelas desimal. Luapan

Luapan numerik

Menunjukkan eksponen lebih besar dari

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

33 setelah pembulatan terjadi. Jika tidak terjebak, hasilnya tergantung pada mode pembulatan, baik menarik ke dalam ke angka hingga terbesar yang dapat diwakili atau membulatkan ke luar ke

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

9. Dalam kedua kasus, dan juga diberi tanda

kelas desimal. Bulat

Pembulatan terjadi meskipun mungkin tidak ada informasi yang hilang

Diberi isyarat setiap kali pembulatan membuang digit; . Jika tidak terjebak, kembalikan hasilnya tidak berubah. Sinyal ini digunakan untuk mendeteksi hilangnya digit signifikan

kelas desimal. Dibawah normal

Eksponen lebih rendah dari

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

_99 sebelum pembulatan

Terjadi ketika hasil operasi di bawah normal (pangkatnya terlalu kecil). Jika tidak terjebak, kembalikan hasilnya tidak berubah

kelas desimal. Aliran bawah

Underflow numerik dengan hasil dibulatkan ke nol

Terjadi ketika hasil subnormal didorong ke nol dengan pembulatan. dan juga diberi tanda

kelas desimal. FloatOperation

Aktifkan semantik yang lebih ketat untuk mencampur pelampung dan Desimal

Jika sinyal tidak terjebak (default), pencampuran float dan Desimal diizinkan di konstruktor, dan semua operator pembanding. Konversi dan perbandingan keduanya tepat. Setiap kemunculan operasi campuran direkam secara diam-diam dengan menyetel di bendera konteks. Konversi eksplisit dengan atau tidak menyetel bendera

Jika tidak (sinyalnya terjebak), hanya perbandingan kesetaraan dan konversi eksplisit yang diam. Semua operasi campuran lainnya meningkat

Tabel berikut merangkum hierarki sinyal

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

Catatan Titik Mengambang

Memitigasi kesalahan pembulatan dengan peningkatan presisi

Penggunaan floating point desimal menghilangkan kesalahan representasi desimal (memungkinkan untuk mewakili

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

20 persis);

Efek kesalahan pembulatan dapat diperkuat dengan penambahan atau pengurangan besaran yang hampir mengimbangi yang mengakibatkan hilangnya signifikansi. Knuth memberikan dua contoh instruktif di mana aritmatika floating point bulat dengan presisi yang tidak memadai menyebabkan kerusakan sifat asosiatif dan distributif penjumlahan

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

Modul memungkinkan untuk mengembalikan identitas dengan memperluas presisi yang cukup untuk menghindari hilangnya signifikansi

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

Nilai-nilai khusus

Sistem bilangan untuk modul memberikan nilai khusus termasuk

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

24,

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> sorted(data)
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
 Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
>>> float(a)
1.34
>>> round(a, 1)
Decimal('1.3')
>>> int(a)
1
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')

9, dan dua angka nol,

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

3 dan

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

Infinitas dapat dibangun langsung dengan.

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_02. Juga, mereka dapat muncul dari pembagian dengan nol ketika sinyal tidak terjebak. Demikian pula, ketika sinyal tidak terperangkap, tak terhingga dapat dihasilkan dari pembulatan di luar batas angka terbesar yang dapat diwakili

Infinitas ditandatangani (affine) dan dapat digunakan dalam operasi aritmatika di mana mereka diperlakukan sebagai bilangan tak tentu yang sangat besar. Misalnya, menambahkan konstanta ke tak terhingga memberikan hasil tak terhingga lainnya

Beberapa operasi tidak dapat ditentukan dan mengembalikan

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1, atau jika sinyal terjebak, ajukan pengecualian. Misalnya,

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

34 mengembalikan

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 yang artinya “bukan angka”. Variasi

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 ini tenang dan, setelah dibuat, akan mengalir melalui perhitungan lain yang selalu menghasilkan

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 lainnya. Perilaku ini dapat berguna untuk rangkaian komputasi yang terkadang memiliki input yang hilang — perilaku ini memungkinkan penghitungan dilanjutkan sambil menandai hasil tertentu sebagai tidak valid

Variannya adalah

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

24 yang memberi sinyal daripada tetap diam setelah setiap operasi. Ini adalah nilai pengembalian yang berguna saat hasil yang tidak valid perlu mengganggu perhitungan untuk penanganan khusus

Perilaku operator perbandingan Python bisa sedikit mengejutkan ketika

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 terlibat. Sebuah tes untuk kesetaraan di mana salah satu operan diam atau sinyal

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1 selalu kembali (bahkan ketika melakukan

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

42), sedangkan tes untuk ketidaksetaraan selalu kembali. Upaya untuk membandingkan dua Desimal menggunakan salah satu dari

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

44,

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

45,

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

46 atau

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

47 operator akan menaikkan sinyal jika salah satu operan adalah

>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')

1, dan kembali jika sinyal ini tidak terjebak. Perhatikan bahwa spesifikasi Aritmatika Desimal Umum tidak menentukan perilaku perbandingan langsung; . 7). Untuk memastikan kepatuhan standar yang ketat, gunakan metode

>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision

54 dan

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

Nol yang ditandatangani dapat dihasilkan dari perhitungan yang kurang. Mereka menyimpan tanda yang akan dihasilkan jika perhitungan dilakukan dengan ketelitian yang lebih tinggi. Karena besarnya nol, baik nol positif maupun negatif diperlakukan sama dan tandanya bersifat informasional

Selain dua angka nol bertanda yang berbeda namun sama, ada berbagai representasi nol dengan presisi berbeda namun setara nilainya. Ini membutuhkan sedikit waktu untuk membiasakan diri. Untuk mata yang terbiasa dengan representasi floating point yang dinormalisasi, tidak segera jelas bahwa perhitungan berikut mengembalikan nilai yang sama dengan nol

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

Bekerja dengan benang

Fungsi mengakses objek yang berbeda untuk setiap utas. Memiliki konteks utas terpisah berarti utas dapat membuat perubahan (seperti

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

56) tanpa mengganggu utas lainnya

Demikian pula, fungsinya secara otomatis menetapkan targetnya ke utas saat ini

Jika belum dipanggil sebelumnya, maka secara otomatis akan membuat konteks baru untuk digunakan di utas saat ini

Konteks baru disalin dari konteks prototipe yang disebut DefaultContext. Untuk mengontrol default sehingga setiap utas akan menggunakan nilai yang sama di seluruh aplikasi, ubah objek DefaultContext secara langsung. Ini harus dilakukan sebelum utas apa pun dimulai sehingga tidak akan ada kondisi balapan di antara pemanggilan utas. Misalnya

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

Resep

Berikut adalah beberapa resep yang berfungsi sebagai fungsi utilitas dan yang menunjukkan cara bekerja dengan kelas

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

FAQ desimal

Q. Sulit untuk mengetik

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

_63. Apakah ada cara untuk meminimalkan pengetikan saat menggunakan juru bahasa interaktif?

A. Beberapa pengguna menyingkat konstruktor menjadi satu huruf saja

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

Q. Dalam aplikasi titik tetap dengan dua tempat desimal, beberapa masukan memiliki banyak tempat dan harus dibulatkan. Lainnya tidak seharusnya memiliki angka berlebih dan perlu divalidasi. Metode apa yang harus digunakan?

A. Metode

>>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)
>>> setcontext(myothercontext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857142857142857142857142857')

>>> ExtendedContext
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[])
>>> setcontext(ExtendedContext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857143')
>>> Decimal(42) / Decimal(0)
Decimal('Infinity')

>>> setcontext(BasicContext)
>>> Decimal(42) / Decimal(0)
Traceback (most recent call last):
  File "", line 1, in -toplevel-
    Decimal(42) / Decimal(0)
DivisionByZero: x / 0

_7 membulatkan angka desimal yang tetap. Jika jebakan dipasang, ini juga berguna untuk validasi

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

Q. Setelah saya memiliki input dua tempat yang valid, bagaimana cara mempertahankan invarian itu di seluruh aplikasi?

A. Beberapa operasi seperti penjumlahan, pengurangan, dan perkalian dengan bilangan bulat akan secara otomatis mempertahankan titik tetap. Operasi lainnya, seperti pembagian dan perkalian bukan bilangan bulat, akan mengubah jumlah tempat desimal dan perlu ditindaklanjuti dengan langkah

>>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)
>>> setcontext(myothercontext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857142857142857142857142857')

>>> ExtendedContext
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[])
>>> setcontext(ExtendedContext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857143')
>>> Decimal(42) / Decimal(0)
Decimal('Infinity')

>>> setcontext(BasicContext)
>>> Decimal(42) / Decimal(0)
Traceback (most recent call last):
  File "", line 1, in -toplevel-
    Decimal(42) / Decimal(0)
DivisionByZero: x / 0

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

Dalam mengembangkan aplikasi fixed-point, akan lebih mudah untuk mendefinisikan fungsi untuk menangani langkah

>>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)
>>> setcontext(myothercontext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857142857142857142857142857')

>>> ExtendedContext
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[])
>>> setcontext(ExtendedContext)
>>> Decimal(1) / Decimal(7)
Decimal('0.142857143')
>>> Decimal(42) / Decimal(0)
Decimal('Infinity')

>>> setcontext(BasicContext)
>>> Decimal(42) / Decimal(0)
Traceback (most recent call last):
  File "", line 1, in -toplevel-
    Decimal(42) / Decimal(0)
DivisionByZero: x / 0

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

Q. Ada banyak cara untuk mengekspresikan nilai yang sama. Angka

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

68,

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

69,

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

70, dan

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

71 semuanya memiliki nilai yang sama di berbagai presisi. Apakah ada cara untuk mengubahnya menjadi satu nilai kanonik yang dapat dikenali?

A. Metode

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

_72 memetakan semua nilai yang setara ke satu perwakilan

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

Q. Beberapa nilai desimal selalu dicetak dengan notasi eksponensial. Apakah ada cara untuk mendapatkan representasi non-eksponensial?

A. Untuk beberapa nilai, notasi eksponensial adalah satu-satunya cara untuk menyatakan jumlah tempat penting dalam koefisien. Misalnya, menyatakan

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

73 sebagai

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

74 mempertahankan nilai konstan tetapi tidak dapat menunjukkan signifikansi dua tempat aslinya

Jika sebuah aplikasi tidak peduli dengan pelacakan signifikansi, mudah untuk menghapus eksponen dan nol di belakang, kehilangan signifikansi, tetapi mempertahankan nilainya tidak berubah

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

Q. Apakah ada cara untuk mengonversi float biasa menjadi a ?

A. Ya, bilangan floating point biner apa pun dapat diekspresikan dengan tepat sebagai Desimal meskipun konversi yang tepat mungkin membutuhkan ketelitian yang lebih tinggi daripada yang disarankan oleh intuisi

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

Q. Dalam perhitungan yang rumit, bagaimana saya bisa memastikan bahwa saya tidak mendapatkan hasil palsu karena presisi yang tidak memadai atau anomali pembulatan

A. Modul desimal memudahkan untuk menguji hasil. Praktik terbaik adalah menjalankan kembali penghitungan menggunakan presisi yang lebih tinggi dan dengan berbagai mode pembulatan. Hasil yang sangat berbeda menunjukkan presisi yang tidak memadai, masalah mode pembulatan, input yang tidak sesuai, atau algoritme yang tidak stabil secara numerik

Q. Saya perhatikan bahwa ketepatan konteks diterapkan pada hasil operasi tetapi tidak pada input. Apakah ada yang harus diperhatikan saat mencampur nilai dengan presisi berbeda?

A. Ya. Prinsipnya adalah semua nilai dianggap tepat dan begitu juga aritmatika pada nilai-nilai tersebut. Hanya hasilnya yang dibulatkan. Keuntungan untuk input adalah "apa yang Anda ketik adalah apa yang Anda dapatkan". Kerugiannya adalah hasilnya bisa terlihat aneh jika Anda lupa bahwa inputnya belum dibulatkan

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

Solusinya adalah dengan meningkatkan presisi atau memaksa pembulatan input menggunakan operasi plus unary

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

Alternatifnya, input dapat dibulatkan saat dibuat menggunakan metode ini

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []

Q. Apakah implementasi CPython cepat untuk jumlah besar?

A. Ya. Dalam implementasi CPython dan PyPy3, versi C/CFFI dari modul desimal mengintegrasikan pustaka libmpdec berkecepatan tinggi untuk presisi sewenang-wenang membulatkan aritmatika floating point desimal dengan benar.

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

77 menggunakan perkalian Karatsuba untuk bilangan berukuran sedang dan untuk bilangan yang sangat besar

Konteksnya harus diadaptasi untuk aritmatika presisi arbitrer yang tepat.

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "", line 1, in 
decimal.FloatOperation: []
>>> Decimal('3.5') == 3.5
True

_99 dan

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

33 harus selalu disetel ke nilai maksimum,

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')

80 harus selalu 0 (default). Pengaturan

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

_79 membutuhkan kehati-hatian

Pendekatan termudah untuk mencoba aritmatika bignum adalah dengan menggunakan nilai maksimum untuk

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')

79 juga

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []

Untuk hasil yang tidak pasti, terlalu besar pada platform 64-bit dan memori yang tersedia tidak mencukupi

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []

Pada sistem dengan alokasi berlebihan (mis. g. Linux), pendekatan yang lebih canggih adalah menyesuaikan ________22______79 dengan jumlah RAM yang tersedia. Misalkan Anda memiliki 8GB RAM dan mengharapkan 10 operan simultan menggunakan maksimal masing-masing 500MB

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "", line 1, in 
decimal.InvalidOperation: []

Secara umum (dan terutama pada sistem tanpa alokasi berlebihan), disarankan untuk memperkirakan batas yang lebih ketat dan mengatur jebakan jika semua perhitungan diharapkan tepat.

Bagaimana Anda membulatkan pelampung ke 4 tempat desimal dengan Python?

Tentang Fungsi round() Bawaan Python . Pemrograman Python menawarkan fungsi round() bawaan yang membulatkan angka ke jumlah digit yang diberikan dan membuat pembulatan angka lebih mudah. Fungsi round() menerima dua argumen numerik, n dan n digit kemudian mengembalikan angka n setelah membulatkannya menjadi digit.

Bagaimana Anda membulatkan float ke sejumlah desimal dengan Python?

Round() Round() adalah fungsi bawaan yang tersedia dengan python. Ini akan mengembalikan Anda angka float yang akan dibulatkan ke tempat desimal yang diberikan sebagai input. Jika tempat desimal yang akan dibulatkan tidak ditentukan, maka dianggap sebagai 0, dan akan dibulatkan ke bilangan bulat terdekat.

Bagaimana Anda mencetak ke 4 tempat desimal dengan Python?

Kita dapat menggunakan formatter %f untuk menentukan jumlah angka desimal yang akan dikembalikan saat angka floating point dibulatkan ke atas.

kode python

Python float bulat ke 4 desimal

Tutorial memulai cepat

Objek desimal

Operan logis

Objek konteks

Konstanta

Rounding modes

Sinyal

Catatan Titik Mengambang

Memitigasi kesalahan pembulatan dengan peningkatan presisi

Nilai-nilai khusus

Bekerja dengan benang

Resep

FAQ desimal

Bagaimana Anda membulatkan pelampung ke 4 tempat desimal dengan Python?

Bagaimana Anda membulatkan float ke sejumlah desimal dengan Python?

Bagaimana Anda mencetak ke 4 tempat desimal dengan Python?

Bài Viết Liên Quan

Có thể bạn quan tâm

Xem Nhiều

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội