search

Putaran float ke 3 tempat desimal python

1 years ago
Komentar: 0
Dibaca: 161

Python menyediakan banyak metode matematika untuk operasi matematika seperti akar kuadrat, eksponen, dan sebagainya

Show

Pada artikel ini, saya akan menunjukkan cara membulatkan angka ke tempat desimal yang ditentukan

Apa itu Tempat Desimal?

Lihat nomor ini. 324. 89

Setiap angka di sini memiliki posisi yang disebut sebagai nilai tempat. Nilai tempat dari

  • 3 adalah ratusan
  • 2 adalah puluhan
  • 4 adalah satu
  • 8 adalah sepersepuluh
  • 9 adalah seperseratus

Setelah titik desimal, Anda memiliki dua angka. 8, lalu 9. Tempat desimal angka adalah posisi angka setelah titik desimal (di sebelah kanannya)

Definisi ini berarti tempat desimal dari 8 (pada posisi persepuluhan) adalah 1, dan 9 (pada posisi keseratus) adalah 2

Cara Membulatkan ke Tempat Desimal Tertentu

Lalu apa artinya membulatkan ke tempat desimal tertentu?

Jika angka setelah tempat desimal adalah 5 atau lebih, angka di belakang desimal dibulatkan +1. Jika tidak, angka di tempat desimal tetap sama dan angka setelah tempat desimal dibulatkan ke bawah menjadi 0

Misalnya, katakanlah kita ingin mengumpulkan 24. 89 ke 1 tempat desimal. Atau Anda dapat menempatkannya sebagai pembulatan ke atas 24. 89 ke puluhan terdekat

Angka 8 berada di 1 tempat desimal, dan angka setelah 8 adalah 9. Karena 9 lebih dari 5, 24. 89, dibulatkan ke persepuluhan terdekat akan menjadi 24. 9

Sebagai contoh lain, mari kita ambil 24. 82 dan bulatkan ke 1 tempat desimal (persepuluhan terdekat). Karena 2 tidak lebih besar dari 5, 8 tetap sama, dan 2 dibulatkan ke bawah – menghasilkan 24. 8

Cara Mengumpulkan Tempat Desimal dengan Python

Sekarang setelah Anda memahami cara membulatkan tempat desimal, mari kita lihat cara melakukannya dengan Python

Anda dapat menggunakan fungsi round global untuk membulatkan angka ke tempat desimal. Sintaksnya adalah

round(number, decimal_point)

Fungsi menerima nomor dan decimal_point sebagai argumen. decimal_point_ menentukan tempat desimal yang ingin Anda bulatkan ke atas. Mari kita lihat contohnya

num = 24.89

rounded = round(num, 1)
print(rounded)

# 24.9
_

Ini contoh lain dari nomor yang lebih panjang

num = 20.4454

rounded3 = round(num, 3)
# to 3 decimal places

rounded2 = round(num, 2)
# to 2 decimal places

print(rounded3)
# 20.445

print(rounded2)
# 20.45

Untuk _______ 308 _______, _______ 309 _______ dibulatkan hingga 3 angka desimal. Di tempat desimal ke-3 adalah 5, dan angka setelahnya adalah 4. Karena 4 tidak lebih besar dari 5, angka 5 tetap sama dan 4 dibulatkan ke bawah menjadi 0

Untuk _______ 310 _______, _______ 309 _______ dibulatkan hingga 2 angka desimal. Di tempat desimal ke-2 adalah 4, dan angka setelahnya adalah 5. Karena angka ini lebih besar dari atau sama dengan 5, angka 4 dibulatkan menjadi 5

Kesimpulan

Membulatkan angka dapat berguna untuk menjaga angka mengambang dalam digit tetap

Misalnya, ini berguna untuk mata uang yang hanya menerima dua tempat desimal (seperti dolar. $100. 99). Dalam kasus di mana perhitungan untuk suatu produk menghasilkan $50. 678, Anda mungkin ingin membulatkannya menjadi 2 tempat desimal, seperti ini. $50. 68. Dengan cara ini, akan lebih mudah untuk memberi seseorang nilai uang yang sebenarnya

Dalam artikel ini, saya telah menjelaskan secara singkat apa itu tempat desimal, dan bagaimana cara membulatkan angka ke tempat desimal tertentu dengan Python

IKLAN

IKLAN

IKLAN

Putaran float ke 3 tempat desimal python
Dillion Megida

Advokat Pengembang dan Pembuat Konten bersemangat untuk membagikan pengetahuan saya tentang Teknologi. Saya mengajar JavaScript / ReactJS / NodeJS / React Frameworks / TypeScript / dkk

Jika Anda membaca sejauh ini, tweet ke penulis untuk menunjukkan bahwa Anda peduli. Tweet terima kasih

Belajar kode secara gratis. Kurikulum open source freeCodeCamp telah membantu lebih dari 40.000 orang mendapatkan pekerjaan sebagai pengembang. Memulai

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

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

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

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

The flags entry shows that the rational approximation to 

>>> 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 was rounded (digits beyond the context precision were thrown away) and that the result is inexact (some of the discarded digits were non-zero)

Individual traps are set using the dictionary in the 

>>> 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 field of a context

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

Most programs adjust the current context only once, at the beginning of the program. And, in many applications, data is converted to with a single cast inside a loop. With context set and decimals created, the bulk of the program manipulates the data no differently than with other Python numeric types

Decimal objects

class decimal. Decimal(value='0' , context=None)

Construct a new object based from value

value can be an integer, string, tuple, , or another object. If no value is given, 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
10. If value is a string, it should conform to the decimal numeric string syntax after leading and trailing whitespace characters, as well as underscores throughout, are removed

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

Other Unicode decimal digits are also permitted where 

>>> 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 appears above. These include decimal digits from various other alphabets (for example, Arabic-Indic and Devanāgarī digits) along with the fullwidth digits 
>>> 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 through 
>>> 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

If value is a , it should have three components, a sign (

>>> 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 for positive 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
16 for negative), a of digits, and an integer exponent. For example, 
>>> 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 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
19

If value is a , the binary floating point value is losslessly converted to its exact decimal equivalent. This conversion can often require 53 or more digits of precision. For example, 

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

The context precision does not affect how many digits are stored. That is determined exclusively by the number of digits in value. For example, 

>>> 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 records all five zeros even if the context precision is only three

The purpose of the context argument is determining what to do if value is a malformed string. If the context traps , an exception is raised; otherwise, the constructor returns a new Decimal with the value of 

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

Once constructed, objects are immutable

Berubah di versi 3. 2. The argument to the constructor is now permitted to be a instance.

Changed in version 3. 3. arguments raise an exception if the trap is set. By default the trap is off.

Changed in version 3. 6. Underscores are allowed for grouping, as with integral and floating-point literals in code.

Decimal floating point objects share many properties with the other built-in numeric types such as and . All of the usual math operations and special methods apply. Likewise, decimal objects can be copied, pickled, printed, used as dictionary keys, used as set elements, compared, sorted, and coerced to another type (such as or )

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

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

>>> getcontext().prec = 7       # Set a new precision
34 diterapkan pada objek Desimal, tanda hasilnya adalah tanda pembagi dan bukan tanda pembagi

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

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

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

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

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 contoh ________21______46 dengan nomor lain 

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

>>> getcontext().prec = 7       # Set a new precision
47. Hal ini untuk menghindari hasil yang membingungkan ketika melakukan perbandingan kesetaraan antara jumlah dari jenis yang berbeda

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

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

disesuaikan()

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

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

>>> getcontext().prec = 7       # Set a new precision
49 mengembalikan tujuh. Digunakan untuk menentukan posisi digit paling signifikan sehubungan dengan titik desimal

as_integer_ratio()

Mengembalikan sepasang 

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

>>> getcontext().prec = 7       # Set a new precision
50 bilangan bulat yang mewakili contoh yang diberikan sebagai pecahan, dalam suku terendah dan dengan penyebut positif

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

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

Konversinya tepat. Tingkatkan OverflowError pada infinitas dan ValueError pada NaN

Baru di versi 3. 6

as_tuple()

Mengembalikan representasi nomor. 

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

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

kanonis()

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

bandingkan(lainnya , konteks=None)

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

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

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

bandingkan_sinyal(lainnya , konteks=None)

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

bandingkan_total(lainnya , konteks=None)

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

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

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

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

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

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

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

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

exp(konteks=Tidak ada)

Kembalikan nilai fungsi eksponensial (alami) 

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

>>> getcontext().prec = 7       # Set a new precision
65 pada nomor yang diberikan. Hasilnya dibulatkan dengan benar menggunakan mode pembulatan

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

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

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

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

Baru di versi 3. 1

fma(lainnya , ketiga, context=None)

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

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

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

Return if the argument is either positive or negative infinity and otherwise

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. The result is correctly rounded using the rounding mode

logb(konteks=Tidak ada)

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

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
00 dikembalikan dan bendera dinaikkan. Jika operan adalah tak terhingga maka 
>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
02 dikembalikan

logis_dan(lainnya , konteks=None)

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

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

logical_invert(konteks=Tidak ada)

adalah operasi logika. Hasilnya adalah inversi operan digit-bijaksana

logis_atau(lainnya , konteks=None)

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

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

logika_xor(lainnya , konteks=None)

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

maks(lainnya , konteks=None)

Seperti 

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
_09 kecuali bahwa aturan pembulatan konteks diterapkan sebelum kembali dan bahwa nilai 
>>> getcontext().prec = 28
>>> Decimal(2).sqrt()
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')
1 ditandai atau diabaikan (bergantung pada konteks dan apakah memberi isyarat 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

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

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)

Return the remainder from dividing self by other. Ini berbeda dari 

>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
_37 di mana tanda sisa dipilih untuk meminimalkan nilai absolutnya. Lebih tepatnya, nilai yang dikembalikan adalah 
>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
_38 di mana 
>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
39 adalah bilangan bulat terdekat dengan nilai pasti dari 
>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
40, dan jika dua bilangan bulat sama-sama dekat maka yang genap dipilih

Jika hasilnya nol maka tandanya adalah tanda diri

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

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)

Uji 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

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

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 mengubah 

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

decimal. 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. If no context is specified, a copy of the current context is used. Argumen kwargs digunakan untuk mengatur atribut konteks baru

For example, the following code sets the current decimal precision to 42 places, performs a calculation, and then automatically restores the previous context

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

Using keyword arguments, the code would be the following

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

Raises if kwargs supplies an attribute that doesn’t support. Raises either or if kwargs supplies an invalid value for an attribute

Changed in version 3. 11. now supports setting context attributes through the use of keyword arguments.

New contexts can also be created using the constructor described below. In addition, the module provides three pre-made contexts

class decimal. BasicContext

This is a standard context defined by the General Decimal Arithmetic Specification. Precision is set to nine. 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

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

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

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

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

buat_desimal_dari_float(f)

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

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

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

Mengembalikan nilai yang sama dengan ________26______32

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

is_finite(x)

Mengembalikan 

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

>>> getcontext().prec = 7       # Set a new precision
_75 jika x terbatas;

is_infinite(x)

Mengembalikan 

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

>>> getcontext().prec = 7       # Set a new precision
_75 jika x tidak terbatas;

is_nan(x)

Mengembalikan 

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

>>> getcontext().prec = 7       # Set a new precision
75 jika x adalah qNaN atau sNaN;

normal(x)

Mengembalikan 

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

>>> getcontext().prec = 7       # Set a new precision
_75 jika x adalah angka normal;

is_qnan(x)

Mengembalikan 

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

>>> getcontext().prec = 7       # Set a new precision
_75 jika x adalah NaN yang tenang;

ditandatangani(x)

Mengembalikan 

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

>>> getcontext().prec = 7       # Set a new precision
_75 jika x negatif;

is_snan(x)

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 sinyal NaN;

adalah_subnormal(x)

Mengembalikan 

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

>>> getcontext().prec = 7       # Set a new precision
_75 jika x subnormal;

adalah_nol(x)

Mengembalikan 

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

>>> getcontext().prec = 7       # Set a new precision
_75 jika x adalah nol;

ln(x)

Mengembalikan logaritma natural (basis e) dari x

log10(x)

Mengembalikan basis 10 logaritma dari x

logb(x)

Mengembalikan eksponen besaran MSD operan

logis_dan(x , y)

Menerapkan operasi logis dan di antara setiap digit operan

logika_balik(x)

Balikkan semua angka di x

logis_atau(x , y)

Menerapkan operasi logis atau di antara setiap digit operan

logical_xor(x , y)

Menerapkan operasi logis xor di antara setiap digit operan

maks(x , y)

Membandingkan dua nilai secara numerik dan mengembalikan maksimum

max_mag(x , y)

Membandingkan nilai secara numerik dengan tanda yang diabaikan

min(x , y)

Membandingkan dua nilai secara numerik dan mengembalikan minimum

min_mag(x , y)

Membandingkan nilai secara numerik dengan tanda yang diabaikan

minus(x)

Minus sesuai dengan operator minus awalan unary di Python

kalikan(x , y)

Kembalikan produk dari x dan y

minus_berikutnya(x)

Mengembalikan angka terwakili terbesar yang lebih kecil dari x

next_plus(x)

Mengembalikan angka terwakili terkecil yang lebih besar dari x

selanjutnya(x , y)

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

normalkan(x)

Mengurangi x ke bentuk yang paling sederhana

kelas_angka(x)

Mengembalikan indikasi kelas x

ditambah(x)

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

power(x , y , modulo=None)

Kembalikan 

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

>>> getcontext().prec = 7       # Set a new precision
_46 dengan pangkat 
>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision
47, kurangi modulo 
>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "<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 jika diberikan

Dengan dua argumen, hitung 

>>> 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. Jika 
>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision
_46 negatif maka ________21______47 harus integral. Hasilnya tidak akan eksak kecuali 
>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
        capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,
        InvalidOperation])

>>> getcontext().prec = 7       # Set a new precision
_47 adalah integral dan hasilnya berhingga dan dapat dinyatakan dengan tepat dalam digit 'presisi'. 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)

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 the two operands have the same exponent

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)

Converts a number to a string using scientific notation

Constants

The constants in this section are only relevant for the C module. They are also included in the pure Python version for compatibility

32-bit

64-bit

decimal. MAX_PREC

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

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

decimal. MAX_EMAX

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

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

decimal. MIN_EMIN

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

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

decimal. MIN_ETINY

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

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

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

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

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

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

Catatan Titik Mengambang

Memitigasi kesalahan pembulatan dengan peningkatan presisi

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

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

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

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "<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
1

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

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "<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
2

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 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 pembanding 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. Tes untuk kesetaraan di mana salah satu operan diam atau memberi 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), sementara 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

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

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

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

Resep

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

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "<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
5

FAQ desimal

Q. Sulit untuk mengetik 

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
_63. Apakah ada cara untuk meminimalkan pengetikan saat menggunakan juru bahasa interaktif?

A. Beberapa pengguna menyingkat konstruktor menjadi satu huruf saja

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "<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
6

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

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

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

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

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

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

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

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

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

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

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

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
68, 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
69, 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
70, dan 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
71 semuanya memiliki nilai yang sama di berbagai presisi. Apakah ada cara untuk mengubahnya menjadi satu nilai kanonik yang dapat dikenali?

A. Metode 

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
_72 memetakan semua nilai yang setara ke satu perwakilan

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

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

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

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
_73 sebagai 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
74 mempertahankan nilai konstan tetapi tidak dapat menunjukkan signifikansi dua tempat aslinya

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

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

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

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

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

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

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

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

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

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

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

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

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

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. Ya. Dalam implementasi CPython dan PyPy3, versi C/CFFI dari modul desimal mengintegrasikan pustaka libmpdec berkecepatan tinggi untuk presisi sewenang-wenang membulatkan aritmatika floating point desimal dengan benar. 

>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
_77 menggunakan perkalian Karatsuba untuk bilangan berukuran sedang dan untuk bilangan yang sangat besar

Konteksnya harus diadaptasi untuk aritmatika presisi arbitrer yang tepat. 

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "<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 harus selalu disetel ke nilai maksimum, 
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
80 harus selalu 0 (default). Pengaturan 
>>> getcontext().prec = 28
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0, (3, 1, 4), -2))
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
_79 membutuhkan kehati-hatian

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

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

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

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

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

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

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

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

Bagaimana Anda mencetak float ke 3 tempat desimal dengan Python?

Gunakan fungsi round() untuk membulatkan float ke 3 desimal , e. g. hasil = bulat(6. 36789, 3). Fungsi round() akan membulatkan angka floating-point menjadi 3 angka desimal dan akan mengembalikan hasilnya.

Bagaimana Anda membulatkan pelampung menjadi 3 angka penting dengan Python?

round_sig = lambda f,p. mengambang(('%. ' + str(p) + 'e') % f) memungkinkan Anda menyesuaikan jumlah digit signifikan.

Bagaimana Anda hanya mendapatkan 3 tempat desimal dengan Python?

21 Jawaban .
Ini pada dasarnya adalah jawaban yang benar, gunakan saja val = '%. 3f'%(1324343032. 324325235) alih-alih cetak. .
Jawaban ini benar, jika Anda ingin membulatkan (naik) ke angka desimal tertentu. .
'%. 2f'% 8866. 316 bulat tapi tidak terpotong. .
Anda membulatkan; . .
Ini tidak memotong

kode python

Pos Terkait

Indeks cocok dengan beberapa kriteria lembar google
Indeks cocok dengan beberapa kriteria lembar google

Kode sumber caesar cipher php
Kode sumber caesar cipher php

Cara menggunakan selenium get css value
Cara menggunakan selenium get css value

Cara menggunakan bit shift string python
Cara menggunakan bit shift string python

Cara menggunakan mysql-bin log location ubuntu
Cara menggunakan mysql-bin log location ubuntu

Membuat langkah langkah cara menginstal mysql xampp?
Membuat langkah langkah cara menginstal mysql xampp?

Cara menggunakan fungsi button html
Cara menggunakan fungsi button html

Penggunaan fungsi STATICLY di PHP
Penggunaan fungsi STATICLY di PHP

Bagaimana cara menyembunyikan semua baris dan kolom di google sheets?
Bagaimana cara menyembunyikan semua baris dan kolom di google sheets?

Google sheets sum jika sel lain berisi teks
Google sheets sum jika sel lain berisi teks

Periklanan

BERITA TERKINI

Cara membuat kotak ajaib dengan python
1 years ago . by VerticalAnkle
Cara menggunakan perintah php-fpm
1 years ago . by HelmetedCloseness
Cara membuat tas dari kain satin
1 years ago . by HomesickClerk
Tarik data dari kamus python bersarang
1 years ago . by SpecializedRegulator
Sesi php berakhir terlalu cepat
1 years ago . by ArrestingPneumonia
Cara menghapus aplikasi yang tidak bisa dihapus di HP Realme
1 years ago . by TemptingHousing
Cara mengecek rumus di google sheets
1 years ago . by SaturatedAppraisal
How to install PHP GD in xampp?
1 years ago . by BorrowedFoyer
Concat string dalam loop php
1 years ago . by CardboardAllegation
Di mana prosedur tersimpan di mysql?
1 years ago . by CounterproductiveLiterature

Toplist Popular

#1
Top 10 6 nilai minimum f x y 4x 2y pada d 16 e 14 2x 3y 18 4x 3y 24 x 0 y 0 adalah a 40 b 36 c 2022
1 years ago
#2
Top 10 dia selalu lupa membawa pensil ke sekolah saran yang tepat untuk dia adalah 2022
1 years ago
#3
Top 10 diketahui sebuah data tunggal 2 4 6, 7 7, 8, 9, 10 berapakah modusnya 2022
1 years ago
#4
Top 10 persamaan kuadrat yang akar akarnya 7/ 2 dan -5 adalah 2022
1 years ago
#5
Top 10 jika panjang sisi bangun persegi panjang 16 cm dan lebar 8 cm maka kelilingnya adalah 2022
1 years ago
#6
Top 9 perhatikan gambar mata berikut nama bagian mata yang ditunjukkan angka i dan ii adalah 2022
1 years ago
#7
Top 10 jelaskan apa yang dimaksud dengan 3 jenis kemasan? 2022
1 years ago
#8
Top 9 sebutkan tiga keadilan yang harus terwujud dalam kehidupan bermasyarakat 2022
1 years ago
#9
Top 10 pada getaran harmonik pegas, jika massa beban yang digantung pada ujung bawah pegas 100g 2022
1 years ago
#10
Top 10 permainan bulu tangkis di atas meja yang dimainkan oleh dua atau empat orang 2022
1 years ago

Periklanan

Terpopuler

Periklanan

Tentang Kami

Legal

Dukungan

Social

homeendejakoptzhthittr
Copyright © 2024 apacode Inc.