Paketler, tip ipuçları ve JSON ile kaydetme

Öğrenirken birkaç sınıfı tek dosyaya yazmak iş görür. Kod büyüdükçe her işi ayrı bir dosyaya taşımak gerekir. 4. haftada bir fonksiyonu başka bir dosyadan import ile almıştınız. Önceki haftalarda yazdığınız mağaza programı tek bir dosyada büyüdü: Product, Customer ve Order sınıfları da, 12. haftadaki OutOfStockError da aynı dosyada. Bu hafta bu sınıfları modüllere (her biri bir .py dosyası) ve bu modülleri bir arada tutan bir pakete (klasöre) böleceğiz. Tip ipucu (type hint) ile de bir fonksiyonun hangi türde değer aldığını ve döndürdüğünü imzasına yazacağız. Fonksiyonun imzası def satırıdır: fonksiyonun adını, parametrelerini ve tip ipucu yazıldıysa dönüş türünü gösterir.

Bu sayfadaki kod hücreleri kendiliğinden çalışmaz. Her hücrede önce çıktıyı tahmin edin, sonra Run Code düğmesine basın. Kodu değiştirip yeniden çalıştırabilir, Start Over ile ilk hâline döndürebilirsiniz. Paket örnekleri birden çok dosya istediği için hücrede çalışmaz. Onları kendi bilgisayarınızda VS Code ve terminalle deneyeceksiniz.

Bu bölümün kapsamı

NotSınavda sorulur
  • Basit paket düzeni ve __init__.py dosyasının rolü
  • ModuleNotFoundError karşısında çalışma dizini denetimi
  • python app.py ile python -m paket.modul ayrımı
  • Kodu modüllere sorumluluğa göre ayırma
  • Tip ipucunun çalışma zamanında türü denetlememesi
  • T | None yazımı ve çağıranın None kontrolü
  • Sınıf ve metot imzalarındaki tip ipuçlarından nesnenin nasıl kullanılacağını okuma
  • Nesneyi sözlüğe çevirip JSON dosyasına kaydetme ve dosyadan okurken nesneyi __init__ ile yeniden oluşturma

Basit paket düzeni

4. haftada fiyat fonksiyonunu pricing.py dosyasına taşıyıp from pricing import final_price ile kullanmıştınız. Her .py dosyası bir modüldür ve başka bir dosya içindeki adları doğrudan import ile alabilir. Birbiriyle ilgili modülleri bir klasörde toplarsanız o klasör bir paket olur:

Çok dosyalı bir Python kod tabanında paket, modül ve sorumluluk ayrımını gösteren diyagram.

Paket ve modül yapısı
project/
├── app.py
└── shop/
    ├── __init__.py
    ├── product.py
    ├── customer.py
    ├── order.py
    ├── errors.py
    └── storage.py

Bir klasörün Python paketi olduğunu göstermenin alışılmış yolu, içine __init__.py dosyası koymaktır. Bu dosya boş olabilir. İsterseniz içine paket ilk kez import edildiğinde çalışacak kodu ya da paketin dışarıya açacağı adları yazabilirsiniz. Bu derste boş bırakacağız.

app.py paketin dışında durur ve programı başlatan dosyadır. En üstteki project/ klasörüne proje kökü denir.

Modülleri sorumluluğa göre ayırın

Kodu dosyalara ayırırken her sınıfa ayrı bir dosya açmanız gerekmez. Hangi sınıfların aynı modülde duracağına şu sorularla karar verin:

  • Bu sınıflar aynı işle mi ilgili?
  • Bir modüldeki değişiklik başka kaç modülü etkiliyor?
  • Modülün dışındaki kod hangi adları kullanmalı?

Yukarıdaki düzende ürünle ilgili kod product.py, siparişle ilgili kod order.py içinde duruyor. Özel istisnalar errors.py içinde toplandı, çünkü birden çok modül onları kullanıyor. Ürünleri dosyaya kaydetme ve dosyadan okuma işi storage.py modülünde durur. Dosyanın biçimi değişirse yalnız bu modül değişir, Product sınıfına dokunmak gerekmez.

_round_money gibi tek alt çizgiyle başlayan adlar, sınıflarda olduğu gibi modüllerde de “bu, modülün içinde kullanılan bir yardımcıdır” anlamına gelir. Python bu adlara dışarıdan erişimi engellemez.

Bir modülden ötekine import

Başka bir dosyadaki adı kullanmak için import satırı yazarsınız. Paketin dışındaki app.py, paketin adıyla başlayan tam yolu yazar:

from shop.product import Product

Paketin içindeki order.py, aynı paketteki product.py dosyasını şöyle alır:

from .product import Product

Baştaki nokta “bu modülle aynı paketteki” demektir. Noktayla başlayan bu yazıma göreli import denir. product.py de hata sınıfını aynı yolla alır:

from .errors import OutOfStockError

Döngüsel import riski

a.py b.py’yi, b.py de a.py’yi import ederse iki modül arasında döngüsel bir bağımlılık oluşabilir. Bu çoğu zaman iki modülün işlerinin birbirine fazla karıştığını gösterir. Çözüm tekniklerine bakmadan önce kendinize şunu sorun: “Bu iki modülün gerçekten birbirini import etmesi gerekiyor mu?”

Çalışma dizini neden önemlidir?

import satırındaki modülü Python kendisi arar, bulamazsa ModuleNotFoundError verir. Önce nereye bakacağı, programı nasıl başlattığınıza bağlıdır:

  • py app.py gibi bir dosyayı başlatırsanız önce o dosyanın bulunduğu klasöre bakar.
  • py -m shop.demo ile başlatırsanız önce terminalin açık olduğu klasöre bakar. Bu klasöre çalışma dizini denir.

Python modülü orada bulamazsa standart kütüphaneye ve kurulu paketlere bakar. Orada da yoksa ModuleNotFoundError verir.

En güvenli yol, terminali proje kökünde açıp programı oradan başlatmaktır. VS Code’da File > Open Folder ile project/ klasörünü açarsanız Terminal > New Terminal ile açılan terminal zaten orada başlar:

py app.py

macOS ve Linux’ta py yerine python3 yazın. Terminal başka bir klasörde açıksa bu komut app.py dosyasını bulamaz ve can't open file ... No such file or directory hatası verir. Bu bir import hatası değildir: Python başlatılacak dosyayı bulamamıştır.

UyarıModuleNotFoundError görünce hemen paket kurmayın

Önce şunları kontrol edin:

  1. Terminal şu an hangi klasörde? PowerShell’de Get-Location (kısaca pwd), macOS ve Linux’ta pwd yazın.
  2. Programı hangi dosyayla ya da hangi komutla başlattınız? Paketin içindeki bir dosyayı doğrudan başlatırsanız Python paketin kendisini bulamaz.
  3. app.py ile paket klasörü aynı proje kökü altında mı?
  4. Dosya ya da paket adında yazım hatası var mı?
  5. VS Code doğru klasörü mü açtı ve doğru Python yorumlayıcısını mı kullanıyor?

Kendi yazdığınız shop gibi bir paket bulunamıyorsa çözüm çoğu zaman PyPI’dan (pip install ile paket indirilen ortak depo) bir şey kurmak değil, programı proje kökünden doğru komutla çalıştırmaktır.

python app.py ile python -m package.module

Paketin modüllerini denemek için paketin içinde bir demo.py dosyası olsun:

# shop/demo.py
from .product import Product

print(Product("P1", "Klavye", 2))

Bu dosyayı python shop/demo.py diye yolunu vererek başlatırsanız Python onu paketten bağımsız bir script (doğrudan başlatılan program dosyası) olarak çalıştırır ve dosyanın shop paketine ait olduğunu bilmez. Göreli import bu yüzden çalışmaz, ImportError: attempted relative import with no known parent package hatası alırsınız. Göreli import yerine from shop.product import Product yazsanız da sonuç değişmez. Python önce başlatılan dosyanın klasörüne, yani shop/ klasörüne bakar ve orada shop adlı bir paket bulamaz: ModuleNotFoundError.

Bir modülü paketin parçası olarak çalıştırmak için proje kökünden şunu yazarsınız:

python -m shop.demo

-m seçeneği dosya yolu yerine modülün paket içindeki tam adını (shop.demo) alır. Python modülü çalışma dizininden başlayarak bulur ve shop paketinin parçası olarak çalıştırır. Göreli import da böylece çözülür. Windows’ta python komutu çalışmazsa aynı komutları py ile yazın: py -m shop.demo.

Bir import hatasını teşhis ederken önce şunu sorun:

“Bu dosya bağımsız script olarak mı, yoksa bir paketin modülü olarak mı çalışıyor?”

app.py ve main guard

4. haftadaki main guard kalıbı (if __name__ == "__main__":, dosya doğrudan çalıştırıldığında __name__ değeri "__main__" olur) çok dosyalı programda da kullanılır. app.py, programı başlatan kodu bir main() fonksiyonuna koyar:

# app.py
from shop.product import Product

def main():
    keyboard = Product("P1", "Klavye", 2)
    print(keyboard)

if __name__ == "__main__":
    main()

python -m shop.demo ile çalıştırılan modülde de __name__ değeri "__main__" olur. Başka bir dosyanın import ettiği modül ise kendi adını alır: shop.product gibi. Bu yüzden product.py içindeki deneme kodunu main guard altına koyarsanız app.py o modülü import ettiğinde deneme kodu çalışmaz.

Tip ipucu nedir?

Bir fonksiyonun ne aldığını ve ne döndürdüğünü şimdiye kadar adından, docstring’inden ya da gövdesinden çıkarıyordunuz. Python’da tür yazmak zorunlu değildir, ama isterseniz tip ipucu ile yazabilirsiniz. Aşağıda prices: list[float], fonksiyonun float değerlerden oluşan bir liste beklediğini söyler. -> float ise bir float döndüreceğini söyler. Hücre ne yazar?

İpucuna uymayan bir değer verirsek ne olur? add iki int bekliyor, ona iki metin veriyoruz. Python bu çağrıyı reddeder mi? Hücre ne yazar?

Tip ipucu:

  • Kodu okuyana fonksiyonun ne beklediğini söyler.
  • Editöre ve statik analiz araçlarına (kodu çalıştırmadan inceleyen mypy gibi araçlar) bilgi verir.
  • Program çalışırken türü denetlemez.

Python tip ipuçlarının geliştirme araçlarına bilgi verdiğini ancak çalışma zamanında tür zorlaması yapmadığını gösteren diyagram.

Tip ipucu ve çalışma zamanı

T | None ve eski sürüm söz dizimi

Aranan ürün bulunamayınca fonksiyon çoğu zaman None döndürür, çağıran kod da sonucun None olup olmadığına bakar. 3. haftada gördüğünüz .get() de anahtar yoksa None döndürüyordu. T | None tip ipucu “ya T türünde bir değer ya da None” demektir. T yerine herhangi bir tür yazılır. Aranan ürün bulunamazsa None döndüren bir metodun imzası:

def find(self, code: str) -> Product | None:
    ...

Bu yazım Python 3.10 ile geldi. Daha önce yazılmış kodlarda aynı şey şöyle yazılır:

from typing import Optional

def find(self, code: str) -> Optional[Product]:
    ...

Python 3.9’dan eski kaynaklarda list[str] yerine List[str], dict[str, int] yerine Dict[str, int] de görebilirsiniz. Bu derste güncel yazımı kullanıyoruz.

Sınıflarda tip ipucu

Tip ipuçları sınıflarda da yazılır. Aşağıdaki Catalog sınıfının imzalarını okuyun: add bir Product alır ve değer döndürmez (-> None). find bir metin kod alır, Product ya da None döndürür. Katalogda P9 kodlu ürün yok. Hücre ne yazar?

self.products: dict[str, Product] satırı niteliğe de ipucu yazar: anahtarlar metin, değerler Product. find sözlüğün .get() metodunu (3. hafta) kullandığı için anahtar yoksa None döndürür. İmzayı okuyan biri, gövdeye bakmadan metodu nasıl çağıracağını ve sonucu nasıl denetleyeceğini bilir.

ÖnemliTip ipucu None kontrolünü sizin yerinize yapmaz

Product | None yazmak metodun None döndürmesini engellemez. result.price satırına gelmeden önce result değerinin None olup olmadığını kontrol etmek yine programcının işidir. Kontrolü unutursanız ürün bulunamadığında AttributeError alırsınız.

Nesneleri JSON dosyasına kaydetmek

Program kapanınca bellekteki nesneler de silinir. Kataloğu programın bir sonraki açılışında kullanmak için ürünleri bir dosyaya yazmanız gerekir. 5. haftada dosyaya satır satır metin yazmıştınız. Nesneleri kaydetmek için yaygın bir metin biçimi daha var: JSON (JavaScript Object Notation). JSON metni Python’daki sözlüğe ve listeye çok benzer: {"code": "P1", "price": 450.0}. Standart kütüphanedeki json modülünün json.dump(veri, dosya) fonksiyonu sözlük, liste, metin, sayı, True, False ve None değerlerini dosyaya JSON olarak yazar. Kod hücreleri 5. haftadaki gibi tarayıcının sanal dosya sistemini kullanır. Ürün listesini doğrudan yazmayı deneyelim. Hücre ne yazar?

json modülü kendi yazdığınız sınıfları tanımaz. Product nesnesinin hangi niteliklerinin, hangi adlarla kaydedileceğini bilemediği için TypeError: Object of type Product is not JSON serializable hatası verir. Bunu sınıfın kendisi söyler: nesneyi sözlüğe çeviren bir to_dict() metodu yazarız. Okurken de dosyadan gelen her sözlükten Product(...) çağrısıyla nesneyi yeniden oluştururuz. Aşağıdaki save_products ve load_products fonksiyonları paket düzeninde shop/storage.py modülüne gider. json.dump çağrısındaki indent=2, JSON metnini girintili ve okunur yazar. Hücre ne yazar?

Dosyada nesne yoktur, sözlüklerden oluşan bir liste vardır. json.load(dosya) bu metni okuyup yine sözlük listesine çevirir. İmzalar da işi anlatır: save_products bir Product listesi ve dosya yolu alır, değer döndürmez. load_products bir dosya yolu alır, Product listesi döndürür.

Nesneyi __init__ ile yeniden oluşturmanın bir yararı daha var: dosyadan gelen değer de 8. haftadaki doğrulamadan geçer. Aşağıdaki dosyada ikinci ürünün fiyatı bozuk. Hücre ne yazar?

Elle düzenlenmiş ya da yarım kalmış bir dosyadaki geçersiz kayıt __init__’e takılır ve program geçersiz bir Product nesnesiyle çalışmaya başlamaz. Sözlüğü nesneye çevirmeden doğrudan kullansaydınız bu denetim hiç çalışmazdı.

Bu haftanın işleri yan yana

Mağaza programını dosyalara bölerken yaptığımız işleri önceki haftalarda nasıl yapardık, bu hafta nasıl yapıyoruz:

İş Önceki haftalarda Bu haftaki Python yolu Dikkat
Ürün, müşteri ve sipariş kodunu ayrı dosyalara koymak 4. haftadaki pricing.py gibi, programın yanında duran tek tek modüller Her sınıf grubu bir .py modülüne, modüller __init__.py bulunan shop/ paketine Her sınıfa ayrı dosya gerekmez, sınıflar işlerine göre gruplanır
Başka dosyadaki sınıfı kullanmak 4. haftada from pricing import final_price Paket dışından from shop.product import Product, paket içinden from .product import Product İki modül birbirini import ediyorsa işler iyi bölünmemiş olabilir
Programı başlatıp “bulunamadı” hatasını çözmek 4. haftada py app.py: modül aynı klasörde olduğu için bulunur Proje kökünden py app.py ya da py -m shop.demo ModuleNotFoundError görünce paket kurmayın, önce çalışma dizinine ve başlatılan dosyaya bakın
Fonksiyonun ne alıp ne döndürdüğünü öğrenmek Docstring’i ya da fonksiyonun gövdesini okumak Tip ipucu: def calculate_total(prices: list[float]) -> float: Python çalışırken türü denetlemez
Bulunamayan ürünü bildirmek None döndürmek, çağıranın None kontrolü yapması Dönüş ipucuna None eklenir, çağıran if result is not None: yazar İpucu None gelmesini engellemez, kontrol çağıranın işidir
Ürünleri program kapandıktan sonra da saklamak 5. haftadaki gibi dosyaya satır satır metin yazmak to_dict() ile sözlüğe çevirip json.dump, okurken json.load ve Product(...) json Product nesnesini tanımaz. Okunan kayıt __init__ doğrulamasından geçer

import satırındaki modülü Python kendisi arar, nereden aramaya başlayacağı da programı hangi klasörden ve hangi komutla başlattığınıza bağlıdır. Modül bulunamayınca bakacağınız yer bellidir: terminalin açık olduğu klasör ve başlattığınız dosya. Tip ipucunu Python denetlemez. Onu kodu okuyan kişi ve editör kullanır. Bulunamayan ürün için 12. haftadaki gibi bir istisna da yükseltebilirdiniz. Aranan ürünün katalogda olmaması olağan bir sonuçsa None döndürmek yeter. Stok yetmemesi gibi bir kural bozulduysa istisna yükseltilir. Nesneyi dosyaya kaydederken de kararı sınıf verir: hangi niteliklerin yazılacağını to_dict() söyler, dosyadan gelen değeri __init__ denetler.

Alıştırmalar

Tip ipuçlarını ekle

Fonksiyonun ne aldığını ve ne döndürdüğünü dict[int, str], int ve str | None ipuçlarıyla imzaya yazın.

Kitapları JSON dosyasına kaydet

Book sınıfına kitabı sözlüğe çeviren bir to_dict() metodu ekleyin. Ardından save_books(books: list[Book], path: str) -> None ve load_books(path: str) -> list[Book] fonksiyonlarını yazın. İki kitabı kaydedip dosyadan yeniden okuyun ve okunan ilk kitabın başlığını yazdırın. Sonra dosyaya ISBN’i boş bir kayıt yazın ve load_books çağrısının ValueError yükselttiğini gösterin.

Çalışma dizini hatasını teşhis et

Kendi bilgisayarınızda project/app.py, project/shop/__init__.py, project/shop/product.py ve project/shop/demo.py dosyalarını oluşturun. demo.py içinde from shop.product import Product satırı olsun. Sonra şu üç denemeyi yapın:

  1. Terminal proje kökündeyken py app.py ve py -m shop.demo
  2. Terminal bir üst klasördeyken py -m shop.demo
  3. Terminal proje kökündeyken py shop/demo.py

Her denemede Get-Location çıktısına ve hata mesajına bakın. Hata veren denemelerde Python’ın shop paketini hangi klasörde aradığını yazın.

ÖnemliPython sürümünü kontrol edin

Sıradaki görevde Book | None gibi ipuçlarını kendi bilgisayarınızda çalıştıracaksınız. list[str] ve dict[str, Product] yazımı Python 3.9, Product | None yazımı Python 3.10 ister. Python 3.10’un desteği Ekim 2026’da bittiği için bu derste en az Python 3.11 kullanın. 1. haftada kurduğunuz güncel sürüm (3.14) bu koşulu karşılar. Sürümü terminalde yeniden kontrol edin:

py --version

macOS ve Linux’ta python3 --version yazın. Yanlış yorumlayıcı seçiliyse VS Code’da Python: Select Interpreter komutunu kullanın.

Üç modüllü sistem

Yerel ortamınızda şu yapıyı oluşturun:

library-project/
├── app.py
└── library/
    ├── __init__.py
    ├── book.py
    ├── member.py
    └── library.py

Library.find_book(isbn) metodu Book | None döndürsün. app.py kitabın bulunamadığı, yani None döndüğü durumda kullanıcıya bir mesaj yazdırsın.

Çalışır kod görevi: Python sürümünüzü not edin ve programı proje kökünden çalıştırın. En az bir paket içi göreli import, bir paket dışı import ve bir Book | None dönüşü kullanın. app.py programı main guard altındaki main() fonksiyonundan başlatsın. Ayrıca küçük bir library/demo.py oluşturup proje kökünden py -m library.demo ile çalıştırın.

Sınav provası

Önce kendi cevabınızı seçin; sonra cevap anahtarında her şıkkın neden doğru veya yanlış olduğunu okuyun. Çeldiriciler uydurma değil, bu konuda gerçekten yapılan hatalardır. Sınav soruları da bu mantıkla yazılır.

1. Bir paket dizinindeki __init__.py dosyası hakkında doğru olan hangisidir?

  • A. İçi boş bırakılırsa paketteki modüller import edilemez
  • B. Yalnızca PyPI’ya yüklenecek paketlerde gerekir
  • C. Paketin bütün sınıflarını içermek zorundadır
  • D. Paketin ana giriş noktasıdır ve python paket ile çalıştırılır
  • E. Klasörü paket olarak işaretler ve boş bırakılabilir

2. Kendi yazdığınız shop paketi için ModuleNotFoundError alıyorsanız ilk olarak ne yapmalısınız?

  • A. Bütün import satırlarını try/except içine almak
  • B. pip install shop komutunu çalıştırmak
  • C. Terminalin proje kökünde açık olup olmadığını denetlemek
  • D. Python’ı kaldırıp güncel sürümle yeniden kurmak
  • E. Paketteki __init__.py dosyasını silip yeniden denemek

3. python -m shop.demo ile python shop/demo.py arasındaki fark nedir?

  • A. -m modülü paketin bir parçası olarak çalıştırır
  • B. -m paketin __init__.py dosyasını çalıştırır
  • C. -m kurulu PyPI paketlerini çalıştırmak içindir
  • D. -m dosyayı derleyip çalıştırır, diğeri yorumlar
  • E. İkisi aynıdır; -m daha kısa bir yazımdır

4. Kodu dosyalara ayırırken hangi ölçüt kullanılmalıdır?

  • A. Sınıf adlarının alfabetik sırası
  • B. Sınıfların yazılma tarihine göre gruplanması
  • C. Dosya başına en fazla 100 satır kuralı
  • D. Her sınıfın kendi dosyasında durması
  • E. Sınıfların aynı işle ilgili olup olmadığı

5. Aşağıdaki program ne yazdırır?

def add(a: int, b: int) -> int:
    return a + b

print(add("a", "b"))
  • A. None
  • B. ValueError
  • C. TypeError
  • D. ab
  • E. SyntaxError

6. def find(self, code: str) -> Product | None: imzası çağırana ne söyler?

  • A. Metodun hiçbir zaman None döndürmeyeceğini
  • B. Çağıranın None durumunu kontrol etmesi gerektiğini
  • C. Python’ın None dönüşünde kendiliğinden hata yükselteceğini
  • D. Metodun iki değer birden döndürdüğünü
  • E. code parametresinin isteğe bağlı olduğunu

7. Bir sınıfın imzaları şöyle:

class Catalog:
    def __init__(self) -> None:
        self.products: dict[str, Product] = {}

    def add(self, product: Product) -> None: ...

    def find(self, code: str) -> Product | None: ...

Product sınıfının kurucusu Product(code: str, price: float) biçimindedir. Aşağıdaki satırlardan hangisi bu imzalara uyar?

  • A. catalog.add("P1", 10.0)
  • B. catalog.find(Product("P1", 10.0))
  • C. catalog.add(Product("P1", 10.0))
  • D. catalog.add(Product("P1", 10.0)).code
  • E. catalog.products.append(Product("P1", 10.0))

8. Aşağıdaki imza çağırana ne söyler?

class Inventory:
    def reserve(self, code: str, amount: int) -> bool: ...
  • A. Metin kod ve tamsayı miktar alır, sonucu bool olarak bildirir
  • B. code isteğe bağlıdır, metot yalnız amount verilerek de çağrılabilir
  • C. Metin kod ve tamsayı miktar alır, ayrılan ürünlerin listesini döndürür
  • D. Başarısız olursa istisna yükseltir, başarılıysa True döndürür
  • E. Kod ve miktarı alır, sonucu ekrana yazar ve değer döndürmez

9. Product nesnelerinden oluşan products listesini JSON dosyasına kaydetmek ve programın bir sonraki açılışında aynı ürünlerle çalışmak istiyorsunuz. Hangi yol doğrudur?

  • A. Her ürünü to_dict() ile sözlüğe çevirip yazmak, okurken sözlükleri Product nesnesi gibi kullanmak
  • B. Her ürünü to_dict() ile sözlüğe çevirip yazmak, okurken her sözlükten Product(...) oluşturmak
  • C. Listeyi json.dump(products, file) ile olduğu gibi yazmak, okurken json.load sonucunu kullanmak
  • D. Her ürünü str(product) ile metne çevirip yazmak, okurken her satırı ürün olarak kullanmak
  • E. Her ürünün __repr__ çıktısını yazmak, okurken Python’ın nesneleri kendiliğinden oluşturmasını beklemek

10. customers.json dosyasının içeriği şöyle:

[{"name": "Ada", "points": 40}, {"name": "Can", "points": -10}]

Aşağıdaki program ne yazdırır?

import json

class Customer:
    def __init__(self, name: str, points: int):
        if points < 0:
            raise ValueError("Puan negatif olamaz")
        self.name = name
        self.points = points

def load_customers(path: str) -> list[Customer]:
    with open(path, encoding="utf-8") as file:
        data = json.load(file)
    customers = []
    for item in data:
        customers.append(Customer(item["name"], item["points"]))
    return customers

try:
    customers = load_customers("customers.json")
    print(len(customers))
except ValueError as error:
    print("Hata:", error)
  • A. Program KeyError ile durur
  • B. 1
  • C. 2
  • D. Hata: Puan negatif olamaz
  • E. Program TypeError ile durur

1. Doğru: E. Klasörün bir Python paketi olduğunu göstermenin alışılmış ve açık yoludur. İsterseniz içine paket ilk import edildiğinde çalışacak kodu ya da paketin dışarıya açacağı adları yazabilirsiniz. Şimdilik boş bırakmak yeterli.

  • A yanlış: Boş bir dosya işe yaramıyormuş gibi görünür. Ama boş bir __init__.py de klasörü paket olarak işaretlemeye yeter.
  • B yanlış: “Paket” sözcüğü pip install ile kurulan paketleri çağrıştırır. Ama __init__.py yerel paketlerde de kullanılır.
  • C yanlış: Dosya paketin kendisini temsil ediyormuş gibi göründüğü için paketin bütün kodunun burada toplandığı sanılabilir. Ama sınıflar ayrı modüllerde durur.
  • D yanlış: __init__ adı, kurucu gibi ilk çalışan şeyi çağrıştırır. Ama bir paketi python -m paket ile çalıştırmak için __main__.py kullanılır.

2. Doğru: C. Terminalin hangi klasörde olduğu ve app.py ile paketin aynı proje kökü altında bulunup bulunmadığı denetlenir. Kendi yazdığınız bir paket bulunamıyorsa eksik olan çoğu zaman bir kurulum değildir; program proje kökünden çalıştırılmamıştır.

  • A yanlış: Hata mesajı kaybolduğu için sorun çözülmüş gibi görünür. Ama hatayı gizler; nedeni ortadan kaldırmaz.
  • B yanlış: Hata mesajı “modül bulunamadı” dediği için eksik bir kurulum akla gelir. Ama paket sizin yazdığınızsa PyPI’da yoktur; aynı adlı yanlış bir paket kurulabilir.
  • D yanlış: Hata Python’dan geldiği için yorumlayıcının bozuk olduğu düşünülebilir. Ama yorumlayıcıyla ilgili bir sorun değildir.
  • E yanlış: Paket yapısını sadeleştirmek sorunu çözecekmiş gibi görünebilir. Ama klasörü paket olarak işaretleyen dosyayı silersiniz; sorun büyür.

3. Doğru: A. -m modülü paket içindeki tam adıyla bulup paketin parçası olarak çalıştırır; dosya yolu verildiğinde Python dosyanın hangi pakete ait olduğunu bilmeyebilir. Fark en çok göreli import kullanan modüllerde ortaya çıkar: proje kökünden -m ile çalıştırılan modül, from .product import ... satırını paketin içinden çözer.

  • B yanlış: Komutta paket adı geçtiği için paketin __init__.py dosyasının çalıştırıldığı sanılabilir. Paket import edilirken o dosya da çalışır ama -m asıl olarak belirtilen modülü çalıştırır.
  • C yanlış: -m çoğu zaman python -m pip gibi kurulu araçlarla görüldüğü için onlara özgü sanılabilir. Ama yerel paketler için de kullanılır.
  • D yanlış: Derleme ve çalıştırma iki ayrı adımmış gibi düşünülürse iki komutun bu adımlara bölündüğü sanılabilir. Ama ikisinde de Python kodu aynı biçimde çalıştırır.
  • E yanlış: Basit bir dosyada iki komut da aynı çıktıyı verdiği için aynı sanılabilir. Ama modülü farklı biçimde başlatırlar; fark göreli import’larda ortaya çıkar.

4. Doğru: E. Bir modül, aynı işle ilgili ve çoğu zaman birlikte değişen sınıfları bir arada tutar. Bir modüldeki değişikliğin kaç modülü etkilediğine de bakılır. Her sınıfa ayrı dosya açmak gerekmez.

  • A yanlış: Dosyaları bulmayı kolaylaştırdığı için düzenli görünür. Ama sıralamaya yarar, hangi sınıfların birlikte durması gerektiğini söylemez.
  • B yanlış: Proje adım adım büyüdüğü için her aşamanın kodunu ayrı tutmak akla gelebilir. Ama yazılma tarihinin sınıfların ne iş yaptığıyla ilgisi yoktur.
  • C yanlış: Kısa dosyalar okunaklı olduğu için sayıya dayalı bir kural cazip görünür. Ama satır sayısı sorumluluğu ölçmez.
  • D yanlış: Düzenli ve uygulaması kolay bir kural gibi görünür. Ama mekanik bir kuraldır; birlikte değişen sınıfları gereksizce ayırır.

5. Doğru: D. Tip ipucu çalışma zamanında türü zorlamaz. İpucu kodu okuyana ve statik analiz araçlarına bilgi verir; yorumlayıcı çağrıyı engellemez. İki str değeri + ile toplanınca birleşir.

  • A yanlış: Çağrı ipucuna uymadığı için fonksiyonun bir şey döndürmeyeceği sanılabilir. Ama gövde çalışır ve birleştirme sonucunu döndürür.
  • B yanlış: "a" metni sayıya çevrilemediği için Python’ın onu int türüne çevirmeye çalışıp hata vereceği sanılabilir. Ama tip ipucu dönüşüm yapmaz; değerler metin olarak kalır.
  • C yanlış: a: int yazımı bir kural gibi okunduğu için int dışındaki türlerin reddedileceği sanılabilir. Ama böyle bir çalışma zamanı denetimi yoktur.
  • E yanlış: -> int gibi yazımlar alışılmadık göründüğü için söz dizimi hatası beklenebilir. Ama tip ipucu yazımı geçerli Python söz dizimidir.

6. Doğru: B. | None aramanın başarısız olabileceğini söyler. Tip ipucu sözleşmeyi açıkça yazar ama metodun None döndürmesini engellemez. product.code satırından önce None kontrolünü yine programcı yapar.

  • A yanlış: Dönüş türünde Product yazdığı için metodun hep ürün döndüreceği sanılabilir. Ama | None yazımı bu olasılığı açıkça bildirir.
  • C yanlış: Tür yazıldığı için Python’ın dönüşü denetleyeceği düşünülebilir. Ama böyle bir otomatik denetim yoktur.
  • D yanlış: | işareti iki türü yan yana yazdığı için iki değer dönüyormuş gibi okunabilir. Ama tek değer döner; imza bu değerin iki türden biri olabileceğini söyler.
  • E yanlış: None çoğu zaman varsayılan parametre değeri olarak görüldüğü için parametreyle ilişkilendirilebilir. Ama ipucu dönüş değerine aittir; code parametresi zorunludur.

7. Doğru: C. add bir Product nesnesi bekler ve değer döndürmez (-> None). Satır yeni bir Product oluşturup add metoduna veriyor ve dönüş değerini kullanmıyor.

  • A yanlış: Ürünü oluşturacak değerleri doğrudan vermek kısa yol gibi görünür. Ama add tek bir product: Product parametresi alır; kod ve fiyatı ayrı ayrı almaz.
  • B yanlış: Aranan ürünün kendisini vermek akla yatkın görünür. Ama find imzasında code: str yazıyor; metot bir ürün kodu bekler, ürün nesnesi beklemez.
  • D yanlış: Ekleme metodunun eklenen ürünü geri verdiği sanılabilir. Ama -> None, add metodunun değer döndürmediğini söyler. None üzerinde .code okunmaya çalışılınca AttributeError alınır.
  • E yanlış: products bir koleksiyon olduğu için listeye eklenir gibi eklenebileceği sanılabilir. Ama nitelik ipucu dict[str, Product] diyor: bu bir sözlüktür ve sözlükte append() metodu yoktur.

8. Doğru: A. Parametre ipuçları metodun bir metin kod ve bir tamsayı miktar beklediğini söyler. -> bool, metot normal biçimde dönerse bir bool değeri döndüreceğini söyler. Bu değerin ne anlama geldiği (örneğin True ayırmanın yapıldığı mı demek) ve metodun hangi istisnaları yükseltebileceği imzada yazmaz; onu metodun belgesi ya da docstring’i açıklar.

  • B yanlış: İmzada code için ayrı bir işaret görülmediği için zorunlu olmadığı sanılabilir. Ama varsayılan değer verilmemiş; iki parametre de zorunludur.
  • C yanlış: Ayırma işi ürünlerle ilgili olduğu için metodun ürünleri döndüreceği düşünülebilir. Ama dönüş türü bool; liste dönseydi list[...] yazardı.
  • D yanlış: Önceki bölümlerde kurallar raise ile korunduğu için başarısızlığın da istisnayla bildirileceği sanılabilir. Ama imza istisnalardan hiç söz etmez; metodun ne yükseltebileceğini ve True değerinin ne anlama geldiğini imzadan okuyamazsınız.
  • E yanlış: İşlemin sonucunu bildirmek ekrana yazmak gibi düşünülebilir. Ama -> bool dönüş değerinin türüdür; metot True ya da False döndürür. Değer döndürmeyen metodun imzasında -> None yazar.

9. Doğru: B. json modülü sözlük ve liste gibi yerleşik türleri yazar, kendi sınıfınızı tanımaz. to_dict() hangi niteliklerin hangi adlarla kaydedileceğini söyler. json.load dosyadan sözlükleri okur. Her sözlükten Product(...) oluşturunca nesneler geri gelir ve dosyadan gelen değerler __init__ doğrulamasından geçer.

  • A yanlış: Kaydetme adımı doğrudur, bu yüzden okumanın da kendiliğinden tamamlandığı sanılabilir. Ama json.load sözlük verir. item.price gibi bir satır AttributeError verir, __init__ doğrulaması da hiç çalışmaz.
  • C yanlış: json her şeyi yazabiliyormuş gibi görünür. Ama Product nesnesini tanımaz ve TypeError: Object of type Product is not JSON serializable hatası verir.
  • D yanlış: __str__ nesneyi okunur bir metne çevirdiği için kaydetmeye de yarayacağı sanılabilir. Ama dosyadan geri okunan şey yalnız metindir; Python o metinden kendiliğinden Product nesnesi oluşturmaz.
  • E yanlış: Product(code='P1', price=450.0) gibi bir repr çıktısı Python koduna benzediği için geri okununca nesneye dönüşeceği sanılabilir. Ama dosyadan okunan değer yalnız bir metindir.

10. Doğru: D. json.load iki sözlüğü okur. İkinci sözlükten Customer(...) oluşturulurken __init__ negatif puanı reddeder ve ValueError yükseltir. load_customers yarıda kalır, print(len(customers)) satırı çalışmaz ve except bloğu hatanın mesajını yazar.

  • A yanlış: Sözlükten değer okunurken anahtarın bulunamayacağı sanılabilir. Ama iki kayıtta da name ve points anahtarları var; hatayı veren __init__ içindeki doğrulamadır.
  • B yanlış: Geçersiz kaydın atlanıp geçerli olanın listeye gireceği sanılabilir. Ama istisna yükselince döngü de fonksiyon da yarıda kalır; hiçbir liste döndürülmez.
  • C yanlış: JSON dosyası düzgün okunduğu için iki kaydın da sorunsuz geleceği sanılabilir. Ama nesneler Customer(...) ile oluşturulur ve __init__ dosyadan gelen değeri de denetler.
  • E yanlış: json kendi sınıflarımızı tanımadığı için okurken de hata vereceği sanılabilir. Ama dosyada nesne değil sözlük vardır, json.load onları sorunsuz okur.

Tek sayfa özet

  • Her .py dosyası bir modüldür. __init__.py bulunan klasör bir pakettir, bu dosya boş olabilir.
  • Kodu modüllere işine göre ayırın. Her sınıfa ayrı dosya gerekmez. İki modül birbirini import ediyorsa iş bölümünü gözden geçirin.
  • Paket dışından from shop.product import Product, paket içinden göreli import ile from .product import Product yazılır.
  • Python modülü önce bir dosyayı başlattıysanız o dosyanın klasöründe, -m ile başlattıysanız çalışma dizininde arar.
  • ModuleNotFoundError görünce önce terminalin hangi klasörde olduğuna, hangi dosyayı başlattığınıza ve seçili yorumlayıcıya bakın.
  • python -m shop.demo modülü paketin parçası olarak çalıştırır. python shop/demo.py dosyayı paketten bağımsız bir script olarak başlatır, göreli import çalışmaz.
  • Tip ipuçları beklenen türü okura ve editöre söyler, program çalışırken türü denetlemez.
  • T | None sonucun bulunamayabileceğini imzada söyler. None kontrolünü yine çağıran yapar.
  • Metot imzası, metodun nasıl kullanılacağını söyler: ne verilir, ne döner, dönüş None olabilir mi.
  • json kendi sınıflarınızın nesnelerini tanımaz. Nesneyi to_dict() ile sözlüğe çevirip json.dump ile yazın. Okurken json.load sözlükleri verir, nesneyi __init__ ile yeniden oluşturun. Böylece dosyadan gelen değer de doğrulanır.
  • Bu ders için Python 3.11 ya da daha yeni bir sürüm kullanın. 1. haftada kurduğunuz 3.14 yeterli.

Bu bölümün kazanımları

Bu bölümü bitiren öğrenci:

  • Basit bir paket düzeni kurar ve __init__.py dosyasının rolünü açıklar.
  • ModuleNotFoundError karşısında önce çalışma dizinini ve proje kökünü denetler.
  • python app.py ile python -m paket.modul arasındaki farkı açıklar.
  • Kodu modüllere sorumluluklarına göre ayırır.
  • Tip ipucunun çalışma zamanında türü denetlemediğini açıklar.
  • T | None yazımını kullanır ve çağıranın None kontrolünü hâlâ yapması gerektiğini bilir.
  • Sınıf ve metot imzalarındaki tip ipuçlarından bir nesnenin nasıl kullanılacağını okur.
  • Nesneyi sözlüğe çevirip JSON dosyasına kaydeder ve dosyadan okurken nesneyi __init__ ile yeniden oluşturur.
Başa dön