0.1 + 0.2 ≠ 0.3: pulni kodda float emas, Decimal va tiyinda saqlash, yaxlitlash va yo'qolgan tiyin
Float'da saqlangan pul oy oxirida tiyinlab farq beradi. Decimal va minor units qanday ishlaydi, HALF_UP va bankir yaxlitlashi qachon farq qiladi va komissiya hisoblashda tiyinni qanday yo'qotmaslik kerak — Django modeli bilan.
Tasavvur qiling: to'lov servisingiz har bir tranzaksiyadan 1,5% komissiya oladi. Mijoz 12 335 so'm to'laydi, kod komissiyani hisoblaydi, merchantga qolganini o'tkazadi. Oy oxirida buxgalteriya hisobotni bank ko'chirmasi bilan solishtiradi va bir necha tiyin farq chiqadi. Kichik summa, lekin endi har bir tranzaksiyani qayta tekshirish kerak, chunki farq qayerdan kelganini hech kim bilmaydi.
Bunday farqlarning deyarli hammasi uchta joydan chiqadi: pulni floatda saqlash, yaxlitlashni tasodifiy joyda va tasodifiy qoida bilan qilish, va summani bo'laklarga bo'lganda qoldiq tiyinni yo'qotish. Bu maqolada uchalasini ham ko'rib chiqamiz va oxirida Django modeli bilan tayyor yechimga kelamiz.
0.1 + 0.2 nega 0.3 emas
Python konsolini oching:
>>> 0.1 + 0.2
0.30000000000000004
>>> sum([0.1] * 10)
0.9999999999999999
>>> round(2.675, 2)
2.67
Bu Python'ning xatosi emas. float — IEEE 754 standartidagi 64-bitli ikkilik (binary) son. U sonni mantissa × 2^daraja ko'rinishida saqlaydi. 1/3 ni o'nli kasrda aniq yozib bo'lmaganidek (0.3333...), 0.1 ni ham ikkilik kasrda aniq yozib bo'lmaydi: u cheksiz takrorlanuvchi kasr. Shuning uchun xotirada 0.1 emas, unga eng yaqin ikkilik son turadi:
>>> from decimal import Decimal
>>> Decimal(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
round(2.675, 2) ning 2.67 qaytarishi ham shu sababdan: xotiradagi qiymat aslida 2.67499999... ga teng, ya'ni "o'rtada" emas.
Fizika yoki grafikada bu xatolik ahamiyatsiz. Pulda esa muammo: xatoliklar yig'iladi, == bilan solishtirish kutilmagan natija beradi, yaxlitlash esa noto'g'ri tomonga ketadi. PostgreSQL'da ham xuddi shu:
SELECT 0.1::float8 + 0.2::float8; -- 0.30000000000000004
SELECT 0.1::numeric + 0.2::numeric; -- 0.3
Pul — bu o'lchov emas, sanoq. Float o'lchov uchun yaratilgan, pul esa aniq sanalishi kerak.
Ikki to'g'ri yo'l: Decimal va minor units
Pulni aniq saqlashning ikki keng tarqalgan usuli bor.
1. O'nli son (Decimal / NUMERIC). Python'dagi decimal.Decimal sonni o'nli raqamlar va o'nli daraja ko'rinishida saqlaydi, shuning uchun Decimal('0.1') aynan 0.1 ga teng. PostgreSQL'dagi numeric turi ham o'nli va aniq. Django'da bu DecimalField.
2. Minor units — eng kichik birlikda butun son. Summani so'mda emas, tiyinda saqlaysiz: 12 335.00 so'm → 1233500 tiyin. Butun sonlar ustida qo'shish va ayirish har doim aniq. Django'da bu BigIntegerField (PostgreSQL'da bigint). Ko'plab to'lov API'lari, masalan Stripe, summani aynan shu tarzda — valyutaning eng kichik birligida qabul qiladi.
Valyutaning nechta "kichik birligi" borligini ISO 4217 belgilaydi: UZS va USD uchun 2 xona (tiyin, sent), JPY uchun 0, KWD uchun 3. Ya'ni "summani 100 ga ko'paytirish" hamma valyuta uchun to'g'ri emas — darajani valyutaga qarab olish kerak.
float |
Decimal / numeric |
Minor units (bigint) |
|
|---|---|---|---|
| Aniqlik | Taxminiy | Aniq | Aniq |
| Kasr qismi | Bor, lekin ikkilik | Istalgancha o'nli | Yo'q, butun son |
| Valyuta aniqligi | — | decimal_places bilan qotiriladi |
Valyuta darajasi alohida saqlanadi |
| Foiz, kurs hisoblash | Xavfli | Qulay | Hisob uchun vaqtincha Decimal kerak |
| JSON'da uzatish | Son sifatida (xavfli) | Odatda string sifatida | Butun son sifatida |
Qaysi birini tanlash — loyihaga bog'liq. Bitta valyutali ichki tizimda DecimalField(max_digits=18, decimal_places=2) yetarli. Ko'p valyutali, tashqi to'lov shlyuzlari bilan ishlaydigan tizimda men minor units'ni afzal ko'raman: summa doim butun son, valyuta esa yonida turadi. Ikkala holatda ham hisob-kitob (foiz, kurs) Decimal bilan qilinadi.
Decimal qanday ishlaydi: kontekst va aniqlik
Decimal ning eng ko'p unutiladigan qismi — kontekst. Har bir arifmetik amal joriy kontekstdagi qoidalar bo'yicha bajariladi:
>>> from decimal import getcontext
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
Bu yerda ikki muhim narsa bor:
prec=28— bu verguldan keyingi xonalar soni emas, jami muhim raqamlar soni.Decimal(1) / 3natijasida 28 ta raqam chiqadi. Pul uchun bu yetarli, lekin "2 xona" degani emas.rounding=ROUND_HALF_EVEN— standart yaxlitlash rejimi "bankir yaxlitlashi". Bunga keyinroq qaytamiz.
Pul summasini kerakli xonagacha yaxlitlash uchun quantize ishlatiladi va rejim har doim aniq ko'rsatiladi:
from decimal import Decimal, ROUND_HALF_UP
amount = Decimal("185.025")
amount.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP) # Decimal('185.03')
Kontekstni global o'zgartirish (getcontext().prec = 10) yomon fikr: u joriy thread yoki asyncio vazifasining butun kodiga ta'sir qiladi. Vaqtincha o'zgartirish kerak bo'lsa, localcontext() ishlating. U bilan foydali himoya ham yoqish mumkin — float aralashib qolsa, darhol xato beradi:
from decimal import Decimal, FloatOperation, localcontext
with localcontext() as ctx:
ctx.traps[FloatOperation] = True
Decimal("0.1") # ishlaydi
Decimal(0.1) # decimal.FloatOperation
Decimal va float ni qo'shish esa kontekstdan qat'i nazar TypeError beradi — bu yaxshi, xato yashirinmaydi:
>>> Decimal("0.1") + 0.2
TypeError: unsupported operand type(s) for +: 'decimal.Decimal' and 'float'
Yaxlitlash rejimlari: HALF_UP va bankir yaxlitlashi
Ikkita asosiy rejim bor va ular faqat aniq "o'rtadagi" qiymatlarda farq qiladi:
| Qiymat | ROUND_HALF_UP |
ROUND_HALF_EVEN (bankir) |
PostgreSQL round(numeric) |
|---|---|---|---|
| 0.5 | 1 | 0 | 1 |
| 1.5 | 2 | 2 | 2 |
| 2.5 | 3 | 2 | 3 |
| -2.5 | -3 | -2 | -3 |
- HALF_UP — maktabda o'rgatilgan usul: .5 noldan uzoqroq tomonga yaxlitlanadi. Python'da
ROUND_HALF_UPmanfiy sonlarda ham noldan uzoqlashtiradi. - HALF_EVEN (bankir yaxlitlashi) — .5 eng yaqin juft songa yaxlitlanadi. Ko'p sonlarni yaxlitlab qo'shganda HALF_UP natijani muntazam ravishda yuqoriga suradi; HALF_EVEN esa bu og'ishni o'rtacha nolga yaqinlashtiradi.
E'tibor bering: Python'ning o'rnatilgan round() funksiyasi ham bankir yaxlitlashini ishlatadi (round(2.5) == 2), PostgreSQL'ning round(numeric) esa noldan uzoqlashtiradi (round(2.5) = 3). Bitta hisobni bir joyda Python'da, boshqa joyda SQL'da qilsangiz, natijalar farq qilishi mumkin.
Qaysi rejimni tanlash — dasturchining didi emas. Odatda bu to'lov provayderi spetsifikatsiyasi, shartnoma yoki moliya bo'limi tomonidan belgilanadi. Sizning vazifangiz — qoidani bitta joyda yozish va hamma yerda shuni ishlatish.
Komissiya: tiyinni yo'qotmaslik
Endi kirishdagi misolga qaytamiz. To'lov 12 335.00 so'm = 1 233 500 tiyin, komissiya 1,5%:
>>> Decimal(1233500) * Decimal("0.015")
Decimal('18502.500')
Aynan o'rtada. HALF_UP bilan 18 503 tiyin, HALF_EVEN bilan 18 502 tiyin. Bitta tiyin, lekin minglab tranzaksiyalarda bu ikki tizim o'rtasida sezilarli farqqa aylanadi.
Undan ham ko'p uchraydigan xato — komissiyani ham, merchant summasini ham alohida yaxlitlash:
# NOTO'G'RI: ikkala qism alohida yaxlitlanadi
fee = round(amount * 0.015, 2)
payout = round(amount * 0.985, 2)
# fee + payout har doim ham amount ga teng emas
Bu yerda float ham, ikki marta yaxlitlash ham bor. To'g'ri yo'l: bitta qismni hisoblab yaxlitlang, ikkinchisini ayirma sifatida oling. Shunda yig'indi har doim aniq bo'ladi:
from decimal import Decimal, ROUND_HALF_UP
def split_fee(amount_minor: int, rate: Decimal) -> tuple[int, int]:
"""Komissiya va merchant ulushini tiyinda qaytaradi; yig'indi doim amount_minor."""
if not isinstance(rate, Decimal):
raise TypeError("rate Decimal bo'lishi kerak")
raw = Decimal(amount_minor) * rate
fee = int(raw.quantize(Decimal("1"), rounding=ROUND_HALF_UP))
return fee, amount_minor - fee
fee, payout = split_fee(1_233_500, Decimal("0.015"))
assert fee + payout == 1_233_500 # 18503 + 1214997
Summani bir nechta qismga bo'lish (masalan, 100 so'mni uch hamkorga) yana bir klassik tuzoq: 33.33 × 3 = 99.99, bitta tiyin yo'qoladi. Yechim — qoldiqni taqsimlash (largest remainder):
def allocate(total_minor: int, weights: list[int]) -> list[int]:
"""total_minor ni weights nisbatida bo'ladi; yig'indi doim total_minor."""
if total_minor < 0 or not weights or any(w < 0 for w in weights) or sum(weights) == 0:
raise ValueError("noto'g'ri argumentlar")
wsum = sum(weights)
shares = [total_minor * w // wsum for w in weights]
remainders = [total_minor * w % wsum for w in weights]
leftover = total_minor - sum(shares)
# qoldiq tiyinlarni eng katta qoldiqqa ega ulushlarga beramiz
order = sorted(range(len(weights)), key=lambda i: remainders[i], reverse=True)
for i in order[:leftover]:
shares[i] += 1
return shares
assert allocate(10_000, [1, 1, 1]) == [3334, 3333, 3333]
assert sum(allocate(1_233_500, [70, 20, 10])) == 1_233_500
Butun sonlar ustida // va % aniq ishlaydi, sorted esa barqaror, shuning uchun natija deterministik: bir xil kirishda doim bir xil taqsimot.
Django modeli: summa va valyuta birga
Summa valyutasiz — bu shunchaki son. "1000" — so'mmi, dollarmi? Shuning uchun summa va valyuta har doim yonma-yon saqlanadi va kodda bitta qiymat sifatida yuradi.
from decimal import Decimal
from django.db import models
from django.db.models import F, Q
MINOR_EXPONENT = {"UZS": 2, "USD": 2, "EUR": 2, "JPY": 0, "KWD": 3}
class Currency(models.TextChoices):
UZS = "UZS", "O'zbek so'mi"
USD = "USD", "AQSh dollari"
EUR = "EUR", "Yevro"
class Payment(models.Model):
amount_minor = models.BigIntegerField(help_text="Eng kichik birlikda: tiyin, sent")
fee_minor = models.BigIntegerField(default=0)
currency = models.CharField(max_length=3, choices=Currency.choices)
created_at = models.DateTimeField(auto_now_add=True)
class Meta:
constraints = [
models.CheckConstraint(
condition=Q(amount_minor__gt=0),
name="payment_amount_positive",
),
models.CheckConstraint(
condition=Q(fee_minor__gte=0) & Q(fee_minor__lte=F("amount_minor")),
name="payment_fee_within_amount",
),
]
@property
def amount(self) -> Decimal:
return Decimal(self.amount_minor).scaleb(-MINOR_EXPONENT[self.currency])
CheckConstraint(condition=...) Django 5.1 dan boshlab ishlaydi (avvalgi check= argumenti eskirgan). Cheklovlar ma'lumotlar bazasi darajasida ishlaydi: kod qayerdan yozmasin — admin, management command yoki to'g'ridan-to'g'ri SQL — manfiy summa yoki summadan katta komissiya saqlanmaydi.
Tashqaridan kelgan summani tiyinga o'tkazish uchun kichik yordamchi funksiya. U float'ni rad etadi va valyuta ruxsat bergandan ko'p xonali summani yashirincha yaxlitlamaydi:
def to_minor(amount: Decimal | str, currency: str) -> int:
if isinstance(amount, float):
raise TypeError("float qabul qilinmaydi, Decimal yoki str bering")
scaled = Decimal(amount).scaleb(MINOR_EXPONENT[currency])
if scaled != scaled.to_integral_value():
raise ValueError(f"{amount} {currency} uchun juda ko'p kasr xonaga ega")
return int(scaled)
assert to_minor("12335.00", "UZS") == 1_233_500
assert to_minor("1500", "JPY") == 1500
Agar DecimalField yo'lini tanlasangiz, model shunday bo'ladi va PostgreSQL'da numeric(18, 2) ustuni yaratiladi:
class Invoice(models.Model):
amount = models.DecimalField(max_digits=18, decimal_places=2)
currency = models.CharField(max_length=3, choices=Currency.choices)
Production'da uchraydigan tuzoqlar
Saqlashda yashirin yaxlitlash. DecimalField(decimal_places=2) ga Decimal("10.005") yozsangiz, full_clean() uni rad etadi, lekin oddiy save() validatsiya chaqirmaydi. PostgreSQL'da qiymat ustun shkalasigacha yaxlitlanadi va bu yerda u noldan uzoqlashtiradi: 10.005 → 10.01. Boshqa backend'da natija boshqacha bo'lishi mumkin. Xulosa: saqlashdan oldin o'zingiz quantize qiling.
SELECT 10.005::numeric(12, 2); -- 10.01
SELECT 12345678901.00::numeric(12, 2); -- ERROR: numeric field overflow
ORM ifodalarida float. F("amount") * 0.015 Django'da FieldError beradi: DecimalField va FloatField aralashgan, natija turi noma'lum. To'g'ri variant — F("amount") * Value(Decimal("0.015")).
JSON. json.dumps Decimalni seriyalay olmaydi (TypeError), shuning uchun ba'zan "tezroq" yechim sifatida float(amount) yoziladi — va aniqlik shu yerda yo'qoladi. Django'ning DjangoJSONEncoder va DRF'ning DecimalField Decimal'ni string sifatida chiqaradi. Kelayotgan JSON'ni o'qishda json.loads(body, parse_float=Decimal) ishlating yoki summani butun tiyin sifatida qabul qiling.
Har qadamda yaxlitlash. Oraliq natijalarni yaxlitlab borish xatolikni yig'adi. Ichki hisobni to'liq aniqlikda qiling va faqat pul "chegarasida" — saqlash, to'lov, chek — bir marta yaxlitlang.
Valyuta kurslari. Kurs pul emas, u ko'proq xonaga muhtoj. Kursni decimal_places=2 li ustunda saqlamang; uning uchun alohida, aniqligi yuqoriroq maydon (masalan, max_digits=20, decimal_places=10) va kurs qachon olinganini saqlang.
Har xil valyutalarni qo'shish. amount_minor larni valyutani tekshirmasdan qo'shish — jim xato. Agregatsiyani doim valyuta bo'yicha guruhlang: Payment.objects.values("currency").annotate(total=Sum("amount_minor")).
PostgreSQL money turi. U chiqish formatini lc_monetary sozlamasiga bog'laydi va valyutani saqlamaydi. Ko'p valyutali tizim uchun numeric yoki bigint + valyuta kodi ancha oldindan aytib bo'ladigan yechim.
Amaliy checklist
- Pul hech qachon
floatbo'lmaydi: na modelda, na hisobda, na JSON'da. - Saqlash formati bitta:
BigIntegerField(minor units) yokiDecimalField— loyiha bo'ylab aralashtirmang. - Summa yonida doim valyuta kodi (ISO 4217) turadi; valyuta darajasi jadvaldan olinadi,
100qotirib yozilmaydi. Decimalfaqatstryokiintdan yaratiladi; testlardaFloatOperationtrap'ini yoqing.- Yaxlitlash rejimi aniq yoziladi (
quantize(..., rounding=...)) va bitta funksiyada joylashadi. - Komissiya: bitta qism yaxlitlanadi, ikkinchisi ayirma; bo'lishda qoldiq taqsimlanadi.
- Ma'lumotlar bazasida
CheckConstraintlar: summa musbat, komissiya summadan oshmaydi. - Testlarda
fee + payout == amountkabi invariantlarni tekshiring.
Xulosa
Float pul uchun yaratilmagan: u taxminiy, pul esa aniq sanaladi. Summani tiyinda butun son yoki Decimal/numeric sifatida saqlang, valyutani doim yonida tuting va yaxlitlash qoidasini bitta joyda, aniq rejim bilan yozing. Eng muhim invariant oddiy: bo'laklar yig'indisi har doim butunga teng bo'lishi kerak — buni kodda ham, testda ham, bazada ham kafolatlang.
// izohlar
Izohlar yuklanmoqda...