Sayısal Tipler: int, float, complex | Ücretsiz Python Programlama: Sıfırdan İleri Seviyeye Kursu

Programlamanın temeli sayılardır. Hesaplama, karşılaştırma, döngü sayacı, koordinat, puan — her yerde sayılar var. Python'un sayısal veri tipleri hem güçlü hem de kullanımı kolay. Bu derste Python'daki üç temel sayısal tipi, aritmetik operatörleri ve sayılarla çalışırken bilmen gereken incelikleri öğreneceksin.

int: Tam Sayılar — Python'ın Süper Gücü

Python'daki int tipi tam sayıları temsil eder: 0, 1, -5, 42, 1000000...

Ama Python'un tam sayıları sıradan değil. C, Java gibi dillerde tam sayıların bir sınırı var — mesela 32-bit integer en fazla yaklaşık 2.1 milyar tutabilir. Python'da böyle bir sınır yok.

Sınırsız Boyut

Python'ın int tipi arbitrary precision (keyfi hassasiyet) aritmetiğini destekler. Bu, istediğin kadar büyük sayılarla çalışabileceğin anlamına gelir.

# Python'da bu tamamen geçerli
buyuk_sayi = 999999999999999999999999999999999999999999
print(buyuk_sayi + 1)
# 1000000000000000000000000000000000000000000

# Faktöriyel hesapla — sonuç devasa olabilir
import math
print(math.factorial(100))
# 93326215443944152681699238856266700490715968264381621468...
# (158 basamaklı bir sayı!)

Bunu bir süper güç gibi düşün. Diğer dillerde "overflow" (taşma) hatası alırken, Python sakin sakin hesaplamaya devam eder.

# 2'nin 1000. kuvveti? Sorun değil.
sonuc = 2 ** 1000
print(sonuc)
# 10715086071862673209484250490600018105614048117055...

print(len(str(sonuc)))  # 302 basamak!

Sayı Okunabilirliği: Alt Çizgi Ayracı

Büyük sayıları okumak zordur. Python 3.6+ ile sayılara alt çizgi ekleyebilirsin — Python bunları yoksayar:

nufus = 85_000_000        # 85 milyon
butce = 1_234_567_890     # 1.2 milyar
renk = 0xFF_FF_FF         # Hex renk kodu
binary = 0b1010_0011      # İkili sayı

print(nufus)  # 85000000 — alt çizgiler çıktıda görünmez

Farklı Sayı Sistemleri

# İkili (binary) — 0b öneki
binary = 0b1010
print(binary)  # 10

# Sekizli (octal) — 0o öneki
octal = 0o17
print(octal)  # 15

# Onaltılı (hexadecimal) — 0x öneki
hexa = 0xFF
print(hexa)  # 255

# Dönüşüm fonksiyonları
print(bin(255))  # '0b11111111'
print(oct(255))  # '0o377'
print(hex(255))  # '0xff'

float: Ondalıklı Sayılar ve Hassasiyet Tuzağı

float tipi ondalıklı (kayan noktalı) sayıları temsil eder. Ama burada bir tuzak var — ve bu tuzak Python'a özgü değil, tüm programlama dillerinde var.

IEEE 754 Standardı

Bilgisayarlar ondalıklı sayıları IEEE 754 standardına göre ikili (binary) formatta saklarlar. Bu format çoğu sayıyı mükemmel temsil eder ama bazı basit görünen sayıları tam olarak temsil edemez.

# Klasik sürpriz
print(0.1 + 0.2)
# 0.30000000000000004

print(0.1 + 0.2 == 0.3)
# False — Evet, False!

Bu bir hata değil. Bilgisayar 0.1'i ikili sistemde tam olarak temsil edemez — tıpkı onluk sistemde 1/3'ü tam yazamadığımız gibi (0.3333333...).

Banka Hesabı Analojisi

Bunu bir paralellikle düşün: Bir pasta 3 kişiye eşit bölünecek. Her dilim 0.333... olur ama üçünü toplarsan 0.999... — tam 1 olmaz. İşte bilgisayar da bazı ondalıklı sayılarda bunu yaşar.

# float hassasiyet örnekleri
print(f"{0.1:.20f}")     # 0.10000000000000000555
print(f"{0.2:.20f}")     # 0.20000000000000001110
print(f"{0.3:.20f}")     # 0.29999999999999998890

# Eşitlik kontrolünde dikkat!
a = 0.1 + 0.2
b = 0.3

# ❌ Yanlış
print(a == b)  # False

# ✅ Doğru — toleranslı karşılaştırma
print(abs(a - b) < 1e-9)  # True

# veya math.isclose kullan
import math
print(math.isclose(a, b))  # True

⚠️ Dikkat: Finansal hesaplamalarda asla float kullanma! Para hesabı yapıyorsan decimal modülünü kullan. 0.1 cent'lik hatalar milyonlarca işlemde büyük farklar yaratır.

float Özel Değerleri

# Sonsuzluk
pozitif_sonsuz = float('inf')
negatif_sonsuz = float('-inf')

print(pozitif_sonsuz > 999999999)  # True
print(pozitif_sonsuz + 1)          # inf

# NaN (Not a Number)
nan = float('nan')
print(nan == nan)  # False — NaN kendisine bile eşit değil!
print(math.isnan(nan))  # True — NaN kontrolü böyle yapılır

float Oluşturma

# Normal gösterim
pi = 3.14159
negatif = -2.5

# Bilimsel gösterim (scientific notation)
avogadro = 6.022e23     # 6.022 × 10²³
planck = 6.626e-34       # 6.626 × 10⁻³⁴

print(avogadro)  # 6.022e+23
print(planck)    # 6.626e-34

# int'ten float'a
x = float(42)
print(x)    # 42.0
print(type(x))  # <class 'float'>

complex: Karmaşık Sayılar

Python, karmaşık sayıları yerel olarak destekler. Elektrik mühendisliği, sinyal işleme veya matematik çalışıyorsan bu çok işine yarar.

Karmaşık sayılar bir gerçel (real) ve bir sanal (imaginary) kısımdan oluşur. Matematikte i ile gösterilen sanal birim, Python'da j ile gösterilir.

z = 3 + 4j
print(z)           # (3+4j)
print(type(z))     # <class 'complex'>

# Gerçel ve sanal kısımlar
print(z.real)      # 3.0
print(z.imag)      # 4.0

# Eşlenik (conjugate)
print(z.conjugate())  # (3-4j)

# Büyüklük (modül)
print(abs(z))      # 5.0 — (3² + 4² = 25, √25 = 5)

# Karmaşık sayılarla aritmetik
z1 = 2 + 3j
z2 = 1 - 1j

print(z1 + z2)  # (3+2j)
print(z1 * z2)  # (5+1j)
print(z1 / z2)  # (-0.5+2.5j)

# complex() fonksiyonu ile oluşturma
z3 = complex(5, -2)  # 5 - 2j
print(z3)  # (5-2j)

Günlük programlamada karmaşık sayıları pek kullanmayabilirsin ama bilimsel hesaplamalarda çok değerli.

Aritmetik Operatörler

Python'un aritmetik operatörleri tanıdık gelecek ama birkaç ince nokta var.

Temel Operatörler

Operatör	İşlem	Örnek	Sonuç
`+`	Toplama	`7 + 3`	`10`
`-`	Çıkarma	`7 - 3`	`4`
`*`	Çarpma	`7 * 3`	`21`
`/`	Bölme	`7 / 3`	`2.3333...`
`//`	Taban bölme	`7 // 3`	`2`
`%`	Mod (kalan)	`7 % 3`	`1`
`**`	Üs alma	`2 ** 10`	`1024`

a, b = 17, 5

print(f"{a} + {b} = {a + b}")     # 17 + 5 = 22
print(f"{a} - {b} = {a - b}")     # 17 - 5 = 12
print(f"{a} * {b} = {a * b}")     # 17 * 5 = 85
print(f"{a} / {b} = {a / b}")     # 17 / 5 = 3.4
print(f"{a} // {b} = {a // b}")   # 17 // 5 = 3
print(f"{a} % {b} = {a % b}")     # 17 % 5 = 2
print(f"{a} ** {b} = {a ** b}")   # 17 ** 5 = 1419857

// (Floor Division) vs / (True Division)

Bu ayrım Python 3'te özellikle önemli. Python 2'de / operatörü iki tam sayı arasında tam sayı bölme yapıyordu. Python 3'te / her zaman gerçek bölme (float sonuç) yapar.

# True division — her zaman float döner
print(10 / 3)    # 3.3333333333333335
print(10 / 2)    # 5.0 — tam bölünse bile float

# Floor division — aşağı yuvarlar
print(10 // 3)   # 3
print(10 // 2)   # 5 — int kalır

# Negatif sayılarda dikkat!
print(-7 // 2)   # -4 (3.5 değil, -4!)
print(7 // -2)   # -4

# Floor division eksi sonsuza yuvarlar
# -7 / 2 = -3.5 → floor(-3.5) = -4

💡 İpucu: // operatörü her zaman aşağıya (eksi sonsuza doğru) yuvarlar. Pozitif sayılarda sıfıra doğru kırpar gibi görünür ama negatif sayılarda fark ortaya çıkar. -7 // 2 sonucu -3 değil -4'tür!

Mod (%) Operatörü

Mod operatörü bölme işleminin kalanını verir. Çok kullanışlıdır:

# Çift/tek kontrolü
sayi = 42
if sayi % 2 == 0:
    print("Çift")  # Çift
else:
    print("Tek")

# Bölünebilirlik kontrolü
if sayi % 7 == 0:
    print(f"{sayi}, 7'ye bölünür")  # 42, 7'ye bölünür

# Dairesel indeksleme
gunler = ["Pzt", "Sal", "Çar", "Per", "Cum", "Cmt", "Paz"]
for i in range(14):
    print(gunler[i % 7], end=" ")
# Pzt Sal Çar Per Cum Cmt Paz Pzt Sal Çar Per Cum Cmt Paz

Üs Alma (**)

print(2 ** 10)     # 1024
print(9 ** 0.5)    # 3.0 — karekök!
print(27 ** (1/3)) # 3.0 — küp kök

# Negatif üs
print(2 ** -3)     # 0.125 (= 1/8)

math Modülü

Python'un math modülü, matematiksel fonksiyonlar ve sabitler içerir. Standart kütüphanenin parçasıdır — ekstra kurulum gerekmez.

import math

# Sabitler
print(math.pi)    # 3.141592653589793
print(math.e)     # 2.718281828459045
print(math.tau)   # 6.283185307179586 (2π)
print(math.inf)   # inf

# Karekök
print(math.sqrt(144))   # 12.0
print(math.sqrt(2))     # 1.4142135623730951

# Üs ve logaritma
print(math.pow(2, 10))  # 1024.0
print(math.log(math.e)) # 1.0 (doğal logaritma)
print(math.log10(1000)) # 3.0
print(math.log2(1024))  # 10.0

# Yuvarlama
print(math.ceil(3.2))   # 4 (yukarı yuvarla)
print(math.floor(3.8))  # 3 (aşağı yuvarla)
print(math.trunc(3.8))  # 3 (sıfıra doğru kırp)
print(math.trunc(-3.8)) # -3

Trigonometrik Fonksiyonlar

import math

# Radyan cinsinden çalışır
print(math.sin(math.pi / 2))  # 1.0
print(math.cos(0))             # 1.0
print(math.tan(math.pi / 4))  # 0.9999999999999999 (≈1)

# Derece ↔ Radyan dönüşümü
print(math.radians(180))  # 3.141592653589793
print(math.degrees(math.pi))  # 180.0

# Hipotenüs
print(math.hypot(3, 4))  # 5.0 — √(3² + 4²)

Diğer Faydalı Fonksiyonlar

import math

# Mutlak değer (math.fabs float döner)
print(abs(-5))        # 5
print(math.fabs(-5))  # 5.0

# Faktöriyel
print(math.factorial(5))  # 120

# GCD (en büyük ortak bölen)
print(math.gcd(48, 18))  # 6

# LCM (en küçük ortak kat) — Python 3.9+
print(math.lcm(4, 6))    # 12

# Sonsuzluk ve NaN kontrolü
print(math.isinf(float('inf')))  # True
print(math.isnan(float('nan')))  # True
print(math.isfinite(42))         # True

round() ve Banker's Rounding

round() fonksiyonu sayıları yuvarlar. Ama beklediğin gibi çalışmayabilir.

Temel Kullanım

print(round(3.7))      # 4
print(round(3.2))      # 3
print(round(3.14159, 2))  # 3.14
print(round(3.14159, 4))  # 3.1416
print(round(1234, -2))    # 1200 — negatif basamak!

Banker's Rounding (Bankacı Yuvarlama)

Python'un round() fonksiyonu .5 durumunda en yakın çift sayıya yuvarlar. Bu, istatistiksel olarak daha adil bir yuvarlama yöntemidir.

# .5 durumunda en yakın çift sayıya yuvarlar
print(round(0.5))   # 0 (en yakın çift: 0)
print(round(1.5))   # 2 (en yakın çift: 2)
print(round(2.5))   # 2 (en yakın çift: 2)
print(round(3.5))   # 4 (en yakın çift: 4)
print(round(4.5))   # 4 (en yakın çift: 4)

Bu, okulda öğrendiğin "5'i yukarı yuvarla" kuralından farklı. Neden böyle? Çünkü her zaman yukarı yuvarlama yaparsan, çok sayıda işlemde toplam yukarı doğru kayar. Banker's rounding bu kaymayı önler.

# Her zaman yukarı yuvarla — toplam yukarı kayar
sayilar = [0.5, 1.5, 2.5, 3.5, 4.5]
geleneksel = sum(1 if s == int(s) + 0.5 else round(s) for s in sayilar)

# Python'un banker's rounding — daha dengeli
python_round = sum(round(s) for s in sayilar)
print(f"Banker's: {python_round}")  # 10

Klasik Yuvarlama İstiyorsan

import math

def klasik_round(sayi, basamak=0):
    carpan = 10 ** basamak
    return math.floor(sayi * carpan + 0.5) / carpan

print(klasik_round(2.5))  # 3.0
print(klasik_round(3.5))  # 4.0

decimal Modülü: Hassas Hesaplama

Finansal hesaplamalar, bilimsel ölçümler veya hassasiyetin kritik olduğu durumlarda decimal modülünü kullan.

from decimal import Decimal

# float ile sorun
print(0.1 + 0.2)  # 0.30000000000000004

# Decimal ile hassas
print(Decimal('0.1') + Decimal('0.2'))  # 0.3 — Tam!

⚠️ Dikkat: Decimal oluştururken string kullan, float değil! Decimal(0.1) dersen float'ın hassasiyet sorununu Decimal'e taşımış olursun.

from decimal import Decimal, getcontext

# ❌ Yanlış — float'tan Decimal
print(Decimal(0.1))
# 0.1000000000000000055511151231257827021181583404541015625

# ✅ Doğru — string'den Decimal
print(Decimal('0.1'))
# 0.1

Hassasiyet Ayarı

from decimal import Decimal, getcontext

# Varsayılan hassasiyet: 28 basamak
print(getcontext().prec)  # 28

# Hassasiyeti artır
getcontext().prec = 50
print(Decimal(1) / Decimal(7))
# 0.14285714285714285714285714285714285714285714285714

# Para hesabı örneği
fiyat = Decimal('19.99')
adet = Decimal('3')
kdv_orani = Decimal('0.18')

ara_toplam = fiyat * adet
kdv = ara_toplam * kdv_orani
toplam = ara_toplam + kdv

print(f"Ara toplam: {ara_toplam}")   # 59.97
print(f"KDV (%18):  {kdv}")          # 10.7946
print(f"Toplam:     {toplam}")        # 70.7646

# Kuruşa yuvarla
toplam_yuvarli = toplam.quantize(Decimal('0.01'))
print(f"Toplam:     {toplam_yuvarli}")  # 70.76

Ne Zaman float, Ne Zaman Decimal?

float: Bilimsel hesaplama, grafik, oyun, makine öğrenmesi — hız önemli, küçük hatalar tolere edilebilir.
Decimal: Finansal hesaplama, para, vergi — hassasiyet kritik.

Sayı Formatlama: f-string ile

Sayıları güzel göstermek programlamanın önemli bir parçası. Python'un f-string'leri bunu çok kolaylaştırır.

Temel Format Specifiers

sayi = 3.14159265

# Ondalık basamak sayısı
print(f"{sayi:.2f}")   # 3.14
print(f"{sayi:.4f}")   # 3.1416
print(f"{sayi:.0f}")   # 3

# Minimum genişlik
print(f"{sayi:10.2f}")  # '      3.14' (10 karakter genişlik)
print(f"{sayi:<10.2f}") # '3.14      ' (sola hizalı)
print(f"{sayi:^10.2f}") # '   3.14   ' (ortaya hizalı)

# Sıfır doldurma
print(f"{sayi:010.2f}") # '0000003.14'

Binlik Ayraç

buyuk_sayi = 1234567890

# Virgülle ayır
print(f"{buyuk_sayi:,}")      # 1,234,567,890

# Alt çizgiyle ayır
print(f"{buyuk_sayi:_}")      # 1_234_567_890

# Ondalıklı ve virgüllü
fiyat = 1234567.89
print(f"{fiyat:,.2f}")        # 1,234,567.89
print(f"₺{fiyat:,.2f}")      # ₺1,234,567.89

Yüzde Formatı

oran = 0.856
print(f"{oran:.1%}")   # 85.6%
print(f"{oran:.0%}")   # 86%

basari = 45 / 60
print(f"Başarı oranı: {basari:.2%}")  # Başarı oranı: 75.00%

Bilimsel Gösterim

buyuk = 6.022e23
kucuk = 1.6e-19

print(f"{buyuk:.3e}")   # 6.022e+23
print(f"{kucuk:.2e}")   # 1.60e-19
print(f"{buyuk:.3E}")   # 6.022E+23 (büyük E)

Farklı Sayı Sistemleri

sayi = 255

print(f"{sayi:b}")   # 11111111 (binary)
print(f"{sayi:o}")   # 377 (octal)
print(f"{sayi:x}")   # ff (hex küçük)
print(f"{sayi:X}")   # FF (hex büyük)
print(f"{sayi:d}")   # 255 (decimal)

# Ön ek ile
print(f"{sayi:#b}")  # 0b11111111
print(f"{sayi:#o}")  # 0o377
print(f"{sayi:#x}")  # 0xff

İşaret Gösterimi

# Pozitif sayılarda da + göster
print(f"{42:+d}")    # +42
print(f"{-42:+d}")   # -42

# Pozitif sayılarda boşluk, negatif sayılarda -
print(f"{42: d}")    # ' 42'
print(f"{-42: d}")   # '-42'

Tip Dönüşümleri

Sayısal tipler arasında dönüşüm yapabilirsin:

# int → float
print(float(42))       # 42.0

# float → int (kırpar, yuvarlamaz!)
print(int(3.7))        # 3
print(int(3.2))        # 3
print(int(-3.7))       # -3

# string → int/float
print(int("42"))       # 42
print(float("3.14"))   # 3.14

# int → string
print(str(42))         # '42'

# Farklı tabandan int
print(int("FF", 16))   # 255
print(int("1010", 2))  # 10
print(int("77", 8))    # 63

Pratik Örnekler

Basit Hesap Makinesi

def hesap_makinesi(a, b, islem):
    islemler = {
        '+': a + b,
        '-': a - b,
        '*': a * b,
        '/': a / b if b != 0 else "Sıfıra bölünemez!",
        '//': a // b if b != 0 else "Sıfıra bölünemez!",
        '%': a % b if b != 0 else "Sıfıra bölünemez!",
        '**': a ** b,
    }
    return islemler.get(islem, "Geçersiz işlem!")

print(hesap_makinesi(10, 3, '/'))   # 3.3333333333333335
print(hesap_makinesi(10, 3, '//'))  # 3
print(hesap_makinesi(2, 10, '**'))  # 1024

Sıcaklık Dönüştürücü

def celsius_to_fahrenheit(c):
    return c * 9 / 5 + 32

def fahrenheit_to_celsius(f):
    return (f - 32) * 5 / 9

print(f"100°C = {celsius_to_fahrenheit(100):.1f}°F")  # 212.0°F
print(f"72°F = {fahrenheit_to_celsius(72):.1f}°C")    # 22.2°C

İki Nokta Arası Mesafe

import math

def mesafe(x1, y1, x2, y2):
    return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)

# veya math.hypot ile (daha temiz)
def mesafe_v2(x1, y1, x2, y2):
    return math.hypot(x2 - x1, y2 - y1)

d = mesafe(0, 0, 3, 4)
print(f"Mesafe: {d}")  # 5.0

d2 = mesafe_v2(1, 2, 4, 6)
print(f"Mesafe: {d2:.2f}")  # 5.00

Bileşik Faiz Hesabı

from decimal import Decimal

def bilesik_faiz(anapara, oran, yil, donem=12):
    """
    anapara: Başlangıç tutarı
    oran: Yıllık faiz oranı (örn: 0.15 = %15)
    yil: Yıl sayısı
    donem: Yıllık bileşik dönem sayısı
    """
    anapara = Decimal(str(anapara))
    oran = Decimal(str(oran))
    
    sonuc = anapara * (1 + oran / donem) ** (donem * yil)
    return sonuc.quantize(Decimal('0.01'))

# 10.000 TL, %15 yıllık faiz, 5 yıl
sonuc = bilesik_faiz(10000, 0.15, 5)
print(f"Sonuç: ₺{sonuc:,}")  # Sonuç: ₺20,113.57

Sayısal Fonksiyonlar: abs(), pow(), divmod()

Python'un built-in (yerleşik) sayısal fonksiyonları da var. Bunlar math modülü olmadan doğrudan kullanılabilir.

abs() — Mutlak Değer

print(abs(-42))      # 42
print(abs(42))       # 42
print(abs(-3.14))    # 3.14
print(abs(3 + 4j))   # 5.0 — karmaşık sayının büyüklüğü

pow() — Üs Alma

# pow(taban, üs) — ** ile aynı
print(pow(2, 10))    # 1024

# pow(taban, üs, mod) — modüler üs alma
# (2^10) % 1000 hesabını verimli yapar
print(pow(2, 10, 1000))  # 24

# Kriptografide çok kullanılır
# pow(base, exp, mod) çok büyük sayılarla bile hızlıdır
print(pow(7, 1000, 13))  # Anında hesaplar

divmod() — Bölüm ve Kalan

# divmod(a, b) → (a // b, a % b) döner
bolum, kalan = divmod(17, 5)
print(f"17 / 5 = {bolum} kalan {kalan}")  # 3 kalan 2

# Saat-dakika dönüşümü
toplam_dakika = 137
saat, dakika = divmod(toplam_dakika, 60)
print(f"{toplam_dakika} dakika = {saat} saat {dakika} dakika")
# 137 dakika = 2 saat 17 dakika

# Saniye → saat:dakika:saniye
toplam_saniye = 3725
dakika, saniye = divmod(toplam_saniye, 60)
saat, dakika = divmod(dakika, 60)
print(f"{saat:02d}:{dakika:02d}:{saniye:02d}")  # 01:02:05

min(), max(), sum()

sayilar = [4, 2, 9, 1, 7, 3]

print(min(sayilar))   # 1
print(max(sayilar))   # 9
print(sum(sayilar))   # 26

# Ortalama hesapla
ortalama = sum(sayilar) / len(sayilar)
print(f"Ortalama: {ortalama:.2f}")  # 4.33

# Doğrudan argüman olarak da çalışır
print(min(10, 20, 5))  # 5
print(max(10, 20, 5))  # 20

Performans Notu

import sys

# int boyutu değere göre değişir
print(sys.getsizeof(0))          # 28 byte
print(sys.getsizeof(1))          # 28 byte
print(sys.getsizeof(10**100))    # 72 byte
print(sys.getsizeof(10**1000))   # 472 byte

# float her zaman sabit boyut
print(sys.getsizeof(3.14))      # 24 byte
print(sys.getsizeof(1e308))     # 24 byte

Python'un int tipi büyüdükçe daha fazla bellek kullanır. float ise her zaman 8 byte (64-bit) — çünkü IEEE 754 standardına uyar.

Performans kritik uygulamalarda (milyonlarca sayısal işlem), numpy gibi kütüphaneler kullanmak çok daha hızlıdır. Ama normal günlük programlama için Python'un yerleşik sayısal tipleri fazlasıyla yeterli.

Özet

int tipi sınırsız büyüklükte tam sayıları destekler — Python'un süper gücü.
float tipi IEEE 754 standardını kullanır; 0.1 + 0.2 != 0.3 gibi hassasiyet sorunlarına dikkat et.
complex tipi karmaşık sayıları destekler (3+4j formatında).
`//` (floor division) aşağıya yuvarlar, `/` (true division) her zaman float döner.
`round()` Banker's rounding kullanır — .5 durumunda en yakın çift sayıya yuvarlar.
`decimal` modülü finansal hesaplamalar için hassas aritmetik sağlar — para hesabında float yerine Decimal kullan.