Giriş

Programlama, en temelinde veriyi işleme sanatıdır. Bir program yazdığımızda, genellikle dış dünyadan (kullanıcı girdisi, dosyalar, veritabanları, ağ bağlantıları vb.) veri alır, bu veriyi belirli kurallara göre işler ve sonuçları yine bir veri formatında (ekran çıktısı, dosyaya yazma, başka bir sisteme gönderme vb.) sunarız. Bu süreçte, üzerinde çalıştığımız verinin türünü bilmek ve anlamak hayati önem taşır. Bir sayıyla bir metni aynı şekilde işleyemeyiz; bir listeyle bir sözlüğü farklı amaçlar için kullanırız. İşte burada veri tipleri (data types) devreye girer.

Veri tipi, bir değişkenin veya değerin ne tür bilgi tuttuğunu (tam sayı, ondalıklı sayı, metin, mantıksal değer vb.) ve bu bilgi üzerinde hangi işlemlerin yapılabileceğini tanımlayan bir sınıflandırmadır. Python, zengin bir yerleşik (built-in) veri tipleri setine sahiptir ve bu tipler, programlarımızı oluştururken bize büyük bir esneklik ve güç sağlar.

Python’un en belirgin özelliklerinden biri dinamik tipli (dynamically typed) bir dil olmasıdır. Bu, C++, Java veya C# gibi statik tipli dillerin aksine, bir değişkenin tipini önceden açıkça belirtme zorunluluğumuzun olmadığı anlamına gelir. Değişkenin tipi, ona atanan değere göre Python yorumlayıcısı tarafından otomatik olarak belirlenir ve programın çalışması sırasında bu tip değişebilir.

veri = 10 # Python, 'veri' değişkeninin tipini 'int' (tam sayı) olarak belirler.
print(type(veri)) #
veri = "Merhaba" # Şimdi aynı 'veri' değişkenine bir metin atıyoruz.
print(type(veri)) # (string - metin)
veri = 3.14 # Şimdi de ondalıklı bir sayı atıyoruz.
print(type(veri)) #
Bu dinamik yapı, kod yazmayı hızlandırsa da, kullandığımız verilerin tiplerini ve özelliklerini iyi anlamak, hatalardan kaçınmak ve verimli kod yazmak için çok önemlidir.

Bu metinde, Python’daki en temel ve yaygın olarak kullanılan yerleşik veri tiplerini derinlemesine inceleyeceğiz:

Sayısal Tipler:

int (Tam Sayılar)
float (Ondalıklı Sayılar)
Metin Tipi:

str (String — Karakter Dizileri)
Mantıksal Tip:

bool (Boolean — Doğru/Yanlış Değerleri)
Koleksiyon (Sequence/Collection) Tipleri:

list (Listeler — Sıralı, Değiştirilebilir)
tuple (Demetler — Sıralı, Değiştirilemez)
dict (Sözlükler — Anahtar-Değer Çiftleri, Sıralı (3.7+), Değiştirilebilir)
set (Kümeler — Sırasız, Benzersiz Öğeler, Değiştirilebilir)
Ayrıca, Python’daki her şeyin bir nesne (object) olduğu kavramına ve veri tiplerinin aslında sınıflar (classes) olduğuna değineceğiz. Her bir veri tipinin özelliklerini, nasıl oluşturulduklarını, üzerlerinde hangi işlemlerin yapılabileceğini ve yaygın kullanım alanlarını örneklerle açıklayacağız.

Bölüm 1: Sayısal Veri Tipleri (int ve float)

Sayısal veriler, programlamanın temel taşlarından biridir. Hesaplamalar yapmak, miktarları saymak, ölçümleri temsil etmek için sayısal tipleri kullanırız. Python’da iki ana sayısal tip bulunur: int ve float. (Ayrıca daha az kullanılan complex tipi de vardır, ancak bu metinde ana odak int ve float olacaktır.)

1.1. int (Integer — Tam Sayılar)

Tanım: Pozitif veya negatif tam sayıları (ondalık kısmı olmayan sayılar) temsil eder. Örneğin: -10, 0, 5, 12345.
Oluşturma: Bir değişkene doğrudan tam sayı değeri atanarak oluşturulur.
yas = 30 sicaklik = -5 sira_numarasi = 101 buyuk_sayi = 999999999999999999999999999999 # Python'da int'lerin boyutu sınırlı değildir!
Özellikler:
Boyut Sınırı Yok: Diğer bazı dillerin aksine (örneğin C’deki int tipi), Python’daki int tipinin teorik olarak bir üst sınırı yoktur. Belleğiniz yettiği sürece çok büyük tam sayıları saklayabilirsiniz. Bu, büyük sayılarla çalışırken taşma (overflow) hatalarıyla uğraşma derdini ortadan kaldırır.
İşlemler: Standart aritmetik işlemler (+, -, , /, %, *, //) int’ler üzerinde yapılabilir.
a = 10 b = 3 toplam = a + b # 13 fark = a - b # 7 carpim = a * b # 30 bolum = a / b # 3.333... (Dikkat: '/' operatörü sonucu her zaman float yapar!) tam_bolum = a // b # 3 (Bölümün tam kısmını alır) kalan = a % b # 1 (Modülüs - Bölümden kalanı verir) us = a ** b # 1000 (a üzeri b) print(f"Toplam: {toplam}, Fark: {fark}, Çarpım: {carpim}") print(f"Bölüm: {bolum}, Tam Bölüm: {tam_bolum}, Kalan: {kalan}, Üs: {us}") print(f"Bölümün tipi: {type(bolum)}") # print(f"Tam Bölümün tipi: {type(tam_bolum)}") #
Taban Dönüşümleri: Python, tam sayıları ikilik (binary), sekizlik (octal) ve onaltılık (hexadecimal) tabanlarda da ifade etmenize ve bunlar arasında dönüşüm yapmanıza olanak tanır.
ondalik = 26 ikilik = bin(ondalik) # '0b11010' (başına '0b' eklenir) sekizlik = oct(ondalik) # '0o32' (başına '0o' eklenir) onaltilik = hex(ondalik) # '0x1a' (başına '0x' eklenir) print(f"{ondalik} sayısının ikilik hali: {ikilik}") print(f"{ondalik} sayısının sekizlik hali: {sekizlik}") print(f"{ondalik} sayısının onaltılık hali: {onaltilik}") # Diğer tabanlardan ondalık tabana dönüşüm: ikilik_sayi = int('0b11010', 2) # 26 (ikinci argüman tabanı belirtir) sekizlik_sayi = int('0o32', 8) # 26 onaltilik_sayi = int('0x1a', 16) # 26 print(ikilik_sayi, sekizlik_sayi, onaltilik_sayi)
Kullanım Alanları: Sayma işlemleri, indisleme (listelerdeki eleman sıraları gibi), döngü sayaçları, kimlik numaraları gibi tam sayı gerektiren her türlü durum.
1.2. float (Floating-Point — Ondalıklı Sayılar)

Tanım: Ondalık kısmı olan sayıları (gerçel sayılar) temsil eder. Örneğin: 3.14, -0.5, 2.71828, 1.0.
Oluşturma: Sayı içinde ondalık nokta (.) kullanılarak veya bilimsel gösterim (e veya E notasyonu) ile oluşturulur.
pi_sayisi = 3.14159 negatif_ondalikli = -2.5 sicaklik_celcius = 23.5 agirlik_kg = 75.0 # Tam sayı gibi görünse de .0 eklenince float olur avogadro_sayisi = 6.022e23 # 6.022 x 10^23 (Bilimsel gösterim) cok_kucuk_sayi = 1e-6 # 0.000001
Özellikler:
Hassasiyet (Precision) Sorunları: Bilgisayarlar, ondalıklı sayıları ikilik tabanda tam olarak temsil etmekte zorlanabilirler. Bu durum, kayan nokta aritmetiği (floating-point arithmetic) olarak bilinir ve bazen beklenmedik küçük hatalara yol açabilir.
sonuc = 0.1 + 0.1 + 0.1 print(sonuc) # 0.30000000000000004 (Beklenen 0.3 değil!) print(sonuc == 0.3) # False # Bu tür durumlar için genellikle küçük bir toleransla karşılaştırma yapılır: epsilon = 1e-9 # Çok küçük bir tolerans değeri print(abs(sonuc - 0.3) < epsilon) # True (Fark toleranstan küçük mü?) # Veya 'decimal' modülü gibi daha hassas araçlar kullanılır. from decimal import Decimal sonuc_decimal = Decimal('0.1') + Decimal('0.1') + Decimal('0.1') print(sonuc_decimal) # 0.3 (Doğru sonuç) print(sonuc_decimal == Decimal('0.3')) # True
Finansal hesaplamalar gibi yüksek hassasiyet gerektiren durumlarda float yerine Decimal modülünü kullanmak daha güvenlidir.
İşlemler: int’lerde olduğu gibi standart aritmetik işlemler float’lar üzerinde de yapılabilir. Bir int ile bir float işleme girdiğinde sonuç genellikle float olur.
x = 5.0 y = 2 print(x + y) # 7.0 (float) print(x * y) # 10.0 (float) print(x / y) # 2.5 (float) print(x // y) # 2.0 (float - tam bölme bile sonucu float yapar) print(x % y) # 1.0 (float) print(x ** y) # 25.0 (float)
Özel Değerler: float tipi ayrıca sonsuzluk (float(‘inf’), float(‘-inf’)) ve “Sayı Değil” (float(‘nan’) — Not a Number) gibi özel değerleri de temsil edebilir. Bu değerler genellikle hatalı matematiksel işlemler sonucunda ortaya çıkar (örn: sıfıra bölme).
pozitif_sonsuz = float('inf') negatif_sonsuz = float('-inf') sayi_degil = float('nan') print(pozitif_sonsuz, negatif_sonsuz, sayi_degil) print(10 / 0.0) # ZeroDivisionError vermez, inf döner (bazı durumlarda) # print(0 / 0.0) # nan dönebilir (tanımsız)
Kullanım Alanları: Ölçümler (ağırlık, uzunluk, sıcaklık), bilimsel hesaplamalar, finansal veriler (hassasiyet konusuna dikkat ederek), grafikler, yüzdeler gibi ondalık değer gerektiren durumlar.
Bölüm 2: Metin Veri Tipi (str)

Metinler, programlamada en sık karşılaşılan veri türlerinden biridir. Kullanıcı adları, mesajlar, dosya içerikleri, web sayfası kodları gibi birçok bilgi metin olarak temsil edilir. Python’da metinler str (string) veri tipi ile ifade edilir.

Tanım: Karakter dizileridir. Bir string, sıralı bir karakterler topluluğudur.
Oluşturma: Tek tırnak (‘…’), çift tırnak (“…”) veya üçlü tırnak (‘’’…’’’ veya “””…”””) içine alınarak oluşturulur. Üçlü tırnaklar, birden fazla satıra yayılan string’ler oluşturmak için veya docstring’ler (belgelendirme metinleri) için kullanılır.
isim = 'Ahmet' mesaj = "Merhaba Dünya!" uzun_metin = """Bu metin birden fazla satırdan oluşmaktadır.""" html_kod = '''

Başlık

Mantıksal değerler, programlamada karar verme ve akış kontrolü için temeldir. Bir durumun doğru mu yanlış mı olduğunu ifade etmek için kullanılırlar.

Tanım: Sadece iki değeri alabilen bir veri tipidir: True (Doğru) ve False (Yanlış). George Boole’un mantık cebirine dayanır. Python’da True ve False büyük harfle başlayan anahtar kelimelerdir.
Oluşturma: Doğrudan True veya False yazılarak veya karşılaştırma (==, !=, >, <, >=, <=) ve mantıksal (and, or, not) operatörlerin sonuçları olarak elde edilir.
is_active = True is_logged_in = False print(type(is_active)) # x = 10 y = 5 is_greater = x > y # True (10, 5'ten büyük mü?) is_equal = (x == y * 2) # True (10, 5*2'ye eşit mi?) print(f"x > y sonucu: {is_greater}") print(f"x == y * 2 sonucu: {is_equal}")
Özellikler:
Karşılaştırma ve Mantıksal Operatörler: bool değerleri genellikle if, while gibi kontrol yapılarında koşulları değerlendirmek için kullanılır. Mantıksal operatörler (and, or, not) boolean değerler üzerinde işlem yapar:
A and B: Her ikisi de True ise True, aksi halde False.
A or B: En az biri True ise True, aksi halde False.
not A: A True ise False, A False ise True.
hava_guzel = True zaman_var = False piknige_gidilir_mi = hava_guzel and zaman_var # False (ikisi de True olmalı) evde_kalinir_mi = not hava_guzel or not zaman_var # True (biri False ise veya ikisi de False ise) print(f"Pikniğe gidilir mi? {piknige_gidilir_mi}") print(f"Evde kalınır mı? {evde_kalinir_mi}")
Doğruluk Değeri (Truthiness): Python’da sadece bool tipinin değil, diğer veri tiplerinin de mantıksal bir bağlamda (örneğin bir if koşulunda) değerlendirildiğinde bir doğruluk değeri vardır. Genel kurallar şunlardır:
Yanlış (False) kabul edilenler:
False
None (Özel bir değer, yokluk anlamına gelir)
Sayısal tiplerde sıfır (0, 0.0)
Boş koleksiyonlar (“”, [], (), {}, set())
Doğru (True) kabul edilenler: Yukarıdakiler dışındaki her şey.
if 0: print("Bu çalışmaz (0 False kabul edilir)") if 10: print("Bu çalışır (0 dışındaki sayılar True kabul edilir)") if "": print("Bu çalışmaz (boş string False kabul edilir)") if "Merhaba": print("Bu çalışır (boş olmayan string True kabul edilir)") if []: print("Bu çalışmaz (boş liste False kabul edilir)") if [1, 2]: print("Bu çalışır (boş olmayan liste True kabul edilir)") if None: print("Bu çalışmaz (None False kabul edilir)")
Bu özellik, kodda sıklıkla kısa kontroller yapmak için kullanılır: if my_list: (liste boş değilse) veya if user_input: (kullanıcı bir girdi verdiyse).
bool Aslında int Alt Sınıfıdır: İlginç bir detay olarak, Python’da bool aslında int’in bir alt sınıfıdır. True, 1 değerine; False, 0 değerine karşılık gelir. Bu nedenle matematiksel işlemlerde kullanılabilirler (ancak bu genellikle kafa karıştırıcı olduğu için önerilmez).
print(True + True) # 2 (1 + 1) print(False * 5) # 0 (0 * 5) print(int(True)) # 1 print(int(False)) # 0
Kullanım Alanları: Koşullu ifadeler (if/elif/else), döngü kontrolü (while koşulları), durum bayrakları (flags), fonksiyonlardan başarı/başarısızlık durumu döndürme.
Bölüm 4: Koleksiyon Veri Tipleri (list, tuple, dict, set)

Şimdiye kadar tek bir değeri temsil eden temel (skalar) veri tiplerini gördük. Ancak çoğu zaman birden fazla değeri bir arada gruplama ihtiyacı duyarız. Python, bu amaçla kullanılan güçlü koleksiyon veri tipleri sunar: list, tuple, dict ve set.

4.1. list (Listeler)

Tanım: Sıralı ve değiştirilebilir (mutable) öğeler koleksiyonudur. Farklı veri tiplerinden öğeleri bir arada tutabilir.
Oluşturma: Köşeli parantezler [] içine öğeler virgülle ayrılarak yazılır. Boş bir liste [] veya list() ile oluşturulur.
sayilar = [1, 2, 3, 4, 5] meyveler = ["elma", "armut", "çilek"] karisik_liste = [10, "Merhaba", 3.14, True, ["iç", "liste"]] bos_liste = [] bos_liste_2 = list()
Özellikler:
Sıralı (Ordered): Öğeler eklendikleri sırayla tutulur ve bu sıra korunur. Her öğenin belirli bir indisi (pozisyonu) vardır (0'dan başlar).
Değiştirilebilir (Mutable): Oluşturulduktan sonra öğeleri eklenebilir, silinebilir veya değiştirilebilir. Bu, listelerin en önemli özelliğidir.
Farklı Tipler İçerebilir: Bir liste içinde int, float, str, bool ve hatta başka listeler gibi farklı veri tiplerinden öğeler bulunabilir.
İndisleme ve Dilimleme: String’lerde olduğu gibi, indis kullanarak tek bir öğeye erişilebilir (liste[indis]) veya dilimleme kullanarak listenin bir alt bölümü alınabilir (liste[baslangic:bitis:adim]). Dilimleme yeni bir liste döndürür.
rakamlar = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] print(rakamlar[0]) # 0 (İlk öğe) print(rakamlar[-1]) # 9 (Son öğe) print(rakamlar[2:5]) # 2, 3, 4 print(rakamlar[:3]) # 0, 1, 2 print(rakamlar[::2]) # 0, 2, 4, 6, 8 print(rakamlar[::-1]) # 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
Öğe Değiştirme: İndis kullanarak belirli bir pozisyondaki öğe güncellenebilir.
renkler = ["kırmızı", "yeşil", "mavi"] renkler[1] = "sarı" # 'yeşil' yerine 'sarı' geldi print(renkler) # ['kırmızı', 'sarı', 'mavi']
Metotlar: Listelerin içeriğini değiştirmek veya bilgi almak için birçok metodu vardır:
append(oge): Listenin sonuna bir öğe ekler.
insert(indis, oge): Belirtilen indise bir öğe ekler, diğer öğeleri sağa kaydırır.
extend(diger_liste): Başka bir listenin (veya yinelenebilir nesnenin) tüm öğelerini mevcut listenin sonuna ekler. + operatörü de benzer işi yapar ancak yeni liste oluşturur.
remove(oge): Listede belirtilen değere sahip ilk öğeyi siler. Öğeyi bulamazsa ValueError verir.
pop(indis=-1): Belirtilen indisteki öğeyi listeden siler ve döndürür. İndis verilmezse son öğeyi siler ve döndürür.
clear(): Listenin tüm öğelerini siler, boş hale getirir.
index(oge): Belirtilen değere sahip ilk öğenin indisini döner. Bulamazsa ValueError verir.
count(oge): Listede belirtilen değerden kaç tane olduğunu sayar.
sort(): Listeyi yerinde (in-place) sıralar (varsayılan olarak küçükten büyüğe veya alfabetik). Orijinal listeyi değiştirir. reverse=True argümanı ile tersten sıralanabilir.
reverse(): Listenin sırasını yerinde tersine çevirir.
copy(): Listenin sığ bir kopyasını (shallow copy) oluşturur.
my_list = [1, 5, 2] my_list.append(4) # my_list = [1, 5, 2, 4] my_list.insert(1, 99) # my_list = [1, 99, 5, 2, 4] my_list.extend([0, 0]) # my_list = [1, 99, 5, 2, 4, 0, 0] my_list.remove(5) # my_list = [1, 99, 2, 4, 0, 0] popped_item = my_list.pop(1) # popped_item = 99, my_list = [1, 2, 4, 0, 0] print(f"Sayılan 0: {my_list.count(0)}") # 2 my_list.sort() # my_list = 0, 0, 1, 2, 4 my_list.reverse() # my_list = 4, 2, 1, 0, 0 print(my_list)
Diğer İşlemler: len(liste) ile öğe sayısı öğrenilebilir, in operatörü ile bir öğenin listede olup olmadığı kontrol edilebilir (oge in liste).
Kullanım Alanları: Öğelerin sırasının önemli olduğu ve içeriğin zamanla değişebileceği durumlar. Örneğin, kullanıcıdan alınan bir dizi girdi, bir alışveriş sepetindeki ürünler, yapılacaklar listesi, bir veritabanı sorgusundan dönen kayıtlar. Python’da en sık kullanılan koleksiyon tipidir.
4.2. tuple (Demetler)

Tanım: Sıralı ve değiştirilemez (immutable) öğeler koleksiyonudur. Listelere çok benzerler ancak oluşturulduktan sonra içerikleri değiştirilemez.
Oluşturma: Normal parantezler () içine öğeler virgülle ayrılarak yazılır. Tek elemanlı bir tuple oluştururken elemandan sonra virgül koymak gerekir, aksi halde Python onu normal bir parantezli ifade olarak algılar. Boş tuple () veya tuple() ile oluşturulur.
koordinatlar = (10.5, 25.0) rgb_renk = (255, 0, 0) # Kırmızı tek_ogeli_tuple = (99,) # Sondaki virgüle dikkat! tek_ogeli_degil = (99) # Bu bir tuple değil, int tipinde 99'dur. bos_tuple = () bos_tuple_2 = tuple()
Özellikler:
Sıralı (Ordered): Listeler gibi, öğelerin sırası korunur ve indisle erişim mümkündür.
Değiştirilemez (Immutable): Oluşturulduktan sonra öğeleri eklenemez, silinemez veya değiştirilemez. Bu, tuple’ların en temel özelliğidir ve onları listelerden ayırır.
my_tuple = (1, 2, 3) print(my_tuple[0]) # 1 # my_tuple[0] = 99 # Bu satır TypeError: 'tuple' object does not support item assignment hatası verir. # my_tuple.append(4) # Hata! 'tuple' nesnesinin 'append' metodu yoktur
Önemli Not: Eğer bir tuple içinde değiştirilebilir bir nesne (örneğin bir liste) varsa, o nesnenin içeriği değiştirilebilir, ancak tuple’ın o pozisyonundaki referansı (yani listenin kendisi) değiştirilemez.
karma_tuple = (1, 2, ["a", "b"]) print(karma_tuple) # (1, 2, ['a', 'b']) karma_tuple[2].append("c") # Tuple içindeki listenin içeriğini değiştiriyoruz. Bu MÜMKÜN! print(karma_tuple) # (1, 2, ['a', 'b', 'c']) # karma_tuple[2] = ["x", "y"] # Hata! Tuple'ın elemanını başka bir listeyle değiştiremeyiz.
Farklı Tipler İçerebilir: Listeler gibi, farklı veri tiplerinden öğeler içerebilir.
İndisleme ve Dilimleme: Listelerle aynı şekilde çalışır. Sonuçlar genellikle yeni bir tuple (dilimleme) veya tek bir öğe (indisleme) olur.
Metotlar: Değiştirilemez oldukları için append, insert, remove, pop, sort, reverse gibi listelerde bulunan değiştirici metotlara sahip değillerdir. Sadece count(oge) ve index(oge) gibi bilgi veren metotları vardır.
Tuple Packing ve Unpacking: Python, bir dizi değeri virgüle ayırarak otomatik olarak bir tuple oluşturmanıza (packing) ve bir tuple’daki değerleri ayrı değişkenlere atamanıza (unpacking) olanak tanır.

Packing nokta = 10, 20, 30 # Otomatik olarak (10, 20, 30) tuple'ı oluşur print(nokta) # (10, 20, 30) print(type(nokta)) # # Unpacking x, y, z = nokta # Tuple'daki değerler sırayla değişkenlere atanır print(f"x={x}, y={y}, z={z}") # x=10, y=20, z=30 # Değişken değerlerini takas etmek için sıkça kullanılır: a = 5 b = 10 a, b = b, a # a, b = (10, 5) -> a=10, b=5 (tuple unpacking sayesinde) print(f"a={a}, b={b}")

Performans: Genellikle aynı boyuttaki listelere göre biraz daha az bellek kullanırlar ve üzerlerinde iterasyon yapmak (döngüyle gezmek) biraz daha hızlı olabilir (ancak bu fark çoğu durumda ihmal edilebilir düzeydedir).
Kullanım Alanları:
İçeriğinin değişmemesi gereken sabit veri koleksiyonları (örneğin, haftanın günleri, ay adları, koordinatlar, RGB renk kodları).
Fonksiyonlardan birden fazla değer döndürmek (fonksiyonlar aslında tek bir tuple döndürür, bu sonra unpack edilir).
Sözlük anahtarı (dictionary key) olarak kullanılabilirler (çünkü immutable’dırlar, listeler key olamaz).
Veri bütünlüğünü korumak istediğiniz durumlar (yanlışlıkla değiştirilmesini istemediğiniz veri setleri).
4.3. dict (Dictionaries — Sözlükler)

Tanım: Anahtar-değer (key-value) çiftlerinden oluşan, sırasız (Python 3.6 ve öncesi) veya eklenme sırasına göre sıralı (Python 3.7 ve sonrası) ve değiştirilebilir (mutable) bir koleksiyondur. Her anahtar benzersiz olmalı ve değiştirilemez (immutable) bir tipte olmalıdır (string, int, float, tuple gibi). Değerler ise herhangi bir tipte olabilir ve tekrarlanabilir.
Oluşturma: Süslü parantezler {} içine anahtar: deger çiftleri virgülle ayrılarak yazılır. Boş bir sözlük {} veya dict() ile oluşturulur.
ogrenci = { "ad": "Ali", "soyad": "Veli", "yas": 20, "bolum": "Bilgisayar Mühendisliği", "notlar": [85, 90, 78] # Değer bir liste olabilir } telefon_rehberi = { "Ahmet": "555-1234", "Ayşe": "555-5678", ( "Can", "Yılmaz" ): "555-9900" # Anahtar bir tuple olabilir } bos_sozluk = {} bos_sozluk_2 = dict()
Özellikler:
Anahtar-Değer Eşlemesi: Sözlüklerin temel amacı, bir anahtar kullanarak ilişkili değere hızlıca erişmektir. Listelerdeki gibi sayısal indisler yerine, anlamlı anahtarlar (genellikle string’ler) kullanılır.
Sıra:
Python 3.6 ve öncesi: Sözlükler sırasızdır. Öğelerin eklenme sırası korunmaz ve iterasyon sırası garanti edilmez.
Python 3.7 ve sonrası: Sözlükler eklenme sırasını korur. Öğeler üzerinde iterasyon yapıldığında, eklendikleri sırayla gelirler. Bu, önemli bir geliştirmedir.
Değiştirilebilir (Mutable): Oluşturulduktan sonra yeni anahtar-değer çiftleri eklenebilir, mevcut anahtarların değerleri güncellenebilir veya çiftler silinebilir.
Benzersiz Anahtarlar (Unique Keys): Bir sözlük içinde her anahtar sadece bir kez bulunabilir. Aynı anahtarla yeni bir değer eklenmeye çalışılırsa, eski değerin üzerine yazılır.
Değiştirilemez Anahtarlar (Immutable Keys): Anahtarlar int, float, str, bool, tuple gibi değiştirilemez tiplerden olmalıdır. Listeler veya diğer sözlükler gibi değiştirilebilir tipler anahtar olarak kullanılamaz (çünkü hash değerleri değişebilir). Değerler ise herhangi bir tipte olabilir.
Değere Erişim: Bir anahtara karşılık gelen değere köşeli parantezler sozluk[anahtar] kullanılarak erişilir. Eğer anahtar sözlükte yoksa KeyError hatası alınır.
print(ogrenci["ad"]) # Ali print(ogrenci["notlar"]) # [85, 90, 78] # print(ogrenci["adres"]) # KeyError: 'adres'
get() Metodu ile Güvenli Erişim: get(anahtar, varsayilan=None) metodu, anahtar varsa değerini, yoksa None (veya belirtilen varsayılan değeri) döndürür. Bu, KeyError almaktan kaçınmak için kullanışlıdır.
print(ogrenci.get("ad")) # Ali print(ogrenci.get("adres")) # None (Hata vermez) print(ogrenci.get("adres", "Bilinmiyor")) # Bilinmiyor (Varsayılan değer)
Ekleme ve Güncelleme: Yeni bir anahtar-değer çifti eklemek veya var olanı güncellemek için sozluk[yeni_anahtar] = yeni_deger kullanılır. update(diger_sozluk) metodu ise başka bir sözlüğün çiftlerini mevcut sözlüğe ekler veya günceller.
ogrenci["sehir"] = "İstanbul" # Yeni çift ekleme ogrenci["yas"] = 21 # Var olan değeri güncelleme print(ogrenci) ek_bilgi = {"universite": "Boğaziçi", "aktif_mi": True} ogrenci.update(ek_bilgi) print(ogrenci)
Silme:
pop(anahtar, varsayilan=None): Belirtilen anahtara sahip çifti siler ve değerini döndürür. Anahtar yoksa ve varsayılan değer belirtilmemişse KeyError verir.
popitem(): (Python 3.7+ için) Son eklenen anahtar-değer çiftini siler ve (anahtar, deger) şeklinde bir tuple olarak döndürür. (3.6 öncesi rastgele bir çifti siler).
del sozluk[anahtar]: Belirtilen anahtara sahip çifti siler. Anahtar yoksa KeyError verir.
clear(): Sözlükteki tüm çiftleri siler.
rehber = {"Ali": "111", "Veli": "222", "Ayşe": "333"} veli_no = rehber.pop("Veli") # veli_no = "222", rehber = {'Ali': '111', 'Ayşe': '333'} print(f"Silinen numara: {veli_no}") son_eklenen = rehber.popitem() # son_eklenen = ('Ayşe', '333'), rehber = {'Ali': '111'} (3.7+ varsayımıyla) print(f"Son silinen: {son_eklenen}") del rehber["Ali"] # rehber = {} print(rehber)
Anahtarları, Değerleri, Çiftleri Alma:
keys(): Sözlükteki tüm anahtarları içeren bir “view” nesnesi döndürür.
values(): Sözlükteki tüm değerleri içeren bir “view” nesnesi döndürür.
items(): Sözlükteki tüm (anahtar, deger) çiftlerini (tuple olarak) içeren bir “view” nesnesi döndürür.
Bu “view” nesneleri dinamiktir, yani sözlük değişirse view de değişir. Genellikle list() ile listeye çevrilerek veya doğrudan döngülerde kullanılırlar.
urun_fiyatlari = {"elma": 5, "armut": 7, "muz": 10} print(list(urun_fiyatlari.keys())) # ['elma', 'armut', 'muz'] print(list(urun_fiyatlari.values())) # [5, 7, 10] print(list(urun_fiyatlari.items())) # [('elma', 5), ('armut', 7), ('muz', 10)] # Döngüyle kullanımları for anahtar in urun_fiyatlari.keys(): print(f"Ürün: {anahtar}") for deger in urun_fiyatlari.values(): print(f"Fiyat: {deger}") for urun, fiyat in urun_fiyatlari.items(): # En yaygın kullanım (tuple unpacking) print(f"{urun.capitalize()} fiyatı: {fiyat} TL")
Diğer İşlemler: len(sozluk) ile çift sayısı öğrenilebilir, anahtar in sozluk ile bir anahtarın sözlükte olup olmadığı kontrol edilebilir (değerlerde arama yapmaz).
Kullanım Alanları: İlişkili verileri bir arada tutmak (bir kişi hakkındaki bilgiler, bir ürünün özellikleri), verileri etiketlemek, JSON gibi veri formatlarını temsil etmek, hızlı arama (lookup) gereken durumlar (anahtar ile değere hızlı erişim), sayaçlar oluşturmak (örneğin, bir metindeki kelime frekanslarını saymak).
4.4. set (Kümeler)

Tanım: Sırasız, değiştirilebilir (mutable) ve benzersiz (unique) öğeler koleksiyonudur. Matematikteki küme kavramına benzer şekilde çalışır.
Oluşturma: Süslü parantezler {} içine öğeler virgülle ayrılarak yazılır. Ancak dikkat: Boş bir küme oluşturmak için {} kullanılmaz (bu boş bir sözlük oluşturur), bunun yerine set() fonksiyonu kullanılır.
tekil_sayilar = {1, 2, 3, 4, 5, 5, 4} # Tekrarlanan değerler otomatik olarak atılır print(tekil_sayilar) # {1, 2, 3, 4, 5} (Sıra garanti değil) harfler = set("merhaba") # String'deki benzersiz harflerden küme oluşturur print(harfler) # {'b', 'r', 'h', 'm', 'e', 'a'} (Sıra garanti değil) bos_kume = set() # bos_kume_yanlis = {} # Bu bir SÖZLÜK oluşturur!
Özellikler:
Sırasız (Unordered): Öğelerin belirli bir sırası yoktur ve indisle erişim desteklenmez (kume[0] gibi bir kullanım hata verir). Üzerinde iterasyon yapıldığında öğelerin hangi sırada geleceği garanti edilmez (ancak genellikle tutarlı bir sıra izler).
Benzersiz Öğeler (Unique Elements): Bir küme içinde her öğe sadece bir kez bulunabilir. Aynı öğeyi tekrar eklemeye çalışmak kümenin içeriğini değiştirmez. Bu, kümelerin en önemli özelliğidir.
Değiştirilebilir (Mutable): Oluşturulduktan sonra öğeler eklenebilir veya silinebilir.
Değiştirilemez Öğeler Gerektirir: Kümelerdeki öğeler, sözlük anahtarları gibi, değiştirilemez (immutable) tiplerden olmalıdır (int, float, str, bool, tuple). Listeler veya diğer kümeler bir kümenin öğesi olamaz.
Küme İşlemleri: Kümelerin gücü, matematiksel küme operasyonlarını kolayca yapabilmelerinden gelir:
Birleşim (Union): kume1 | kume2 veya kume1.union(kume2) — İki kümedeki tüm benzersiz öğeleri içeren yeni bir küme döndürür.
Kesişim (Intersection): kume1 & kume2 veya kume1.intersection(kume2) — Her iki kümede de ortak olan öğeleri içeren yeni bir küme döndürür.
Fark (Difference): kume1 — kume2 veya kume1.difference(kume2) — Birinci kümede olup ikinci kümede olmayan öğeleri içeren yeni bir küme döndürür.
Simetrik Fark (Symmetric Difference): kume1 ^ kume2 veya kume1.symmetric_difference(kume2) — Sadece bir kümede bulunan (ortak olmayan) tüm öğeleri içeren yeni bir küme döndürür.
set_a = {1, 2, 3, 4} set_b = {3, 4, 5, 6} birlesim = set_a | set_b # {1, 2, 3, 4, 5, 6} kesisim = set_a & set_b # {3, 4} fark_a_b = set_a - set_b # {1, 2} (A'da olup B'de olmayanlar) fark_b_a = set_b - set_a # {5, 6} (B'de olup A'da olmayanlar) simetrik_fark = set_a ^ set_b # {1, 2, 5, 6} (Ortak olmayanlar) print(f"Birleşim: {birlesim}") print(f"Kesişim: {kesisim}") print(f"Fark (A-B): {fark_a_b}") print(f"Fark (B-A): {fark_b_a}") print(f"Simetrik Fark: {simetrik_fark}")
Metotlar: Öğeleri yönetmek ve ilişkileri kontrol etmek için metotlar bulunur:
add(oge): Kümeye bir öğe ekler (eğer zaten yoksa).
update(diger_kume): Başka bir kümenin (veya yinelenebilir nesnenin) tüm öğelerini mevcut kümeye ekler.
remove(oge): Belirtilen öğeyi kümeden siler. Öğeyi bulamazsa KeyError verir.
discard(oge): Belirtilen öğeyi kümeden siler. Öğeyi bulamazsa hata vermez.
pop(): Kümeden rastgele bir öğeyi siler ve döndürür. Küme boşsa KeyError verir.
clear(): Kümedeki tüm öğeleri siler.
issubset(diger_kume): Mevcut küme, diğer kümenin alt kümesi ise True döner (<= operatörü de kullanılabilir).
issuperset(diger_kume): Mevcut küme, diğer kümenin üst kümesi ise True döner (>= operatörü de kullanılabilir).
isdisjoint(diger_kume): İki kümenin hiç ortak elemanı yoksa True döner.
my_set = {10, 20} my_set.add(30) # {10, 20, 30} my_set.add(20) # {10, 20, 30} (Değişiklik olmaz) my_set.update({40, 50, 10}) # {10, 20, 30, 40, 50} my_set.remove(10) # {20, 30, 40, 50} my_set.discard(60) # Hata vermez, {20, 30, 40, 50} # my_set.remove(60) # KeyError verir! popped = my_set.pop() # Rastgele bir elemanı (örn: 40) siler, popped = 40 print(f"Pop edilen: {popped}, Kalan: {my_set}") set1 = {1, 2} set2 = {1, 2, 3} set3 = {4, 5} print(set1.issubset(set2)) # True print(set2.issuperset(set1)) # True print(set1.isdisjoint(set3)) # True
Diğer İşlemler: len(kume) ile öğe sayısı öğrenilebilir, oge in kume ile bir öğenin kümede olup olmadığı çok hızlı bir şekilde kontrol edilebilir (kümeler üyelik testi için optimize edilmiştir).
Kullanım Alanları:
Bir koleksiyondaki yinelenen öğeleri kaldırmak (örneğin, bir listeden benzersiz öğeleri almak için: unique_list = list(set(original_list))).
Üyelik testi (bir öğenin bir grupta olup olmadığını hızlıca kontrol etmek).
Matematiksel küme operasyonları (birleşim, kesişim, fark vb.) gerektiren algoritmalar.
Bölüm 5: Tip Kontrolü ve Dönüşümü

Python dinamik tipli olsa da, bazen bir değişkenin veya değerin tipini bilmek veya bir tipi diğerine dönüştürmek gerekebilir.

Tip Kontrolü:
type(nesne): Bir nesnenin tam tipini (sınıfını) döndürür.
x = 10 y = "hello" z = [1, 2] print(type(x)) # print(type(y)) # print(type(z)) #
isinstance(nesne, tip): Bir nesnenin belirtilen tipte (veya o tipin alt sınıflarından birinde) olup olmadığını kontrol eder ve True veya False döndürür. Genellikle type() ile doğrudan karşılaştırmaktan daha esnek ve tercih edilen bir yöntemdir. Birden fazla tip kontrolü için ikinci argüman olarak tiplerden oluşan bir tuple verilebilir.
print(isinstance(x, int)) # True print(isinstance(y, str)) # True print(isinstance(z, list)) # True print(isinstance(x, str)) # False print(isinstance(z, (list, tuple))) # True (Liste veya tuple mı?) print(isinstance(True, int)) # True (Çünkü bool, int'in alt sınıfıdır) print(type(True) == int) # False (Doğrudan tipler eşit değil)
Tip Dönüşümü (Type Casting/Conversion): Bir veri tipini başka bir veri tipine dönüştürmek için yerleşik fonksiyonlar kullanılır. Dönüşüm her zaman mümkün olmayabilir ve bazen ValueError gibi hatalara yol açabilir.
int(x): x’i tam sayıya dönüştürür (float ise ondalık kısmı atar, string ise sayısal karakterlerden oluşmalıdır).
float(x): x’i ondalıklı sayıya dönüştürür (int veya sayısal string olabilir).
str(x): x’i string temsiline dönüştürür (hemen hemen her tip için çalışır).
bool(x): x’i boolean değere dönüştürür (“Truthiness” kurallarına göre).
list(x): Yinelenebilir (iterable) bir nesneyi (string, tuple, set, dict keys/values/items) listeye dönüştürür.
tuple(x): Yinelenebilir bir nesneyi tuple’a dönüştürür.
set(x): Yinelenebilir bir nesneyi kümeye dönüştürür (yinelenenler atılır).
dict(x): Belirli formatlardaki (örneğin, [(anahtar1, deger1), (anahtar2, deger2)] gibi çiftlerden oluşan liste/tuple) yinelenebilir nesneleri sözlüğe dönüştürür.
num_str = "123" num_int = int(num_str) # 123 (int) num_float = float(num_int) # 123.0 (float) num_str_again = str(num_float) # "123.0" (str) print(f"{num_int} ({type(num_int)}), {num_float} ({type(num_float)}), {num_str_again} ({type(num_str_again)})") val1 = 0 val2 = "hello" print(bool(val1)) # False print(bool(val2)) # True my_tuple = (1, 2, 2, 3) my_list = list(my_tuple) # [1, 2, 2, 3] my_set = set(my_list) # {1, 2, 3} (Benzersiz öğeler) print(my_list, my_set) # Hatalı dönüşüm denemesi: try: int("merhaba") except ValueError as e: print(f"Hata: {e}") # Hata: invalid literal for int() with base 10: 'merhaba'
Bölüm 6: Doğru Veri Tipini Seçmek

Programlamada verimlilik ve doğruluk için doğru veri tipini seçmek önemlidir. Karar verirken şu soruları göz önünde bulundurun:

Tek bir değer mi, yoksa bir koleksiyon mu? (int, float, str, bool vs. list, tuple, dict, set)

Koleksiyon ise, öğelerin sırası önemli mi?

Evet ise: list veya tuple.
Hayır ise: set veya dict.
Koleksiyonun içeriği program çalışırken değişecek mi (Mutable mi)?

Evet ise: list, dict, set.
Hayır ise: tuple (veya string).
Koleksiyondaki öğeler benzersiz (unique) olmalı mı?

Evet ise: set.
Hayır ise: list, tuple.
Veriye anahtar (key) kullanarak mı erişmek gerekiyor?

Evet ise: dict.
Hayır ise (sıra numarası/indis yeterliyse): list, tuple.
Özet Tablo:

Veri TipiTanımSıralı?Değiştirilebilir?Benzersiz Öğeler?Erişim YöntemiTemel KullanımintTam Sayı — — Sayma, indisleme, tam sayı hesaplamalarıfloatOndalıklı Sayı — — Ölçümler, hassas hesaplamalar (dikkatli)strKarakter DizisiEvetHayır (Immutable)-İndis, DilimMetin işleme, kullanıcı arayüzleri, dosyalarboolMantıksal (True/False) — — Koşullar, durum kontrolülistSıralı KoleksiyonEvetEvet (Mutable)Hayırİndis, DilimSırası önemli, değişebilen öğe gruplarıtupleSıralı KoleksiyonEvetHayır (Immutable)Hayırİndis, DilimSırası önemli, değişmeyen öğe grupları, dict keydictAnahtar-Değer Çiftleri3.7+ EvetEvet (Mutable)Evet (Anahtarlar)Anahtarİlişkili veri eşleme, hızlı arama (lookup)setSırasız Benzersiz KoleksiyonHayırEvet (Mutable)Evet (Öğeler)Üyelik TestiBenzersizlik sağlama, küme işlemleri, hızlı üyelik

Sonuç

Python’un veri tipleri, dilin esnekliğinin ve gücünün temelini oluşturur. int, float, str ve bool gibi temel tipler, tekil verileri temsil ederken; list, tuple, dict ve set gibi koleksiyon tipleri, birden fazla veriyi anlamlı şekillerde bir araya getirmemizi sağlar. Her bir veri tipinin kendine özgü özellikleri (sıra, değiştirilebilirlik, benzersizlik) ve metotları vardır.

Python’un dinamik tipli yapısı kod yazmayı kolaylaştırsa da, verimli ve hatasız kod yazmak için bu veri tiplerini, özelliklerini ve ne zaman hangisini kullanmak gerektiğini iyi anlamak kritik öneme sahiptir. Verinin doğasına ve yapılması gereken işlemlere en uygun veri tipini seçmek, programınızın performansını, okunabilirliğini ve doğruluğunu doğrudan etkiler. Bu temel yapı taşlarını sağlam bir şekilde kavradıktan sonra, Python ile daha karmaşık ve güçlü uygulamalar geliştirmek için sağlam bir zemine sahip olursunuz.

Abdulkadir Güngör - Kişisel WebSite
Abdulkadir Güngör - Kişisel WebSite
Abdulkadir Güngör - Özgeçmiş
Github
Github
Linkedin