├── .gitignore ├── README.md ├── 3. Ders ├── Örnekler │ ├── ornek_1.py │ ├── ornek_2.py │ ├── ornek_3.py │ ├── ornek_4.py │ └── ornek_5.py └── Ders Notları │ ├── Ders_3-2.md │ └── Ders_3-1.md ├── 2. Ders ├── Örnekler │ ├── ornek_1.py │ ├── ornek_5.py │ ├── ornek_2.py │ ├── ornek_6.py │ ├── ornek_4.py │ └── ornek_3.py └── Ders Notları │ ├── Ders_2-2.md │ └── Ders_2-1.md ├── 1. Ders ├── Örnekler │ ├── ornek_2.py │ ├── ornek_3.py │ ├── ornek_1.py │ └── ornek_4.py └── Ders Notları │ ├── degiskenler_extra.py │ ├── Ders_1-2.md │ ├── Ders_1-3.md │ └── Ders_1-1.md └── 4. Ders ├── Örnekler ├── ornek_1.py ├── ornek_2.py ├── ornek_3.py └── ornek_4.py └── Ders Notları ├── 2-kalitim.ipynb ├── 3-scope.ipynb ├── 1-siniflar.ipynb └── Ders-4.md /.gitignore: -------------------------------------------------------------------------------- 1 | .vscode/ 2 | __pycache__/ 3 | *.pyc -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # IEEE İTÜ Python 2 | 3 | IEEE İTÜ Python 2025-2026 için düzenlenmiş ders notları ve kaynak kodları bu repoda bulunmaktadır. Önceki dönemlere ait notlara erişim için geçmiş commitlere bakabilirsiniz. 4 | 5 | -------------------------------------------------------------------------------- /3. Ders/Örnekler/ornek_1.py: -------------------------------------------------------------------------------- 1 | #### Aldığı tüm elemanları toplayan bir fonksiyon yazacağız. 2 | def liste_topla(*args): 3 | toplam = 0 4 | for sayi in args: 5 | toplam += sayi 6 | return toplam 7 | 8 | print(liste_topla(99,6,3)) 9 | sonuc = liste_topla(1, 2, 3, 4, 5, 6) 10 | print(sonuc) 11 | 12 | -------------------------------------------------------------------------------- /2. Ders/Örnekler/ornek_1.py: -------------------------------------------------------------------------------- 1 | # Bahsettiğimiz gibi, tuple'lar üzerinde değişiklik yapamayız. Ancak veri tipini değiştirerek bunu gerçekleştirebiliriz. 2 | # Tuple'ı liste haline çevirerek üzerinde değişiklikler yapan bir program 3 | 4 | array = (1, 2, 3, 4, 5, 6) 5 | 6 | print(type(array)) 7 | array = list(array) 8 | array.append(99) 9 | array.remove(1) 10 | array = tuple(array) 11 | print(array) 12 | print(type(array)) 13 | -------------------------------------------------------------------------------- /2. Ders/Örnekler/ornek_5.py: -------------------------------------------------------------------------------- 1 | # Bu örnekte, for döngüsü'nün yaptığını yapan bir while döngüsü yazacağız 2 | 3 | chars = ("a", "b", "c", "d", "e", "f") 4 | 5 | limit = len(chars) 6 | i = 0 7 | while (i < limit): 8 | print(chars[i]) 9 | i += 1 10 | 11 | print("\n") 12 | ############################ Aynı İşi yapan for döngüsü:############################ 13 | 14 | chars = ("a", "b", "c", "d", "e", "f") 15 | 16 | for char in chars: 17 | print(char) -------------------------------------------------------------------------------- /1. Ders/Örnekler/ornek_2.py: -------------------------------------------------------------------------------- 1 | """ 2 | Bu örneğimizde, bir öğrencinin notlarını alan ve ortalamasını hesaplayan bir program hazırlayacağız. 3 | """ 4 | 5 | # Öğrencinin notlarını alalım 6 | vize1 = int(input("1. Vize Notu: ")) 7 | vize2 = int(input("2. Vize Notu: ")) 8 | final = int(input("Final Notu: ")) 9 | 10 | # Ortalama hesaplayalım 11 | ortalama = (vize1 * 0.3) + (vize2 * 0.3) + (final * 0.4) 12 | 13 | # Ortalamayı bir üst tam sayıya yuvarlayalım 14 | ortalama = round(ortalama) 15 | 16 | # Ortalamayı yazdıralım 17 | print(f"Ortalama: {ortalama}") 18 | 19 | # Ortalama 50'den küçükse kaldı, 50'den büyükse geçti, geçme durumunu true/false olarak yazdıralım 20 | 21 | gecme_durumu = ortalama >= 50 22 | 23 | print(f"Geçme Durumu: {gecme_durumu}") 24 | -------------------------------------------------------------------------------- /1. Ders/Örnekler/ornek_3.py: -------------------------------------------------------------------------------- 1 | """ 2 | Bu örnekte kullanıcıdan yaş bilgisi alıp, doğum yılını hesaplayan bir program yazacağız. 3 | Ayrıca yaşa göre bazı bilgiler vereceğiz. 4 | """ 5 | 6 | # Mevcut yılı tanımlayalım 7 | current_year = 2025 8 | 9 | # Kullanıcıdan yaş bilgisi alalım 10 | age = int(input("Yaşınızı girin: ")) 11 | 12 | # Doğum yılını hesaplayalım 13 | birth_year = current_year - age 14 | 15 | # Sonuçları yazdıralım 16 | print(f"\nTahmini doğum yılınız: {birth_year}") 17 | print(f"Bugün itibariyle yaklaşık {age * 365} gün yaşadınız!") 18 | print(f"Bir sonraki doğum gününüzde {age + 1} yaşında olacaksınız.") 19 | 20 | # Yaşa göre kategori belirleyelim 21 | if age < 13: 22 | kategori = "Çocuk" 23 | elif age < 20: 24 | kategori = "Genç" 25 | elif age < 65: 26 | kategori = "Yetişkin" 27 | else: 28 | kategori = "Yaşlı" 29 | 30 | print(f"Yaş kategoriniz: {kategori}") 31 | -------------------------------------------------------------------------------- /1. Ders/Örnekler/ornek_1.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Bu örneğimizde, tüm öğrendiklerimizi kullanarak bir öğrencinin verilerini alan ve yazdıran bir program hazırlayacağız. 3 | 4 | Alışmak için değişken tanımlamaları ingilizce yapılmıştır, bildiğimiz üzere değişken isimlerini keyfi yapabiliriz, ancak ingilizce yapmaya alışmanız daha sağlklı olur. 5 | 6 | ''' 7 | # Öğrenci bilgilerini almak için kullanıcıdan input alıyoruz 8 | ad = input("Ad: ") 9 | soyad = input("Soyad: ") 10 | faculty = input("Fakülte: ") 11 | department = input("Bölüm: ") 12 | gpa = input("Ortalama: ") 13 | 14 | # Alınan bilgileri düzenli bir şekilde ekrana yazdırıyoruz 15 | print("\n") # Bir satır boşluk bırakmak için \n özel karakteri kullanılır 16 | print("="*24) 17 | print("---Öğrenci Bilgileri---") 18 | print("="*24) 19 | print("\n") 20 | print(f"Okulumuz öğrencilerinden {ad} {soyad}, {faculty} Fakültesi {department} Bölümünde okumaktadır ve {gpa} ortalamaya sahiptir.") -------------------------------------------------------------------------------- /2. Ders/Örnekler/ornek_2.py: -------------------------------------------------------------------------------- 1 | """ 2 | Bu örnekte dictionary kullanarak bir telefon rehberi oluşturacağız. 3 | Kullanıcı isim ekleyebilir, arayabilir ve tüm rehberi görebilir. 4 | """ 5 | 6 | # Boş bir telefon rehberi oluşturalım 7 | phone_book = {} 8 | 9 | print("=" * 40) 10 | print(" TELEFON REHBERİ") 11 | print("=" * 40) 12 | 13 | # Birkaç kişi ekleyelim 14 | phone_book["Ali Veli"] = "555-1234" 15 | phone_book["Ayşe Yılmaz"] = "555-5678" 16 | phone_book["Mehmet Demir"] = "555-9012" 17 | 18 | print("\nRehberde kayıtlı kişiler:") 19 | for isim, numara in phone_book.items(): 20 | print(f"{isim}: {numara}") 21 | 22 | # Yeni kişi ekleyelim 23 | print("\n" + "-" * 40) 24 | yeni_isim = input("Eklemek istediğiniz kişinin adı: ") 25 | yeni_numara = input("Telefon numarası: ") 26 | phone_book[yeni_isim] = yeni_numara 27 | 28 | print(f"\n{yeni_isim} rehbere eklendi!") 29 | 30 | # Arama yapalım 31 | print("\n" + "-" * 40) 32 | aranan = input("Aramak istediğiniz kişinin adı: ") 33 | 34 | if aranan in phone_book: 35 | print(f"{aranan}: {phone_book[aranan]}") 36 | else: 37 | print("Bu isim rehberde bulunamadı!") 38 | 39 | # Toplam kişi sayısı 40 | print(f"\nRehberde toplam {len(phone_book)} kişi kayıtlı.") 41 | -------------------------------------------------------------------------------- /1. Ders/Örnekler/ornek_4.py: -------------------------------------------------------------------------------- 1 | """ 2 | Bu örnekte basit bir hesap makinesi yapacağız. 3 | Kullanıcıdan iki sayı ve bir işlem alıp, sonucu göstereceğiz. 4 | """ 5 | 6 | print("=" * 30) 7 | print(" Basit Hesap Makinesi") 8 | print("=" * 30) 9 | 10 | # İlk sayıyı alalım 11 | sayi1 = float(input("\nBirinci sayıyı girin: ")) 12 | 13 | # İkinci sayıyı alalım 14 | sayi2 = float(input("İkinci sayıyı girin: ")) 15 | 16 | # İşlem türünü alalım 17 | print("\nİşlem seçin:") 18 | print("1. Toplama (+)") 19 | print("2. Çıkarma (-)") 20 | print("3. Çarpma (*)") 21 | print("4. Bölme (/)") 22 | 23 | islem = input("\nİşlem numarasını girin (1-4): ") 24 | 25 | # İşlemi gerçekleştirelim 26 | if islem == "1": 27 | sonuc = sayi1 + sayi2 28 | islem_simge = "+" 29 | elif islem == "2": 30 | sonuc = sayi1 - sayi2 31 | islem_simge = "-" 32 | elif islem == "3": 33 | sonuc = sayi1 * sayi2 34 | islem_simge = "*" 35 | elif islem == "4": 36 | if sayi2 != 0: 37 | sonuc = sayi1 / sayi2 38 | islem_simge = "/" 39 | else: 40 | print("Hata: Sıfıra bölme yapılamaz!") 41 | exit() 42 | else: 43 | print("Geçersiz işlem!") 44 | exit() 45 | 46 | # Sonucu yazdıralım 47 | print(f"\nSonuç: {sayi1} {islem_simge} {sayi2} = {sonuc}") 48 | -------------------------------------------------------------------------------- /3. Ders/Örnekler/ornek_2.py: -------------------------------------------------------------------------------- 1 | # Küsüratlı sayılara yuvarlama işlemi yapan bir fonksiyon tanımlayacağız. Bu fonksiyona değer olarak yuvarlanamayacak bir girdi(sayı olmayan) verilirse, bu hatayı yakalamaya çalışacağız. 2 | 3 | def yuvarla(sayi, basamak): 4 | basamak = int(basamak) 5 | try: 6 | float(sayi) 7 | except ValueError: 8 | print("Lütfen Doğru formatta bir sayı giriniz.") 9 | return 10 | try: 11 | int(basamak) 12 | except: 13 | print("Lütfen geçerli bir basamak sayısı girin.") 14 | return 15 | try: 16 | tam_kisim = sayi.split(".")[0] 17 | küsürat = sayi.split(".")[1] 18 | except: 19 | print("Yuvarlama işlemi için ondalık bir sayı girmelisiniz.") 20 | return 21 | if(basamak == 0): 22 | return int(tam_kisim) 23 | else: 24 | if(int(küsürat[basamak - 1]) < 5): 25 | yuvarlak_küsürat = küsürat[:basamak] 26 | else: 27 | x = str(int(küsürat[basamak - 1]) + 1) 28 | yuvarlak_küsürat = küsürat[:basamak - 1] + x 29 | sonuc = float(tam_kisim + "." + yuvarlak_küsürat) 30 | return sonuc 31 | 32 | sayi = input("Yuvarlanacak sayıyı girin: ") 33 | basamak = input("Yuvarlanacak basamak sayısı girin: ") 34 | 35 | sonuc = yuvarla(sayi, basamak) 36 | print(sonuc) 37 | 38 | 39 | -------------------------------------------------------------------------------- /1. Ders/Ders Notları/degiskenler_extra.py: -------------------------------------------------------------------------------- 1 | # Adım 1: var isminde bir değişken oluşturuyoruz ve ona 42 sayısını atıyoruz 2 | # Python'da aynı ismi farklı şeyler için kullanabiliriz (ama tavsiye edilmez!) 3 | var = 42 4 | print(f"Adım 1: var:{var} (Değişken tipi: {type(var)})") 5 | 6 | # Adım 2: Şimdi var ismine bir string atıyoruz (bu adım string(var) metoduyla aynı değildir!) 7 | # Değişken tamamen değişti ve artık bir string tutuyor 8 | var = "Merhaba, Dünya!" 9 | print(f"Adım 2: var:{var} (Değişken tipi: {type(var)})") 10 | 11 | # Adım 3: Şimdi var ismini bir fonksiyon için kullanıyoruz 12 | # Bu fonksiyon aldığı sayının karesini hesaplıyor (x ** 2 = x'in karesi) 13 | def var(x): 14 | return x ** 2 15 | 16 | print(f"Adım 3: var(5): {var(5)} (Değişken tipi: {type(var)})") 17 | 18 | # Adım 4: Şimdi var ismini bir sınıf (class) için kullanıyoruz 19 | # Bu sınıf bir değer tutuyor ve çarpma işlemi yapabiliyor 20 | class var: 21 | def __init__(self, value): 22 | self.value = value 23 | 24 | def multiply(self, factor): 25 | return self.value * factor 26 | 27 | # Sonrasında bu var sınıfından çarpma işlemini çağırıyoruz (İlerleyen konularda detaylı anlatılacak) 28 | print(f"Adım 4: {var(10).multiply(3)} (Değişken tipi: {type(var)})") 29 | 30 | # SONUÇ: 31 | # Birden fazla değişkene aynı ismi vermek mümkündür ancak bu, önceki değerin üzerine yazılmasına neden olur. 32 | # Bu nedenle, değişken isimlendirmesinde dikkatli olunmalı ve farklı isimler tercih edilmelidir. 33 | -------------------------------------------------------------------------------- /4. Ders/Örnekler/ornek_1.py: -------------------------------------------------------------------------------- 1 | # Araçların bilgileriin tutan bir sınıf oluşturalım. 2 | 3 | class Vehicle: # Parent Class oluşturulması 4 | def __init__(self, brand, model): 5 | self.brand = brand 6 | self.model = model 7 | def display_info(self): 8 | print(f"Araç: {self.brand} {self.model}") 9 | 10 | 11 | class Car(Vehicle): # Arabalar için child class oluşturulması 12 | def __init__(self, brand, model, num_doors): 13 | super().__init__(brand, model) # Önce parent class'ın fonksiyonu çağrılır 14 | self.num_doors = num_doors 15 | 16 | def display_info(self): 17 | super().display_info() # Önce parent class'ın fonksiyonu çağrılır 18 | print(f"Tür: Araba, Kapı Sayısı: {self.num_doors}") 19 | 20 | class Motorcycle(Vehicle): 21 | def __init__(self, brand, model, num_wheels): 22 | super().__init__(brand, model) # Önce parent class'ın fonksiyonu çağrılır 23 | self.num_wheels = num_wheels 24 | 25 | def display_info(self): 26 | super().display_info() # Önce parent class'ın fonksiyonu çağrılır 27 | print(f"Tür: Motosiklet, Tekerlek Sayısı: {self.num_wheels}") 28 | 29 | # Sınıflardan objelerin oluşturulması 30 | vehicle1 = Vehicle("Generic", "Vehicle") 31 | car1 = Car("Toyota", "Corolla", 4) 32 | motorcycle1 = Motorcycle("Harley-Davidson", "Sportster", 2) 33 | 34 | # Bilgilerin gösterilmesi 35 | vehicle1.display_info() 36 | print("\n") 37 | car1.display_info() 38 | print("\n") 39 | motorcycle1.display_info() -------------------------------------------------------------------------------- /2. Ders/Örnekler/ornek_6.py: -------------------------------------------------------------------------------- 1 | """ 2 | Bu örnekte while döngüsü kullanarak bir tahmin oyunu yapacağız. 3 | Bilgisayar bir sayı tutar, kullanıcı tahmin eder. 4 | """ 5 | 6 | import random 7 | 8 | print("=" * 40) 9 | print(" SAYI TAHMİN OYUNU") 10 | print("=" * 40) 11 | 12 | # Bilgisayar 1-100 arasında rastgele bir sayı tutsun 13 | tutulan_sayi = random.randint(1, 100) 14 | 15 | # Tahmin sayısını tutacak değişken 16 | tahmin_sayisi = 0 17 | max_tahmin = 7 # Kullanıcıya 7 tahmin hakkı verelim 18 | 19 | print(f"\n1 ile 100 arasında bir sayı tuttum.") 20 | print(f"Toplam {max_tahmin} tahmin hakkınız var.\n") 21 | 22 | # Oyun döngüsü 23 | while tahmin_sayisi < max_tahmin: 24 | kalan_hak = max_tahmin - tahmin_sayisi 25 | print(f"Kalan hak: {kalan_hak}") 26 | 27 | # Kullanıcıdan tahmin alalım 28 | try: 29 | tahmin = int(input("Tahmininiz: ")) 30 | except: 31 | print("Lütfen geçerli bir sayı girin!\n") 32 | continue 33 | 34 | tahmin_sayisi += 1 35 | 36 | # Tahmini kontrol edelim 37 | if tahmin == tutulan_sayi: 38 | print(f"\n🎉 Tebrikler! {tahmin_sayisi}. tahminde doğru sayıyı buldunuz!") 39 | print(f"Doğru cevap: {tutulan_sayi}") 40 | break 41 | elif tahmin < tutulan_sayi: 42 | print("⬆️ Daha büyük bir sayı deneyin!\n") 43 | else: 44 | print("⬇️ Daha küçük bir sayı deneyin!\n") 45 | else: 46 | # While döngüsü normal biterse (break ile çıkılmazsa) 47 | print(f"\n😞 Tahmin hakkınız bitti!") 48 | print(f"Doğru cevap: {tutulan_sayi}") 49 | -------------------------------------------------------------------------------- /3. Ders/Örnekler/ornek_3.py: -------------------------------------------------------------------------------- 1 | """ 2 | Bu örnekte, kullanıcıdan alınan metni analiz eden fonksiyonlar yazacağız. 3 | Sesli harf sayısı, kelime sayısı gibi istatistikleri hesaplayacağız. 4 | """ 5 | 6 | def sesli_harf_say(metin): 7 | """Metindeki sesli harf sayısını döndürür""" 8 | sesli_harfler = "aeıioöuüAEIİOÖUÜ" 9 | sayac = 0 10 | for harf in metin: 11 | if harf in sesli_harfler: 12 | sayac += 1 13 | return sayac 14 | 15 | def kelime_say(metin): 16 | """Metindeki kelime sayısını döndürür""" 17 | kelimeler = metin.split() 18 | return len(kelimeler) 19 | 20 | def karakter_say(metin): 21 | """Metindeki karakter sayısını döndürür (boşluksuz)""" 22 | return len(metin.replace(" ", "")) 23 | 24 | def en_uzun_kelime(metin): 25 | """Metindeki en uzun kelimeyi döndürür""" 26 | kelimeler = metin.split() 27 | if kelimeler: 28 | return max(kelimeler, key=len) 29 | return "" 30 | 31 | def metin_analizi(metin): 32 | """Tüm analizleri birleştiren ana fonksiyon""" 33 | print("\n" + "=" * 50) 34 | print("METİN ANALİZİ") 35 | print("=" * 50) 36 | print(f"Metin: {metin}") 37 | print("-" * 50) 38 | print(f"Toplam karakter sayısı (boşluksuz): {karakter_say(metin)}") 39 | print(f"Toplam kelime sayısı: {kelime_say(metin)}") 40 | print(f"Sesli harf sayısı: {sesli_harf_say(metin)}") 41 | print(f"En uzun kelime: {en_uzun_kelime(metin)} ({len(en_uzun_kelime(metin))} harf)") 42 | print("=" * 50) 43 | 44 | # Programı çalıştıralım 45 | print("Metin Analiz Programı") 46 | kullanici_metni = input("Analiz edilecek metni girin: ") 47 | metin_analizi(kullanici_metni) 48 | -------------------------------------------------------------------------------- /2. Ders/Örnekler/ornek_4.py: -------------------------------------------------------------------------------- 1 | # Kullanıcıdan istenilen sayıda öğrenci isimleri ve sınav notları alan, ortalamasını hesaplayan, ve harf notu veren bir program yazalım 2 | # sınavlar sırasıyla %10, 20, 30 ve 40 ağırlıklı olsun 3 | 4 | students = {} # Verileri tutacağımız boş dictionary 5 | num = int(input("Öğrenci Sayısı Girin: ")) 6 | print("\n") 7 | i = 0 8 | while i < num: # Öğrenci notlarını alacak döngü 9 | notes = [] # Öğrenci notlarını tutacağımız boş listeyi oluşturuyoruz (döngü 2. kez döndüğü sefer için de listeyi boşaltmış oluyoruz.) 10 | print("\n") 11 | name = input("Öğrenci Adı Girin: ") 12 | j = 0 13 | while j < 4: 14 | note = int(input(f"{j + 1}. Sınav Notu: ")) 15 | notes.append(note) 16 | j += 1 17 | students[name] = notes # Dictionary içine o öğrenci ve sahip olduğu notlar girildi 18 | i += 1 19 | 20 | avg_notes = {} # Not ortalamalarını tutacağımız değişken 21 | 22 | for name, notes in students.items(): # Ortalamaları hesaplayacak döngü 23 | total = 0 # not toplamını tutacak deiğişken 24 | for note in notes: 25 | total += note 26 | avg = total / len(notes) # Not ortalaması hesabı 27 | avg_notes[name] = avg # Dictionary içine o öğrenci ve nor ortalaması girildi 28 | 29 | grades = {} # Harf notlarını tutacağımız değişken 30 | 31 | for name, note in avg_notes.items(): # Harf notlarının atanması 32 | if note > 90 : 33 | grade = "A" 34 | elif note > 70: 35 | grade = "B" 36 | elif note > 50: 37 | grade = "C" 38 | elif note > 40: 39 | grade = "D" 40 | else: 41 | grade = "F" 42 | grades[name] = grade 43 | 44 | print(grades) 45 | 46 | 47 | 48 | -------------------------------------------------------------------------------- /2. Ders/Örnekler/ornek_3.py: -------------------------------------------------------------------------------- 1 | """ 2 | Bu örnekte liste üzerinde çeşitli işlemler yapacağız. 3 | Kullanıcıdan alınan sayıları listeye ekleyip, istatistiklerini hesaplayacağız. 4 | """ 5 | 6 | # Boş bir liste oluşturalım 7 | sayilar = [] 8 | 9 | print("Sayı Listesi Programı") 10 | print("(Durdurmak için 'q' yazın)\n") 11 | 12 | # Kullanıcıdan sayılar alalım 13 | while True: 14 | girdi = input("Bir sayı girin: ") 15 | 16 | if girdi.lower() == 'q': 17 | break 18 | 19 | try: 20 | sayi = float(girdi) 21 | sayilar.append(sayi) 22 | print(f"✓ {sayi} listeye eklendi") 23 | except: 24 | print("✗ Lütfen geçerli bir sayı girin!") 25 | 26 | # Liste boş değilse istatistikleri gösterelim 27 | if len(sayilar) > 0: 28 | print("\n" + "=" * 40) 29 | print("İSTATİSTİKLER") 30 | print("=" * 40) 31 | 32 | # Listeyi yazdıralım 33 | print(f"Girilen sayılar: {sayilar}") 34 | 35 | # Eleman sayısı 36 | print(f"Toplam eleman sayısı: {len(sayilar)}") 37 | 38 | # En büyük ve en küçük 39 | print(f"En büyük sayı: {max(sayilar)}") 40 | print(f"En küçük sayı: {min(sayilar)}") 41 | 42 | # Toplam ve ortalama 43 | toplam = sum(sayilar) 44 | ortalama = toplam / len(sayilar) 45 | print(f"Toplam: {toplam}") 46 | print(f"Ortalama: {ortalama:.2f}") 47 | 48 | # Sıralı hali 49 | sayilar.sort() 50 | print(f"Küçükten büyüğe sıralı: {sayilar}") 51 | 52 | # Pozitif ve negatif sayılar 53 | pozitif = [s for s in sayilar if s > 0] 54 | negatif = [s for s in sayilar if s < 0] 55 | print(f"Pozitif sayılar: {len(pozitif)} adet") 56 | print(f"Negatif sayılar: {len(negatif)} adet") 57 | else: 58 | print("\nListeye hiç sayı eklenmedi!") 59 | -------------------------------------------------------------------------------- /3. Ders/Örnekler/ornek_4.py: -------------------------------------------------------------------------------- 1 | """ 2 | Bu örnekte, matematik işlemleri yapan bir modül oluşturacağız. 3 | Farklı fonksiyonlarla faktöriyel, asal sayı kontrolü gibi işlemler yapacağız. 4 | """ 5 | 6 | def faktoriyel(n): 7 | """Bir sayının faktöriyelini hesaplar""" 8 | if n < 0: 9 | return "Negatif sayıların faktöriyeli hesaplanamaz!" 10 | elif n == 0 or n == 1: 11 | return 1 12 | else: 13 | sonuc = 1 14 | for i in range(2, n + 1): 15 | sonuc *= i 16 | return sonuc 17 | 18 | def asal_mi(sayi): 19 | """Bir sayının asal olup olmadığını kontrol eder""" 20 | if sayi < 2: 21 | return False 22 | for i in range(2, int(sayi ** 0.5) + 1): 23 | if sayi % i == 0: 24 | return False 25 | return True 26 | 27 | def fibonacci(n): 28 | """İlk n fibonacci sayısını döndürür""" 29 | if n <= 0: 30 | return [] 31 | elif n == 1: 32 | return [0] 33 | elif n == 2: 34 | return [0, 1] 35 | 36 | fib_listesi = [0, 1] 37 | for i in range(2, n): 38 | fib_listesi.append(fib_listesi[-1] + fib_listesi[-2]) 39 | return fib_listesi 40 | 41 | def mukemmel_kare_mi(sayi): 42 | """Bir sayının mükemmel kare olup olmadığını kontrol eder""" 43 | if sayi < 0: 44 | return False 45 | karekok = int(sayi ** 0.5) 46 | return karekok * karekok == sayi 47 | 48 | # Test edelim 49 | print("MATEMAT İK İŞLEMLER") 50 | print("=" * 50) 51 | 52 | # Faktöriyel testi 53 | print("\n1. Faktöriyel Hesaplama") 54 | sayi = int(input("Bir sayı girin: ")) 55 | print(f"{sayi}! = {faktoriyel(sayi)}") 56 | 57 | # Asal sayı testi 58 | print("\n2. Asal Sayı Kontrolü") 59 | sayi = int(input("Bir sayı girin: ")) 60 | if asal_mi(sayi): 61 | print(f"{sayi} asal bir sayıdır!") 62 | else: 63 | print(f"{sayi} asal bir sayı değildir.") 64 | 65 | # Fibonacci dizisi 66 | print("\n3. Fibonacci Dizisi") 67 | n = int(input("Kaç fibonacci sayısı görmek istersiniz? ")) 68 | print(f"İlk {n} fibonacci sayısı: {fibonacci(n)}") 69 | 70 | # Mükemmel kare kontrolü 71 | print("\n4. Mükemmel Kare Kontrolü") 72 | sayi = int(input("Bir sayı girin: ")) 73 | if mukemmel_kare_mi(sayi): 74 | print(f"{sayi} mükemmel bir karedir! (√{sayi} = {int(sayi ** 0.5)})") 75 | else: 76 | print(f"{sayi} mükemmel bir kare değildir.") 77 | -------------------------------------------------------------------------------- /3. Ders/Ders Notları/Ders_3-2.md: -------------------------------------------------------------------------------- 1 | # Ders 3-2 : Dekoratörler ve Lambda Fonksiyonları 2 | 3 | ## Dekoratörler 4 | Dekoratörler, bir fonksiyonu alıp ona yeni işlevsellik ekleyen özel fonksiyonlardır. Dekoratörler, genellikle fonksiyonların davranışını değiştirmek veya genişletmek için kullanılır. Dekoratörler, `@` sembolü ile uygulanır. 5 | Örnek bir dekoratör tanımlayalım: 6 | 7 | ```python 8 | def example_decorator(func): 9 | def wrapper(): 10 | print("Fonksiyon çalışmadan öncesi.") 11 | func() 12 | print("Fonksiyon çalıştıktan sonrası.") 13 | return wrapper 14 | 15 | @example_decorator 16 | def example_function(): 17 | print("Hello World!") 18 | ``` 19 | 20 | Çıktısı şöyle olacaktır: 21 | ``` 22 | Fonksiyon çalışmadan öncesi. 23 | Hello World! 24 | Fonksiyon çalıştıktan sonrası. 25 | ``` 26 | 27 | Başka bir örnek olarak, bir fonksiyonun çalışma süresini ölçen bir dekoratör yapalım: 28 | 29 | ```python 30 | import time 31 | 32 | def zamanlayici(fonksiyon): 33 | def sarmalayıcı(*args, **kwargs): 34 | baslangic = time.time() 35 | sonuc = fonksiyon(*args, **kwargs) 36 | bitis = time.time() 37 | print(f"{fonksiyon.__name__} fonksiyonu {bitis - baslangic} saniye sürdü.") 38 | return sonuc 39 | return sarmalayıcı 40 | 41 | @zamanlayici 42 | def uzun_sureli_islem(): 43 | time.sleep(2) 44 | print("İşlem tamamlandı.") 45 | 46 | uzun_sureli_islem() 47 | ``` 48 | 49 | Burada, `zamanlayici` dekoratörü, `uzun_sureli_islem` fonksiyonunun çalışma süresini ölçer ve sonucu ekrana yazdırır. 50 | 51 | ## Lambda Fonksiyonları 52 | Lambda fonksiyonları, tek satırlık anonim fonksiyonlardır. `lambda` anahtar kelimesi ile tanımlanırlar ve genellikle kısa ve basit işlemler için kullanılırlar. Lambda fonksiyonları, normal fonksiyonlara göre daha kısa ve özdür. Örnek bir lambda fonksiyonu tanımlayalım: 53 | 54 | ```python 55 | topla = lambda x, y: x + y 56 | print(topla(3, 5)) # Çıktı: 8 57 | ``` 58 | Lambda fonksiyonları, genellikle `map()`, `filter()` ve `reduce()` gibi fonksiyonlarla birlikte kullanılırlar. Örneğin, bir liste içindeki sayıları iki katına çıkarmak için `map()` fonksiyonu ile birlikte bir lambda fonksiyonu kullanabiliriz: 59 | 60 | ```python 61 | sayilar = [1, 2, 3, 4, 5] 62 | iki_kat = list(map(lambda x: x * 2, sayilar)) 63 | print(iki_kat) # Çıktı: [2, 4, 6, 8, 10] 64 | ``` 65 | Benzer şekilde, `filter()` fonksiyonu ile bir liste içindeki çift sayıları seçmek için bir lambda fonksiyonu kullanabiliriz: 66 | 67 | ```python 68 | cift_sayilar = list(filter(lambda x: x % 2 == 0, sayilar)) 69 | print(cift_sayilar) # Çıktı: [2, 4] 70 | ``` 71 | 72 | -------------------------------------------------------------------------------- /3. Ders/Örnekler/ornek_5.py: -------------------------------------------------------------------------------- 1 | """ 2 | Bu örnekte, liste ve dictionary kullanarak bir to-do list (yapılacaklar listesi) uygulaması yapacağız. 3 | Modüler fonksiyonlar kullanarak program yazacağız. 4 | """ 5 | 6 | def gorev_ekle(gorevler, gorev): 7 | """Yeni bir görev ekler""" 8 | gorevler.append({"gorev": gorev, "tamamlandi": False}) 9 | print(f"✓ '{gorev}' görevi eklendi!") 10 | 11 | def gorevleri_listele(gorevler): 12 | """Tüm görevleri listeler""" 13 | if not gorevler: 14 | print("Henüz görev eklenmemiş!") 15 | return 16 | 17 | print("\n" + "=" * 60) 18 | print("YAPILACAKLAR LİSTESİ") 19 | print("=" * 60) 20 | for index, gorev in enumerate(gorevler, 1): 21 | durum = "✓" if gorev["tamamlandi"] else "○" 22 | print(f"{index}. [{durum}] {gorev['gorev']}") 23 | print("=" * 60) 24 | 25 | def gorev_tamamla(gorevler, index): 26 | """Bir görevi tamamlanmış olarak işaretler""" 27 | if 0 <= index < len(gorevler): 28 | gorevler[index]["tamamlandi"] = True 29 | print(f"✓ '{gorevler[index]['gorev']}' tamamlandı!") 30 | else: 31 | print("Geçersiz görev numarası!") 32 | 33 | def gorev_sil(gorevler, index): 34 | """Bir görevi siler""" 35 | if 0 <= index < len(gorevler): 36 | silinen = gorevler.pop(index) 37 | print(f"✓ '{silinen['gorev']}' silindi!") 38 | else: 39 | print("Geçersiz görev numarası!") 40 | 41 | def istatistikler(gorevler): 42 | """Görev istatistiklerini gösterir""" 43 | toplam = len(gorevler) 44 | tamamlanan = sum(1 for g in gorevler if g["tamamlandi"]) 45 | kalan = toplam - tamamlanan 46 | 47 | print(f"\n📊 Toplam görev: {toplam}") 48 | print(f"✓ Tamamlanan: {tamamlanan}") 49 | print(f"○ Kalan: {kalan}") 50 | if toplam > 0: 51 | print(f"📈 Tamamlanma oranı: %{(tamamlanan/toplam)*100:.1f}") 52 | 53 | # Ana program 54 | gorevler = [] 55 | 56 | print("=" * 60) 57 | print("YAPILACAKLAR LİSTESİ UYGULAMASI") 58 | print("=" * 60) 59 | 60 | while True: 61 | print("\n1. Görev Ekle") 62 | print("2. Görevleri Listele") 63 | print("3. Görevi Tamamla") 64 | print("4. Görev Sil") 65 | print("5. İstatistikler") 66 | print("6. Çıkış") 67 | 68 | secim = input("\nSeçiminiz (1-6): ") 69 | 70 | if secim == "1": 71 | gorev = input("Görev: ") 72 | gorev_ekle(gorevler, gorev) 73 | 74 | elif secim == "2": 75 | gorevleri_listele(gorevler) 76 | 77 | elif secim == "3": 78 | gorevleri_listele(gorevler) 79 | try: 80 | index = int(input("Tamamlanacak görev numarası: ")) - 1 81 | gorev_tamamla(gorevler, index) 82 | except: 83 | print("Geçersiz giriş!") 84 | 85 | elif secim == "4": 86 | gorevleri_listele(gorevler) 87 | try: 88 | index = int(input("Silinecek görev numarası: ")) - 1 89 | gorev_sil(gorevler, index) 90 | except: 91 | print("Geçersiz giriş!") 92 | 93 | elif secim == "5": 94 | istatistikler(gorevler) 95 | 96 | elif secim == "6": 97 | print("Programdan çıkılıyor. Hoşça kalın!") 98 | break 99 | 100 | else: 101 | print("Geçersiz seçim! Lütfen 1-6 arası bir sayı girin.") 102 | -------------------------------------------------------------------------------- /1. Ders/Ders Notları/Ders_1-2.md: -------------------------------------------------------------------------------- 1 | # Ders 1-2: Temel Kavramlar 2 | 3 | ## Değişkenler ve Veri Tipleri 4 | 5 | Python'da değişkenler, verileri saklamak için kullanılır. Değişkenler herhangi bir veri tipini içerebilir, örneğin sayılar, metinler (string), listeler, vb. 6 | 7 | ### Değişken Tanımlama 8 | 9 | Python'da bir değişken tanımlamak için, değişkenin adını yazıp eşittir (`=`) işareti ile bir değer atamanız yeterlidir. Örneğin: 10 | 11 | ```python 12 | sayi = 10 13 | metin = "Merhaba" 14 | durum = True # Neden böyle bir değer atadık? 15 | ``` 16 | 17 | Tanımlanan değişkenler daha sonra programın herhangi bir yerinde kullanılabilir. Tanımladığımız değişkenlerin değerlerini ekrana yazdırmak için `print()` fonksiyonunu kullanabilirsiniz: 18 | 19 | ```python 20 | print(sayi) # Çıktı: 10 21 | print(metin) # Çıktı: Merhaba 22 | print(durum) # Çıktı: True 23 | ``` 24 | Bir değişkenin değerini değiştirmek de oldukça basittir. Yeni bir değer atayarak mevcut değeri güncelleyebilirsiniz: 25 | 26 | ```python 27 | sayi = 20 28 | print(sayi) # Çıktı: 20 29 | sayi = sayi + 5 30 | print(sayi) # Çıktı: 25 31 | sayi = 2 32 | print(sayi) # Çıktı: 2 33 | ``` 34 | 35 | Python'da değişken adları harfler, rakamlar ve alt çizgi (`_`) içerebilir, ancak rakamla başlayamaz. Ayrıca, Python anahtar kelimeleri (örneğin `if`, `for`, `while` gibi) değişken adı olarak kullanılamaz. 36 | 37 | ### Veri tipleri 38 | 39 | Python veriyi saklamak için çeşitli veri tipleri sunar. Sayıları saklamak için kullandığımız veri tiplerine bakacak olursak: 40 | - `int`: Tam sayılar için kullanılır. Örneğin: `5`, `-3`, `0` 41 | - `float`: Ondalıklı sayılar için kullanılır. Örneğin: `3.14`, `-0.001`, `2.0` 42 | - `complex`: Karmaşık sayılar için kullanılır. Örneğin: `2 + 3j`, `-1 + 0j` 43 | 44 | Bu veri tiplerini kullanarak değişkenler tanımlayabiliriz: 45 | 46 | ```python 47 | a = 10 # int 48 | b = 3.14 # float 49 | c = 2 + 3j # complex 50 | print(type(a)) # Çıktı: 51 | print(type(b)) # Çıktı: 52 | print(type(c)) # Çıktı: 53 | ``` 54 | Bu sayı tipleri birbirine dönüştürülebilir. Örneğin, bir `int` değeri `float`'a dönüştürmek için `float()` fonksiyonunu kullanabilirsiniz: 55 | 56 | ```python 57 | x = 5 # int 58 | y = float(x) # float 59 | print(x) # Çıktı: 5 60 | print(type(x)) # Çıktı: 61 | print(y) # Çıktı: 5.0 62 | print(type(y)) # Çıktı: 63 | ``` 64 | Metin (string) veri tipi, karakter dizilerini saklamak için kullanılır. Metinler tek tırnak (`'`) veya çift tırnak (`"`) içinde tanımlanabilir: 65 | 66 | ```python 67 | metin1 = 'Merhaba' 68 | metin2 = "Dünya" 69 | print(metin1) # Çıktı: Merhaba 70 | print(metin2) # Çıktı: Dünya 71 | print(type(metin1)) # Çıktı: 72 | ``` 73 | Stringler de aynı şekilde başka türlere dönüştürülebilir. Örneğin, bir sayıyı string'e dönüştürmek için `str()` fonksiyonunu kullanabilirsiniz: 74 | 75 | ```python 76 | sayi = 100 77 | metin = str(sayi) 78 | print(sayi) # Çıktı: 100 79 | print(type(sayi)) # Çıktı: 80 | print(metin) # Çıktı: 100 81 | print(type(metin))# Çıktı: 82 | ``` 83 | Boolean (bool) veri tipi, sadece iki değerden birini alabilir: `True` (doğru) veya `False` (yanlış). Genellikle koşullu ifadelerde kullanılır: 84 | 85 | ```python 86 | durum1 = True 87 | durum2 = False 88 | print(durum1) # Çıktı: True 89 | print(durum2) # Çıktı: False 90 | print(type(durum1)) # Çıktı: 91 | ``` 92 | 93 | 94 | -------------------------------------------------------------------------------- /4. Ders/Örnekler/ornek_2.py: -------------------------------------------------------------------------------- 1 | """ 2 | Bu örnekte bir banka hesabı sistemi oluşturacağız. 3 | Sınıflar kullanarak hesap oluşturma, para yatırma, çekme işlemleri yapacağız. 4 | """ 5 | 6 | class BankaHesabi: 7 | """Temel banka hesabı sınıfı""" 8 | 9 | hesap_sayisi = 0 # Class attribute - toplam hesap sayısı 10 | 11 | def __init__(self, hesap_sahibi, bakiye=0): 12 | self.hesap_sahibi = hesap_sahibi 13 | self.bakiye = bakiye 14 | BankaHesabi.hesap_sayisi += 1 15 | self.hesap_no = f"TR{1000 + BankaHesabi.hesap_sayisi}" 16 | 17 | def para_yatir(self, miktar): 18 | """Hesaba para yatırır""" 19 | if miktar > 0: 20 | self.bakiye += miktar 21 | print(f"✓ {miktar} TL yatırıldı. Yeni bakiye: {self.bakiye} TL") 22 | else: 23 | print("✗ Geçersiz miktar!") 24 | 25 | def para_cek(self, miktar): 26 | """Hesaptan para çeker""" 27 | if miktar > 0: 28 | if miktar <= self.bakiye: 29 | self.bakiye -= miktar 30 | print(f"✓ {miktar} TL çekildi. Kalan bakiye: {self.bakiye} TL") 31 | else: 32 | print("✗ Yetersiz bakiye!") 33 | else: 34 | print("✗ Geçersiz miktar!") 35 | 36 | def bakiye_goster(self): 37 | """Hesap bakiyesini gösterir""" 38 | print(f"💰 Bakiye: {self.bakiye} TL") 39 | 40 | def __str__(self): 41 | return f"Hesap No: {self.hesap_no} | Hesap Sahibi: {self.hesap_sahibi} | Bakiye: {self.bakiye} TL" 42 | 43 | 44 | class VadesizHesap(BankaHesabi): 45 | """Vadesiz hesap - ek özelliklerle""" 46 | 47 | def __init__(self, hesap_sahibi, bakiye=0): 48 | super().__init__(hesap_sahibi, bakiye) 49 | self.islem_ucreti = 2 # Her işlemde 2 TL ücret 50 | 51 | def para_cek(self, miktar): 52 | """Para çekme işleminde ücret kesilir""" 53 | toplam = miktar + self.islem_ucreti 54 | if toplam <= self.bakiye: 55 | self.bakiye -= toplam 56 | print(f"✓ {miktar} TL çekildi ({self.islem_ucreti} TL işlem ücreti)") 57 | print(f"Kalan bakiye: {self.bakiye} TL") 58 | else: 59 | print("✗ Yetersiz bakiye! (İşlem ücreti dahil)") 60 | 61 | 62 | class VadeliHesap(BankaHesabi): 63 | """Vadeli hesap - faiz kazandırır""" 64 | 65 | def __init__(self, hesap_sahibi, bakiye=0, faiz_orani=0.05): 66 | super().__init__(hesap_sahibi, bakiye) 67 | self.faiz_orani = faiz_orani # Yıllık %5 faiz 68 | 69 | def faiz_ekle(self): 70 | """Hesaba faiz ekler""" 71 | faiz = self.bakiye * self.faiz_orani 72 | self.bakiye += faiz 73 | print(f"✓ {faiz:.2f} TL faiz eklendi. Yeni bakiye: {self.bakiye:.2f} TL") 74 | 75 | def para_cek(self, miktar): 76 | """Vadeli hesaptan para çekmek için ceza var""" 77 | print("⚠️ Vadeli hesaptan erken çekimde %10 ceza uygulanır.") 78 | ceza = miktar * 0.1 79 | toplam = miktar + ceza 80 | if toplam <= self.bakiye: 81 | self.bakiye -= toplam 82 | print(f"✓ {miktar} TL çekildi ({ceza:.2f} TL ceza)") 83 | print(f"Kalan bakiye: {self.bakiye:.2f} TL") 84 | else: 85 | print("✗ Yetersiz bakiye!") 86 | 87 | 88 | # Programı test edelim 89 | print("=" * 60) 90 | print("BANKA HESAP SİSTEMİ") 91 | print("=" * 60) 92 | 93 | # Farklı hesap türleri oluşturalım 94 | hesap1 = BankaHesabi("Ahmet Yılmaz", 1000) 95 | hesap2 = VadesizHesap("Ayşe Demir", 500) 96 | hesap3 = VadeliHesap("Mehmet Kaya", 2000, 0.08) 97 | 98 | print(f"\n{hesap1}") 99 | print(f"{hesap2}") 100 | print(f"{hesap3}") 101 | 102 | # İşlemler yapalım 103 | print("\n" + "-" * 60) 104 | print("HESAP 1 İŞLEMLERİ (Normal Hesap)") 105 | print("-" * 60) 106 | hesap1.para_yatir(500) 107 | hesap1.para_cek(200) 108 | hesap1.bakiye_goster() 109 | 110 | print("\n" + "-" * 60) 111 | print("HESAP 2 İŞLEMLERİ (Vadesiz Hesap)") 112 | print("-" * 60) 113 | hesap2.para_yatir(300) 114 | hesap2.para_cek(100) # İşlem ücreti kesilecek 115 | hesap2.bakiye_goster() 116 | 117 | print("\n" + "-" * 60) 118 | print("HESAP 3 İŞLEMLERİ (Vadeli Hesap)") 119 | print("-" * 60) 120 | hesap3.faiz_ekle() 121 | hesap3.para_cek(500) # Ceza uygulanacak 122 | hesap3.bakiye_goster() 123 | 124 | print(f"\n Toplam açılan hesap sayısı: {BankaHesabi.hesap_sayisi}") 125 | -------------------------------------------------------------------------------- /4. Ders/Örnekler/ornek_3.py: -------------------------------------------------------------------------------- 1 | """ 2 | Bu örnekte abstraction (soyutlama) kullanarak bir şekil hesaplama sistemi yapacağız. 3 | Abstract base class ile farklı şekiller için ortak arayüz oluşturacağız. 4 | """ 5 | 6 | from abc import ABC, abstractmethod 7 | import math 8 | 9 | class Sekil(ABC): 10 | """Abstract base class - tüm şekiller için temel sınıf""" 11 | 12 | def __init__(self, isim): 13 | self.isim = isim 14 | 15 | @abstractmethod 16 | def alan_hesapla(self): 17 | """Her şekil kendi alan hesaplama yöntemini tanımlamalı""" 18 | pass 19 | 20 | @abstractmethod 21 | def cevre_hesapla(self): 22 | """Her şekil kendi çevre hesaplama yöntemini tanımlamalı""" 23 | pass 24 | 25 | def bilgi_goster(self): 26 | """Şekil bilgilerini gösterir - concrete method""" 27 | print(f"\n{'=' * 50}") 28 | print(f"Şekil: {self.isim}") 29 | print(f"Alan: {self.alan_hesapla():.2f} birim²") 30 | print(f"Çevre: {self.cevre_hesapla():.2f} birim") 31 | print(f"{'=' * 50}") 32 | 33 | 34 | class Kare(Sekil): 35 | """Kare şekli""" 36 | 37 | def __init__(self, kenar): 38 | super().__init__("Kare") 39 | self.kenar = kenar 40 | 41 | def alan_hesapla(self): 42 | return self.kenar ** 2 43 | 44 | def cevre_hesapla(self): 45 | return 4 * self.kenar 46 | 47 | 48 | class Dikdortgen(Sekil): 49 | """Dikdörtgen şekli""" 50 | 51 | def __init__(self, uzunluk, genislik): 52 | super().__init__("Dikdörtgen") 53 | self.uzunluk = uzunluk 54 | self.genislik = genislik 55 | 56 | def alan_hesapla(self): 57 | return self.uzunluk * self.genislik 58 | 59 | def cevre_hesapla(self): 60 | return 2 * (self.uzunluk + self.genislik) 61 | 62 | 63 | class Daire(Sekil): 64 | """Daire şekli""" 65 | 66 | def __init__(self, yaricap): 67 | super().__init__("Daire") 68 | self.yaricap = yaricap 69 | 70 | def alan_hesapla(self): 71 | return math.pi * (self.yaricap ** 2) 72 | 73 | def cevre_hesapla(self): 74 | return 2 * math.pi * self.yaricap 75 | 76 | 77 | class Ucgen(Sekil): 78 | """Üçgen şekli (kenar uzunlukları ile)""" 79 | 80 | def __init__(self, kenar1, kenar2, kenar3): 81 | super().__init__("Üçgen") 82 | self.kenar1 = kenar1 83 | self.kenar2 = kenar2 84 | self.kenar3 = kenar3 85 | 86 | def cevre_hesapla(self): 87 | return self.kenar1 + self.kenar2 + self.kenar3 88 | 89 | def alan_hesapla(self): 90 | # Heron formülü kullanarak alan hesaplama 91 | s = self.cevre_hesapla() / 2 92 | alan = math.sqrt(s * (s - self.kenar1) * (s - self.kenar2) * (s - self.kenar3)) 93 | return alan 94 | 95 | 96 | class Yamuk(Sekil): 97 | """Yamuk şekli""" 98 | 99 | def __init__(self, taban1, taban2, yukseklik, kenar1, kenar2): 100 | super().__init__("Yamuk") 101 | self.taban1 = taban1 102 | self.taban2 = taban2 103 | self.yukseklik = yukseklik 104 | self.kenar1 = kenar1 105 | self.kenar2 = kenar2 106 | 107 | def alan_hesapla(self): 108 | return ((self.taban1 + self.taban2) * self.yukseklik) / 2 109 | 110 | def cevre_hesapla(self): 111 | return self.taban1 + self.taban2 + self.kenar1 + self.kenar2 112 | 113 | 114 | # Şekilleri oluşturalım ve test edelim 115 | print("=" * 50) 116 | print("GEOMETRİK ŞEKİL HESAPLAMA SİSTEMİ") 117 | print("=" * 50) 118 | 119 | # Farklı şekiller oluşturalım 120 | kare = Kare(5) 121 | dikdortgen = Dikdortgen(8, 4) 122 | daire = Daire(3) 123 | ucgen = Ucgen(3, 4, 5) 124 | yamuk = Yamuk(6, 4, 3, 3.5, 3.5) 125 | 126 | # Tüm şekilleri bir listede tutalım 127 | sekiller = [kare, dikdortgen, daire, ucgen, yamuk] 128 | 129 | # Her şeklin bilgilerini gösterelim 130 | for sekil in sekiller: 131 | sekil.bilgi_goster() 132 | 133 | # Toplam alan hesabı 134 | print("\n" + "=" * 50) 135 | print("TOPLU İSTATİSTİKLER") 136 | print("=" * 50) 137 | toplam_alan = sum(sekil.alan_hesapla() for sekil in sekiller) 138 | toplam_cevre = sum(sekil.cevre_hesapla() for sekil in sekiller) 139 | 140 | print(f"Toplam {len(sekiller)} şekil hesaplandı") 141 | print(f"Toplam alan: {toplam_alan:.2f} birim²") 142 | print(f"Toplam çevre: {toplam_cevre:.2f} birim") 143 | print(f"Ortalama alan: {toplam_alan/len(sekiller):.2f} birim²") 144 | 145 | # En büyük alana sahip şekil 146 | en_buyuk = max(sekiller, key=lambda s: s.alan_hesapla()) 147 | print(f"En büyük alan: {en_buyuk.isim} ({en_buyuk.alan_hesapla():.2f} birim²)") 148 | -------------------------------------------------------------------------------- /2. Ders/Ders Notları/Ders_2-2.md: -------------------------------------------------------------------------------- 1 | # Ders 2-2: Döngüler ve Error Handling 2 | 3 | ## Döngüler 4 | 5 | Döngüler, belirli bir koşul sağlandığı sürece bir kod bloğunu tekrar tekrar çalıştırmak için kullanılır. Python'da en yaygın kullanılan döngü türleri `for` döngüsü ve `while` döngüsüdür. 6 | 7 | ### For Döngüsü 8 | 9 | `for` döngüsü, bir dizinin (liste, tuple, set, vb.) elemanları üzerinde döngü yapmak için kullanılır. Örnek: 10 | 11 | ```python 12 | meyveler = ["elma", "armut", "muz"] 13 | for meyve in meyveler: 14 | print(meyve) 15 | ``` 16 | 17 | Yukarıdaki örnekte, `meyveler` listesindeki her bir meyve için döngü çalışır ve meyve adı ekrana yazdırılır. 18 | 19 | ### While Döngüsü 20 | 21 | `while` döngüsü, belirli bir koşul doğru olduğu sürece döngüyü çalıştırır. Örnek: 22 | 23 | ```python 24 | sayi = 0 25 | while sayi < 5: 26 | print(sayi) 27 | sayi += 1 28 | ``` 29 | 30 | Bu örnekte, `sayi` değişkeni 5'ten küçük olduğu sürece döngü çalışır ve her seferinde `sayi` 1 artırılır. 31 | 32 | ### For ve While Döngülerinin Karşılaştırılması 33 | - `for` döngüsü, genellikle belirli bir koleksiyonun elemanları üzerinde işlem yapmak için kullanılır. 34 | - `while` döngüsü ise, belirli bir koşul sağlandığı sürece çalışır ve genellikle koşula bağlı işlemler için tercih edilir. 35 | 36 | Daha iyi oturması için bir metafor kullanabiliriz: 37 | 38 | - 50 Tane şınav çekmak istiyorsanız ve her şınavı tek tek sayacaksanız, `for` döngüsü kullanırsınız. 39 | - Ancak, şınav çekmeye devam edeceksiniz ama ne zaman duracağınızı bilmiyorsanız, örneğin "Artık yoruldum" dediğinizde duracaksanız, o zaman `while` döngüsü kullanırsınız. 40 | 41 | ### Break ve Continue 42 | 43 | Döngülerde `break` ve `continue` anahtar kelimeleri de kullanılır. 44 | 45 | - `break`: Döngüyü sonlandırmak için kullanılır. 46 | - `continue`: Döngünün o anki iterasyonunu atlayıp bir sonraki iterasyona geçmek için kullanılır. 47 | 48 | Örnek: 49 | 50 | ```python 51 | for i in range(10): 52 | if i == 5: 53 | break 54 | print(i) 55 | ``` 56 | 57 | Yukarıdaki örnekte, `i` 5 olduğunda döngü sonlanır ve 0'dan 4'e kadar olan sayılar ekrana yazdırılır. 58 | 59 | ```python 60 | for i in range(10): 61 | if i % 2 == 0: 62 | continue 63 | print(i) 64 | ``` 65 | 66 | Bu örnekte ise, `i` çift sayı olduğunda o iterasyon atlanır ve sadece tek sayılar ekrana yazdırılır. 67 | 68 | ## Error Handling 69 | 70 | Hataları yönetmek için Python'da `try` ve `except` blokları kullanılır. Bu bloklar, hata oluşabilecek kodları güvenli bir şekilde çalıştırmak için kullanılır. 71 | 72 | Örnek: 73 | 74 | ```python 75 | try: 76 | sayi = int(input("Bir sayı girin: ")) 77 | print("Girdiğiniz sayı:", sayi) 78 | except ValueError: 79 | print("Geçersiz bir sayı girdiniz.") 80 | ``` 81 | 82 | Yukarıdaki örnekte, kullanıcıdan bir sayı girmesi istenir. Eğer kullanıcı geçersiz bir giriş yaparsa (örneğin bir harf girerse), `ValueError` hatası yakalanır ve kullanıcıya bir hata mesajı gösterilir. 83 | 84 | ```python 85 | try: 86 | sonuc = 10 / 0 87 | except ZeroDivisionError: 88 | print("Bir sayıyı sıfıra bölemezsiniz.") 89 | ``` 90 | 91 | Bu örnekte ise, sıfıra bölme hatası yakalanır ve kullanıcıya uygun bir mesaj gösterilir. 92 | 93 | ```python 94 | try: 95 | dosya = open("varolmayan_dosya.txt", "r") 96 | except FileNotFoundError: 97 | print("Dosya bulunamadı.") 98 | ``` 99 | 100 | Bu örnekte, var olmayan bir dosya açılmaya çalışıldığında `FileNotFoundError` hatası yakalanır ve kullanıcıya bir hata mesajı gösterilir. 101 | 102 | Bunların yanında `else` ve `finally` blokları da kullanılabilir: 103 | - `else`: Hata oluşmadığında çalıştırılacak kod bloğunu belirtir. 104 | - `finally`: Hata oluşsa da oluşmasa da her durumda çalıştırılacak kod bloğunu belirtir. 105 | 106 | ```python 107 | try: 108 | sayi = int(input("Bir sayı girin: ")) 109 | except ValueError: 110 | print("Geçersiz bir sayı girdiniz.") 111 | else: 112 | print("Girdiğiniz sayı:", sayi) 113 | finally: 114 | print("Program sona erdi.") 115 | ``` 116 | 117 | Error handling yaparken sıkça kullanılan bir yapı da `raise` ifadesidir. Bu ifade, bilerek bir hata oluşturmak için kullanılır. 118 | 119 | ```python 120 | pozitif_sayi = int(input("Pozitif bir sayı girin: ")) 121 | if pozitif_sayi < 0: 122 | raise ValueError("Negatif bir sayı girdiniz!") 123 | else: 124 | print("Girdiğiniz pozitif sayı:", pozitif_sayi) 125 | ``` 126 | 127 | Bu örnekte, kullanıcıdan pozitif bir sayı girmesi istenir. Eğer kullanıcı negatif bir sayı girerse, `ValueError` hatası bilerek oluşturulur ve kullanıcıya bir hata mesajı gösterilir. Eğer pozitif bir sayı girilirse, sayı ekrana yazdırılır. 128 | 129 | Hatalar hakkında daha detaylı bilgi edinmek için Python'un resmi dokümantasyonuna bakabilirsiniz: https://docs.python.org/3/tutorial/errors.html 130 | 131 | 132 | -------------------------------------------------------------------------------- /3. Ders/Ders Notları/Ders_3-1.md: -------------------------------------------------------------------------------- 1 | # Ders 3-1: Fonksiyonlar ve Modüller 2 | ## Fonksiyonlar 3 | 4 | Fonksiyonlar, belirli bir görevi yerine getiren kod bloklarıdır. Fonksiyonlar, kodunuzu daha düzenli ve tekrar kullanılabilir hale getirir. Python'da fonksiyonlar `def` anahtar kelimesi ile tanımlanır. Fonksiyonlar parametreler alabilir ve değer döndürebilir. 5 | 6 | ```python 7 | def selamla(isim): 8 | print("Merhaba, " + isim + "!") 9 | selamla("Ali") # Çıktı: Merhaba, Ali! 10 | ``` 11 | 12 | Fonksiyonlar, varsayılan parametreler de alabilir: 13 | 14 | ```python 15 | def selamla(isim="Dünya"): 16 | print("Merhaba, " + isim + "!") 17 | selamla() # Çıktı: Merhaba, Dünya! 18 | selamla("Ayşe") # Çıktı: Merhaba, Ayşe! 19 | ``` 20 | Fonksiyonlar ayrıca birden fazla değer döndürebilir: 21 | 22 | ```python 23 | def hesapla(a, b): 24 | toplam = a + b 25 | fark = a - b 26 | return toplam, fark 27 | ``` 28 | Burada kullanılan `return` ifadesi, fonksiyonun çağrıldığı yere değer döndürmesini sağlar. Hesapla fonksiyonu iki değeri birden döndürüyor ve bu değerler bir demet (tuple) olarak geri geliyor. 29 | 30 | ```python 31 | sonuc = hesapla(10, 5) 32 | print(sonuc) # Çıktı: (15, 5) 33 | ``` 34 | Bunun için bir örnek daha: 35 | 36 | ```python 37 | def carp(x, y): 38 | return x * y 39 | 40 | sonuc = carp(4, 5) 41 | 42 | print(sonuc) # Çıktı: 20 43 | print(carp(sonuc, 2)) # Çıktı: 40 44 | ``` 45 | 46 | ## Modüller 47 | Modüller, Python kodunu organize etmek için kullanılan dosyalardır. Bir modül, fonksiyonlar, sınıflar ve değişkenler içerebilir. Modüller, kodunuzu daha yönetilebilir hale getirir ve tekrar kullanılabilirliği artırır. Modüller, `import` ifadesi ile programa dahil edilir. 48 | 49 | ### Built-in Modüller 50 | Python, birçok yerleşik (built-in) modül ile birlikte gelir. Örneğin, `math` modülü matematiksel işlemler için kullanılır: 51 | 52 | ```python 53 | import math 54 | print(math.sqrt(16)) # Çıktı: 4.0 55 | print(math.pi) # Çıktı: 3.141592653589793 56 | ``` 57 | Başka builtin modüller de vardır, örneğin `random`, `datetime`, `os` gibi. Bunların kullanımına da örnek verecek olursak: 58 | 59 | ```python 60 | import random 61 | print(random.randint(1, 10)) # 1 ile 10 arasında rastgele bir sayı üretir 62 | import datetime 63 | print(datetime.datetime.now()) # Şu anki tarih ve saati gösterir 64 | import os 65 | print(os.getcwd()) # Geçerli çalışma dizinini gösterir 66 | ``` 67 | 68 | Bu modülleri kullanacaksanız daha detaylı öğrenmek için Python dokümantasyonına bakabilirsiniz. 69 | 70 | ### Pip ve Üçüncü Parti Modüller 71 | Python'da üçüncü parti modülleri yüklemek için `pip` adlı paket yöneticisi kullanılır. Örneğin, `requests` modülünü yüklemek için terminalde şu komutu kullanabilirsiniz: 72 | 73 | ``` 74 | pip install requests 75 | ``` 76 | 77 | Yükledikten sonra, modülü programınıza dahil edebilirsiniz: 78 | 79 | ```python 80 | import requests 81 | response = requests.get('https://api.github.com') 82 | print(response.status_code) # Çıktı: 200 (başarılı istek) 83 | ``` 84 | 85 | Paketleri yükledikten sonra, modüllerin nasıl kullanılacağına dair dokümantasyonlarına bakmanız faydalı olacaktır. Python paket dizinleri sayesinde birçok modül bulabilirsiniz: https://pypi.org/ 86 | 87 | Paketleri yükledikten sonra kullanmaya başlamadan önce, modülün dökümantasyonunu incelemek her zaman iyi bir pratiktir. Hangi fonksiyonların ve sınıfların mevcut olduğunu, nasıl kullanılacağını öğrenmek için dökümantasyon önemlidir. Dökümantasyon genellikle modülün resmi web sitesinde veya PyPI sayfasında bulunabilir. 88 | 89 | ### Python Paket Yöneticileri ve Sanal Ortamlar 90 | 91 | Python'da paket yönetimi için `pip` dışında başka araçlar da bulunmaktadır. Örneğin, `conda` özellikle veri bilimi ve makine öğrenimi projelerinde popülerdir. Güncel olarak `conda`, `venv` ve `uv` gibi araçlar da kullanılmaktadır. Bu araçlar, paketlerin ve bağımlılıkların yönetimini kolaylaştırır. 92 | 93 | Farklı projeler genelde farklı bağımlılıklar gerektirir. Bu nedenle her proje için izole bir ortam oluşturmak iyi bir uygulamadır. Sanal ortamları oluşturmak için `venv`, `conda` veya `uv` gibi araçlar kullanılabilir. 94 | 95 | Bunlar arasında kişisel olarak önerdiğim `uv` aracı, modern ve kullanımı kolay bir paket yöneticisidir. `uv` ile sanal ortam oluşturmak ve paketleri yönetmek oldukça basittir. Bunun dışında conda da oldukça güçlüdür ve özellikle veri bilimi projelerinde yaygın olarak kullanılır. 96 | 97 | Doğru paket yöneticisini ve sanal ortam aracını seçmek, projenizin ihtiyaçlarına ve kişisel tercihinize bağlıdır. Her iki araç da bağımlılık yönetimini kolaylaştırır ve projelerinizin daha düzenli olmasını sağlar. Bunların araştırmasını ve hangisinin sizin için en uygun olduğunu belirleme kısmını size bırakıyorum. Bu ders özelinde paket yöneticisi kullanacak kadar karmaşık projelere girmeyeceğiz. Kendi kullanımınız için araştırmanızı yapabilirsiniz. 98 | 99 | 100 | 101 | 102 | 103 | -------------------------------------------------------------------------------- /4. Ders/Ders Notları/2-kalitim.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "# İTÜ IEEE Python Eğitimi \n", 9 | "## 4. Hafta\n" 10 | ] 11 | }, 12 | { 13 | "attachments": {}, 14 | "cell_type": "markdown", 15 | "metadata": {}, 16 | "source": [ 17 | "##### Kalıtım (Inheritance)\n", 18 | "\n", 19 | "Python'da kalıtım, bir sınıftan diğerine özelliklerin ve methodların kalmasını sağlar. Özelliklerini veren sınıfa `Parent Class`, Özellikleri alan sınıfa `Child Class` adı verilir.\n", 20 | "\n", 21 | "Örnekler üzerinden anlaşılması çok daha kolay olacaktır:" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 4, 27 | "metadata": {}, 28 | "outputs": [ 29 | { 30 | "name": "stdout", 31 | "output_type": "stream", 32 | "text": [ 33 | "21\n", 34 | "3.0\n", 35 | "22\n" 36 | ] 37 | } 38 | ], 39 | "source": [ 40 | "class Insan: # Parent class tanımlanması. (Normal class tanımlıyoruz)\n", 41 | " def __init__(self, ad, yas):\n", 42 | " self.ad = ad\n", 43 | " self.yas = yas\n", 44 | " self.iş = \"çalışan\"\n", 45 | " def dogum_gunu(self):\n", 46 | " self.yas += 1\n", 47 | "\n", 48 | "class Ogrenci(Insan): # Chil class tanımlanması\n", 49 | " def __init__(self, ad, yas, note):\n", 50 | " super().__init__(ad, yas) # Parent class'ın init'ini çağırırız\n", 51 | " self.note = note\n", 52 | " self.iş = \"öğrenci\"\n", 53 | " def not_ver(self, n):\n", 54 | " self.note = n\n", 55 | "\n", 56 | "umur = Insan(\"Umur\", 21)\n", 57 | "batu = Ogrenci(\"Batu\", 21, 3.0)\n", 58 | "\n", 59 | "print(umur.yas)\n", 60 | "print(batu.note)\n", 61 | "batu.dogum_gunu()\n", 62 | "print(batu.yas)\n", 63 | "print(batu.iş)" 64 | ] 65 | }, 66 | { 67 | "attachments": {}, 68 | "cell_type": "markdown", 69 | "metadata": {}, 70 | "source": [ 71 | "Yukarıda anlattığımız üzere child class olan `Ogrenci`'yi tanımlarken, parent class olan `Insan`'dan tüm methodları ve attribute'ları da alır. Ancak eğer biz child class içerisinde parent class da olan bir fonksiyonu tanımlamak istersek, parent da olan kısım override'lanır (yani, childda tanımlanan fonksiyonun parent'dakinin yerini alır.) Biz örnekte, `İnsan`'da yer alan `__init__` fonksiyonunun `Ogrenci`'de de olmasını istiyoruz, bu sebeple `super().__init__(ad, yas)` satırını ekledik. Burada `super()` fonksiyonu üstteki parent classı temsil ediyor, yani biz bu classa ait olan `__init__` fonksiyonunu çağırıyoruz ve ilk olarak onu çalıştırıyoruz. Sonrasında ise `Ogrenci`'ye özel olmasını istediğimiz `__init__` fonksiyonunun kalanını alta yazıyoruz.\n", 72 | "\n", 73 | "Yani, Child fonksiyonlar Parent fonksiyonların istenilen özelliklerini ve fonksiyonlarını barındıran özelleşmiş sınıflardır. Bu yapıyı daha da büyütüp dallandırmak mümkündür:" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": null, 79 | "metadata": {}, 80 | "outputs": [], 81 | "source": [ 82 | "class Canlilar:\n", 83 | " pass\n", 84 | "\n", 85 | "class Omurgalılar(Canlilar):\n", 86 | " pass\n", 87 | "\n", 88 | "class Memeliler(Omurgalılar):\n", 89 | " pass\n", 90 | "\n", 91 | "class Insan(Memeliler):\n", 92 | " pass\n", 93 | "\n", 94 | "class Omurgasizlar(Canlilar):\n", 95 | " pass" 96 | ] 97 | }, 98 | { 99 | "attachments": {}, 100 | "cell_type": "markdown", 101 | "metadata": {}, 102 | "source": [ 103 | "Yukarıdaki yapıda `Insan` sınıfına ait bir obje, overridelamadığı sürece, `Canlilar` sınıfının özellik ve fonksiyonlarını da içerir.\n" 104 | ] 105 | }, 106 | { 107 | "attachments": {}, 108 | "cell_type": "markdown", 109 | "metadata": {}, 110 | "source": [ 111 | "Bu şekilde teorik anlatımla tam olarak kafanıza oturması ve alışmanız pek mümkün değil. Bu sebeple bu haftaki derste sayı olarak fazla örneğe bakacağız. [Class](https://www.w3schools.com/python/python_classes.asp) ve [Inheritance](https://www.w3schools.com/python/python_inheritance.asp) yapıları için bu bağlantılara tıklayarak çok daha çeşitli örnekler görebilirsiniz." 112 | ] 113 | } 114 | ], 115 | "metadata": { 116 | "kernelspec": { 117 | "display_name": "Python 3", 118 | "language": "python", 119 | "name": "python3" 120 | }, 121 | "language_info": { 122 | "codemirror_mode": { 123 | "name": "ipython", 124 | "version": 3 125 | }, 126 | "file_extension": ".py", 127 | "mimetype": "text/x-python", 128 | "name": "python", 129 | "nbconvert_exporter": "python", 130 | "pygments_lexer": "ipython3", 131 | "version": "3.9.13" 132 | } 133 | }, 134 | "nbformat": 4, 135 | "nbformat_minor": 2 136 | } 137 | -------------------------------------------------------------------------------- /1. Ders/Ders Notları/Ders_1-3.md: -------------------------------------------------------------------------------- 1 | # Ders 1-3: Operatörler ve Bazı Yararlı Fonksiyonlar 2 | 3 | ## Operatörler 4 | 5 | Operatörler, değişkenler ve değerler üzerinde işlemler gerçekleştirmek için kullanılır. Python'da çeşitli operatör türleri vardır: 6 | 7 | ### Aritmetik Operatörler 8 | 9 | Aritmetik operatörler, matematiksel işlemler yapmak için kullanılır. Python'da bulunan aritmetik operatörler şunlardır: 10 | 11 | - `+` : Toplama 12 | - `-` : Çıkarma 13 | - `*` : Çarpma 14 | - `/` : Bölme 15 | - `//` : Tam Bölme 16 | - `%` : Modül (Kalan) 17 | - `**` : Üslü 18 | 19 | Örnek kullanım: 20 | 21 | ```python 22 | x = 10 23 | y = 3 24 | print(x + y) # Çıktı: 13 25 | print(x - y) # Çıktı: 7 26 | print(x * y) # Çıktı: 30 27 | print(x / y) # Çıktı: 3.3333333333333335 28 | print(x // y) # Çıktı: 3 29 | print(x % y) # Çıktı: 1 30 | print(x ** y) # Çıktı: 1000 31 | ``` 32 | 33 | ### Karşılaştırma Operatörleri 34 | 35 | Karşılaştırma operatörleri, iki değeri karşılaştırmak için kullanılır ve genellikle boolean (True/False) sonuç döner. Python'da bulunan karşılaştırma operatörleri şunlardır: 36 | 37 | - `==` : Eşitlik 38 | - `!=` : Eşitsizlik 39 | - `>` : Büyüklük 40 | - `<` : Küçüklük 41 | - `>=` : Büyük veya Eşit 42 | - `<=` : Küçük veya Eşit 43 | 44 | Örnek kullanım: 45 | 46 | ```python 47 | x = 10 48 | y = 5 49 | print(x == y) # Çıktı: False 50 | print(x != y) # Çıktı: True 51 | print(x > y) # Çıktı: True 52 | print(x < y) # Çıktı: False 53 | print(x >= y) # Çıktı: True 54 | print(x <= y) # Çıktı: False 55 | ``` 56 | 57 | ### Mantıksal Operatörler 58 | 59 | Mantıksal operatörler, boolean değerler üzerinde mantıksal işlemler yapmak için kullanılır. Python'da bulunan mantıksal operatörler şunlardır: 60 | 61 | - `and` : Ve 62 | - `or` : Veya 63 | - `not` : Değil 64 | 65 | Örnek kullanım: 66 | 67 | ```python 68 | x = True 69 | y = False 70 | print(x and y) # Çıktı: False 71 | print(x or y) # Çıktı: True 72 | print(not x) # Çıktı: False 73 | ``` 74 | 75 | ### Üyelik Operatörleri 76 | Listeleri ilerleyen derslerde detaylı inceleyeceğiz ancak şimdilik üyelik operatörlerine göz atalım. 77 | Üyelik operatörleri, bir değerin bir koleksiyonda (liste, demet, sözlük vb.) bulunup bulunmadığını kontrol etmek için kullanılır. Python'da bulunan üyelik operatörleri şunlardır: 78 | 79 | - `in` : İçinde 80 | - `not in` : İçinde Değil 81 | 82 | Örnek kullanım: 83 | 84 | ```python 85 | liste = [1, 2, 3, 4, 5] 86 | print(3 in liste) # Çıktı: True 87 | print(6 not in liste) # Çıktı: True 88 | ``` 89 | 90 | ### Kimlik Operatörleri 91 | 92 | Kimlik operatörleri, iki nesnenin aynı bellek alanını paylaş olup olmadığını kontrol etmek için kullanılır. Python'da bulunan kimlik operatörleri şunlardır: 93 | 94 | - `is` : Aynı 95 | - `is not` : Aynı Değil 96 | 97 | Örnek kullanım: 98 | 99 | ```python 100 | x = [1, 2, 3] 101 | y = x 102 | z = x[:] # Burada z değişkeni x'in bir kopyasıdır. 103 | print(x is y) # Çıktı: True 104 | print(x is z) # Çıktı: False 105 | print(x == z) # Çıktı: True 106 | ``` 107 | 108 | ## Bazı Yararlı Fonksiyonlar 109 | 110 | Python, çeşitli yerleşik fonksiyonlar sunar. Fonksiyonlara detaylı olarak ilerleyen derslerde değineceğiz, ancak burada bazı temel fonksiyonlara göz atalım: 111 | 112 | - `print()`: Ekrana çıktı vermek için kullanılır. (Bu fonksiyonu zaten sıkça kullandık!) 113 | - `input()`: Kullanıcıdan veri girişi almak için kullanılır. 114 | 115 | Örnek kullanım: 116 | 117 | ```python 118 | isim = input("Adınızı girin: ") 119 | print("Merhaba, " + isim + "!") 120 | ``` 121 | String türündeki verileri kontrol etmek ve dönüştürmek için bazı yararlı fonksiyonlar şunlardır: 122 | 123 | - `.upper()`: Stringi büyük harflere dönüştürür. 124 | - `.lower()`: Stringi küçük harflere dönüştürür. 125 | - `.strip()`: Stringin başındaki ve sonundaki boşlukları kaldırır. 126 | - `.format()`: String içerisinde dinamik veri yerleştirmek için kullanılır. 127 | - `.replace()`: Belirtilen bir alt stringi başka bir alt stringle değiştirir. 128 | - `.split()`: Stringi belirli bir ayırıcıya göre parçalara böler ve liste olarak döner. 129 | - `.startswith()`: Stringin belirli bir alt stringle başlayıp başlamadığını kontrol eder. 130 | - `.join()`: Bir listeyi belirli bir ayırıcı kullanarak tek bir stringe dönüştürür. 131 | - `.isalpha()`: Stringin sadece harflerden oluşup oluşmadığını kontrol eder. 132 | - `.isdecimal()`: Stringin sadece rakamlardan oluşup oluşmadığını kontrol eder. 133 | 134 | Örnek kullanım: 135 | 136 | ```python 137 | txt = "merhaba DÜNYA" 138 | 139 | print(txt.upper()) 140 | print(txt.lower()) 141 | print(txt.replace("DÜNYA", "IEEE")) # Evet fonksiyonlar birden fazla parametre alabilir. 142 | print(txt.capitalize()) 143 | print(txt.startswith("merh")) 144 | ``` 145 | 146 | Az önce gördüğümüz `format()` fonksiyonu da oldukça kullanışlıdır. Verilerimiz asla sabit kalmadığı için dinamik bir şekilde formatlama yapmamıza olanak tanır. Biraz detaylı inceleyelim: 147 | 148 | ```python 149 | sayi1 = 6 150 | sayi2 = 5 151 | 152 | print("IEEE içerisinde {} komite ve {} ekip bulunur.".format(sayi1, sayi2)) 153 | print("IEEE içerisinde {0} komite ve {1} ekip bulunur.".format(sayi1, sayi2)) 154 | print("IEEE içerisinde {komite} komite ve {ekip} ekip bulunur.".format(komite = sayi1, ekip = sayi2)) 155 | print(f"IEEE içerisinde {sayi1} komite ve {sayi2} ekip bulunur.") 156 | ``` 157 | -------------------------------------------------------------------------------- /4. Ders/Ders Notları/3-scope.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "# İTÜ IEEE Python Eğitimi \n", 9 | "## 4. Hafta\n" 10 | ] 11 | }, 12 | { 13 | "attachments": {}, 14 | "cell_type": "markdown", 15 | "metadata": {}, 16 | "source": [ 17 | "##### Scope (Kapsam)\n", 18 | "\n", 19 | "Pythonda bir değişken, sadece tanımlandığı bölgede erişilebilirdir. Buna kapsam denir. Şu örneği inceleyelim:" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 5, 25 | "metadata": {}, 26 | "outputs": [], 27 | "source": [ 28 | "def myfunc():\n", 29 | " x = 300\n", 30 | " print(x)\n", 31 | "\n", 32 | "myfunc()\n", 33 | "print(x) # Hata alırız, x tanımlandığı bölgenin dışında erişilebilir değildir." 34 | ] 35 | }, 36 | { 37 | "attachments": {}, 38 | "cell_type": "markdown", 39 | "metadata": {}, 40 | "source": [ 41 | "Gördüğümüz gibi `x` değeri tanımlandığı bölge dışında çağrılamıyor. Ancak, tanımlandığı bölgenin içerisinde başka iç fonksiyonlarda erişilebilirdir." 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": null, 47 | "metadata": {}, 48 | "outputs": [], 49 | "source": [ 50 | "def func1():\n", 51 | " x = 100\n", 52 | " def func2():\n", 53 | " print(x)\n", 54 | " \n", 55 | " func2()\n", 56 | "\n", 57 | "func1()" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": null, 63 | "metadata": {}, 64 | "outputs": [], 65 | "source": [ 66 | "def f():\n", 67 | " def g():\n", 68 | " x = 5\n", 69 | " print(x)\n", 70 | " print(x) # x değişkeni iç fonksiyonda tanımlı, burada tanımlı değil" 71 | ] 72 | }, 73 | { 74 | "attachments": {}, 75 | "cell_type": "markdown", 76 | "metadata": {}, 77 | "source": [ 78 | "**Global Scope:** Python kodunun ana gövdesinde, yani en dışarıda tanımlanan değişkenler global scope'a sahiptir. Yani her şeyin dışında oldukları için diğer fonksiyon sınıf vblerin içinde çağrılabilirler." 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": null, 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [ 87 | "x = 300\n", 88 | "\n", 89 | "def myfunc():\n", 90 | " print(x)\n", 91 | "\n", 92 | "myfunc()\n", 93 | "\n", 94 | "print(x)" 95 | ] 96 | }, 97 | { 98 | "attachments": {}, 99 | "cell_type": "markdown", 100 | "metadata": {}, 101 | "source": [ 102 | "Eğer dışarıda tanımlanan bir değişkeni, aynı isimle fonksiyonun içerisinde de tanımlamaya çalışırsanız; Python 2 değişkeni birbirlerinden farklı olarak tutar. Biri local bir değişken, diğeri global bir değişken olur:" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": 1, 108 | "metadata": {}, 109 | "outputs": [ 110 | { 111 | "name": "stdout", 112 | "output_type": "stream", 113 | "text": [ 114 | "200\n", 115 | "300\n" 116 | ] 117 | } 118 | ], 119 | "source": [ 120 | "x = 300\n", 121 | "\n", 122 | "def myfunc():\n", 123 | " x = 200\n", 124 | " print(x)\n", 125 | "\n", 126 | "myfunc()\n", 127 | "\n", 128 | "print(x)" 129 | ] 130 | }, 131 | { 132 | "attachments": {}, 133 | "cell_type": "markdown", 134 | "metadata": {}, 135 | "source": [ 136 | "Bu bahsettiğimiz durumdan ötürü, aslında bir fonksiyonun içerisinde direkt olarak global bir değişken tanımlayamayız. Bu durumu aşmak istediğimizde `global` keywordünü kullanabiliriz. İlk başta incelediğimiz örneğe terkar bakalım:" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": 2, 142 | "metadata": {}, 143 | "outputs": [ 144 | { 145 | "name": "stdout", 146 | "output_type": "stream", 147 | "text": [ 148 | "300\n", 149 | "300\n" 150 | ] 151 | } 152 | ], 153 | "source": [ 154 | "def myfunc():\n", 155 | " global x\n", 156 | " x = 300\n", 157 | " print(x)\n", 158 | "\n", 159 | "myfunc()\n", 160 | "print(x) " 161 | ] 162 | }, 163 | { 164 | "attachments": {}, 165 | "cell_type": "markdown", 166 | "metadata": {}, 167 | "source": [ 168 | "Bu sayede, içerde tanımladığımız değişkenimiz yerel olmaktan kurtulup global bir hal aldı.\n", 169 | "Değişkenlerin kapsamlarına, local olup olmadıklarına dikkat etmemek, programımızda hataların oluşmasına yol açabiliyor. Bir program yazarken bir değişkenin tanımlı olmamasına veya beklediğimizden farklı bir değer almasına dair bir hata aldığımızda, kodumuzda değişkenlerin kapsamlarına göz atmamız gerekebilir.\n", 170 | "\n", 171 | "Ayrıca yanlış anlaşılmaısn, değikenlerimizin global veya local olmasını isteyebiliriz duruma göre, çoğu zaman fonksiyonların içerindeki değişkenleri hep local tanımlarız. Her değişken global olmalı diye bir yanlış anlaşılma olmasın." 172 | ] 173 | } 174 | ], 175 | "metadata": { 176 | "kernelspec": { 177 | "display_name": "Python 3", 178 | "language": "python", 179 | "name": "python3" 180 | }, 181 | "language_info": { 182 | "codemirror_mode": { 183 | "name": "ipython", 184 | "version": 3 185 | }, 186 | "file_extension": ".py", 187 | "mimetype": "text/x-python", 188 | "name": "python", 189 | "nbconvert_exporter": "python", 190 | "pygments_lexer": "ipython3", 191 | "version": "3.12.0" 192 | }, 193 | "orig_nbformat": 4 194 | }, 195 | "nbformat": 4, 196 | "nbformat_minor": 2 197 | } 198 | -------------------------------------------------------------------------------- /1. Ders/Ders Notları/Ders_1-1.md: -------------------------------------------------------------------------------- 1 | # Ders 1-1: Kurulum ve Temel Bilgiler 2 | ## Python ve Yardımcı Araçların Kurulumu 3 | 4 | Bilgisayarımızda Python kodlarını ve dosyalarını çalıştırabilmek için Python'u kurmamız gerekiyor. 5 | 6 | İşletim sisteminize göre aşağıdaki adımları takip ederek Python'u bilgisayarınıza kurabilirsiniz. 7 | 8 |
9 | Windows 10/11 10 | 11 | 1. Bilgisayarınızda halihazırda Python kurulumu olup olmadığını kontrol edin. Bunu yapmak için: 12 | 13 | a. Başlat menüsüne gidin ve "powershell" yazarak PowerShell'i açın. 14 | 15 | b. Aşağıdaki komutu girin: 16 | 17 | ``` 18 | python --version 19 | ``` 20 | veya 21 | ``` 22 | py --version 23 | ``` 24 | 25 | Eğer Python yüklüyse, sürüm numarasını göreceksiniz. 26 | 27 | Örneğin: 28 | 29 | Python 3.13.9 30 | 31 | 32 | Yüklü değilse, bir hata mesajı alacaksınız. 33 | 2. Python yüklü değilse: 34 | 35 | [Python'un resmi web sitesinden](https://www.python.org/downloads/windows/) en son sürümü indirin. İndirilen dosyayı çalıştırın ve kurulum sihirbazını takip edin. **"Add Python to PATH" seçeneğini işaretlemeyi unutmayın!!!** Kurulum tamamlandıktan sonra PowerShell'i yeniden açın ve yukarıdaki komutu tekrar girerek Python'un doğru şekilde yüklendiğini doğrulayın. 36 | 37 |
38 | 39 |
40 | macOS 41 | macOS 12.3 sürümünden itibaren Python 2.x sürümü macOS ile birlikte gelmemektedir. Varsayılan olarak gelen Python sürümü resmi Python sürümü değildir ve bazı kısıtlamalar içerebilir. Bu nedenle, Python'un resmi sürümünü kurmanız önerilir. 42 | 43 | 1. Terminal'i açın. Bunu yapmak için Spotlight'ı açın (Cmd + Space) ve "Terminal" yazın. 44 | 45 | 2. Aşağıdaki komutu girin: 46 | 47 | ``` 48 | python3 --version 49 | ``` 50 | 51 | Eğer Python yüklüyse, sürüm numarasını göreceksiniz. 52 | 53 | Örneğin: 54 | 55 | Python 3.13.9 56 | 57 | Yüklü değilse, bir hata mesajı alacaksınız. 58 | 3. Python yüklü değilse: 59 | 60 | [Python'un resmi web sitesinden](https://www.python.org/downloads/macos/) en son sürümü indirin. İndirilen dosyayı çalıştırın ve kurulum sihirbazını takip edin. Kurulum tamamlandıktan sonra Terminal'i yeniden açın ve yukarıdaki komutu tekrar girerek Python'un doğru şekilde yüklendiğini doğrulayın. 61 | 62 |
63 | 64 |
65 | Linux 66 | 67 | 1. Terminal'i açın. (Genellikle Ctrl + Alt + T kısayoluyla açılabilir.) 68 | 69 | 2. Aşağıdaki komutu girin: 70 | 71 | ``` 72 | python3 --version 73 | ``` 74 | 75 | Eğer Python yüklüyse, sürüm numarasını göreceksiniz. 76 | 77 | Örneğin: 78 | 79 | Python 3.13.9 80 | 81 | Yüklü değilse, bir hata mesajı alacaksınız. 82 | 3. Python yüklü değilse: 83 | 84 | - Debian/Ubuntu tabanlı sistemlerde: 85 | 86 | ``` 87 | sudo apt update 88 | sudo apt install python3 89 | ``` 90 | 91 | - Fedora tabanlı sistemlerde: 92 | 93 | ``` 94 | sudo dnf install python3 95 | ``` 96 | 97 | - Arch Linux tabanlı sistemlerde: 98 | 99 | ``` 100 | sudo pacman -S python 101 | ``` 102 | Kurulum tamamlandıktan sonra Terminal'i yeniden açın ve yukarıdaki komutu tekrar girerek Python'un doğru şekilde yüklendiğini doğrulayın. 103 | 104 |
105 | 106 | ## Kod Editörü Kurulumu 107 | 108 | Python kodlarını istediğiniz bir metin editöründe yazabilirsiniz. Ancak, kod yazmayı ve yönetmeyi kolaylaştıran gelişmiş özelliklere sahip bir kod editörü kullanmanız önerilir. Bu derslerde Visual Studio Code (VS Code) editörünü kullanacağız. Dilerseniz PyCharm veya başka bir editör de kullanabilirsiniz. 109 | 110 | VS Code'u kurmak için aşağıdaki adımları takip edebilirsiniz: 111 | 112 |
113 | Windows 10/11 114 | 115 | 1. [Visual Studio Code'un resmi web sitesine](https://code.visualstudio.com/) gidin. 116 | 2. "Download" butonuna tıklayın ve Windows için en son sürümü indirin. 117 | 3. İndirilen dosyayı çalıştırın ve kurulum sihirbazını takip edin. 118 | 4. Kurulum tamamlandıktan sonra Visual Studio Code'u başlatın. 119 | 120 |
121 | 122 |
123 | macOS 124 | 125 | 1. [Visual Studio Code'un resmi web sitesine](https://code.visualstudio.com/) gidin. 126 | 2. "Download" butonuna tıklayın ve macOS için en son sürümü indirin. 127 | 3. İndirilen .zip dosyasını açın ve Visual Studio uygulamasını "Applications" klasörüne sürükleyin. 128 | 4. "Applications" klasöründen Visual Studio Code'u başlatın. 129 |
130 | 131 |
132 | Linux 133 | 134 | 1. [Visual Studio Code'un resmi web sitesine](https://code.visualstudio.com/docs/setup/linux) gidin. 135 | 2. Dağıtımınıza uygun kurulum talimatlarını takip edin. Örneğin, Debian ve Ubuntu için resmi sitedeki .deb paketini indirip aşağıdaki komutları kullanabilirsiniz: 136 | 137 | ``` 138 | sudo apt install ./.deb 139 | ``` 140 | 3. Kurulum tamamlandıktan sonra terminalden `code` komutunu kullanarak Visual Studio Code'u başlatabilirsiniz. 141 |
142 | 143 | VS Code'u kurduktan sonra, Python geliştirme ortamınızı optimize etmek için "Python" uzantısını yüklemenizi önerilir. Bunu yapmak için: 144 | 145 | 1. Visual Studio Code'u açın. 146 | 2. Sol kenar çubuğundaki "Extensions" (Uzantılar) simgesine tıklayın. 147 | 3. Arama çubuğuna "Python" yazın ve çıkan sonuçlardan Microsoft'un "Python" uzantısını bulun. 148 | 4. "Install" (Yükle) butonuna tıklayarak uzantıyı yükleyin. 149 | 150 | Artık Python kodlarını yazmaya ve çalıştırmaya hazırsınız! İlk kodumuzu yazmak için yeni bir dosya oluşturun, uzantısını `.py` olarak ayarlayın (örneğin, `hello.py`) ve aşağıdaki kodu ekleyin: 151 | 152 | ```python 153 | print("Hello World!") 154 | ``` 155 | Dosyayı kaydedin ve çalıştırmak için terminalde aşağıdaki komutu kullanın ya da VS Code içindeki Çalıştır butonuna tıklayın: 156 | 157 | ``` 158 | python hello.py 159 | ``` 160 | -------------------------------------------------------------------------------- /4. Ders/Örnekler/ornek_4.py: -------------------------------------------------------------------------------- 1 | """ 2 | Bu örnekte bir kütüphane yönetim sistemi yapacağız. 3 | Kalıtım, soyutlama ve çok biçimlilik (polymorphism) kavramlarını kullanacağız. 4 | """ 5 | 6 | from abc import ABC, abstractmethod 7 | from datetime import datetime, timedelta 8 | 9 | class Materyal(ABC): 10 | """Abstract base class - tüm kütüphane materyalleri için""" 11 | 12 | materyal_sayisi = 0 13 | 14 | def __init__(self, baslik, yazar): 15 | self.baslik = baslik 16 | self.yazar = yazar 17 | self.odunc_durumu = False 18 | self.odunc_alan = None 19 | self.odunc_tarihi = None 20 | Materyal.materyal_sayisi += 1 21 | self.id = Materyal.materyal_sayisi 22 | 23 | @abstractmethod 24 | def odunc_suresi(self): 25 | """Her materyal türü kendi ödünç süresini belirler""" 26 | pass 27 | 28 | def odunc_ver(self, kisi_adi): 29 | """Materyali ödünç verir""" 30 | if not self.odunc_durumu: 31 | self.odunc_durumu = True 32 | self.odunc_alan = kisi_adi 33 | self.odunc_tarihi = datetime.now() 34 | iade_tarihi = self.odunc_tarihi + timedelta(days=self.odunc_suresi()) 35 | print(f"✓ '{self.baslik}' {kisi_adi} tarafından ödünç alındı") 36 | print(f" İade tarihi: {iade_tarihi.strftime('%d/%m/%Y')}") 37 | else: 38 | print(f"✗ '{self.baslik}' şu anda {self.odunc_alan} tarafından kullanılıyor") 39 | 40 | def iade_et(self): 41 | """Materyali iade eder""" 42 | if self.odunc_durumu: 43 | gun_gecti = (datetime.now() - self.odunc_tarihi).days 44 | ceza = max(0, (gun_gecti - self.odunc_suresi()) * 2) # Geç iade için günlük 2 TL 45 | 46 | print(f"✓ '{self.baslik}' iade edildi") 47 | if ceza > 0: 48 | print(f" ⚠️ Geç iade cezası: {ceza} TL") 49 | 50 | self.odunc_durumu = False 51 | self.odunc_alan = None 52 | self.odunc_tarihi = None 53 | else: 54 | print(f"✗ '{self.baslik}' zaten kütüphanede") 55 | 56 | def bilgi_goster(self): 57 | """Materyal bilgilerini gösterir""" 58 | durum = f"Ödünçte ({self.odunc_alan})" if self.odunc_durumu else "Mevcut" 59 | print(f"[{self.id}] {self.baslik} - {self.yazar} | {durum}") 60 | 61 | 62 | class Kitap(Materyal): 63 | """Kitap sınıfı""" 64 | 65 | def __init__(self, baslik, yazar, sayfa_sayisi): 66 | super().__init__(baslik, yazar) 67 | self.sayfa_sayisi = sayfa_sayisi 68 | 69 | def odunc_suresi(self): 70 | return 14 # Kitaplar 14 gün ödünç verilebilir 71 | 72 | 73 | class Dergi(Materyal): 74 | """Dergi sınıfı""" 75 | 76 | def __init__(self, baslik, yazar, sayi): 77 | super().__init__(baslik, yazar) 78 | self.sayi = sayi 79 | 80 | def odunc_suresi(self): 81 | return 7 # Dergiler 7 gün ödünç verilebilir 82 | 83 | 84 | class DVD(Materyal): 85 | """DVD sınıfı""" 86 | 87 | def __init__(self, baslik, yonetmen, sure): 88 | super().__init__(baslik, yonetmen) 89 | self.sure = sure 90 | 91 | def odunc_suresi(self): 92 | return 3 # DVD'ler 3 gün ödünç verilebilir 93 | 94 | 95 | class Kutuphane: 96 | """Kütüphane yönetim sınıfı""" 97 | 98 | def __init__(self, isim): 99 | self.isim = isim 100 | self.materyaller = [] 101 | 102 | def materyal_ekle(self, materyal): 103 | """Kütüphaneye yeni materyal ekler""" 104 | self.materyaller.append(materyal) 105 | print(f"✓ '{materyal.baslik}' kütüphaneye eklendi") 106 | 107 | def materyal_listele(self, sadece_mevcut=False): 108 | """Tüm materyalleri listeler""" 109 | print(f"\n{'=' * 70}") 110 | print(f"{self.isim} - Materyal Listesi") 111 | print(f"{'=' * 70}") 112 | 113 | for materyal in self.materyaller: 114 | if sadece_mevcut and materyal.odunc_durumu: 115 | continue 116 | materyal.bilgi_goster() 117 | 118 | print(f"{'=' * 70}") 119 | 120 | def materyal_ara(self, arama_kelime): 121 | """Başlıkta arama yapar""" 122 | bulunanlar = [m for m in self.materyaller if arama_kelime.lower() in m.baslik.lower()] 123 | 124 | if bulunanlar: 125 | print(f"\n'{arama_kelime}' araması için {len(bulunanlar)} sonuç bulundu:") 126 | for m in bulunanlar: 127 | m.bilgi_goster() 128 | else: 129 | print(f"'{arama_kelime}' için sonuç bulunamadı") 130 | 131 | def istatistikler(self): 132 | """Kütüphane istatistiklerini gösterir""" 133 | toplam = len(self.materyaller) 134 | odunç = sum(1 for m in self.materyaller if m.odunc_durumu) 135 | mevcut = toplam - odunç 136 | 137 | print(f"\n📊 Kütüphane İstatistikleri") 138 | print(f"Toplam materyal: {toplam}") 139 | print(f"Ödünçte: {odunç}") 140 | print(f"Mevcut: {mevcut}") 141 | 142 | 143 | # Kütüphane sistemini test edelim 144 | print("=" * 70) 145 | print("KÜTÜPHANE YÖNETİM SİSTEMİ") 146 | print("=" * 70) 147 | 148 | # Kütüphane oluştur 149 | kutuphane = Kutuphane("İTÜ Kütüphanesi") 150 | 151 | # Materyaller ekle 152 | kitap1 = Kitap("Python Programlama", "Ahmet Yılmaz", 350) 153 | kitap2 = Kitap("Veri Bilimi", "Ayşe Demir", 420) 154 | dergi1 = Dergi("Bilim ve Teknik", "TÜBİTAK", 550) 155 | dvd1 = DVD("Python Eğitim Seti", "Mehmet Kaya", 180) 156 | 157 | kutuphane.materyal_ekle(kitap1) 158 | kutuphane.materyal_ekle(kitap2) 159 | kutuphane.materyal_ekle(dergi1) 160 | kutuphane.materyal_ekle(dvd1) 161 | 162 | # Materyalleri listele 163 | kutuphane.materyal_listele() 164 | 165 | # Ödünç verme işlemleri 166 | print("\n" + "-" * 70) 167 | kitap1.odunc_ver("Ali Yılmaz") 168 | dergi1.odunc_ver("Zeynep Kaya") 169 | 170 | # Mevcut materyalleri listele 171 | kutuphane.materyal_listele(sadece_mevcut=True) 172 | 173 | # İade işlemi 174 | print("\n" + "-" * 70) 175 | kitap1.iade_et() 176 | 177 | # Arama yap 178 | print("\n" + "-" * 70) 179 | kutuphane.materyal_ara("Python") 180 | 181 | # İstatistikler 182 | print("\n" + "-" * 70) 183 | kutuphane.istatistikler() 184 | -------------------------------------------------------------------------------- /2. Ders/Ders Notları/Ders_2-1.md: -------------------------------------------------------------------------------- 1 | # Ders 2-1: Diziler ve Koşullu İfadeler 2 | 3 | ## Diziler (Array) 4 | 5 | 6 | Diziler, Python'da bir değişken de birden fazla veri saklamamızı sağlayan değişken türleridir. Farklı türleri mevcuttur. 7 | 8 | 9 | __List__ 10 | 11 | Pythonda en çok kullanılan dizi tipidir. Elemanlar sıralı saklanır, değiştirilebilir ve aynı eleman birden fazla kez bulunabilir. 12 |
Bir liste şu şekilde tanımlanır: 13 | 14 | ```python 15 | liste = [1, 2, 3, 4, 5] 16 | print(liste) # Çıktı: [1, 2, 3, 4, 5] 17 | ``` 18 | 19 | Elemanlara indeks numaraları ile erişilir. **İndeks numaraları 0'dan başlar.** 20 | 21 | ```python 22 | print(liste[0]) # Çıktı: 1 23 | print(liste[2]) # Çıktı: 3 24 | print(liste[-1]) # Çıktı: 5 (indeks numarasını negatife çevirdiğimizde sondan başlarız) 25 | ``` 26 | Aynı yöntemle listemizden alt listeler de oluşturabiliriz: 27 | 28 | ```python 29 | print(liste[1:4]) # Çıktı: [2, 3, 4] (1. indexten 4. indexe kadar olan elemanlar) 30 | print(liste[:3]) # Çıktı: [1, 2, 3] (başlangıçtan 3. indexe kadar olan elemanlar) 31 | print(liste[2:]) # Çıktı: [3, 4, 5] (2. indexten sona kadar olan elemanlar) 32 | ``` 33 | 34 | __Yararlı fonksiyon ve kavramlar__ 35 | 36 | - `in` : listede bir elemanın olup olmadığını verir. 37 | - `.count()` parametre olarak girilen elemanın listede kaç tane olduğunu verir. 38 | - `.append()` parametre olarak girilen ifadeyi liste sonuna ekler. 39 | - `.extend()` parametre olarak girilen listeyi listenin sonuna ekler 40 | - `.pop()` parametre olarak girilen index'teki elemanı listeden siler. 41 | - `.remove()` parametre olarak girilen değerdeki elemanları listeden siler. 42 | 43 | En çok kullanılan metodları listeledik, diğerlerine [buradan](https://www.w3schools.com/python/python_lists_methods.asp) ulaşabilirsin 44 |
Bunların kullanımlarını incelersek: 45 | 46 | ```python 47 | data = ["İTÜ", "since", 1773, True] 48 | 49 | print("İTÜ" in data) # True, çünkü "İTÜ" listede var 50 | print(data.count("1773")) # 0, çünkü string değil integer olarak var 1773 51 | 52 | data.append("IEEE") # Liste sonuna "IEEE" ekler 53 | print(data) # Çıktı: ['İTÜ', 'since', 1773, True, 'IEEE'] 54 | data.pop(3) # 3. indexteki elemanı siler 55 | data.remove(1773) # Değeri 1773 olan elemanı siler 56 | print(data.index("IEEE")) # "IEEE" elemanının index numarasını verir 57 | print(data) # Çıktı: ['İTÜ', 'since', 'IEEE'] 58 | ``` 59 | Listede belli bir konumdaki elemanı değiştirmek de mümkündür: 60 | 61 | ```python 62 | data = [10, 20, 30, 40, 50] 63 | data[2] = 99 # 2. indexteki elemanı 99 ile değiştirir 64 | print(data) # Çıktı: [10, 20, 99, 40, 50] 65 | ``` 66 | 67 | __Tuple__ 68 | 69 | Bir diğer dizi türüdür. Elemanlar sıralı depolanır, ancak tuple'lar değiştirilemez. Bu sebeple değişmeyen verilerin saklanmasında oldukça kullanışlıdır. listelerle ortak bir çok metoda ve kullanıma sahiptir. 70 |
Tanımlanması ve kullanımı şu şekildedir: 71 | 72 | ```python 73 | tuple_ornek = (1, 2, 3, 4, 5) 74 | print(tuple_ornek) # Çıktı: (1, 2, 3, 4, 5) 75 | print(tuple_ornek[0]) # Çıktı: 1 76 | ``` 77 | 78 | Tuple'lar değiştirilemez, bu yüzden eleman ekleme, silme veya değiştirme işlemleri yapılamaz. Ancak, tuple'lar üzerinde indeksleme ve dilimleme işlemleri yapılabilir. 79 | 80 | ```python 81 | print(tuple_ornek[1:4]) # Çıktı: (2, 3, 4) 82 | tuple_ornek[0] = 10 # Hata! Tuple'lar değiştirilemez 83 | ``` 84 | __Set__ 85 | 86 | Setler, benzersiz elemanlardan oluşan sırasız koleksiyonlardır. Yani, bir sette aynı eleman birden fazla kez bulunamaz ve elemanların belirli bir sırası yoktur.
Set tanımlaması ve kullanımı şu şekildedir: 87 | ```python 88 | set_ornek = {1, 2, 3, 4, 5} 89 | print(set_ornek) # Çıktı: {1, 2, 3, 4, 5} 90 | ``` 91 | Setler üzerinde ekleme ve silme işlemleri yapılabilir, ancak indeksleme veya dilimleme işlemleri yapılamaz çünkü setler sırasızdır. 92 | 93 | ```python 94 | set_ornek.add(6) # Set'e 6 ekler 95 | print(set_ornek) # Çıktı: {1, 2, 3, 4, 5, 6} 96 | set_ornek.remove(3) # Set'ten 3'ü siler 97 | print(set_ornek) # Çıktı: {1, 2, 4, 5, 6} 98 | ``` 99 | 100 | __Dictionary__ 101 | 102 | Dictionary'ler, anahtar-değer çiftlerinden oluşan sırasız koleksiyonlardır. Her anahtar benzersizdir ve bir değere karşılık gelir.
Dictionary tanımlaması ve kullanımı şu şekildedir: 103 | ```python 104 | dict_ornek = {"İsim": "Ali", "Yaş": 19, "Şehir": "İstanbul"} 105 | print(dict_ornek) # Çıktı: {'İsim': 'Ali', 'Yaş': 19, 'Şehir': 'İstanbul'} 106 | print(dict_ornek["İsim"]) # Çıktı: Ali 107 | ``` 108 | Dictionary'ler üzerinde ekleme, silme ve güncelleme işlemleri yapılabilir. 109 | 110 | ```python 111 | dict_ornek["Meslek"] = "Öğrenci" # Yeni anahtar-değer çifti ekler 112 | print(dict_ornek) # Çıktı: {'İsim': 'Ali', 'Yaş': 19, 'Şehir': 'İstanbul', 'Meslek': 'Öğrenci'} 113 | del dict_ornek["Yaş"] # 'Yaş' anahtarını siler 114 | print(dict_ornek) # Çıktı: {'İsim': 'Ali', 'Şehir': 'İstanbul', 'Meslek': 'Öğrenci'} 115 | dict_ornek["Şehir"] = "Ankara" # 'Şehir' anahtarının değerini günceller 116 | print(dict_ornek) # Çıktı: {'İsim': 'Ali', 'Şehir': 'Ankara', 'Meslek': 'Öğrenci'} 117 | ``` 118 | 119 | ## Koşullu İfadeler 120 | 121 | Koşullu ifadeler, belirli bir koşulun doğru olup olmadığını kontrol etmek için kullanılır. Python'da en yaygın kullanılan koşullu ifadeler `if`, `elif` ve `else` anahtar kelimeleri ile oluşturulur. 122 | 123 | ```python 124 | sayi = 10 125 | if sayi > 0: 126 | print("Sayı pozitif.") 127 | elif sayi == 0: 128 | print("Sayı sıfır.") 129 | else: 130 | print("Sayı negatif.") 131 | ``` 132 | 133 | Yukarıdaki örnekte ilk defa gördüğümüz bir kavram var: **Girintileme (Indentation)**. Python'da kod blokları girintileme ile belirlenir. `if`, `elif` ve `else` ifadelerinden sonra gelen kod blokları, bu ifadelerin altında ve aynı seviyede girintilenmiş olmalıdır. Genellikle 4 boşluk kullanılır. Modern kod editörleri bu girintilemeyi TAB tuşuna basınca otomatik olarak yapar. 134 | 135 | Ayrıca fark ettiğiniz üzere koşullu ifadeyi kullanırken iki nokta üst üste `:` kullanılır. Bu, Python'a bir kod bloğunun başlayacağını belirtir. 136 | 137 | Programlama dillerinde yazım kurallarına "syntax" denir. Python'un syntax'ı diğer dillere göre daha sade ve okunabilir olmasıyla bilinir. Eğer kodunuzu çalıştırdığınızda SyntaxError alıyorsanız, kodunuzun Python'un yazım kurallarına uygun olup olmadığını kontrol etmelisiniz. 138 | 139 | if-else yapısında birkaç örnek daha inceleyelim: 140 | 141 | ```python 142 | sinif = { 143 | "Ali" : [40, 50, 70], 144 | "Zehra" : [50, 45, 82], 145 | "Efe" : [10, 30, 65] 146 | } 147 | 148 | ogrenci = input("Öğrenci adı:") 149 | 150 | if(not ogrenci in sinif): # Verilen isim listemizde yoksa 151 | print("Listede olmayan bir öğrenci adı girdiniz!") 152 | 153 | else: 154 | notlar = sinif[ogrenci] 155 | toplam = notlar[0] + notlar[1] + notlar[2] # 3 notun toplamak için tüm elemanları ayrı ayrı çekip topladık. 156 | ortalama = toplam / len(notlar) # Ortalamayı almak için toplamı listenin eleman sayısı olan 3 e bölüyoruz 157 | sonuc = round(ortalama, 2) # Küsürattan kurtulalım 158 | print(sonuc) 159 | ``` 160 | 161 | Bu örnekte, kullanıcıdan bir öğrenci adı alıyoruz ve bu adın `sinif` sözlüğünde olup olmadığını kontrol ediyoruz. Eğer öğrenci adı sözlükte yoksa, kullanıcıya bir uyarı mesajı gösteriyoruz. Eğer öğrenci adı sözlükte varsa, öğrencinin notlarını alıp ortalamasını hesaplıyoruz ve sonucu ekrana yazdırıyoruz. 162 | 163 | Mantıksal operatörler de koşullu ifadelerde sıkça kullanılır. Dikkat ettiyseniz if-elif ifadelerinde parantez içinde yazdığımız değerlerin çıktıları `True` veya `False` oluyor. Bunu daha karmaşık koşullar oluşturmak için kullanabiliriz. 164 | 165 | ```python 166 | a = 0 167 | b = 10 168 | 169 | if (a > 10 and b > 10): 170 | print("a ve b değerleri 10'dan büyük sayılar") 171 | 172 | elif (a > 100 or b > 100): 173 | print("a ve b değerleri 100'den büyük sayılar") 174 | 175 | elif (a < 10 and not b > 10): 176 | print("a değeri 10'dan küçük ve b değeri 10'dan büyük değil") 177 | 178 | elif(a != 0 and b == 0): 179 | print("a değeri 0'a eşit değil ve b değeri 0'a eşit") 180 | 181 | else: 182 | print("diğer koşullar sağlanmadı") 183 | ``` 184 | 185 | **SORU** : Bu döngüde a = 117 and b = 245 koşulu sağlandığında hangi mesaj ekrana yazdırılır? Kodu çalıştırmadan cevabı düşünün ve ardından kodu çalıştırarak cevabınızı kontrol edin. 186 | 187 | if-else yapısında iç içe koşullar da oluşturulabilir: 188 | 189 | ```python 190 | sayi = int(input("Bir sayı girin: ")) 191 | if sayi >= 0: 192 | if sayi == 0: 193 | print("Sayı sıfır.") 194 | else: 195 | print("Sayı pozitif.") 196 | else: 197 | print("Sayı negatif.") 198 | ``` 199 | 200 | Bu örnekte, ilk `if` ifadesi sayının pozitif, negatif veya sıfır olup olmadığını kontrol eder. Eğer sayı pozitifse, iç içe bir `if` ifadesi kullanılarak sayının sıfır olup olmadığı kontrol edilir. 201 | 202 | 203 | -------------------------------------------------------------------------------- /4. Ders/Ders Notları/1-siniflar.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# İTÜ IEEE Python Eğitimi \n", 8 | "## 4. Hafta\n" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "metadata": {}, 14 | "source": [ 15 | "##### Sınıflar/Objeler\n", 16 | "\n", 17 | "Python, bir nesne tabanlı programlama dilidir (Object Oriented Programming - OOP). Bu demek oluyor ki, aslında pythonda kullandığımız nerdeyse tüm yapılar birer nesnedir: String, int, list, dict, fonksiyon vb bir çok şey.\n", 18 | "\n", 19 | "Sınıflar (class), objeler yaratırken kullandığımız birer taslak gibidir.\n", 20 | "\n", 21 | "Geçtiğimiz haftalarda `type()` fonksiyonu kullandığımızda aldığımız çıktıya tekrar göz atalım:" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 1, 27 | "metadata": {}, 28 | "outputs": [ 29 | { 30 | "name": "stdout", 31 | "output_type": "stream", 32 | "text": [ 33 | "\n", 34 | "\n", 35 | "\n", 36 | "\n" 37 | ] 38 | } 39 | ], 40 | "source": [ 41 | "a = 5\n", 42 | "b = \"IEEE\"\n", 43 | "c = []\n", 44 | "def d():\n", 45 | " pass\n", 46 | "\n", 47 | "print(type(a))\n", 48 | "print(type(b))\n", 49 | "print(type(c))\n", 50 | "print(type(d))" 51 | ] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "metadata": {}, 56 | "source": [ 57 | "Göreceğiniz üzere, a değişkeni aslında integer sınıfına ait bir örnek. Burada class (sınıf) ve object (nesne) kavramları önemlidir. Class, bir taslaktır, obje ise o class kullanılarak üretilmiş her instance'dan(örnekten) biridir. Integer, function, string, list birer class, yukarıda yarattığımız a, b, c, d birer nesnedir.\n", 58 | "\n", 59 | "Kafanız karıştıysa, bu hafta tamamen sınıf ve nesnelerle ilgileniyor olacağız. Bu esnada iyice anlayacaksınız.\n", 60 | "\n", 61 | "Şimdi, bir sınıfın nasıl tanımlandığına bakalım. Bunun için `class` keyword'ü kullanılır:" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": 3, 67 | "metadata": {}, 68 | "outputs": [], 69 | "source": [ 70 | "class MyClass:\n", 71 | " x = 5" 72 | ] 73 | }, 74 | { 75 | "cell_type": "markdown", 76 | "metadata": {}, 77 | "source": [ 78 | "Şu an `MyClass` adında bir sınıf oluşturduk. Bu sınıftan oluşturduğumuz objelerin taslağı bu olacak.\n", 79 | "\n", 80 | "Bu sınıftan obje oluşturmak içinse:\n" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": 5, 86 | "metadata": {}, 87 | "outputs": [ 88 | { 89 | "name": "stdout", 90 | "output_type": "stream", 91 | "text": [ 92 | "5\n", 93 | "\n" 94 | ] 95 | } 96 | ], 97 | "source": [ 98 | "nesne1 = MyClass()\n", 99 | "nesne2 = MyClass()\n", 100 | "print(nesne1.x)\n", 101 | "print(type(nesne2))" 102 | ] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": {}, 107 | "source": [ 108 | "Taslak derken ne demek istenildiği daha net anlaşılmıştır. `nesne1` ve `nesne2`, artık `MyClass` classına ait objeler. `x` ise bu objelere ait birer özellik (attribute). Bir objeye ait özelliklere ve methodlara erişmek için `obje.özellik` formatını kullanırız. \n", 109 | "\n", 110 | "Gerçek hayatta, birbirine tıpatıp benzeyen objelere değil de, aynı taslaktan çıkan farklı objelere ihtiyaç duyarız. Bunu nasıl yapabileceğimize bir örnek üzerinden bakalım" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": 7, 116 | "metadata": {}, 117 | "outputs": [ 118 | { 119 | "name": "stdout", 120 | "output_type": "stream", 121 | "text": [ 122 | "2022 model BMW M2\n", 123 | "2022\n" 124 | ] 125 | } 126 | ], 127 | "source": [ 128 | "class Araba:\n", 129 | " def __init__(self, marka, model, yil):\n", 130 | " self.marka = marka\n", 131 | " self.model = model\n", 132 | " self.yil = yil\n", 133 | " \n", 134 | " def yazdir(self):\n", 135 | " return f\"{self.yil} model {self.marka} {self.model}\"\n", 136 | "\n", 137 | "benim_arac = Araba(\"BMW\", \"M2\", \"2022\")\n", 138 | "print(benim_arac.yazdir())\n", 139 | "print(benim_arac.yil)" 140 | ] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": [ 146 | "Yukarıdaki örnekte yeni bir çok şey var. Hepsine tek tek bakalım:\n", 147 | "\n", 148 | "Geçen hafta gördüğümüz fonksiyonlar, sınıfların içinde de olabilir. Bir objeye ait olan fonksiyonlara method diyoruz. Bir fonksiyonun içerisinde istediğimiz gibi methodlar tanımlayabiliriz. Ancak python tarafından bazı özel methodlar bulunur, isimlerinin baş ve sonlarındakş `__` işaretlerinden ayırt edebiliriz. Bu methodlara \"Dunder Methods\" veya \"Magic Methods adı verilir. Bazı sık karşılaştığımız dunder methodlar: (Daha fazla Dunder Method'a [buradan](https://nitesh-yadav.medium.com/dunder-methods-in-python-really-crazy-functions-3455ecb6472d#:~:text=Dunder%20methods%2C%20also%20known%20as,or%20functionalities%20in%20Python%20classes.) ulaşabilirsiniz)\n", 149 | "- `__init__(self, ..)`: Bu method objenin inşasını sağlar. Obje ilk yaratılırken çağrılır. Genel olarak objeye attribute eklenmesi ve gerekli setup'ların yapılmasında kullanılır. Farklı parametreler alabilir. Yukarıda `benim_arac = Araba(\"BMW\", \"M2\", \"2022\")` yazdığımızda aslında init fonksiyonunu çağırmış oluyoruz, bu parametreleri de o alıyor\n", 150 | "- `__str__(self)` : Bu method objeye ait string bir değer döndürmeyi sağlar. Genel olarak `str()` fonksiyonu içine obje konduğunda veya obje printlenmeye çalıştığında çağrılır.\n", 151 | "- `__len__(self)` : Bu method objenin uzunluğunu döndürür. Genel olarak `len()` fonksiyonu içine obje konulduğunda çağrılır.\n", 152 | "\n", 153 | "Yani, örneğin aslında geçmişte kullandığımız her değişken tipi birer fonksiyon olduğuna göre, bu temel methodlar onlar için de tanımlıdır.\n", 154 | "\n", 155 | "Methodlar da aynı fonksiyonlar gibi parametreler alırlar, ancak ilk parametreleri özel bir değişken olan `self` parametresidir. `self`, o sınıfa ait o an erişilen objeyi temsil eder. Bu parametre, python tarafından otomatik olarak o anki nesne olacak şekilde verilir. Sınıfın içerisinde methodu tanımlarken ilk parametre olarak yazarız, ve daha sonrasında bu argümanı methodun içinde kullanırız. Ancak sınıfın dışında bu fonksiyonu çağırırken tekrar self için bir değer yollamayız, yukarıda söylediğimiz üzere otomatik olarak verilir.\n", 156 | "\n", 157 | "Birkaç örnek daha verelim:" 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": 10, 163 | "metadata": {}, 164 | "outputs": [ 165 | { 166 | "name": "stdout", 167 | "output_type": "stream", 168 | "text": [ 169 | "----\n", 170 | "Umur Uğurer\n", 171 | "1000\n", 172 | "----\n", 173 | "Furkan Ünüvar\n", 174 | "1200\n", 175 | "1100\n", 176 | "Umur Ata Uğurer\n" 177 | ] 178 | } 179 | ], 180 | "source": [ 181 | "# Class tanımlanması\n", 182 | "class calisan:\n", 183 | " sirket = \"İTÜ\" # Bu bir class attribute: Bu sınıfa ait her obje için aynı\n", 184 | " def __init__(self, ad, soyad, maas): # Parametre olarak alınan verilerin objeye atanması\n", 185 | " self.ad = ad # Bunlar objeye ait özellikler. Her bir objenin kendine ait , objeden objeye değişebilir\n", 186 | " self.soyad = soyad\n", 187 | " self.maas = maas\n", 188 | " def __str__(self):\n", 189 | " return f\"{self.ad} {self.soyad}\"\n", 190 | " def zam(self, miktar):\n", 191 | " self.maas += miktar\n", 192 | "\n", 193 | "# İki farklı obje tanımlanması\n", 194 | "calisan1 = calisan(\"Umur\", \"Uğurer\", 1000)\n", 195 | "calisan2 = calisan(\"Furkan\", \"Ünüvar\", 1200) \n", 196 | "\n", 197 | "# Attribute'ların printlenmesi\n", 198 | "print(\"----\")\n", 199 | "print(calisan1)\n", 200 | "print(calisan1.maas)\n", 201 | "print(calisan1.sirket)\n", 202 | "print(\"----\")\n", 203 | "print(calisan2)\n", 204 | "print(calisan2.maas)\n", 205 | "print(calisan2.sirket)\n", 206 | "# Maaşlara zam yapılması\n", 207 | "\n", 208 | "calisan2.zam(100)\n", 209 | "print(calisan2.maas)\n", 210 | "\n", 211 | "# Direkt olarak bir objenin attribute'unun değiştirilmesi:\n", 212 | "calisan1.ad = \"Umur Ata\"\n", 213 | "print(calisan1)\n", 214 | "\n", 215 | "calisan1.saat = 40 # Bu şekilde var olmayan yeni attribute'lar da eklenebilir" 216 | ] 217 | } 218 | ], 219 | "metadata": { 220 | "kernelspec": { 221 | "display_name": "Python 3", 222 | "language": "python", 223 | "name": "python3" 224 | }, 225 | "language_info": { 226 | "codemirror_mode": { 227 | "name": "ipython", 228 | "version": 3 229 | }, 230 | "file_extension": ".py", 231 | "mimetype": "text/x-python", 232 | "name": "python", 233 | "nbconvert_exporter": "python", 234 | "pygments_lexer": "ipython3", 235 | "version": "3.9.13" 236 | } 237 | }, 238 | "nbformat": 4, 239 | "nbformat_minor": 2 240 | } 241 | -------------------------------------------------------------------------------- /4. Ders/Ders Notları/Ders-4.md: -------------------------------------------------------------------------------- 1 | # Ders 4: Nesne Tabanlı Programlama (OOP) 2 | 3 | ## Sınıflar (Classes) 4 | 5 | Python, nesne tabanlı bir programlama dilidir (Object Oriented Programming - OOP). Bu demek oluyor ki, Python'da kullandığımız neredeyse tüm yapılar birer nesnedir: string, int, list, dict, fonksiyon gibi pek çok şey. 6 | 7 | Sınıflar (class), objeler yaratırken kullandığımız birer taslak gibidir. Geçtiğimiz haftalarda `type()` fonksiyonunu kullandığımızda aldığımız çıktıya tekrar göz atalım: 8 | 9 | ```python 10 | a = 5 11 | b = "IEEE" 12 | c = [] 13 | def d(): 14 | pass 15 | 16 | print(type(a)) # Çıktı: 17 | print(type(b)) # Çıktı: 18 | print(type(c)) # Çıktı: 19 | print(type(d)) # Çıktı: 20 | ``` 21 | 22 | Göreceğiniz üzere, `a` değişkeni aslında `int` sınıfına ait bir örnek. Burada **class (sınıf)** ve **object (nesne)** kavramları önemlidir: 23 | 24 | - **Class (Sınıf)**: Bir taslaktır, blueprint'tir 25 | - **Object (Nesne)**: O class kullanılarak üretilmiş her bir örnektir (instance) 26 | 27 | Integer, function, string, list birer class; yukarıda yarattığımız a, b, c, d ise birer nesnedir. 28 | 29 | ### Sınıf Tanımlamak 30 | 31 | Bir sınıf tanımlamak için `class` anahtar kelimesi kullanılır: 32 | 33 | ```python 34 | class MyClass: 35 | x = 5 36 | ``` 37 | 38 | Bu şekilde `MyClass` adında bir sınıf oluşturduk. Bu sınıftan oluşturacağımız objelerin taslağı bu olacak. 39 | 40 | ### Obje Oluşturmak 41 | 42 | Bu sınıftan obje oluşturmak için: 43 | 44 | ```python 45 | nesne1 = MyClass() 46 | nesne2 = MyClass() 47 | print(nesne1.x) # Çıktı: 5 48 | print(type(nesne2)) # Çıktı: 49 | ``` 50 | 51 | `nesne1` ve `nesne2`, artık `MyClass` sınıfına ait objeler. `x` ise bu objelere ait bir özellik (attribute). Bir objeye ait özelliklere ve methodlara erişmek için `obje.özellik` formatını kullanırız. 52 | 53 | ### Constructor (__init__ Methodu) 54 | 55 | Gerçek hayatta, birbirine tıpatıp benzeyen objeler değil, aynı taslaktan çıkan farklı objelere ihtiyaç duyarız. Bunun için `__init__` methodunu kullanırız: 56 | 57 | ```python 58 | class Araba: 59 | def __init__(self, marka, model, yil): 60 | self.marka = marka 61 | self.model = model 62 | self.yil = yil 63 | 64 | def yazdir(self): 65 | return f"{self.yil} model {self.marka} {self.model}" 66 | 67 | benim_arac = Araba("BMW", "M2", "2022") 68 | print(benim_arac.yazdir()) # Çıktı: 2022 model BMW M2 69 | print(benim_arac.yil) # Çıktı: 2022 70 | ``` 71 | 72 | ### self Parametresi 73 | 74 | Yukarıdaki örnekte yeni bir şey fark ettiniz: `self` parametresi. `self`, o sınıfa ait o an erişilen objeyi temsil eder. Bu parametre, Python tarafından otomatik olarak verilir. Sınıfın içerisinde method tanımlarken ilk parametre olarak yazarız, ancak sınıfın dışında bu methodu çağırırken `self` için bir değer yollamayız. 75 | 76 | ### Dunder Methods (Magic Methods) 77 | 78 | Python tarafından tanımlanan özel methodlara "Dunder Methods" veya "Magic Methods" denir. İsimlerinin başında ve sonunda `__` işareti bulunur. En yaygın kullanılanlar: 79 | 80 | - `__init__(self, ..)`: Obje ilk yaratılırken çağrılır. Constructor olarak bilinir. 81 | - `__str__(self)`: `print()` veya `str()` fonksiyonu ile obje string'e çevrilmek istendiğinde çağrılır. 82 | - `__len__(self)`: `len()` fonksiyonu ile objenin uzunluğu sorulduğunda çağrılır. 83 | 84 | Daha fazla Dunder Method'a [buradan](https://nitesh-yadav.medium.com/dunder-methods-in-python-really-crazy-functions-3455ecb6472d) ulaşabilirsiniz. 85 | 86 | ### Class ve Instance Attribute'ları 87 | 88 | ```python 89 | class Calisan: 90 | sirket = "İTÜ" # Bu bir class attribute: Bu sınıfa ait her obje için aynı 91 | 92 | def __init__(self, ad, soyad, maas): 93 | self.ad = ad # Bunlar instance attribute: Her obje için farklı olabilir 94 | self.soyad = soyad 95 | self.maas = maas 96 | 97 | def __str__(self): 98 | return f"{self.ad} {self.soyad}" 99 | 100 | def zam(self, miktar): 101 | self.maas += miktar 102 | 103 | # İki farklı obje tanımlanması 104 | calisan1 = Calisan("Mike", "Tyson", 1000) 105 | calisan2 = Calisan("Mustafa", "Yurtseven", 1200) 106 | 107 | # Attribute'ların kullanımı 108 | print(calisan1) # Çıktı: Mike Tyson 109 | print(calisan1.maas) # Çıktı: 1000 110 | print(calisan1.sirket) # Çıktı: İTÜ 111 | print(calisan2.maas) # Çıktı: 1200 112 | 113 | # Method çağırma 114 | calisan2.zam(100) 115 | print(calisan2.maas) # Çıktı: 1300 116 | 117 | # Direkt olarak bir objenin attribute'unun değiştirilmesi 118 | calisan1.ad = "John" 119 | print(calisan1) # Çıktı: John Tyson 120 | 121 | # Var olmayan yeni attribute eklemek 122 | calisan1.saat = 40 123 | ``` 124 | 125 | **Önemli Not**: Class attribute'lar tüm objeler tarafından paylaşılır. Instance attribute'lar ise her objeye özgüdür. 126 | 127 | ## Kalıtım (Inheritance) 128 | 129 | Kalıtım, bir sınıftan diğerine özelliklerin ve methodların aktarılmasını sağlar. Özellikleri veren sınıfa **Parent Class (Üst Sınıf)**, özellikleri alan sınıfa **Child Class (Alt Sınıf)** adı verilir. 130 | 131 | ### Temel Kalıtım 132 | 133 | ```python 134 | class Insan: # Parent class 135 | def __init__(self, ad, yas): 136 | self.ad = ad 137 | self.yas = yas 138 | self.is_durumu = "çalışan" 139 | 140 | def dogum_gunu(self): 141 | self.yas += 1 142 | 143 | class Ogrenci(Insan): # Child class 144 | def __init__(self, ad, yas, not_ortalamasi): 145 | super().__init__(ad, yas) # Parent class'ın __init__'ini çağırır 146 | self.not_ortalamasi = not_ortalamasi 147 | self.is_durumu = "öğrenci" 148 | 149 | def not_ver(self, yeni_not): 150 | self.not_ortalamasi = yeni_not 151 | 152 | # Kullanım 153 | ali = Insan("Ali", 21) 154 | hasan = Ogrenci("Hasan", 21, 3.0) 155 | 156 | print(ali.yas) # Çıktı: 21 157 | print(hasan.not_ortalamasi) # Çıktı: 3.0 158 | ali.dogum_gunu() 159 | print(hasan.yas) # Çıktı: 22 160 | print(hasan.is_durumu) # Çıktı: öğrenci 161 | ``` 162 | 163 | ### super() Fonksiyonu 164 | 165 | `super()` fonksiyonu, parent class'a erişmemizi sağlar. Child class'ta parent class'ın methodlarını çağırmak istediğimizde kullanırız. Yukarıdaki örnekte, `Ogrenci` class'ının `__init__` methodunda `super().__init__(ad, yas)` yazarak `Insan` class'ının `__init__` methodunu çağırdık. 166 | 167 | ### Override (Üzerine Yazma) 168 | 169 | Child class'ta parent class'ın bir methodunu yeniden tanımlarsak, parent'taki method override edilir (üzerine yazılır). Child class'ta tanımlanan method, parent'taki methodun yerini alır. 170 | 171 | ```python 172 | class Hayvan: 173 | def ses_cikar(self): 174 | print("Hayvan ses çıkarıyor") 175 | 176 | class Kedi(Hayvan): 177 | def ses_cikar(self): 178 | print("Miyav!") 179 | 180 | class Kopek(Hayvan): 181 | def ses_cikar(self): 182 | print("Hav hav!") 183 | 184 | kedi = Kedi() 185 | kopek = Kopek() 186 | 187 | kedi.ses_cikar() # Çıktı: Miyav! 188 | kopek.ses_cikar() # Çıktı: Hav hav! 189 | ``` 190 | 191 | ### Çoklu Kalıtım Hiyerarşisi 192 | 193 | Kalıtım yapısını dallandırarak daha karmaşık hiyerarşiler oluşturabiliriz: 194 | 195 | ```python 196 | class Canlilar: 197 | def __init__(self): 198 | self.canli = True 199 | 200 | class Omurgalilar(Canlilar): 201 | def __init__(self): 202 | super().__init__() 203 | self.omurga = True 204 | 205 | class Memeliler(Omurgalilar): 206 | def __init__(self): 207 | super().__init__() 208 | self.sut_salgisi = True 209 | 210 | class Insan(Memeliler): 211 | def __init__(self, ad): 212 | super().__init__() 213 | self.ad = ad 214 | self.akilli = True 215 | 216 | ali = Insan("Ali") 217 | print(ali.canli) # Çıktı: True 218 | print(ali.omurga) # Çıktı: True 219 | print(ali.sut_salgisi) # Çıktı: True 220 | print(ali.akilli) # Çıktı: True 221 | ``` 222 | 223 | Bu yapıda `Insan` sınıfına ait bir obje, override etmediği sürece, tüm üst sınıfların özellik ve methodlarını içerir. 224 | 225 | Bu şekilde teorik anlatımla tam olarak kafanıza oturması ve alışmanız pek mümkün değil. Bu sebeple bu haftaki derste sayı olarak fazla örneğe bakacağız. [Class](https://www.w3schools.com/python/python_classes.asp) ve [Inheritance](https://www.w3schools.com/python/python_inheritance.asp) yapıları için bu bağlantılara tıklayarak çok daha çeşitli örnekler görebilirsiniz. 226 | 227 | ## Soyutlama (Abstraction) 228 | 229 | Soyutlama (abstraction), nesne tabanlı programlamanın temel prensiplerinden biridir. Karmaşık detayları gizleyerek, kullanıcıya sadece gerekli bilgileri gösterme prensibidir. Gerçek hayattan bir örnek vermek gerekirse: Bir arabayı kullanırken motor nasıl çalışıyor bilmemize gerek yoktur. Sadece gaza basıp, frene basıp, direksiyonu kullanarak arabayı kullanabiliriz. İşte bu soyutlamadır. 230 | 231 | Python'da soyutlama için **Abstract Base Classes (ABC)** kullanılır. Abstract class'lar, doğrudan instance oluşturulamayan, ancak diğer class'ların miras alabileceği şablon class'lardır. 232 | 233 | ### Abstract Class Tanımlama 234 | 235 | Abstract class tanımlamak için `abc` modülünü kullanırız: 236 | 237 | ```python 238 | from abc import ABC, abstractmethod 239 | 240 | class Sekil(ABC): # Abstract base class 241 | @abstractmethod 242 | def alan_hesapla(self): 243 | pass 244 | 245 | @abstractmethod 246 | def cevre_hesapla(self): 247 | pass 248 | ``` 249 | 250 | Yukarıdaki örnekte `Sekil` bir abstract class'tır. `@abstractmethod` dekoratörü ile işaretlenen methodlar, bu class'tan türetilen tüm child class'larda **mutlaka** tanımlanmalıdır. 251 | 252 | ### Abstract Class'tan Türetme 253 | 254 | Abstract class'tan türeyen bir child class, tüm abstract methodları implement etmelidir: 255 | 256 | ```python 257 | from abc import ABC, abstractmethod 258 | 259 | class Sekil(ABC): 260 | @abstractmethod 261 | def alan_hesapla(self): 262 | pass 263 | 264 | @abstractmethod 265 | def cevre_hesapla(self): 266 | pass 267 | 268 | class Dikdortgen(Sekil): 269 | def __init__(self, uzunluk, genislik): 270 | self.uzunluk = uzunluk 271 | self.genislik = genislik 272 | 273 | def alan_hesapla(self): 274 | return self.uzunluk * self.genislik 275 | 276 | def cevre_hesapla(self): 277 | return 2 * (self.uzunluk + self.genislik) 278 | 279 | class Daire(Sekil): 280 | def __init__(self, yaricap): 281 | self.yaricap = yaricap 282 | 283 | def alan_hesapla(self): 284 | return 3.14 * self.yaricap ** 2 285 | 286 | def cevre_hesapla(self): 287 | return 2 * 3.14 * self.yaricap 288 | 289 | # Kullanım 290 | dikdortgen = Dikdortgen(5, 3) 291 | print(dikdortgen.alan_hesapla()) # Çıktı: 15 292 | print(dikdortgen.cevre_hesapla()) # Çıktı: 16 293 | 294 | daire = Daire(7) 295 | print(daire.alan_hesapla()) # Çıktı: 153.86 296 | print(daire.cevre_hesapla()) # Çıktı: 43.96 297 | ``` 298 | 299 | **Önemli**: Abstract class'tan doğrudan obje oluşturamazsınız: 300 | 301 | ```python 302 | # sekil = Sekil() # Hata! Abstract class'tan instance oluşturulamaz 303 | ``` 304 | 305 | ### Neden Soyutlama Kullanırız? 306 | 307 | 1. **Kod Organizasyonu**: Benzer özelliklere sahip class'lar için ortak bir arayüz tanımlarız. 308 | 2. **Zorunlu Implementasyon**: Child class'ların belirli methodları implement etmesini garanti ederiz. 309 | 3. **Esneklik**: Farklı implementasyonlar oluşturabiliriz ama ortak bir yapı korunur. 310 | 4. **Güvenlik**: Karmaşık detaylar gizlenir, sadece gerekli arayüz gösterilir. 311 | 312 | ### Daha Gelişmiş Bir Örnek 313 | 314 | ```python 315 | from abc import ABC, abstractmethod 316 | 317 | class Odeme(ABC): 318 | @abstractmethod 319 | def odeme_yap(self, miktar): 320 | pass 321 | 322 | @abstractmethod 323 | def odeme_iptal(self): 324 | pass 325 | 326 | class KrediKartiOdeme(Odeme): 327 | def __init__(self, kart_no): 328 | self.kart_no = kart_no 329 | 330 | def odeme_yap(self, miktar): 331 | print(f"Kredi kartı ile {miktar} TL ödeme yapıldı.") 332 | print(f"Kart No: {self.kart_no}") 333 | 334 | def odeme_iptal(self): 335 | print("Kredi kartı ödemesi iptal edildi.") 336 | 337 | class HavaleOdeme(Odeme): 338 | def __init__(self, iban): 339 | self.iban = iban 340 | 341 | def odeme_yap(self, miktar): 342 | print(f"Havale ile {miktar} TL ödeme yapıldı.") 343 | print(f"IBAN: {self.iban}") 344 | 345 | def odeme_iptal(self): 346 | print("Havale ödemesi iptal edildi.") 347 | 348 | # Kullanım 349 | kart_odeme = KrediKartiOdeme("1234-5678-9012-3456") 350 | kart_odeme.odeme_yap(150) 351 | # Çıktı: 352 | # Kredi kartı ile 150 TL ödeme yapıldı. 353 | # Kart No: 1234-5678-9012-3456 354 | 355 | havale_odeme = HavaleOdeme("TR123456789") 356 | havale_odeme.odeme_yap(200) 357 | # Çıktı: 358 | # Havale ile 200 TL ödeme yapıldı. 359 | # IBAN: TR123456789 360 | ``` 361 | 362 | ### Abstract ve Concrete Methods Birlikte 363 | 364 | Bir abstract class, hem abstract hem de normal (concrete) methodlar içerebilir: 365 | 366 | ```python 367 | from abc import ABC, abstractmethod 368 | 369 | class Calisan(ABC): 370 | def __init__(self, ad, soyad): 371 | self.ad = ad 372 | self.soyad = soyad 373 | 374 | # Normal method - tüm child class'lar kullanabilir 375 | def tam_ad(self): 376 | return f"{self.ad} {self.soyad}" 377 | 378 | # Abstract method - child class'lar implement etmeli 379 | @abstractmethod 380 | def maas_hesapla(self): 381 | pass 382 | 383 | class TamZamanli(Calisan): 384 | def __init__(self, ad, soyad, aylik_maas): 385 | super().__init__(ad, soyad) 386 | self.aylik_maas = aylik_maas 387 | 388 | def maas_hesapla(self): 389 | return self.aylik_maas 390 | 391 | class Freelance(Calisan): 392 | def __init__(self, ad, soyad, saatlik_ucret, calisma_saati): 393 | super().__init__(ad, soyad) 394 | self.saatlik_ucret = saatlik_ucret 395 | self.calisma_saati = calisma_saati 396 | 397 | def maas_hesapla(self): 398 | return self.saatlik_ucret * self.calisma_saati 399 | 400 | # Kullanım 401 | tam_zamanli = TamZamanli("Ali", "Veli", 15000) 402 | print(tam_zamanli.tam_ad()) # Çıktı: Ali Veli 403 | print(tam_zamanli.maas_hesapla()) # Çıktı: 15000 404 | 405 | freelance = Freelance("Ayşe", "Yılmaz", 100, 120) 406 | print(freelance.tam_ad()) # Çıktı: Ayşe Yılmaz 407 | print(freelance.maas_hesapla()) # Çıktı: 12000 408 | ``` 409 | 410 | ### Soyutlama ile İlgili Önemli Notlar 411 | 412 | 1. Abstract class'tan doğrudan instance (obje) oluşturamazsınız. 413 | 2. Abstract methodları implement etmeyen child class da abstract olarak kalır ve ondan da instance oluşturamazsınız. 414 | 3. `@abstractmethod` dekoratörü, methodun abstract olduğunu belirtir. 415 | 4. Abstract class'lar, bir arayüz (interface) sağlar ve polymorphism'i destekler. 416 | 5. Python'da interface yoktur, ancak abstract class'lar benzer bir amaç için kullanılır. 417 | 418 | ## Özet 419 | 420 | Bu derste nesne tabanlı programlamanın temel kavramlarını öğrendik: 421 | 422 | 1. **Sınıflar ve Objeler**: Class'lar taslaktır, objeler bu taslaktan üretilen örneklerdir. 423 | 2. **Constructor (`__init__`)**: Obje yaratılırken çağrılan özel method. 424 | 3. **self Parametresi**: Objenin kendisini temsil eder. 425 | 4. **Attribute'lar**: Class attribute (tüm objeler için ortak) ve instance attribute (her objeye özel). 426 | 5. **Kalıtım**: Bir class'ın başka bir class'tan özellik ve methodları miras alması. 427 | 6. **super()**: Parent class'a erişimi sağlar. 428 | 7. **Override**: Child class'ta parent class'ın methodlarını yeniden tanımlama. 429 | 8. **Soyutlama**: Karmaşık detayları gizleyerek ortak arayüzler oluşturma. 430 | 431 | Bu kavramları iyi anlamak için bol bol pratik yapmanız önerilir. Farklı senaryolar için kendi class'larınızı oluşturun ve kalıtım yapılarını deneyin! 432 | --------------------------------------------------------------------------------