kode python

Apa artinya 0,3 f dalam python?

“print” memperlakukan % sebagai karakter khusus yang perlu Anda tambahkan, sehingga dapat diketahui, bahwa ketika Anda mengetikkan “f”, angka (hasil) yang akan dicetak akan menjadi tipe floating point, dan “. 2" memberi tahu "cetak" Anda untuk mencetak hanya 2 digit pertama setelah titik

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

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 "<stdin>", line 1, in <module> decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>] 7 dan >>> Decimal("1e9999999999999999999") Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.InvalidOperation: [<class '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 "<stdin>", line 1, in <module> decimal.InvalidOperation: [<class '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') 8
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') 9, >>> 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') 3

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') 2

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

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 "<stdin>", line 1, in <module> decimal.InvalidOperation: [<class '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 "<pyshell#143>", 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 "<pyshell#143>", 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 03

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

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

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 13

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 19

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 22

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

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 36

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 pembanding Python untuk membandingkan instance >>> 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 penuh.

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

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

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

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 64

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. Sebagai contoh

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

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 72

Catatan

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

Baru di versi 3. 1

fma(lainnya , ketiga, context=None)

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

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)

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 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') 19

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

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') 34

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

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') 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') 44

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 16

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 menyetel 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

Menggunakan argumen kata kunci, kodenya adalah sebagai berikut

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 "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class '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 disetel 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 "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class '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 "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class '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; . Sebagai contoh

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 "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class '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 "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class '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 "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class '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 "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class '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 "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class '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 15

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 15

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

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

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 "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class '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()

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 "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class '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)

is_infinite(x)

is_nan(x)

normal(x)

is_qnan(x)

ditandatangani(x)

is_snan(x)

adalah_subnormal(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 subnormal; 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 76

adalah_nol(x)

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)

Applies the logical operation and between each operand’s digits

logical_invert(x)

Invert all the digits in x

logical_or(x , y)

Applies the logical operation or between each operand’s digits

logical_xor(x , y)

Applies the logical operation xor between each operand’s digits

max(x , y)

Compares two values numerically and returns the maximum

max_mag(x , y)

Compares the values numerically with their sign ignored

min(x , y)

Compares two values numerically and returns the minimum

min_mag(x , y)

Compares the values numerically with their sign ignored

minus(x)

Minus corresponds to the unary prefix minus operator in Python

multiply(x , y)

Return the product of x and y

next_minus(x)

Returns the largest representable number smaller than x

next_plus(x)

Returns the smallest representable number larger than x

next_toward(x , y)

Returns the number closest to x, in direction towards y

normalize(x)

Reduces x to its simplest form

number_class(x)

Returns an indication of the class of x

plus(x)

Plus corresponds to the unary prefix plus operator in Python. This operation applies the context precision and rounding, so it is not an identity operation

daya(x , y, modulo=None)

Return >>> 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 to the power of >>> 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, reduced modulo >>> c = getcontext() >>> c.traps[FloatOperation] = True >>> Decimal(3.14) Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') == 3.5 True 58 if given

With two arguments, compute >>> c = getcontext() >>> c.traps[FloatOperation] = True >>> Decimal(3.14) Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') == 3.5 True 59. If >>> 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 is negative then >>> 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 must be integral. The result will be inexact unless >>> 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 is integral and the result is finite and can be expressed exactly in ‘precision’ digits. The rounding mode of the context is used. Results are always correctly rounded in the Python version

>>> c = getcontext() >>> c.traps[FloatOperation] = True >>> Decimal(3.14) Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') == 3.5 True 63 results in >>> Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN) Decimal('7.32') >>> Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP) Decimal('8') 3, and if >>> Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN) Decimal('7.32') >>> Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP) Decimal('8') 3 is not trapped, then results in >>> c = getcontext() >>> c.traps[FloatOperation] = True >>> Decimal(3.14) Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') == 3.5 True 66

Changed in version 3. 3. The C module computes in terms of the correctly rounded and functions. The result is well-defined but only “almost always correctly rounded”.

With three arguments, compute >>> c = getcontext() >>> c.traps[FloatOperation] = True >>> Decimal(3.14) Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') == 3.5 True 70. For the three argument form, the following restrictions on the arguments hold

all three arguments must be 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 must be nonnegative
at least one of >>> 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 or >>> 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 must be nonzero
>>> c = getcontext() >>> c.traps[FloatOperation] = True >>> Decimal(3.14) Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') == 3.5 True 58 must be nonzero and have at most ‘precision’ digits

The value resulting from >>> c = getcontext() >>> c.traps[FloatOperation] = True >>> Decimal(3.14) Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') == 3.5 True 75 is equal to the value that would be obtained by computing >>> c = getcontext() >>> c.traps[FloatOperation] = True >>> Decimal(3.14) Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') == 3.5 True 70 with unbounded precision, but is computed more efficiently. The exponent of the result is zero, regardless of the exponents of >>> 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 and >>> c = getcontext() >>> c.traps[FloatOperation] = True >>> Decimal(3.14) Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') == 3.5 True 58. The result is always exact

quantize(x , y)

Returns a value equal to x (rounded), having the exponent of y

radiks()

Just returns 10, as this is Decimal, . )

remainder(x , y)

Returns the remainder from integer division

The sign of the result, if non-zero, is the same as that of the original dividend

remainder_near(x , y)

Returns >>> c = getcontext() >>> c.traps[FloatOperation] = True >>> Decimal(3.14) Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') == 3.5 True 80, where n is the integer nearest the exact value of >>> c = getcontext() >>> c.traps[FloatOperation] = True >>> Decimal(3.14) Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') == 3.5 True 81 (if the result is 0 then its sign will be the sign of x)

rotate(x , y)

Returns a rotated copy of x, y times

same_quantum(x , y)

scaleb(x , y)

Returns the first operand after adding the second value its exp

shift(x , y)

Returns a shifted copy of x, y times

sqrt(x)

Square root of a non-negative number to context precision

subtract(x , y)

Return the difference between x and 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)

Rounds to an integer

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

desimal. MAX_EMAX

desimal. MIN_EMIN

desimal. MIN_ETINY

desimal. HAVE_THREADS

Nilainya 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 _75. Tidak digunakan lagi, karena Python sekarang selalu memiliki utas

Tidak digunakan lagi sejak versi 3. 9

desimal. HAVE_CONTEXTVAR

Nilai defaultnya 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 _75. Jika Python adalah , versi C menggunakan thread-local daripada konteks coroutine-local dan nilainya 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 76. Ini sedikit lebih cepat dalam beberapa skenario konteks bersarang

Baru di versi 3. 9. di-backport ke 3. 7 dan 3. 8.

Mode pembulatan

desimal. ROUND_CEILING

Bulat menuju >>> 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

desimal. ROUND_DOWN

Putaran menuju nol

desimal. ROUND_FLOOR

Putaran menuju >>> 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

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

Jika pengaktif perangkap konteks disetel untuk sinyal, maka kondisi tersebut menyebabkan pengecualian Python dimunculkan. 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 "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class '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

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 "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class '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

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

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

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') 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') 0, >>> 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') 2

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 serangkaian 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') 53

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

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. Sebagai contoh

Resep

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

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

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 "<pyshell#143>", 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

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 "<pyshell#143>", line 1, in -toplevel- Decimal(42) / Decimal(0) DivisionByZero: x / 0 7

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 "<pyshell#143>", line 1, in -toplevel- Decimal(42) / Decimal(0) DivisionByZero: x / 0 7

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

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

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

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

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

Alternatifnya, input dapat dibulatkan saat dibuat menggunakan metode ini

>>> Decimal("1e9999999999999999999") Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>] 0

Q. Apakah implementasi CPython cepat untuk jumlah besar?

A. Yes. In the CPython and PyPy3 implementations, the C/CFFI versions of the decimal module integrate the high speed libmpdec library for arbitrary precision correctly rounded decimal floating point arithmetic . >>> 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 uses Karatsuba multiplication for medium-sized numbers and the for very large numbers

The context must be adapted for exact arbitrary precision arithmetic. >>> c = getcontext() >>> c.traps[FloatOperation] = True >>> Decimal(3.14) Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') < 3.7 Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.FloatOperation: [<class 'decimal.FloatOperation'>] >>> Decimal('3.5') == 3.5 True 99 and >>> 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 should always be set to the maximum values, >>> 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 should always be 0 (the default). Setting >>> 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 requires some care

The easiest approach for trying out bignum arithmetic is to use the maximum value for >>> 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 as well

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

For inexact results, is far too large on 64-bit platforms and the available memory will be insufficient

>>> Decimal("1e9999999999999999999") Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>] 2

On systems with overallocation (e. g. Linux), a more sophisticated approach is to adjust >>> 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 to the amount of available RAM. Suppose that you have 8GB of RAM and expect 10 simultaneous operands using a maximum of 500MB each

>>> Decimal("1e9999999999999999999") Traceback (most recent call last): File "<stdin>", line 1, in <module> decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>] 3

In general (and especially on systems without overallocation), it is recommended to estimate even tighter bounds and set the trap if all calculations are expected to be exact

Apa. 3f do in Python?

"f" stands for floating point. Bilangan bulat (di sini 3) mewakili jumlah desimal setelah titik. "%. 3f" will print a real number with 3 figures after the point .

What does 0. 2 F mean in Python?

%f is for floats. 02. 01 In addition to the indicator, you can also put formatting information. The 0. 2 here tells Python to put as many digits to the left of the decimal as you like, but only 2 significant digits to the right . 02. 15 This formatting will work in more than just floats.

What is the meaning of . 2f dengan Python?

A format of . 2f (perhatikan f ) berarti menampilkan angka dengan dua digit setelah titik desimal. So the number 1 would display as 1. 00 dan angka 1. 5555 akan ditampilkan sebagai 1. 56

Apa itu 2. 2 F dengan Python?

Anda salah paham tentang %2. 2f berarti. Itu berarti " berikan total 2 kolom float, dan tampilkan 2 posisi setelah titik radix ".