Skip to content

Python'un int Tipi: Sınırsız Tam Sayı ve Diğer Dillerde Olmayan Süper Güç

Java'da int 2.1 milyarda taşar, C'de tanımsız davranış. Python'da int sınırsız — 1000! veya RSA için 4096-bit sayı, hepsi doğal yazılır. Bu derste: integer literals (binary/hex/octal), underscore separator, bit operasyonları, small int caching, performans karakteristikleri, ve 'neden Python kriptoda Java'yı yener'.

Şükrü Yusuf KAYA
19 min read
Beginner
Python'un int Tipi: Sınırsız Tam Sayı ve Diğer Dillerde Olmayan Süper Güç
🔢 'int' senin sandığından çok daha güçlü
Python'da
2 ** 1000
yazınca — çalışıyor. Sonuç: 302 basamaklı bir sayı. Java'da bu kodu yazsan integer overflow alırsın. C'de tanımsız davranış. Python'un int'i bu açıdan diğer dillerden köklü farklı: sınırsız precision. Bu özellik kriptografi, bilim, finans gibi alanlarda Python'a benzersiz bir avantaj veriyor. Bu derste neden ve nasıl olduğunu görüyoruz.

Diğer dillerde int sınırlıdır#

Hadi Python dışı dillerde int neye benziyor görelim:
C dilinde:
int x = 2147483647;        // 32-bit max
x = x + 1;                 // -2147483648 (overflow! signed)
Java'da:
int x = Integer.MAX_VALUE;  // 2,147,483,647 (32-bit)
x = x + 1;                  // -2,147,483,648 (silently overflow)

long y = Long.MAX_VALUE;    // 9,223,372,036,854,775,807 (64-bit)
y = y + 1;                  // -9,223,372,036,854,775,808
JavaScript:
const x = Number.MAX_SAFE_INTEGER;  // 9,007,199,254,740,991 (2^53-1)
x + 1                                // 9007199254740992 (precision loss!)

// BigInt geç (2020+):
const y = 9007199254740993n;        // 'n' suffix
y + 1n                               // OK
Python'da:
x = 9999999999999999999999999999999999999999999999
y = x ** 2
print(y)
# 99999999999999999999999999999999999999999999980000000000000000000000000000000000000000000000001
Hiçbir taşma yok. Bellek izin verdiğince büyür. Bu sayıyı yazdırırsan ekrana sığmıyor — Python umursamıyor.
Bu özelliğe arbitrary-precision integer veya bignum deniyor. Python int'inin C'deki implementasyonu (CPython'da
Include/cpython/longintrepr.h
) sayıyı 30-bit "digit"lere bölerek dinamik bir array'de tutuyor. Sayı büyüdükçe array büyüyor.
Pratik karşılığı:
  • Faktöriyel(1000) — 2568 basamaklı sayı, Python anında hesaplar.
  • RSA-4096 — 4096 bitlik prime number, Python doğal aritmetik ile yapar.
  • Permütasyon hesabı — kombinasyonlar Java'da BigInteger ile hesaplanır; Python'da
    math.factorial()
    .
Bu süper güç AI/ML/bilim projelerinde Python'un baskınlığının ana sebeplerinden biri.
python
# Sınırsız int demosu
import math
 
# Faktöriyel(1000) — 2568 basamak
big_fact = math.factorial(1000)
print(f"1000! → {len(str(big_fact))} basamak")
print(f"İlk 50 basamak: {str(big_fact)[:50]}")
 
# 2^1000 — 302 basamak
huge = 2 ** 1000
print(f"\n2^1000 → {len(str(huge))} basamak")
 
# Mersenne primes (büyük asal sayılar — kriptografi için)
mersenne = 2 ** 19937 - 1
print(f"\n2^19937 - 1 → {len(str(mersenne))} basamak")
print(f"Asal mı? Evet (Mersenne prime)")
 
# Saatlik milyar nano-saniye — saatlerle çalışırken
nanoseconds_per_hour = 3600 * 10 ** 9
print(f"\n1 saat = {nanoseconds_per_hour:,} nanosecond")
 
# Çıktı:
# 1000! → 2568 basamak
# İlk 50 basamak: 40238726007709377354370243392300398571937486421071
#
# 2^1000 → 302 basamak
#
# 2^19937 - 1 → 6002 basamak
# Asal mı? Evet (Mersenne prime)
#
# 1 saat = 3,600,000,000,000 nanosecond
Big int aritmetiği — sınır olmadığı için doğal yazılıyor. Java'da BigInteger sınıfı kullanmak zorunda kalırsın.

Integer literals — sayı yazma yöntemleri#

Python'da int yazmanın 4 farklı yolu var:
# 1. Decimal (temel — günlük)
x = 42
y = -100
z = 0

# 2. Binary (0b prefix)
flags = 0b1010_1100      # 8-bit binary
print(flags)              # 172

# 3. Octal (0o prefix)
permission = 0o755        # rwxr-xr-x
print(permission)         # 493

# 4. Hexadecimal (0x prefix)
color = 0xFF_AB_CD        # RGB renk
print(color)              # 16755149
addr = 0xDEADBEEF
Hepsi aynı tip —
int
. Sadece yazma kolaylığı:
>>> type(42)
<class 'int'>
>>> type(0b101)
<class 'int'>
>>> type(0xFF)
<class 'int'>

>>> 42 == 0b101010 == 0o52 == 0x2A
True

Underscore separator (3.6+)#

Büyük sayıları okuyabilir kılmak için
_
ile gruplayabilirsin:
million = 1_000_000               # 1000000 ile aynı
billion = 1_000_000_000
salary = 50_000.50                 # float'ta da çalışıyor

# Binary'da byte ayırımı
flags = 0b1010_1100_1110_0001
# Hex'te byte ayırımı
mac = 0xAA_BB_CC_DD_EE_FF

# Underscore sadece görsel; değer aynı
1000000 == 1_000_000  # True
Bu özelliği geç kullanmak — milyon yerine
1000000
veya 1B yerine
1000000000
yazmak — okuyana hayatı zorlaştırıyor. Modern Python kodu underscore separator'u standart kullanıyor.

Conversion — bin/hex/oct ve int()#

# int → string (farklı tabanda)
n = 255
bin(n)   # '0b11111111'
oct(n)   # '0o377'
hex(n)   # '0xff'

# Stringi temizle (prefix'siz)
bin(n)[2:]   # '11111111'
hex(n)[2:]   # 'ff'

# format() ile padding kontrolü
f"{n:b}"     # '11111111'
f"{n:08b}"   # '11111111' (zaten 8 karakter; fazla zerozer pad)
f"{n:08b}"   # '11111111'
f"{15:08b}"  # '00001111' (8 karaktere pad)
f"{n:o}"     # '377'
f"{n:x}"     # 'ff'
f"{n:X}"     # 'FF' (uppercase)
f"{n:#x}"    # '0xff' (prefix dahil)
f"{n:08x}"   # '000000ff'

# String → int
int("42")           # 42 (default base 10)
int("42", 10)       # 42 (explicit base)
int("0b101010", 2)  # 42 (binary)
int("101010", 2)    # 42 (binary, prefix'siz)
int("0o52", 8)      # 42 (octal)
int("0x2A", 16)     # 42 (hex)
int("ff", 16)       # 255

# Geçersiz
int("3.14")         # ValueError! float string'i int'e parse etmiyor
int("abc")          # ValueError
int("3.14", 10)     # ValueError

# Doğrusu
int(float("3.14"))  # 3 (önce float'a, sonra int — truncate)
Bu pattern'ler özellikle veri ile çalışırken sürekli karşına çıkacak. CSV'den oku, JSON'dan parse et, hex string'i sayıya çevir — hepsi bu fonksiyonları kullanıyor.

int üzerinde method çağırma#

Python'da her şey nesne — int dahil. Yani
5
üzerinde method çağırabilirsin:
n = 12345

# bit_length: Bu sayıyı binary'de göstermek için kaç bit gerekir
n.bit_length()      # 14 (12345 = 0b11000000111001, 14 bit)
(255).bit_length()  # 8
(256).bit_length()  # 9 (256 = 2^8 olduğundan 9. bit gerekir)

# bit_count (3.10+): Sayıdaki '1' bit sayısı
(0b1011_0010).bit_count()  # 4 (4 tane 1 var)

# to_bytes: int → bytes
(255).to_bytes(2, "big")        # b'\x00\xff'
(255).to_bytes(2, "little")     # b'\xff\x00'
(1234).to_bytes(4, "big", signed=True)  # b'\x00\x00\x04\xd2'

# from_bytes: bytes → int (classmethod)
int.from_bytes(b"\x00\xff", "big")   # 255
int.from_bytes(b"\xff\x00", "little") # 255

# real, imag, numerator, denominator (genel sayı protokolü)
(5).real        # 5
(5).imag        # 0 (kompleks parçası, real number için 0)
(5).numerator   # 5 (kesir — int için kendisi)
(5).denominator # 1

# conjugate (kompleks sayı protokolü)
(5).conjugate() # 5 (real için kendisi)
bit_length
ve
to_bytes/from_bytes
özellikle network programlama, kriptografi, dosya formatları için kritik.
Mesela bir IP adresini integer'a çevirme:
# IP adresi → 32-bit integer
ip = "192.168.1.1"
parts = [int(x) for x in ip.split(".")]
ip_int = (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3]
print(ip_int)              # 3232235777
print(hex(ip_int))         # '0xc0a80101'

# Tersi
ip_bytes = ip_int.to_bytes(4, "big")
print(".".join(str(b) for b in ip_bytes))  # '192.168.1.1'

int ile aritmetik — bilmen gereken davranışlar#

Python int aritmetiği genelde temiz, ama birkaç önemli not:

/
her zaman float,
//
int (floor division)#

10 / 3       # 3.3333333333333335 (float)
10 // 3      # 3 (int — floor)
10 // 4      # 2
-10 // 3     # -4 (negatif sayıda floor sıkıntılı — toward minus infinity)

# Round vs floor — fark var
import math
math.floor(-10/3)  # -4
int(-10/3)         # -3 (truncation, sıfıra doğru)

%
modulus — Python'da matematiksel modulo#

10 % 3       # 1
-10 % 3      # 2 (NOT -1; matematiksel modulo)
10 % -3      # -1
C/Java'da
-10 % 3 == -1
. Python farklı: sonuç divisor'un işaretine sahip. Matematiksel olarak daha tutarlı; algoritmalarda dikkat et.

**
üs alma#

2 ** 10           # 1024
2 ** 0.5          # 1.4142135623730951 (float — kare kök)
2 ** -1           # 0.5 (negative üs → float)
(-2) ** 3         # -8
(-2) ** 0.5       # complex! (1.2246467991473532e-16+1.4142135623730951j)

# Modüler üs alma (kriptografi'de kritik)
pow(2, 100, 7)    # (2^100) mod 7 = 2 — direkt hesap
# Eşdeğer ama daha yavaş:
(2 ** 100) % 7    # önce 2^100, sonra mod (büyük sayı yaratır)
pow(base, exp, mod)
üç argümanlı versiyonu modüler üs alma yapıyor — RSA gibi kriptografik algoritmalarda standart.

divmod — bölme + modulus aynı anda#

divmod(17, 5)       # (3, 2) — 17 = 3*5 + 2
divmod(20, 7)       # (2, 6) — 20 = 2*7 + 6

# Saat hesaplama: dakikadan saat-dakika
total_minutes = 145
hours, mins = divmod(total_minutes, 60)
print(f"{hours}h {mins}m")    # "2h 25m"

# Saniye → saat:dakika:saniye
def format_duration(seconds):
    hours, remainder = divmod(seconds, 3600)
    minutes, secs = divmod(remainder, 60)
    return f"{hours:02d}:{minutes:02d}:{secs:02d}"

format_duration(3725)   # '01:02:05'

Bit-level operatörler#

Python int üzerinde C-tarzı bit operasyonları destekliyor:
OperatörAnlamÖrnek
&
AND
0b1100 & 0b1010 = 0b1000
``OR
^
XOR
0b1100 ^ 0b1010 = 0b0110
~
NOT
~0b1010 = -0b1011
(sign bit'le ilgili)
<<
Left shift
0b0011 << 2 = 0b1100
>>
Right shift
0b1100 >> 2 = 0b0011
# Permission flags (Unix-style)
READ = 0b100      # 4
WRITE = 0b010     # 2
EXECUTE = 0b001   # 1

# Birleştir
permissions = READ | WRITE         # 0b110 = 6
print(bin(permissions))            # '0b110'

# Kontrol et
has_read = permissions & READ      # 0b100 = 4 (truthy)
has_execute = permissions & EXECUTE  # 0 (falsy)
print(bool(has_read), bool(has_execute))   # True False

# Toggle (XOR ile)
permissions ^= EXECUTE             # execute bit toggle
print(bin(permissions))            # '0b111'

# Shift ile çarpma/bölme (2'nin kuvvetleri için hızlı)
x = 5
x << 3   # 5 * 2^3 = 40 (left shift = multiply by power of 2)
x >> 1   # 5 / 2 = 2 (right shift = floor divide by power of 2, integer)

# Bit mask örnekleri
def low_byte(n):
    return n & 0xFF

def high_byte(n):
    return (n >> 8) & 0xFF

low_byte(0xABCD)   # 0xCD = 205
high_byte(0xABCD)  # 0xAB = 171
Bit operasyonları embedded systems, network protocols, graphics, kriptografi, flags/permissions için günlük araç. Ama uygulama kodunda nadiren ihtiyaç duyarsın.

Chained comparison — Python'un zarif özelliği#

Python'da karşılaştırmalar zincirlenebilir:
# Zincirli (Pythonic)
x = 5
if 0 < x < 10:
    print("0 ile 10 arasında")

# Eski (C/Java tarzı)
if 0 < x and x < 10:
    print("0 ile 10 arasında")

# Daha karmaşık
age = 25
if 18 <= age < 65:
    print("Çalışma yaşında")

# Eşitlikle de
a, b, c = 5, 5, 5
if a == b == c:
    print("Üçü eşit")
Matematiksel notasyona yakın, okuyucu rahat — Python'un az bilinen ama zarif özelliklerinden.

Small int caching — performans hilesi#

CPython'un içinde gizli bir optimizasyon var: -5 ile 256 arası integer'ları pre-allocate ediyor. Yani sen
5
yazdığında her seferinde yeni nesne yaratılmıyor; cache'lenmiş olan kullanılıyor.
a = 100
b = 100
print(a is b)       # True (her ikisi cache'teki aynı 100 nesnesi)

a = 256
b = 256
print(a is b)       # True (256 hâlâ cache'te — sınır)

a = 257
b = 257
print(a is b)       # False (genelde) — cache dışı, ayrı nesneler
Bu davranışa GÜVENME. Implementation detail. PyPy farklı sınır kullanabilir; CPython gelecek sürümünde değişebilir.
Kural: Integer karşılaştırmasında her zaman
==
kullan, asla
is
.
# 🚫
if x is 5: ...

# ✅
if x == 5: ...

# Sadece sentinel için is uygun
if x is None: ...   # ✅ (None her zaman tek nesne)

Performans — int aritmetiği ne kadar hızlı?#

CPython'un small int operations'ı oldukça hızlı (~10-20 ns / operation). Big int (256+ bit) işlemler doğal olarak daha yavaş — sayı büyüklüğü ile orantılı.
import timeit

# Small int
print(timeit.timeit("5 + 3", number=10_000_000))
# ~0.5 saniye

# Medium int
print(timeit.timeit("12345 + 67890", number=10_000_000))
# ~0.5 saniye (hâlâ küçük, "single digit" big int)

# Big int
print(timeit.timeit("(2**1000) + (2**1000)", number=1_000_000))
# Birkaç saniye (her hesap büyük sayı)
NumPy gibi kütüphaneler için
np.int64
gibi sabit-genişlik tip kullanırsan C-seviyesi performans alırsın (Python int'inden 100x hızlı). AI/ML için
np.int32
veya
np.float32
standart.

Gerçek dünya: int süper gücü kullanılan yerler#

1. Faktöriyel ve kombinasyon — kombinatorik#

import math

# 50 öğrenci içinden 10 kişilik takım kaç farklı şekilde seçilir?
combinations = math.comb(50, 10)
print(combinations)   # 10,272,278,170 — 10 milyar üstü

# 100 kart arasında permütasyon
permutations = math.perm(100, 5)
print(permutations)   # 9,034,502,400
math.comb(n, k) = n! / (k! * (n-k)!)
— Python int'inin sınırsızlığı sayesinde
comb(1000, 500)
bile hesaplanır (300 basamaklı sayı).

2. RSA-style kriptografi (kavramsal)#

# RSA temel mantık (gerçek güvenli değil, sadece kavram)
# 1. İki büyük asal seç
p = 61
q = 53

# 2. n = p * q
n = p * q   # 3233

# 3. Euler totient
phi = (p-1) * (q-1)   # 3120

# 4. Public exponent (genelde 65537)
e = 17

# 5. Private exponent (multiplicative inverse)
d = pow(e, -1, phi)   # 2753

# Şifrele
message = 65   # 'A'
ciphertext = pow(message, e, n)
print(f"Şifreli: {ciphertext}")

# Çöz
decrypted = pow(ciphertext, d, n)
print(f"Çözülen: {decrypted}")  # 65 → 'A'

# Gerçek RSA: p, q ~2048-bit. Python doğal aritmetikle yapıyor.
pow(base, exp, mod)
modüler üs hesabı — sayı ne kadar büyük olursa olsun. C++'de OpenSSL gibi kütüphaneler kullanmak zorundasın; Python'da builtin.

3. Hash ve checksum#

import hashlib

text = "Hello, World!"
hash_obj = hashlib.sha256(text.encode())
hash_int = int.from_bytes(hash_obj.digest(), "big")
print(f"SHA256 (int): {hash_int}")
print(f"  bit_length: {hash_int.bit_length()}")  # 256-bit

# Hex olarak görünüm
print(f"SHA256 (hex): {hex(hash_int)}")
256-bit hash'i tek bir int olarak tutmak — Java'da BigInteger ile yapılır; Python doğal.

4. Bilim — astronomi sayıları#

# Evrendeki atom sayısı tahmini ~10^80
universe_atoms = 10 ** 80
print(f"Universe atoms (yaklaşık): {universe_atoms}")

# Saniyedeki ışık hızı * 1 yıl = ışık yılı
c = 299_792_458  # m/s
seconds_per_year = 365.25 * 24 * 3600
light_year_meters = int(c * seconds_per_year)
print(f"1 ışık yılı: {light_year_meters:,} metre")
# 9,460,730,777,119,564 (16 basamak)

5. Blockchain — adres ve hash hesabı#

Ethereum adresleri 160-bit, transaction hash'leri 256-bit. Python int ile direkt çalışılıyor.
Bütün bu örneklerde Java/JavaScript için extra kütüphane gerekiyor; Python'da temel int yetiyor.
python
# Hands-on: FizzBuzz — int klasiği
# 1'den 100'e: 3'ün katlarına "Fizz", 5'in katlarına "Buzz",
# 15'in katlarına "FizzBuzz", diğerlerine sayı
 
for i in range(1, 101):
    if i % 15 == 0:
        print("FizzBuzz")
    elif i % 3 == 0:
        print("Fizz")
    elif i % 5 == 0:
        print("Buzz")
    else:
        print(i)
 
# Daha Pythonic versiyon
for i in range(1, 101):
    output = ""
    if i % 3 == 0:
        output += "Fizz"
    if i % 5 == 0:
        output += "Buzz"
    print(output or i)
 
# Tek satır (öğretici, ama pratik kullanmaya değmez)
print("\n".join(
    "FizzBuzz" if i % 15 == 0
    else "Fizz" if i % 3 == 0
    else "Buzz" if i % 5 == 0
    else str(i)
    for i in range(1, 101)
))
FizzBuzz — junior dev'in temel testi. Bu problemi çözebiliyorsan modulo (%) operatörü oturmuş demektir.

Yaygın tuzaklar#

1.
int()
ile float string parse#

int("3.14")   # ValueError: invalid literal for int() with base 10: '3.14'

# Doğrusu (truncate ile):
int(float("3.14"))   # 3

# Yuvarlama ile:
round(float("3.14"))  # 3

2.
/
her zaman float#

# Tuzak: int sonucu beklerken float aldı
total = 100 / 4   # 25.0 — float!

# Beklenmedik bug yaratabilir
data = list(range(total))   # TypeError: 'float' object cannot be interpreted as an integer

# Doğrusu
total = 100 // 4   # 25 — int
data = list(range(total))   # OK

3. Negatif sayı modulus#

# C/Java tarzı düşünüyorsun
-5 % 3   # 1 (NOT -2!)

# Pythonic davranış: divisor'un işareti
# Algoritmik kod yazarken dikkat

4. Big int performansı#

# Naif Fibonacci — yavaş ama çalışır
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

print(fib(35))   # ~5 saniye

# Iteratif — hızlı
def fib_iter(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

print(fib_iter(1000))   # Anında — 209 basamaklı sayı
Big int hesabı CPU'yu yer; algoritma seçimi önemli.

5. Float'tan int'e dönerken precision kaybı#

# Float yetersiz precision için
huge = 10 ** 17
huge_float = float(huge)
back_to_int = int(huge_float)
print(huge - back_to_int)   # Fark olabilir!

# 10^16'dan büyük sayılar float'ta tam temsil edilemez
Finans/bilim için float'a int gibi davran — Modül 2/Ders 4'te detayda.

Bu derste neler kazandın?#

✓ Python int sınırsız (arbitrary-precision) — Java/C/JS'de standart
int
'lerle karşılaştırma.
✓ 4 integer literal: decimal, binary (0b), octal (0o), hex (0x).
✓ Underscore separator (
1_000_000
) — büyük sayıları okunabilir yapma.
✓
bin()
,
oct()
,
hex()
 ve
int(s, base)
ile dönüşümler.
✓ int methods:
bit_length
,
bit_count
,
to_bytes
,
from_bytes
.
✓ Aritmetik özellikleri:
/
float,
//
floor int,
%
matematiksel modulo,
**
üs,
pow(b, e, m)
modüler üs,
divmod(a, b)
.
✓ Bit-level operatörler:
& | ^ ~ << >>
ile permission flags, IP encode, mask örnekleri.
✓ Chained comparison
0 < x < 10
— Python'un zarif özelliği.
✓ Small int caching (-5..256) — performans optimizasyonu, ama
is
kullanma.
✓ 5 gerçek dünya uygulaması: kombinatorik, RSA kriptografi, hash, astronomi, blockchain.
✓ 5 yaygın tuzak: float string parse,
/
float, negatif modulus, big int performansı, float→int precision.
Sıradaki ders:
float
— IEEE 754 standardı ve precision tuzakları.
0.1 + 0.2 == 0.3
neden
False
?
math.isclose()
ne zaman gerekli?
Decimal
ve
Fraction
modülleri ne zaman tercih edilir? Finansal hesap, bilim, AI/ML — float'ın hayatın her köşesi.

Frequently Asked Questions

**Performans + bellek**. Python int dinamik allocation; her int en az ~28 byte (object overhead). NumPy int32 — 4 byte, int64 — 8 byte. Milyon eleman için fark dramatik (28 MB vs 8 MB). Ayrıca C-seviye hesap (NumPy ufunc'lar) sabit-genişlik integer ile çalışıyor. AI/ML/bilim için NumPy int kullanırsın; uygulama kodunda Python int.

Yorumlar & Soru-Cevap

(0)
Yorum yazmak için giriş yap.
Yorumlar yükleniyor...

Related Content

Modül 1: Giriş ve Kurulum

Python Nedir, Neden Bu Kadar Popüler?

Start Learning
Modül 1: Giriş ve Kurulum

Python Sürümlerinin Tarihi: 2'den 3.14'e, AI Winter'lardan 'No-GIL' Devrimine

Start Learning
Modül 1: Giriş ve Kurulum

Python Implementasyonları: CPython, PyPy, MicroPython, Jython, IronPython, Pyodide

Start Learning