🐍 Python Veri Tipleri

20 Farklı Örnekle Kapsamlı Rehber

Integer (int) TAM SAYI

Tam sayıları temsil eder. Pozitif, negatif veya sıfır olabilir. Python'da integer boyutu sınırsızdır.

Örnek Kod:
# Integer örnekleri
pozitif_sayi = 42
negatif_sayi = -15
buyuk_sayi = 999999999999999999
print(type(pozitif_sayi))
print(f"Toplam: {pozitif_sayi + negatif_sayi}")
▶ <class 'int'>
▶ Toplam: 27
✓ Sınırsız boyut
✓ Matematiksel işlemler
✓ Değiştirilemez
Float ONDALIKLI SAYI

Ondalıklı (kesirli) sayıları temsil eder. Bilimsel gösterimle de yazılabilir.

Örnek Kod:
# Float örnekleri
pi = 3.14159
bilimsel = 2.5e-3  # 0.0025
negatif = -7.89
print(f"Pi × 2 = {pi * 2}")
print(f"Bilimsel gösterim: {bilimsel}")
▶ Pi × 2 = 6.28318
▶ Bilimsel gösterim: 0.0025
✓ Ondalık hassasiyet
✓ Bilimsel gösterim
✓ IEEE 754 standardı
String (str) METİN

Metin verilerini temsil eder. Tek, çift veya üçlü tırnak ile tanımlanır.

Örnek Kod:
# String örnekleri
isim = "Python"
mesaj = 'Merhaba Dünya!'
cok_satirli = """Bu bir
çok satırlı
string örneğidir"""
print(isim.upper())
print(f"Uzunluk: {len(mesaj)}")
▶ PYTHON
▶ Uzunluk: 14
✓ Unicode desteği
✓ Birçok metod
✓ Değiştirilemez
Boolean (bool) MANTIKSAL

Mantıksal değerleri temsil eder. Sadece True veya False değerini alabilir.

Örnek Kod:
# Boolean örnekleri
aktif = True
tamamlandi = False
karsilastirma = 5 > 3  # True
print(f"Aktif mi? {aktif}")
print(f"5 > 3: {karsilastirma}")
▶ Aktif mi? True
▶ 5 > 3: True
✓ True/False
✓ Mantıksal işlemler
✓ Koşul ifadeleri
List (Listeler) SIRALANMIŞ

Sıralı, değiştirilebilir ve farklı veri tiplerini içerebilen koleksiyonlardır.

Örnek Kod:
# List örnekleri
meyveler = ["elma", "armut", "muz"]
karisik = [1, "iki", 3.0, True]
meyveler.append("çilek")
print(f"Meyveler: {meyveler}")
print(f"İlk meyve: {meyveler[0]}")
▶ Meyveler: ['elma', 'armut', 'muz', 'çilek']
▶ İlk meyve: elma
✓ Değiştirilebilir
✓ Sıralı
✓ İndeksleme
Tuple DEĞİŞMEZ LİSTE

Sıralı ancak değiştirilemez koleksiyonlardır. Parantez ile tanımlanır.

Örnek Kod:
# Tuple örnekleri
koordinat = (10, 20)
renkler = ("kırmızı", "yeşil", "mavi")
x, y = koordinat  # Tuple unpacking
print(f"X: {x}, Y: {y}")
print(f"Renk sayısı: {len(renkler)}")
▶ X: 10, Y: 20
▶ Renk sayısı: 3
✓ Değiştirilemez
✓ Daha hızlı
✓ Tuple unpacking
Dictionary (dict) ANAHTAR-DEĞER

Anahtar-değer çiftlerini saklayan sırasız ve değiştirilebilir koleksiyonlardır.

Örnek Kod:
# Dictionary örnekleri
kisi = {
    "ad": "Ahmet",
    "yas": 25,
    "sehir": "İstanbul"
}
print(f"Ad: {kisi['ad']}")
print(f"Anahtarlar: {list(kisi.keys())}")
▶ Ad: Ahmet
▶ Anahtarlar: ['ad', 'yas', 'sehir']
✓ Hızlı erişim
✓ Anahtar-değer
✓ Değiştirilebilir
Set (Kümeler) BENZERSİZ

Sırasız ve benzersiz elemanlardan oluşan koleksiyonlardır. Matematiksel küme işlemleri yapılabilir.

Örnek Kod:
# Set örnekleri
sayilar = {1, 2, 3, 3, 4}  # Tekrar eden 3 silinir
set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(f"Sayılar: {sayilar}")
print(f"Birleşim: {set1 | set2}")
▶ Sayılar: {1, 2, 3, 4}
▶ Birleşim: {1, 2, 3, 4, 5}
✓ Benzersiz elemanlar
✓ Küme işlemleri
✓ Hızlı üyelik testi
NoneType BOŞ DEĞER

Hiçbir değerin olmadığını veya boş bir değeri temsil eder. None tek bir None nesnesidir.

Örnek Kod:
# None örnekleri
sonuc = None
def fonksiyon():
    pass  # Hiçbir şey döndürmez (None döner)

deger = fonksiyon()
print(f"Sonuç: {sonuc}")
print(f"Fonksiyon dönüşü: {deger}")
▶ Sonuç: None
▶ Fonksiyon dönüşü: None
✓ Boş değer
✓ Tekil nesne
✓ Varsayılan dönüş
Complex (Karmaşık Sayılar) KARMAŞIK

Gerçek ve sanal kısımlardan oluşan karmaşık sayıları temsil eder. a + bj formatında yazılır.

Örnek Kod:
# Complex örnekleri
z1 = 3 + 4j
z2 = complex(2, -5)  # 2-5j
print(f"z1: {z1}")
print(f"Gerçek kısım: {z1.real}")
print(f"Sanal kısım: {z1.imag}")
▶ z1: (3+4j)
▶ Gerçek kısım: 3.0
▶ Sanal kısım: 4.0
✓ Gerçek + Sanal
✓ Matematiksel işlemler
✓ j gösterimi
Bytes BYTE DİZİSİ

Değiştirilemez byte dizileridir. İkili veri (binary data) ile çalışmak için kullanılır.

Örnek Kod:
# Bytes örnekleri
b1 = b"Merhaba"
b2 = "Python".encode('utf-8')
b3 = bytes([65, 66, 67])  # ABC
print(f"b1: {b1}")
print(f"b3: {b3}")
▶ b1: b'Merhaba'
▶ b3: b'ABC'
✓ İkili veri
✓ Değiştirilemez
✓ Kodlama desteği
Bytearray DEĞİŞEBİLİR BYTE

Bytes'ın değiştirilebilir versiyonudur. Byte dizileri üzerinde değişiklik yapılabilir.

Örnek Kod:
# Bytearray örnekleri
ba = bytearray(b"Hello")
ba[0] = 74  # 'J' ASCII kodu
ba.append(33)  # '!' ekle
print(f"Değiştirilmiş: {ba}")
print(f"String: {ba.decode()}")
▶ Değiştirilmiş: bytearray(b'Jello!')
▶ String: Jello!
✓ Değiştirilebilir
✓ Byte manipülasyonu
✓ Performanslı
Range SAYI ARALIĞI

Sayı dizilerini temsil eder. Genellikle döngülerde kullanılır ve bellek tasarrufludur.

Örnek Kod:
# Range örnekleri
r1 = range(5)  # 0'dan 4'e kadar
r2 = range(2, 10, 2)  # 2'den 10'a 2'şer artarak
print(f"r1 listesi: {list(r1)}")
print(f"r2 listesi: {list(r2)}")
▶ r1 listesi: [0, 1, 2, 3, 4]
▶ r2 listesi: [2, 4, 6, 8]
✓ Bellek tasarruflu
✓ Tembel değerlendirme
✓ Döngüler için ideal
Frozenset DEĞİŞMEZ KÜME

Set'in değiştirilemez versiyonudur. Dictionary anahtarı olarak kullanılabilir.

Örnek Kod:
# Frozenset örnekleri
fs1 = frozenset([1, 2, 3, 3])
fs2 = frozenset([2, 3, 4])
birlesim = fs1 | fs2
print(f"fs1: {fs1}")
print(f"Birleşim: {birlesim}")
▶ fs1: frozenset({1, 2, 3})
▶ Birleşim: frozenset({1, 2, 3, 4})
✓ Değiştirilemez
✓ Hashlenebilir
✓ Dict anahtarı
List Comprehension LİSTE OLUŞTURMA

Tek satırda liste oluşturmanın elegant bir yoludur. Döngü ve koşul içerebilir.

Örnek Kod:
# List comprehension örnekleri
kareler = [x**2 for x in range(6)]
cift_sayilar = [x for x in range(10) if x % 2 == 0]
matris = [[i*j for j in range(3)] for i in range(3)]
print(f"Kareler: {kareler}")
print(f"Çift sayılar: {cift_sayilar}")
▶ Kareler: [0, 1, 4, 9, 16, 25]
▶ Çift sayılar: [0, 2, 4, 6, 8]
✓ Tek satır
✓ Okunabilir
✓ Performanslı
Dictionary Comprehension SÖZLÜK OLUŞTURMA

Tek satırda dictionary oluşturmanın kısa yoludur. Anahtar-değer çiftleri dinamik olarak oluşturulur.

Örnek Kod:
# Dictionary comprehension örnekleri
kareler_dict = {x: x**2 for x in range(6)}
ters_dict = {v: k for k, v in {'a': 1, 'b': 2}.items()}
filtreli = {k: v for k, v in kareler_dict.items() if v > 10}
print(f"Kareler: {kareler_dict}")
print(f"Filtreli: {filtreli}")
▶ Kareler: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
▶ Filtreli: {4: 16, 5: 25}
✓ Kompakt sözdizimi
✓ Dinamik oluşturma
✓ Filtreleme
Set Comprehension KÜME OLUŞTURMA

Tek satırda set oluşturmanın pratik yoludur. Otomatik olarak tekrarlayan değerleri kaldırır.

Örnek Kod:
# Set comprehension örnekleri
kare_set = {x**2 for x in range(-3, 4)}
harfler = {c.upper() for c in "python"}
tek_sayilar = {x for x in range(20) if x % 2 != 0}
print(f"Kareler: {kare_set}")
print(f"Harfler: {harfler}")
▶ Kareler: {0, 1, 4, 9}
▶ Harfler: {'P', 'Y', 'T', 'H', 'O', 'N'}
✓ Benzersiz değerler
✓ Kısa sözdizimi
✓ Otomatik filtreleme
Generator Expression ÜRETKEN İFADE

List comprehension'a benzer ancak tembel değerlendirme yapar. Bellek dostu bir yaklaşımdır.

Örnek Kod:
# Generator expression örnekleri
gen = (x**2 for x in range(5))
toplam = sum(x for x in range(1000))
print(f"Generator tipi: {type(gen)}")
print(f"Liste: {list(gen)}")
print(f"Toplam (0-999): {toplam}")
▶ Generator tipi: <class 'generator'>
▶ Liste: [0, 1, 4, 9, 16]
▶ Toplam (0-999): 499500
✓ Bellek tasarruflu
✓ Tembel değerlendirme
✓ Büyük veriler için ideal
Nested Collections İÇ İÇE YAPILAR

Liste, dictionary ve diğer veri yapıları iç içe kullanılarak karmaşık veri modelleri oluşturulabilir.

Örnek Kod:
# Nested collections örnekleri
ogrenciler = [
    {"ad": "Ali", "notlar": [85, 90, 78]},
    {"ad": "Ayşe", "notlar": [92, 88, 95]}
]
matris = [[1, 2], [3, 4], [5, 6]]
print(f"{ogrenciler[0]['ad']}'nin ilk notu: {ogrenciler[0]['notlar'][0]}")
print(f"Matris 2. satır: {matris[1]}")
▶ Ali'nin ilk notu: 85
▶ Matris 2. satır: [3, 4]
✓ Karmaşık yapılar
✓ Çok boyutlu veri
✓ Esnek modelleme
Type Conversion (Tip Dönüşümü) DÖNÜŞÜM

Bir veri tipini başka bir veri tipine dönüştürme işlemleridir. Explicit ve implicit dönüşümler yapılabilir.

Örnek Kod:
# Type conversion örnekleri
sayi_str = "123"
sayi_int = int(sayi_str)
sayi_float = float(sayi_int)
liste = list("Python")
set_den_liste = list({1, 2, 3})
print(f"String → Int: {sayi_int}, tip: {type(sayi_int)}")
print(f"String → List: {liste}")
▶ String → Int: 123, tip: <class 'int'>
▶ String → List: ['P', 'y', 't', 'h', 'o', 'n']
✓ Esnek dönüşüm
✓ Tip kontrolü
✓ Çok yönlü