Nesne Tabanlı Programlama

6 - Sözlükler, Kümeler ve Yerleşik Fonksiyonlar

Emre Can Yılmaz
[email protected]

Ondokuz Mayıs Üniversitesi

2024

Sözlükler (Dictionaries): Anahtar-Değer Çiftleri

  • Anahtar-değer (key-value) çiftleri şeklinde veri saklarlar.
  • Değiştirilebilir (Mutable): Elemanlar eklenebilir, silinebilir veya değiştirilebilir.
  • Süslü parantez ({}) ile tanımlanırlar.

Örnekler

telefon_rehberi = {"Ahmet": "555-1234", "Mehmet": "555-5678"}
ürünler = {"kalem": 2.50, "defter": 5.00, "silgi": 1.00}
ogrenci = {"ad": "Ahmet", "soyad": "Yılmaz", "yas": 20}

Sözlük Elemanlarına Erişme

  • Anahtarlar kullanılarak elemanlara erişebiliriz.
ogrenci = {"ad": "Ahmet", "soyad": "Yılmaz", "yas": 20}

print(ogrenci["ad"]) # Çıktı: Ahmet
print(ogrenci["soyad"]) # Çıktı: Yılmaz
print(ogrenci["yas"]) # Çıktı: 20

Sözlüklerde Eleman Ekleme, Değiştirme ve Silme

  • Yeni eleman ekleme:
ogrenci["bolum"] = "Bilgisayar Mühendisliği"
print(ogrenci)
# Çıktı: {'ad': 'Ahmet', 'soyad': 'Yılmaz', 'yas': 20, 'bolum': 'Bilgisayar Mühendisliği'}
  • Varolan bir elemanın değerini değiştirme:
ogrenci["yas"] = 21
print(ogrenci)
# Çıktı: {'ad': 'Ahmet', 'soyad': 'Yılmaz', 'yas': 21, 'bolum': 'Bilgisayar Mühendisliği'}
  • Bir elemanı silme:
del ogrenci["soyad"]
print(ogrenci)
# Çıktı: {'ad': 'Ahmet', 'yas': 21, 'bolum': 'Bilgisayar Mühendisliği'}

Sözlük Metotları

  • keys(): Sözlükteki tüm anahtarları döndürür.
  • values(): Sözlükteki tüm değerleri döndürür.
  • items(): Sözlükteki tüm anahtar-değer çiftlerini döndürür.
ogrenci = {"ad": "Ahmet", "soyad": "Yılmaz", "yas": 20}

print(ogrenci.keys())
# Çıktı: dict_keys(['ad', 'soyad', 'yas'])
print(ogrenci.values())
# Çıktı: dict_values(['Ahmet', 'Yılmaz', 20])
print(ogrenci.items())
# Çıktı: dict_items([('ad', 'Ahmet'), ('soyad', 'Yılmaz'), ('yas', 20)])
  • get(anahtar, varsayılan_değer): Belirtilen anahtarın değerini döndürür. Anahtar yoksa, varsayılan değeri döndürür.
  • pop(anahtar, varsayılan_değer): Belirtilen anahtara karşılık gelen değeri sözlükten çıkarır ve döndürür. Anahtar yoksa, varsayılan değeri döndürür.
  • update(diger_sozluk): Sözlüğü, başka bir sözlükteki anahtar-değer çiftleriyle günceller.
print(ogrenci.get("bolum", "Bilgi Yok")) # Çıktı: Bilgi Yok
print(ogrenci.pop("yas", 0)) # Çıktı: 20
print(ogrenci) # Çıktı: {'ad': 'Ahmet', 'soyad': 'Yılmaz'}

ogrenci.update({"bolum": "Bilgisayar Mühendisliği", "not_ortalamasi": 3.5})
print(ogrenci)
# Çıktı: {'ad': 'Ahmet', 'soyad': 'Yılmaz', 'bolum': 'Bilgisayar Mühendisliği', 'not_ortalamasi': 3.5}
  • popitem(): Python 3.7 ve sonrasında son girilen öğeyi döner ve siler. Boş sözlükte KeyError hatası verir.
stok = {
    "kalem": 100,
    "defter": 50,
    "silgi": 75
    }
stok.popitem() # ('silgi', 75)
print(stok) # Çıktı: {'kalem': 100, 'defter': 50}
  • setdefault(): setdefault() metodu, bir sözlükte belirli bir anahtarı kontrol edip, bu anahtar mevcutsa ilgili değeri döner, yoksa sözlüğe bu anahtarı ekleyip ona bir varsayılan değer atar.
bilgiler = {"isim": "Ahmet", "yas": 30}
sonuc = bilgiler.setdefault("isim", "Mehmet")
print(sonuc)     # Çıktı: Ahmet
print(bilgiler)    # Çıktı: {"isim": "Ahmet", "yas": 30}

sonuc = bilgiler.setdefault("meslek", "Mühendis")
print(sonuc)       # Çıktı: Mühendis
print(bilgiler)   # Çıktı: {'isim': 'Ahmet', 'yas': 30, 'meslek': 'Mühendis'}
  • fromkeys(): Verilen bir iterable dan yeni bir sözlük oluşturmak için kullanılır.
anahtarlar = ['isim', 'yas', 'meslek']
sozluk = dict.fromkeys(anahtarlar)
print(sozluk) # Çıktı: {'isim': None, 'yas': None, 'meslek': None}
  • copy(): Sözlüğün yüzeysel (shallow) bir kopyasını oluşturur.
  • clear(): Verilen bir sözlüğü temizler.
user = {"isim": "Ahmet", "yas": 30}
user2 = user.copy()
print(user) # Çıktı: {'isim': 'Ahmet', 'yas': 30}
print(user2) # Çıktı: {'isim': 'Ahmet', 'yas': 30}

user.clear()
print(user) # Çıktı: {}
print(user2) # Çıktı: {'isim': 'Ahmet', 'yas': 30}

Dikkat: copy() ve Yüzeysel Kopyalama

copy() metodu yüzeysel (shallow) kopyalama yapar.

Eğer sözlük içinde liste gibi başka değiştirilebilir nesneler varsa, bu iç nesnelerin kopyası değil, referansı kopyalanır. Bu durumda, kopyalanan sözlükteki liste değiştiğinde orijinal sözlükteki liste de değişir.

data = {"id": 1, "notlar": [80, 90]}
data_copy = data.copy()

# Kopyalanan sözlükteki listeyi değiştirelim:
data_copy["notlar"].append(100)

# Orijinal sözlük de etkilendi!
print(data)       # Çıktı: {'id': 1, 'notlar': [80, 90, 100]}
print(data_copy)  # Çıktı: {'id': 1, 'notlar': [80, 90, 100]}
  • Tamamen bağımsız bir kopya için copy modülündeki copy.deepcopy() fonksiyonu gerekir.

Sözlüklerde Döngüler

  • Anahtarlar veya anahtar-değer çiftleri üzerinde döngü kullanabiliriz.
ogrenci = {"ad": "Ahmet", "soyad": "Yılmaz", "yas": 20}

for anahtar in ogrenci:
    print(anahtar, ":", ogrenci[anahtar])

for anahtar, deger in ogrenci.items():
    print(f"{anahtar}: {deger}")

Sözlüklerde in ve not in Operatörleri

  • in: Bir anahtarın sözlükte olup olmadığını kontrol eder.
  • not in: Bir anahtarın sözlükte olup olmadığını kontrol eder.
ogrenci = {"ad": "Ahmet", "soyad": "Yılmaz", "yas": 20}

print("ad" in ogrenci)     # Çıktı: True
print("bolum" in ogrenci)  # Çıktı: False
print("yas" not in ogrenci) # Çıktı: False

# Not: `in` operatörü, sözlüklerde sadece anahtarları kontrol eder.

Kümeler (Sets): Benzersiz Elemanlardan Oluşan Koleksiyonlar

  • Benzersiz: Her eleman sadece bir kez bulunabilir.
  • Süslü parantez ({}) ile tanımlanırlar veya set() fonksiyonu kullanılarak oluşturulabilirler.

Örnek

  • Tekrar Eden Kelimeleri Bulma: Bir metindeki tekrar eden kelimeleri bulmak için bir küme kullanabiliriz.
  • Kullanıcı İzinleri: Bir kullanıcının bir web sitesinde veya uygulamada sahip olduğu izinleri saklamak için bir küme kullanabiliriz.
meyveler = {"elma", "armut", "muz"}
sayilar = set([1, 2, 3, 4, 5])
  • Boş bir sözlük {} ile oluşturulur: bos_sozluk = {}
  • Boş bir küme oluşturmak için mutlaka set() fonksiyonu kullanılmalıdır: bos_kume = set()

Kümelerde in ve not in Operatörleri

  • in: Bir elemanın kümede olup olmadığını kontrol eder.
  • not in: Bir elemanın kümede olup olmadığını kontrol eder.
meyveler = {"elma", "armut", "muz"}

print("elma" in meyveler)   # Çıktı: True
print("kivi" in meyveler)   # Çıktı: False
print("üzüm" not in meyveler) # Çıktı: True

Küme Metotları

  • add(eleman): Kümeye yeni bir eleman ekler (zaten varsa, hiçbir şey yapmaz).
meyveler = {"elma", "armut", "muz"}
meyveler.add("kivi")
print(meyveler) # {'kivi', 'muz', 'armut', 'elma'} (Sıra farklı olabilir)

sayilar = {1, 2, 3}
sayilar.add(4)
print(sayilar) # Çıktı: {1, 2, 3, 4} (Sıra farklı olabilir)
  • remove(eleman): Belirtilen elemanı kümeden siler (yoksa, KeyError hatası verir).
meyveler = {"elma", "armut", "muz"}
meyveler.remove("kivi")
print(meyveler) # {'elma', 'muz', 'armut'}
meyveler.remove("kavun") # KeyError: 'kavun'
  • discard(eleman): Belirtilen elemanı kümeden siler (yoksa, hata vermez).
meyveler = {"elma", "armut", "muz"}
meyveler.discard("kivi")
print(meyveler) # {'elma', 'muz', 'armut'}
meyveler.discard("kavun")
  • union(diger_kume): İki kümenin birleşimini döndürür.
kume1 = {1, 2, 3}
kume2 = {3, 4, 5}
kume3 = kume1.union(kume2)
print(kume1) # {1, 2, 3}
print(kume2) # {3, 4, 5}
print(kume3) # {1, 2, 3, 4, 5}
  • intersection(diger_kume): İki kümenin kesişimini döndürür.
kume1 = {1, 2, 3}
kume2 = {3, 4, 5}
print(kume1.intersection(kume2)) # {3}
  • difference(diger_kume): İlk kümenin, ikinci kümede olmayan elemanlarını içeren bir küme döndürür.
kume1 = {1, 2, 3}
kume2 = {3, 4, 5}
print(kume1.difference(kume2)) # {1, 2}

Python’da Yerleşik Fonksiyonlar

  • Python’da yerleşik olarak bulunan birçok fonksiyon, veri yapılarını işlemek ve matematiksel işlemler yapmak gibi işlemleri oldukça kolaylaştırır.

  • Bu fonksiyonlardan bazıları liste, tuple gibi dizilerin elemanlarını toplama, sıralama, minimum veya maksimum değerlerini bulma gibi işlemleri sağlar.

  • sum(): Bir dizinin (liste, tuple gibi) sayısal elemanlarını toplar.
    • Parametre olarak başlangıç değeri verilebilir.
sayilar = [10, 20, 30, 40]
toplam = sum(sayilar)
toplam2 = sum(sayilar, 30)
print(toplam)  # Çıktı: 100
print(toplam2) # Çıktı: 130
  • max():
sayilar = [10, 20, 30, 40]
en_buyuk = max(sayilar)
print(en_buyuk)  # Çıktı: 40
print(max(3, 1, 5))  # Çıktı: 5
  • min():
sayilar = [10, 20, 30, 40]
en_kucuk = min(sayilar)
print(en_kucuk)      # Çıktı: 10
print(min(3, 1, 5))  # Çıktı: 1
  • len(): Bir iterable ın (liste, tuple, string vb.) eleman sayısını döndürür.
sayilar = [10, 20, 30, 40]
uzunluk = len(sayilar)
print(uzunluk)     # Çıktı: 4
kelime = "Python"
print(len(kelime)) # Çıktı: 6
  • sorted(): Bir diziyi sıralı bir şekilde döndürür. Orijinal diziyi değiştirmez.
sayilar = [30, 10, 50, 20, 40]
sirali_sayilar = sorted(sayilar)
print(sirali_sayilar)  # Çıktı: [10, 20, 30, 40, 50]
ters_sirali_sayilar = sorted(sayilar, reverse=True)
print(ters_sirali_sayilar)  # Çıktı: [50, 40, 30, 20, 10]
  • reversed(): Bir diziyi tersten sıralanmış şekilde döndürür. Ancak orijinal diziyi değiştirmez.
sayilar = [10, 20, 30, 40]
ters_sayilar = list(reversed(sayilar))
print(ters_sayilar)  # Çıktı: [40, 30, 20, 10]
  • all(): Verilen dizideki tüm elemanlar True değerinde ise True döner. Aksi halde False döner.
degerler = [True, True, True]
print(all(degerler))  # Çıktı: True

degerler = [True, False, True]
print(all(degerler))  # Çıktı: False
  • any(): Verilen dizide en az bir eleman True ise True döner.
degerler = [False, False, True]
print(any(degerler))  # Çıktı: True

degerler = [False, False, False]
print(any(degerler))  # Çıktı: False
  • enumerate(): Bir iteratable ı numaralandırarak döner, her bir öğe ile birlikte indeksini verir.
meyveler = ["elma", "armut", "muz"]
for indeks, meyve in enumerate(meyveler):
    print(f"{indeks}: {meyve}")
0: elma
1: armut
2: muz
  • zip(): birden fazla iterable’ı (örneğin, listeler, demetler) aynı anda ele alarak bu iterablelerin her birinden sırayla bir eleman alıp, bu elemanları birleştirerek tuple’lar oluşturan bir fonksiyondur.
isimler = ["Ahmet", "Mehmet", "Ayşe"]
yaslar = [25, 30, 22]

# İki listeyi zip ile birleştir
birlesim = zip(isimler, yaslar)

# Sonuç olarak tuple'lar içeren bir zip nesnesi döner
print(list(birlesim))  # [('Ahmet', 25), ('Mehmet', 30), ('Ayşe', 22)]
  • En kısa iterable’ın uzunluğuna göre çalışır. Uzun olanlardaki fazla elemanlar dikkate alınmaz.
isimler = ["Ahmet", "Mehmet", "Ayşe"] # 3 eleman
yaslar = [25, 30]                     # 2 eleman

birlesim = zip(isimler, yaslar)

# Sonuç 2 elemanlı olacaktır
print(list(birlesim))  # [('Ahmet', 25), ('Mehmet', 30)]
# 'Ayşe' eşleşecek bir yaş olmadığı için dışarıda kaldı.

Hangi Veri Yapısını Kullanmalıyım?

  • Değiştirilebilir bir koleksiyon, tekrarlayan elemanlara izin veriyorsanız: Liste (list)
  • Değiştirilemez bir koleksiyon, veri bütünlüğü önemliyse ve daha hızlı erişime ihtiyaç duyuyorsanız: Demet (tuple)
  • Anahtar-değer çiftleri ile veri saklamak, hızlı anahtar tabanlı erişim sağlamak için: Sözlük (dict)
  • Benzersiz elemanlardan oluşan bir koleksiyon, küme işlemleri (birleşim, kesişim, fark) için: Küme (set)

Quiz

  1. Aşağıdaki kod bloğunun çıktısı nedir?
liste = [1, 2, 3, 2, 4, 2]
print(liste.count(2))
  1. Aşağıdaki kod bloğunun çıktısı nedir?
demet = (1, 2, 3, 4, 5)
print(demet[1:4])
  1. Aşağıdaki kod bloğunun çıktısı nedir?
sayilar = [1, 5, 2, 4, 3]
sayilar.sort()
print(sayilar[0])
  1. Aşağıdaki kod bloğunun çıktısı nedir?
meyveler = {"elma", "armut", "muz"}
meyveler.add("elma")
print(len(meyveler))
  1. Aşağıdaki kod bloğunun çıktısı nedir?
kisi = {"ad": "Ali", "yas": 30}
print(kisi.get("meslek", "Bilinmiyor"))
  1. Aşağıdaki kod bloğunun çıktısı nedir?
sayilar = [1, 2, 2, 3, 4, 4, 5]
benzersiz_sayilar = set(sayilar)
print(benzersiz_sayilar)
  1. Aşağıdaki kod bloğunun çıktısı nedir?
ogrenci = {"ad": "Ali", "notlar": [80, 90, 70]}
print(sum(ogrenci["notlar"]) / len(ogrenci["notlar"]))

Alıştırmalar

  1. Kullanıcıdan alınan 3 meyve adını bir kümeye ekleyin.
  2. Kümedeki elemanları alfabetik sıraya göre yazdırın.
  1. Aşağıda verilen metin değişkenini kullanarak, her bir kelimenin o metin içinde kaç kez geçtiğini (frekansını) hesaplayan bir program yazın.
metin = "elma armut elma çilek armut elma"

İstenenler:

  • Programınızın çıktısı mutlaka bir sözlük olmalıdır.

  • Bu sözlükte, metindeki her bir benzersiz kelime anahtar (key) olarak yer almalı.

  • O kelimenin metin içinde kaç kez geçtiği ise o anahtarın değeri (value) olmalıdır.

İstenen Çıktı:

{'elma': 3, 'armut': 2, 'çilek': 1}
  1. Aşağıdaki ürünler listesini kullanarak:
ürünler = [
    {"ad": "Laptop", "fiyat": 25000, "kategori": "Elektronik"},
    {"ad": "Klavye", "fiyat": 750, "kategori": "Elektronik"},
    {"ad": "Kahve", "fiyat": 150, "kategori": "Gıda"},
    {"ad": "Defter", "fiyat": 80, "kategori": "Kırtasiye"},
    {"ad": "Mouse", "fiyat": 450, "kategori": "Elektronik"}
]
  1. Fiyatı 500’den yüksek olan “Elektronik” kategorisindeki ürünlerin adlarını yazdırın.
  2. “Kırtasiye” kategorisindeki ürünlerin toplam fiyatını hesaplayın.
  3. En pahalı ürünün adını bulun.
  1. Bir öğrenci not sistemi oluşturan bir program yazın. Program aşağıdaki özellikleri sağlamalıdır:
    • Kullanıcıdan öğrenci adı, soyadı ve 3 notu alın (vize1, vize2, final).
    • Kullanıcı ad bilgisine “q” değeri girene kadar yeni öğrenci bilgisi almaya devam edin.
    • Bu bilgileri bir sözlükte saklayın.
    • Her öğrenci için bir liste oluşturun ve notlarını bu listeye ekleyin.
    • Öğrencinin ortalama notunu hesaplayın (vize1: %30, vize2: %30, final: %40).
    • Öğrencinin harf notunu hesaplayın (90-100: AA, 80-89: BA, 70-79: BB, 60-69: CB, 0-59: FF).
    • Tüm öğrenci bilgilerini (ad, soyad, notlar, ortalama, harf notu) ekrana yazdırın.
  1. Basit bir alışveriş sepeti uygulaması yazın. Program aşağıdaki özellikleri sağlamalıdır:
  • Ürünlerin adını ve fiyatını içeren bir sözlük oluşturun.
  • Kullanıcıdan ürün seçmesini ve miktar (tamsayı) girmesini isteyin.
  • Seçilen ürün ve miktarı bir listeye ekleyin.
  • Var olan ürün tekrar eklenirse önceki miktara eklenir.
  • Kullanıcı “tamam” yazana kadar ürün eklemeye devam etsin.
  • Kullanıcı “tamam” yazdığında, toplam tutarı hesaplayın ve yazdırın.