🐍 Python ile Programlamaya Hoş Geldiniz

# Liste işlemleri
sayilar = [1, 2, 3, 4, 5]
sayilar.append(6)
sayilar.insert(0, 0)
sayilar.remove(3)
print(f"Liste: {sayilar}")

# Slicing
print(f"İlk 3: {sayilar[:3]}")
print(f"Son 3: {sayilar[-3:]}")

# Liste metodları
kopya = sayilar.copy()
kopya.sort(reverse=True)
print(f"Sıralı: {kopya}")

# Dictionary işlemleri
ogrenci = {
    "ad": "Halil",
    "yas": 20,
    "bolum": "Bilgisayar Müh.",
    "notlar": [85, 90, 78]
}

# Değerlere erişim
print(f"Ad: {ogrenci['ad']}")
print(f"Ortalama: {sum(ogrenci['notlar']) / len(ogrenci['notlar'])}")

# Yeni ekleme
ogrenci["email"] = "Halil@mail.com"

# Döngü ile gezinme
for anahtar, deger in ogrenci.items():
    print(f"{anahtar}: {deger}")

# Set (benzersiz elemanlar)
sayilar = {1, 2, 3, 3, 4, 5, 5}
print(f"Set: {sayilar}")  # {1, 2, 3, 4, 5}

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
print(f"Birleşim: {set1 | set2}")
print(f"Kesişim: {set1 & set2}")
print(f"Fark: {set1 - set2}")

# Tuple (değiştirilemez)
koordinat = (10, 20)
renkler = ("kırmızı", "yeşil", "mavi")
print(f"Koordinat: {koordinat}")
print(f"İlk renk: {renkler[0]}")

 # Temel fonksiyon def selamla(isim): return f"Merhaba {isim}!"
Çoklu parametre ve varsayılan değerler

def hesapla(a, b, islem="+"):
if islem == "+":
return a + b
elif islem == "-":
return a - b
elif islem == "*":
return a * b
elif islem == "/":
return a / b if b != 0 else "Hata: Sıfıra bölme"
*args ve **kwargs kullanımı

def topla_hepsi(*sayilar):
"""
*args olarak da bilinen *sayilar, fonksiyona
değişken sayıda pozisyonel (sıralı) argüman gönderilmesine olanak sağlar.
Fonksiyon içerisine gelen tüm bu argümanlar bir tuple (demet) içinde toplanır.
Örneğin, fonksiyon topla_hepsi(1, 2, 3) olarak çağrıldığında,
sayilar = (1, 2, 3) şeklinde olur.
Bu sayede fonksiyon kaç argüman gelirse hepsini esnek bir şekilde işleyebilir.
"""
return sum(sayilar)

def bilgi_goster(**kwargs):
"""
**kwargs olarak da bilinen **kwargs, fonksiyona
değişken sayıda anahtar-değer çiftinden oluşan argümanlar gönderilmesine imkan tanır.
Fonksiyon içi bu argümanlar bir dictionary (sözlük) içinde tutulur.
Örneğin, bilgi_goster(ad="Ali", yas=30) olarak çağrıldığında,
kwargs = {"ad": "Ali", "yas": 30} olur.
Böylece fonksiyon, isimlendirilmiş parametrelerin sayısı ve isimleri önceden bilinmeden kullanılabilir.
"""
for k, v in kwargs.items():
print(f"{k}: {v}")
Lambda fonksiyonları (anonim fonksiyonlar)

kare = lambda x: x ** 2 # Verilen sayının karesini döndürür
ciftmi = lambda x: x % 2 == 0 # Sayının çift olup olmadığını kontrol eder

sayilar =

​
kareler = list(map(lambda x: x**2, sayilar)) # Sayıların karelerini hesaplar
ciftler = list(filter(lambda x: x%2==0, sayilar)) # Çift sayıları seçer

print(f"Kareler: {kareler}")
print(f"Çift sayılar: {ciftler}")

# Temel sınıf tanımlama
class Araba:
    def __init__(self, marka, model, yil):
        self.marka = marka
        self.model = model
        self.yil = yil
        self.km = 0
    
    def bilgi(self):
        return f"{self.yil} {self.marka} {self.model}"
    
    def km_ekle(self, mesafe):
        self.km += mesafe

# Kalıtım (Inheritance)
class ElektrikliAraba(Araba):
    def __init__(self, marka, model, yil, batarya_kapasitesi):
        super().__init__(marka, model, yil)
        self.batarya = batarya_kapasitesi
        self.sarj_seviyesi = 100
    
    def sarj_et(self, miktar):
        self.sarj_seviyesi = min(100, self.sarj_seviyesi + miktar)
        return f"Şarj seviyesi: %{self.sarj_seviyesi}"
    
    def bilgi(self):  # Method overriding
        return f"{super().bilgi()} (Elektrikli - {self.batarya}kWh)"

# Kullanım
tesla = ElektrikliAraba("Tesla", "Model 3", 2023, 75)
print(tesla.bilgi())
print(tesla.sarj_et(20))

# Dosya işlemleri simülasyonu (bellekte)
class DosyaSistemi:
    def __init__(self):
        self.dosyalar = {}
    
    def yaz(self, dosya_adi, icerik):
        self.dosyalar[dosya_adi] = icerik
        return f"{dosya_adi} yazıldı"
    
    def oku(self, dosya_adi):
        return self.dosyalar.get(dosya_adi, "Dosya bulunamadı")
    
    def listele(self):
        return list(self.dosyalar.keys())

# JSON işlemleri
import json

veri = {
    "isim": "Halil",
    "yas": 25,
    "sehir": "Yalova",
    "hobiler": ["kitap", "müzik", "spor"]
}

# JSON'a çevir
json_str = json.dumps(veri, indent=2, ensure_ascii=False)
print("JSON formatı:")
print(json_str)

# JSON'dan oku
geri_veri = json.loads(json_str)
print(f"\nİsim: {geri_veri['isim']}")

# CSV benzeri veri işleme
class CSVIsleyici:
    def __init__(self):
        self.veriler = []
        self.basliklar = []
    
    def veri_ekle(self, basliklar, satirlar):
        self.basliklar = basliklar
        self.veriler = satirlar
    
    def goster(self):
        # Başlıkları yazdır
        print(" | ".join(self.basliklar))
        print("-" * 50)
        # Verileri yazdır
        for satir in self.veriler:
            print(" | ".join(str(v) for v in satir))
    
    def filtrele(self, kolon_index, deger):
        return [s for s in self.veriler if s[kolon_index] == deger]

# Kullanım
csv = CSVIsleyici()
csv.veri_ekle(
    ["İsim", "Yaş", "Şehir"],
    [
        ["Halil", 25, "Yalova"],
        ["Ayşe", 30, "Ankara"],
        ["Muhammed", 25, "İstanbul"]
    ]
)
csv.goster()

# Temel try-except
try:
    sayi = int(input("Bir sayı girin: "))
    sonuc = 100 / sayi
    print(f"Sonuç: {sonuc}")
except ValueError:
    print("Hata: Geçerli bir sayı girin")
except ZeroDivisionError:
    print("Hata: Sıfıra bölme yapılamaz")
except Exception as e:
    print(f"Beklenmeyen hata: {e}")
finally:
    print("İşlem tamamlandı")

# Özel hata sınıfı
class YetersizBakiyeHatasi(Exception):
    def __init__(self, bakiye, miktar):
        self.bakiye = bakiye
        self.miktar = miktar
        super().__init__(f"Yetersiz bakiye: {bakiye} TL (İhtiyaç: {miktar} TL)")

class Hesap:
    def __init__(self, bakiye):
        self.bakiye = bakiye
    
    def para_cek(self, miktar):
        if miktar > self.bakiye:
            raise YetersizBakiyeHatasi(self.bakiye, miktar)
        self.bakiye -= miktar
        return f"Çekilen: {miktar} TL"

# Kullanım
hesap = Hesap(1000)
try:
    print(hesap.para_cek(500))
    print(hesap.para_cek(600))  # Hata fırlatır
except YetersizBakiyeHatasi as e:
    print(f"HATA: {e}")

# Basit decorator
def zamanlayici(func):
    import time
    def wrapper(*args, **kwargs):
        baslangic = time.time()
        sonuc = func(*args, **kwargs)
        bitis = time.time()
        print(f"{func.__name__} çalışma süresi: {bitis-baslangic:.4f} saniye")
        return sonuc
    return wrapper

@zamanlayici
def yavas_fonksiyon():
    toplam = 0
    for i in range(1000000):
        toplam += i
    return toplam

# Parametreli decorator
def tekrar(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator

@tekrar(3)
def selamla(isim):
    print(f"Merhaba {isim}!")

# Generator fonksiyon
def fibonacci_generator(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

# Kullanım
for sayi in fibonacci_generator(10):
    print(sayi, end=" ")

# Generator expression
kareler = (x**2 for x in range(10))
print(list(kareler))

# Sonsuz generator
def sonsuz_sayilar():
    sayi = 0
    while True:
        yield sayi
        sayi += 1

# List comprehension
kareler = [x**2 for x in range(10)]
ciftler = [x for x in range(20) if x % 2 == 0]
matris = [[i*j for j in range(5)] for i in range(5)]

# Dictionary comprehension
kare_dict = {x: x**2 for x in range(6)}
print(kare_dict)

# Set comprehension
tekil_uzunluklar = {len(kelime) for kelime in ["elma", "armut", "muz", "kivi"]}
print(tekil_uzunluklar)

# Bubble Sort
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

# Selection Sort
def selection_sort(arr):
    for i in range(len(arr)):
        min_idx = i
        for j in range(i+1, len(arr)):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

# Quick Sort
def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

# Binary Search
def binary_search(arr, hedef):
    sol, sag = 0, len(arr) - 1
    while sol <= sag:
        orta = (sol + sag) // 2
        if arr[orta] == hedef:
            return orta
        elif arr[orta] < hedef:
            sol = orta + 1
        else:
            sag = orta - 1
    return -1

# Linear Search
def linear_search(arr, hedef):
    for i, eleman in enumerate(arr):
        if eleman == hedef:
            return i
    return -1

# Stack (Yığıt)
class Stack:
    def __init__(self):
        self.items = []
    
    def push(self, item):
        self.items.append(item)
    
    def pop(self):
        if not self.is_empty():
            return self.items.pop()
    
    def peek(self):
        if not self.is_empty():
            return self.items[-1]
    
    def is_empty(self):
        return len(self.items) == 0

# Queue (Kuyruk)
class Queue:
    def __init__(self):
        self.items = []
    
    def enqueue(self, item):
        self.items.insert(0, item)
    
    def dequeue(self):
        if not self.is_empty():
            return self.items.pop()
    
    def is_empty(self):
        return len(self.items) == 0

# Mini Web Framework
class MiniFlask:
    def __init__(self):
        self.routes = {}
    
    def route(self, path):
        def decorator(func):
            self.routes[path] = func
            return func
        return decorator
    
    def run(self, path):
        if path in self.routes:
            return self.routes[path]()
        return "404 - Sayfa Bulunamadı"

# Uygulama oluştur
app = MiniFlask()

@app.route("/")
def anasayfa():
    return "Anasayfaya hoş geldiniz!"

@app.route("/hakkimizda")
def hakkimizda():
    return "Hakkımızda sayfası"

@app.route("/iletisim")
def iletisim():
    return "İletişim: info@example.com"

# REST API örneği
class API:
    def __init__(self):
        self.data = {}
        self.id_counter = 1
    
    def get_all(self):
        return list(self.data.values())
    
    def get_by_id(self, id):
        return self.data.get(id, {"error": "Not found"})
    
    def create(self, item):
        id = self.id_counter
        self.data[id] = {"id": id, **item}
        self.id_counter += 1
        return self.data[id]
    
    def update(self, id, item):
        if id in self.data:
            self.data[id].update(item)
            return self.data[id]
        return {"error": "Not found"}
    
    def delete(self, id):
        if id in self.data:
            del self.data[id]
            return {"message": "Deleted"}
        return {"error": "Not found"}

# GUI Framework Simülasyonu
class Widget:
    def __init__(self, text=""):
        self.text = text
        self.x = 0
        self.y = 0
    
    def render(self):
        return f"[{self.__class__.__name__}] {self.text}"

class Button(Widget):
    def __init__(self, text, command=None):
        super().__init__(text)
        self.command = command
    
    def click(self):
        if self.command:
            return self.command()
        return "Button clicked"

class Label(Widget):
    pass

class Entry(Widget):
    def __init__(self):
        super().__init__()
        self.value = ""
    
    def set_value(self, value):
        self.value = value
    
    def get_value(self):
        return self.value

class Window:
    def __init__(self, title):
        self.title = title
        self.widgets = []
    
    def add_widget(self, widget):
        self.widgets.append(widget)
    
    def show(self):
        print(f"\n{'='*50}")
        print(f"  {self.title}")
        print('='*50)
        for widget in self.widgets:
            print(widget.render())
        print('='*50)