EduBot 2.0 - Profil 4: Python Eğitimi (Gün 11–15)

🐍 Gün 11 – Modüller ve Paketler

Python'da programlarımız büyüdükçe ve karmaşıklaştıkça, kodumuzu organize etmek ve yeniden kullanılabilir parçalara ayırmak önem kazanır. İşte bu noktada modüller ve paketler devreye girer. Bir modül, Python tanımlamalarını ve ifadelerini içeren bir dosyadır. Dosya adı, modül adıdır ve sonuna `.py` uzantısı eklenir. Örneğin, `hesaplamalar.py` adında bir dosya oluşturursanız, bu `hesaplamalar` adında bir modül olur. Bu modülün içindeki fonksiyonları, sınıfları veya değişkenleri başka bir Python programından `import` anahtar kelimesiyle çağırabilir ve kullanabiliriz. Bu, kod tekrarını önler ve projelerimizi daha yönetilebilir hale getirir.

Modülleri kullanmanın temel amacı, mantıksal olarak birbiriyle ilişkili kod parçalarını bir arada tutmaktır. Örneğin, matematiksel işlemler yapan tüm fonksiyonlarınızı tek bir modülde toplayabilirsiniz. Bir modülü programınıza dahil etmek için `import modul_adi` sözdizimini kullanırsınız. Modül içindeki bir fonksiyona erişmek için ise `modul_adi.fonksiyon_adi()` şeklinde bir notasyon kullanılır. Eğer modülün sadece belirli bir fonksiyonuna veya sınıfına ihtiyacınız varsa, `from modul_adi import fonksiyon_adi` şeklinde daha spesifik bir import işlemi yapabilirsiniz. Bu sayede fonksiyonu çağırırken modül adını önek olarak kullanmanıza gerek kalmaz.

Paketler ise modülleri organize etmenin bir sonraki seviyesidir. Bir paket, basitçe modüller içeren bir dizindir. Bir dizinin Python tarafından bir paket olarak tanınması için içinde `__init__.py` adında (boş olabilen) bir dosya bulunması gerekir. Bu yapı, birbiriyle ilişkili modülleri hiyerarşik bir düzende gruplamamıza olanak tanır. Örneğin, bir web uygulamasında veritabanı işlemlerini, kullanıcı kimlik doğrulama işlemlerini ve arayüz bileşenlerini ayrı ayrı modüllere ayırıp, hepsini `uygulamam` adında bir paketin altında toplayabiliriz. Paket içindeki bir modüle erişmek için `import paket.modul` veya `from paket.modul import fonksiyon` gibi noktalı notasyonlar kullanılır.

Sonuç olarak, modüller ve paketler, Python'da büyük ölçekli ve sürdürülebilir yazılımlar geliştirmenin temel taşlarıdır. Kodun modülerliği, okunabilirliği ve bakımının kolaylaşmasını sağlarlar. Standart kütüphanede gelen `math`, `os`, `datetime` gibi yüzlerce modülün yanı sıra, `pip` gibi araçlarla kurabileceğimiz binlerce üçüncü parti paket (örneğin `requests`, `numpy`, `pandas`) Python ekosisteminin gücünü oluşturur. Kendi modül ve paketlerinizi yazarak hem kendi projelerinizi daha düzenli hale getirebilir hem de kodunuzu başkalarıyla kolayca paylaşabilirsiniz.

# matematiksel.py adında bir modülümüz olduğunu varsayalım.
# İçeriği:
# def topla(a, b):
#   return a + b
# def carp(a, b):
#   return a * b

# Ana programımızda bu modülü kullanalım:
import math # Python'un standart bir modülü
# import matematiksel # Kendi modülümüz (aynı dizinde olmalı)

sayi = 25
print(f"{sayi} sayısının karekökü: {math.sqrt(sayi)}")

# sonuc_toplama = matematiksel.topla(10, 5)
# print(f"10 + 5 = {sonuc_toplama}")

📂 Gün 12 – Dosya İşlemleri

Python'da programların kalıcı verilerle çalışması sıkça karşılaşılan bir durumdur. Kullanıcı girdilerini, program ayarlarını veya işlem sonuçlarını daha sonra kullanmak üzere saklamak için dosya işlemleri kullanılır. Python, dosyaları okumak, yazmak ve yönetmek için son derece basit ve güçlü yerleşik fonksiyonlar sunar. Dosya işlemleri için temel fonksiyon `open()`'dır. Bu fonksiyon, iki temel argüman alır: dosyanın yolu (adı) ve dosyanın hangi modda açılacağı. Modlar, dosyayla ne yapacağimizi belirtir: 'r' (read - okuma), 'w' (write - yazma, dosya varsa içeriğini siler), 'a' (append - ekleme, dosyanın sonuna yazar) ve 'x' (create - oluşturma, dosya zaten varsa hata verir). Ayrıca, dosyanın metin ('t') mi yoksa ikili ('b') formatta mı açılacağını belirten ek modlar da vardır; genellikle 'rt' (metin okuma) varsayılan değerdir.

Bir dosyayı açtıktan sonra üzerinde okuma veya yazma işlemleri yapabiliriz. Okuma için `.read()` (tüm içeriği okur), `.readline()` (tek bir satır okur) veya `.readlines()` (tüm satırları bir liste olarak okur) metodları kullanılır. Yazma işlemleri için ise `.write()` (bir string yazar) veya `.writelines()` (bir liste içindeki tüm stringleri yazar) metodları mevcuttur. İşlemler bittikten sonra, dosya ile olan bağlantıyı sonlandırmak ve sistem kaynaklarını serbest bırakmak için `.close()` metodunu çağırmak çok önemlidir. Eğer dosyayı kapatmayı unutursak, yazılan veriler dosyaya tam olarak kaydedilmeyebilir veya program beklenmedik hatalar verebilir.

Ancak, `.close()` metodunu manuel olarak çağırmak bazen unutulabilir veya programda bir hata oluştuğunda bu satıra hiç ulaşılamayabilir. Bu sorunu çözmek için Python'da `with` ifadesi kullanılır. `with open('dosya.txt', 'w') as f:` sözdizimi, bir "context manager" (bağlam yöneticisi) oluşturur. `with` bloğu içindeki işlemler bittiğinde veya bloktan herhangi bir nedenle (örneğin bir hata) çıkıldığında, Python dosyayı otomatik olarak ve güvenli bir şekilde kapatır. Bu yöntem, dosya işlemleri için en çok tavsiye edilen ve en güvenli yoldur, çünkü kaynak sızıntılarını ve veri kaybını önler. Modern Python kodlarında dosya işlemleri neredeyse her zaman `with` ifadesi ile yapılır.

Dosya işlemleri sadece metin dosyalarıyla sınırlı değildir. 'rb' (ikili okuma) veya 'wb' (ikili yazma) modlarını kullanarak resimler, ses dosyaları veya diğer ikili formatlardaki verilerle de çalışabilirsiniz. Ayrıca, `os` modülü gibi standart kütüphaneler sayesinde dosyaları yeniden adlandırmak (`os.rename()`), silmek (`os.remove()`) veya bir dizindeki dosyaları listelemek (`os.listdir()`) gibi işletim sistemi seviyesinde dosya yönetimi görevlerini de kolayca gerçekleştirebilirsiniz. Bu yetenekler, Python'ı veri işleme, otomasyon ve sistem yönetimi gibi alanlarda son derece güçlü bir araç haline verir.

# 'with' ifadesi ile güvenli dosya yazma ve okuma
dosya_adi = "gun12_notlar.txt"

# Dosyaya yazma ('w' modu)
with open(dosya_adi, 'w', encoding='utf-8') as f:
    f.write("Python dosya işlemleri harika!\n")
    f.write("Bu ikinci satır.\n")

# Dosyanın sonuna ekleme ('a' modu)
with open(dosya_adi, 'a', encoding='utf-8') as f:
    f.write("Bu da eklenen üçüncü satır.\n")

# Dosyayı okuma ('r' modu)
print(f"'{dosya_adi}' içeriği okunuyor:")
with open(dosya_adi, 'r', encoding='utf-8') as f:
    icerik = f.read()
    print(icerik)

'gun12_notlar.txt' içeriği okunuyor:
Python dosya işlemleri harika!
Bu ikinci satır.
Bu da eklenen üçüncü satır.

🔧 Gün 13 – Hata Ayıklama (Exception Handling)

Yazdığımız programlar ne kadar mükemmel olursa olsun, bazen beklenmedik durumlarla karşılaşabilirler. Kullanıcının sayı yerine metin girmesi, var olmayan bir dosyayı okumaya çalışmak veya sıfıra bölme işlemi yapmak gibi durumlar, programın normal akışını bozarak çökmesine neden olan hatalara (exceptions) yol açar. Python'da bu tür hataları yönetmek ve programın çökmesini engellemek için `try...except` blokları kullanılır. Bu mekanizmaya "hata ayıklama" veya "istisna yönetimi" (exception handling) denir. Temel fikir, hata verme potansiyeli olan kodu `try` bloğu içine almaktır. Eğer bu blok içinde bir hata meydana gelirse, program çökmek yerine `except` bloğuna atlar ve oradaki kodları çalıştırır.

Bir `try` bloğunu birden fazla `except` bloğu takip edebilir. Bu, farklı türdeki hataları farklı şekillerde ele almamıza olanak tanır. Örneğin, kullanıcıdan bir sayı alıp bununla bir bölme işlemi yaptığımızı düşünelim. Kullanıcı metin girerse `ValueError`, bölen olarak sıfır girerse `ZeroDivisionError` hatası alırız. `except ValueError:` ve `except ZeroDivisionError:` şeklinde ayrı bloklar yazarak her bir duruma özel bir kullanıcı mesajı gösterebiliriz. Eğer olası tüm hataları tek bir blokta yakalamak istersek, genel bir `except Exception as e:` ifadesi kullanabiliriz. Buradaki `as e` kısmı, oluşan hata nesnesini bir değişkene atar, böylece hata hakkında daha detaylı bilgi (örneğin hata mesajı) alıp kullanıcıya gösterebilir veya bir log dosyasına yazabiliriz.

`try...except` yapısına ek olarak `else` ve `finally` blokları da eklenebilir. `else` bloğu, `try` bloğunda hiçbir hata oluşmazsa çalıştırılır. Genellikle, sadece `try` bloğundaki kod başarılı olduğunda çalışması gereken kodları `else` bloquna koymak iyi bir pratiktir. `finally` bloğu ise en önemli parçalardan biridir; bu blok içindeki kodlar, `try` bloğunda hata olsun ya da olmasın, her durumda çalıştırılır. Bu özellik, dosya kapatma, veritabanı bağlantısını sonlandırma veya geçici kaynakları temizleme gibi "temizlik" işlemleri için hayati önem taşır. Programın akışı ne olursa olsun bu işlemlerin mutlaka yapılması `finally` ile garanti altına alınır.

Hata ayıklama, sadece programın çökmesini önlemekle kalmaz, aynı zamanda daha sağlam, güvenilir ve kullanıcı dostu uygulamalar yazmamızı sağlar. Beklenmedik durumlara karşı hazırlıklı olmak, kullanıcının neyin yanlış gittiğini anlamasına yardımcı olan açıklayıcı mesajlar göstermek ve programın durumunu tutarlı bir şekilde korumak, profesyonel yazılım geliştirmenin temel prensiplerindendir. Python'ın sunduğu `try, except, else, finally` yapısı, bu prensipleri uygulamak için esnek ve güçlü bir araç seti sunar. Ayrıca `raise` anahtar kelimesi ile kendi özel hatalarımızı oluşturup fırlatabilir, böylece programımızın mantığına özgü hata durumlarını yönetebiliriz.

try:
    sayi1 = int(input("Bölünecek sayıyı girin: "))
    sayi2 = int(input("Bölen sayıyı girin: "))
    sonuc = sayi1 / sayi2
except ValueError:
    print("Hata: Lütfen sadece sayısal değerler girin.")
except ZeroDivisionError:
    print("Hata: Bir sayıyı sıfıra bölemezsiniz.")
except Exception as e:
    print(f"Beklenmedik bir hata oluştu: {e}")
else:
    # Bu blok sadece hata olmadığında çalışır
    print(f"İşlem başarılı! Sonuç: {sonuc}")
finally:
    # Bu blok her zaman çalışır
    print("Hata ayıklama bloğu sona erdi.")

🏢 Gün 14 – Nesne Yönelimli Programlama (OOP) Temelleri

Nesne Yönelimli Programlama (Object-Oriented Programming - OOP), yazılım geliştirmede yaygın olarak kullanılan bir programlama paradigmalarından biridir. Temel amacı, karmaşık problemleri daha küçük, yönetilebilir ve yeniden kullanılabilir parçalara ayırmaktır. Bu parçalar "nesne" (object) olarak adlandırılır. Gerçek dünyadaki nesneler gibi, Python'daki nesnelerin de kendilerine özgü "nitelikleri" (attributes) ve yapabildikleri "davranışları" (methods) vardır. Örneğin, bir "Araba" nesnesinin nitelikleri renk, model, hız olabilirken; davranışları ise hızlanmak, yavaşlamak, durmak olabilir. OOP, bu nesneleri oluşturmak için bir şablon veya kalıp görevi gören "sınıf" (class) kavramını kullanır.

Python'da bir sınıf oluşturmak için `class` anahtar kelimesi kullanılır. `class Araba:` şeklinde bir tanım, Araba nesneleri için bir kalıp oluşturur. Bu sınıfın içinde, nesne oluşturulduğunda otomatik olarak çağrılan özel bir metot olan `__init__()` bulunur. Bu metot, nesnenin başlangıç niteliklerini (örneğin renk, model) ayarlamak için kullanılır. Sınıf içinde tanımlanan fonksiyonlara "metot" denir ve bunlar nesnenin davranışlarını belirler. Örneğin, `def hizlan(self, miktar):` şeklinde bir metot, arabanın hızını artırmasını sağlar. Buradaki `self` parametresi, metodun ait olduğu nesnenin kendisini temsil eder ve o nesnenin niteliklerine (`self.hiz` gibi) erişmek için kullanılır.

OOP'nin dört temel prensibi vardır: Kapsülleme (Encapsulation), Kalıtım (Inheritance), Çok Biçimlilik (Polymorphism) ve Soyutlama (Abstraction). Kapsülleme, bir nesnenin niteliklerini ve bu nitelikleri değiştiren metotlarını bir arada tutarak veriyi dış müdahalelerden koruma fikridir. Kalıtım, mevcut bir sınıfın (üst sınıf veya ebeveyn) tüm nitelik ve metotlarını yeni bir sınıfa (alt sınıf veya çocuk) aktarma yeteneğidir. Bu, kod tekrarını önler ve hiyerarşik bir ilişki kurar (örneğin, `ElektrikliAraba` sınıfı `Araba` sınıfından kalıtım alabilir). Çok biçimlilik, farklı sınıflardaki nesnelerin aynı isimdeki metoda farklı şekillerde yanıt vermesidir. Soyutlama ise nesnenin karmaşık iç yapısını gizleyip sadece gerekli olan arayüzü sunmaktır.

OOP, özellikle büyük ve karmaşık projelerde kodun daha organize, modüler ve bakımı kolay olmasını sağlar. Sınıflar ve nesneler sayesinde, programın farklı bileşenleri arasında net sınırlar çizilir. Bu, ekip çalışmasını kolaylaştırır ve geliştirilen kodun gelecekte genişletilmesini veya değiştirilmesini basitleştirir. Python, saf bir OOP dili olmasa da, nesne yönelimli programlamayı tam olarak destekler ve bu yaklaşım, dilin en güçlü yönlerinden biridir. Veri bilimi kütüphanelerinden (`pandas` DataFrame'leri birer nesnedir) web framework'lerine (`Django` ve `Flask`) kadar Python ekosisteminin büyük bir kısmı OOP prensipleri üzerine kurulmuştur.

# Araba adında bir sınıf (class) tanımlayalım
class Araba:
    # Bu __init__ metodu, bir Araba nesnesi oluşturulduğunda çalışır
    def __init__(self, marka, model, renk):
        self.marka = marka
        self.model = model
        self.renk = renk
        self.hiz = 0

    # Nesnenin davranışlarını belirleyen metotlar
    def hizlan(self, artis):
        self.hiz += artis
        print(f"{self.marka} {self.model} hızlandı. Yeni hız: {self.hiz} km/s")

    def bilgi_ver(self):
        return f"Marka: {self.marka}, Model: {self.model}, Renk: {self.renk}"

# Araba sınıfından bir nesne (instance) oluşturalım
araba1 = Araba("Tesla", "Model S", "Kırmızı")

print(araba1.bilgi_ver())
araba1.hizlan(50)

🏁 Gün 15 – Final ve Mezuniyet!

Tebrikler! Python temelleri eğitiminin son gününe ulaştın. Bu yolculuk boyunca, Python'ın temel sözdiziminden başlayarak değişkenler, veri tipleri, döngüler ve koşullu ifadeler gibi programlamanın yapı taşlarını öğrendin. Fonksiyonlar yazarak kodunu nasıl daha modüler ve tekrar kullanılabilir hale getireceğini, listeler, demetler ve sözlükler gibi veri yapılarıyla bilgiyi nasıl etkili bir şekilde organize edeceğini keşfettin. Bu temel bilgiler, daha karmaşık programlama konseptlerine geçiş yapman için sağlam bir zemin oluşturdu.

Eğitimin ikinci yarısında ise daha ileri seviye konulara daldık. Modüller ve paketler ile kodunu nasıl organize edeceğini ve Python'un zengin kütüphane ekosisteminden nasıl faydalanacağını gördün. Dosya işlemleriyle programlarının kalıcı verilerle çalışmasını sağladın. Hata ayıklama (exception handling) ile programlarını daha sağlam ve güvenilir hale getirmeyi öğrendin. Son olarak, Nesne Yönelimli Programlama'nın (OOP) temellerine giriş yaparak sınıflar ve nesnelerle modern yazılım geliştirme yaklaşımlarını anladın. Bu konular, seni basit scriptler yazmaktan daha büyük ve yapılandırılmış projeler geliştirmeye taşıyacak anahtarlardır.

Unutma ki programlama, sürekli öğrenme ve pratik yapma gerektiren bir beceridir. Bu eğitim, Python dünyasına atılmış önemli bir ilk adımdı. Buradan sonra yapabileceğin en iyi şey, öğrendiklerini kendi küçük projelerinde uygulamaktır. Bir web sitesinden veri çekmek, basit bir otomasyon scripti yazmak veya küçük bir oyun geliştirmek gibi hedefler belirleyebilirsin. Takıldığın yerlerde araştırma yapmaktan, Python dokümantasyonunu okumaktan ve topluluk forumlarından yardım istemekten çekinme. Şimdi, öğrendiklerini ölçme zamanı! Aşağıdaki final quizi ile bilgilerini test et ve bu eğitim yolculuğunu başarıyla tamamla.