Dağıtık Sistemlere Giriş ve Python Hatırlatma

# Değişken tanımlama
isim = "Ahmet"          # str (metin/string)
yas = 21                # int (tam sayı)
boy = 1.75              # float (ondalıklı sayı)
ogrenci_mi = True       # bool (mantıksal değer)

# Değişkenleri ekrana yazdırma
print(isim)             # Ahmet
print(type(isim))       # 
print(type(yas))        # 
print(type(boy))        # 
print(type(ogrenci_mi)) # 

# f-string ile formatlı yazdırma
print(f"Merhaba, ben {isim}. {yas} yaşındayım ve boyum {boy} metre.")

# Liste oluşturma
notlar = [85, 92, 78, 95, 88]
isimler = ["Ahmet", "Ayşe", "Mehmet", "Fatma"]
karisik = [1, "hello", 3.14, True]  # Farklı tipler olabilir

# Eleman erişimi (index 0'dan başlar!)
print(notlar[0])    # 85 (ilk eleman)
print(notlar[-1])   # 88 (son eleman)
print(notlar[1:3])  # [92, 78] (1. ve 2. index, 3 dahil değil)

# Liste uzunluğu
print(len(notlar))  # 5

# Eleman ekleme
notlar.append(100)         # Sona ekle
notlar.insert(0, 70)       # Başa ekle
print(notlar)              # [70, 85, 92, 78, 95, 88, 100]

# Eleman silme
notlar.remove(78)          # Değere göre sil
silinen = notlar.pop()     # Son elemanı çıkar ve döndür
print(f"Silinen: {silinen}")

# Liste sıralama
notlar.sort()              # Küçükten büyüğe
print(notlar)

# Faydalı fonksiyonlar
print(f"En yüksek not: {max(notlar)}")
print(f"En düşük not: {min(notlar)}")
print(f"Ortalama: {sum(notlar) / len(notlar):.1f}")

# Sözlük oluşturma
ogrenci = {
    "isim": "Ahmet",
    "yas": 21,
    "bolum": "Bilişim Teknolojileri",
    "notlar": [85, 92, 78],
    "aktif": True
}

# Değer okuma
print(ogrenci["isim"])        # Ahmet
print(ogrenci.get("yas"))     # 21
print(ogrenci.get("adres", "Belirtilmemiş"))  # Belirtilmemiş (varsayılan)

# Değer ekleme/güncelleme
ogrenci["email"] = "ahmet@mail.com"  # Yeni anahtar ekleme
ogrenci["yas"] = 22                   # Mevcut değeri güncelleme

# Sözlük üzerinde gezinme
for anahtar, deger in ogrenci.items():
    print(f"{anahtar}: {deger}")

# Tüm anahtarlar ve değerler
print(ogrenci.keys())    # Anahtarlar
print(ogrenci.values())  # Değerler

# Sözlüğün içinde sözlük (iç içe yapı)
sinif = {
    "ogrenci_1": {"isim": "Ahmet", "not": 85},
    "ogrenci_2": {"isim": "Ayşe", "not": 92},
    "ogrenci_3": {"isim": "Mehmet", "not": 78},
}
print(sinif["ogrenci_2"]["isim"])  # Ayşe

# Liste üzerinde gezinme
meyveler = ["elma", "armut", "portakal", "muz"]

for meyve in meyveler:
    print(f"🍎 {meyve}")

# range() ile sayı döngüsü
for i in range(5):        # 0, 1, 2, 3, 4
    print(i, end=" ")
print()                   # Yeni satır

# range(başlangıç, bitiş, adım)
for i in range(1, 10, 2):  # 1, 3, 5, 7, 9
    print(i, end=" ")
print()

# enumerate() ile index ve değer birlikte
for index, meyve in enumerate(meyveler):
    print(f"{index + 1}. {meyve}")

# Sözlük üzerinde döngü
ogrenci = {"isim": "Ahmet", "yas": 21, "bolum": "BT"}
for key, value in ogrenci.items():
    print(f"{key} → {value}")

# Bir koşul doğru olduğu sürece döner
sayac = 0
while sayac < 5:
    print(f"Sayaç: {sayac}")
    sayac += 1

# Toplam hesaplama
toplam = 0
sayi = 1
while sayi <= 100:
    toplam += sayi
    sayi += 1
print(f"1'den 100'e toplam: {toplam}")  # 5050

# Klasik yol
kareler = []
for i in range(1, 6):
    kareler.append(i ** 2)
print(kareler)  # [1, 4, 9, 16, 25]

# List comprehension ile aynı şey (tek satır!)
kareler = [i ** 2 for i in range(1, 6)]
print(kareler)  # [1, 4, 9, 16, 25]

# Koşullu list comprehension
cift_sayilar = [x for x in range(20) if x % 2 == 0]
print(cift_sayilar)  # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# String işlemiyle birlikte
isimler = ["ahmet", "ayşe", "mehmet"]
buyuk_isimler = [isim.upper() for isim in isimler]
print(buyuk_isimler)  # ['AHMET', 'AYŞE', 'MEHMET']

# Basit fonksiyon
def selamla(isim):
    """Verilen ismi selamlar."""
    return f"Merhaba, {isim}! 👋"

mesaj = selamla("Ahmet")
print(mesaj)  # Merhaba, Ahmet! 👋

# Birden fazla parametre
def toplam_bul(sayilar):
    """Bir listedeki sayıların toplamını döndürür."""
    sonuc = 0
    for sayi in sayilar:
        sonuc += sayi
    return sonuc

notlar = [85, 92, 78, 95, 88]
print(f"Toplam: {toplam_bul(notlar)}")  # 438

# Varsayılan parametre
def bilgi_goster(isim, bolum="Belirtilmemiş"):
    print(f"İsim: {isim}, Bölüm: {bolum}")

bilgi_goster("Ahmet", "Bilişim")   # İsim: Ahmet, Bölüm: Bilişim
bilgi_goster("Ayşe")                # İsim: Ayşe, Bölüm: Belirtilmemiş

# Birden fazla değer döndürme
def istatistikler(sayilar):
    """Min, max ve ortalama döndürür."""
    return min(sayilar), max(sayilar), sum(sayilar) / len(sayilar)

en_kucuk, en_buyuk, ortalama = istatistikler(notlar)
print(f"Min: {en_kucuk}, Max: {en_buyuk}, Ort: {ortalama:.1f}")

# Normal fonksiyon
def kare_al(x):
    return x ** 2

# Aynısı lambda ile
kare_al = lambda x: x ** 2
print(kare_al(5))  # 25

# İki parametre
topla = lambda a, b: a + b
print(topla(3, 4))  # 7

# Sıralama'da lambda kullanımı
ogrenciler = [
    {"isim": "Ahmet", "not": 85},
    {"isim": "Ayşe", "not": 92},
    {"isim": "Mehmet", "not": 78},
]

# Nota göre sırala (büyükten küçüğe)
sirali = sorted(ogrenciler, key=lambda x: x["not"], reverse=True)
for o in sirali:
    print(f"{o['isim']}: {o['not']}")

# Basit bir sınıf tanımlama
class Ogrenci:
    """Öğrenci bilgilerini tutan sınıf."""

    def __init__(self, isim, numara, bolum="Bilişim"):
        # Özellikler (attributes)
        self.isim = isim
        self.numara = numara
        self.bolum = bolum
        self.notlar = []

    def not_ekle(self, not_):
        """Öğrenciye not ekler."""
        self.notlar.append(not_)

    def ortalama(self):
        """Not ortalamasını döndürür."""
        if not self.notlar:
            return 0
        return sum(self.notlar) / len(self.notlar)

    def bilgi(self):
        """Öğrenci bilgilerini yazdırır."""
        print(f"📋 {self.isim} ({self.numara}) - {self.bolum}")
        print(f"   Notlar: {self.notlar}")
        print(f"   Ortalama: {self.ortalama():.1f}")

# Nesne (object/instance) oluşturma
ahmet = Ogrenci("Ahmet Yılmaz", "2024001")
ahmet.not_ekle(85)
ahmet.not_ekle(92)
ahmet.not_ekle(78)
ahmet.bilgi()

# Farklı parametrelerle başka bir nesne
ayse = Ogrenci("Ayşe Demir", "2024002", "Elektrik")
ayse.not_ekle(95)
ayse.bilgi()

# Neden önemli? Pandas'ta her DataFrame aslında bir nesne!
# df = pd.DataFrame(...)  # DataFrame sınıfından nesne oluşturma
# df.head()               # head() bir metot
# df.shape                # shape bir özellik (attribute)

# ─── Dosyaya yazma ───
with open("merhaba.txt", "w", encoding="utf-8") as dosya:
    dosya.write("Merhaba Dünya!\n")
    dosya.write("Büyük Veri Teknolojileri dersi.\n")

# ─── Dosyadan okuma ───
with open("merhaba.txt", "r", encoding="utf-8") as dosya:
    icerik = dosya.read()
    print(icerik)

# ─── Satır satır okuma (büyük dosyalar için!) ───
with open("merhaba.txt", "r", encoding="utf-8") as dosya:
    for satir_no, satir in enumerate(dosya, 1):
        print(f"Satır {satir_no}: {satir.strip()}")

# ─── Sonuna ekleme (append) ───
with open("merhaba.txt", "a", encoding="utf-8") as dosya:
    dosya.write("Bu satır sonradan eklendi.\n")

# Git kurulumu
# Windows: https://git-scm.com/download/win
# Mac: brew install git
# Linux: sudo apt install git

# İlk kurulum (bir kez yapılır)
git config --global user.name "Adınız Soyadınız"
git config --global user.email "email@adresiniz.com"

# Yeni bir proje başlatma
mkdir odevim
cd odevim
git init                    # Bu klasörü Git deposu yap

# Dosya ekleyip kaydetme
echo "Merhaba" > README.md
git add README.md           # Dosyayı sahneye al (stage)
git commit -m "İlk commit" # Değişikliği kaydet

# GitHub'a bağlama ve gönderme
git remote add origin https://github.com/kullanici/odevim.git
git push -u origin main     # GitHub'a gönder

# Örnek 1: Sayıların karesini alma
sayilar = [1, 2, 3, 4, 5]

# Klasik yol (döngü ile)
kareler_v1 = []
for s in sayilar:
    kareler_v1.append(s ** 2)
print(kareler_v1)  # [1, 4, 9, 16, 25]

# map() ile
kareler_v2 = list(map(lambda x: x ** 2, sayilar))
print(kareler_v2)  # [1, 4, 9, 16, 25]

# Örnek 2: Sıcaklıkları Celsius'tan Fahrenheit'a çevirme
celsius = [0, 20, 37, 100]
fahrenheit = list(map(lambda c: (c * 9/5) + 32, celsius))
print(fahrenheit)  # [32.0, 68.0, 98.6, 212.0]

# Örnek 3: İsimlerin ilk harfini büyük yapma
isimler = ["ahmet", "ayşe", "mehmet"]
duzgun_isimler = list(map(str.capitalize, isimler))
print(duzgun_isimler)  # ['Ahmet', 'Ayşe', 'Mehmet']

# Örnek 4: Bir fonksiyon tanımlayıp map ile kullanma
def not_degerlendirme(not_):
    if not_ >= 90: return "AA"
    elif not_ >= 80: return "BA"
    elif not_ >= 70: return "BB"
    elif not_ >= 60: return "CB"
    else: return "FF"

notlar = [95, 82, 67, 45, 78]
harf_notlari = list(map(not_degerlendirme, notlar))
print(harf_notlari)  # ['AA', 'BA', 'CB', 'FF', 'BB']

# Örnek 1: Çift sayıları filtreleme
sayilar = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
ciftler = list(filter(lambda x: x % 2 == 0, sayilar))
print(ciftler)  # [2, 4, 6, 8, 10]

# Örnek 2: Geçen öğrencileri filtreleme (50 ve üstü)
notlar = [45, 82, 33, 91, 67, 28, 75]
gecenler = list(filter(lambda n: n >= 50, notlar))
print(f"Geçenler: {gecenler}")      # [82, 91, 67, 75]
print(f"Geçen sayısı: {len(gecenler)}")

# Örnek 3: Boş olmayan stringleri filtreleme
veriler = ["Ahmet", "", "Ayşe", None, "Mehmet", "", "Fatma"]
temiz = list(filter(None, veriler))  # None ve boş string'ler atılır
print(temiz)  # ['Ahmet', 'Ayşe', 'Mehmet', 'Fatma']

# Örnek 4: Sözlük listesinden filtreleme
ogrenciler = [
    {"isim": "Ahmet", "not": 85},
    {"isim": "Ayşe", "not": 42},
    {"isim": "Mehmet", "not": 91},
    {"isim": "Fatma", "not": 38},
]

basarili = list(filter(lambda o: o["not"] >= 50, ogrenciler))
for o in basarili:
    print(f"  ✅ {o['isim']}: {o['not']}")

from functools import reduce

# Örnek 1: Toplam hesaplama
sayilar = [1, 2, 3, 4, 5]
toplam = reduce(lambda a, b: a + b, sayilar)
print(f"Toplam: {toplam}")  # 15

# Nasıl çalışır?
# Adım 1: 1 + 2 = 3
# Adım 2: 3 + 3 = 6
# Adım 3: 6 + 4 = 10
# Adım 4: 10 + 5 = 15

# Örnek 2: Çarpım hesaplama (faktöriyel gibi)
carpim = reduce(lambda a, b: a * b, sayilar)
print(f"Çarpım: {carpim}")  # 120

# Örnek 3: En büyük elemanı bulma
en_buyuk = reduce(lambda a, b: a if a > b else b, sayilar)
print(f"En büyük: {en_buyuk}")  # 5

# Örnek 4: Kelime listesini birleştirme
kelimeler = ["Büyük", "Veri", "Teknolojileri"]
cumle = reduce(lambda a, b: a + " " + b, kelimeler)
print(cumle)  # "Büyük Veri Teknolojileri"

from functools import reduce

# Senaryo: Bir sınıftaki notlardan...
# 1) 50'nin altını filtrele (kalanlar)
# 2) Her notu 10 puan bonus ekle (map)
# 3) Ortalamasını hesapla (reduce)

notlar = [45, 82, 33, 91, 67, 28, 75, 88, 54, 39]

# Adım 1: Geçenleri filtrele
gecenler = list(filter(lambda n: n >= 50, notlar))
print(f"Geçen notlar: {gecenler}")

# Adım 2: 10 puan bonus ekle (max 100)
bonuslu = list(map(lambda n: min(n + 10, 100), gecenler))
print(f"Bonuslu notlar: {bonuslu}")

# Adım 3: Ortalama hesapla
toplam = reduce(lambda a, b: a + b, bonuslu)
ortalama = toplam / len(bonuslu)
print(f"Ortalama: {ortalama:.1f}")

# Basit Word Count - Tek bilgisayar versiyonu

metin = """
Python büyük veri dünyasında çok popüler bir dildir
Büyük veri teknolojileri ile veri analizi yapabiliriz
Python ile veri işleme çok kolaydır
"""

# Metni küçük harfe çevir ve kelimelere ayır
kelimeler = metin.lower().split()

# Kelimeleri say
kelime_sayilari = {}
for kelime in kelimeler:
    if kelime in kelime_sayilari:
        kelime_sayilari[kelime] += 1
    else:
        kelime_sayilari[kelime] = 1

# Sonuçları en çok geçenden en az geçene sırala
sirali = sorted(kelime_sayilari.items(), key=lambda x: x[1], reverse=True)

print("=== Kelime Sayıları ===")
for kelime, sayi in sirali:
    print(f"  {kelime:20s} → {sayi}")

from functools import reduce

# ─── Veri ───
metin = """
Python büyük veri dünyasında çok popüler bir dildir
Büyük veri teknolojileri ile veri analizi yapabiliriz
Python ile veri işleme çok kolaydır
Dağıtık sistemler büyük veri için gereklidir
"""

# ─── ADIM 1: SPLIT (Veriyi parçalara böl) ───
# Gerçek Hadoop'ta bu farklı bilgisayarlara gönderilir
satirlar = metin.strip().lower().split('\n')
print("📦 Parçalar (her satır ayrı bir düğümde işlenebilir):")
for i, satir in enumerate(satirlar):
    print(f"  Düğüm {i+1}: '{satir.strip()}'")

# ─── ADIM 2: MAP (Her parçada kelimeleri say) ───
def map_fonksiyonu(satir):
    """Her kelime için (kelime, 1) çifti üret."""
    kelimeler = satir.strip().split()
    return [(kelime, 1) for kelime in kelimeler]

# Her satırı map fonksiyonundan geçir
map_sonuclari = list(map(map_fonksiyonu, satirlar))

print("\n🗺️ MAP Sonuçları:")
for i, sonuc in enumerate(map_sonuclari):
    print(f"  Düğüm {i+1}: {sonuc}")

# ─── ADIM 3: SHUFFLE (Düzleştir ve grupla) ───
# Tüm (kelime, 1) çiftlerini tek listeye topla
tum_ciftler = reduce(lambda a, b: a + b, map_sonuclari)
print(f"\n🔀 SHUFFLE - Tüm çiftler: {len(tum_ciftler)} adet")

# ─── ADIM 4: REDUCE (Aynı kelimelerin sayılarını topla) ───
def reduce_fonksiyonu(ciftler):
    """Aynı kelimelerin sayılarını topla."""
    sonuc = {}
    for kelime, sayi in ciftler:
        sonuc[kelime] = sonuc.get(kelime, 0) + sayi
    return sonuc

nihai_sonuc = reduce_fonksiyonu(tum_ciftler)

# Sonuçları sırala ve göster
sirali = sorted(nihai_sonuc.items(), key=lambda x: x[1], reverse=True)

print("\n📊 REDUCE - Nihai Sonuç:")
print("=" * 35)
for kelime, sayi in sirali:
    bar = "█" * sayi
    print(f"  {kelime:20s} {sayi:2d} {bar}")

# Python'un yerleşik (built-in) modülleri
import math
print(math.pi)        # 3.141592653589793
print(math.sqrt(16))  # 4.0

import random
print(random.randint(1, 100))  # 1-100 arası rastgele sayı

import datetime
simdi = datetime.datetime.now()
print(simdi)  # 2026-02-16 14:30:00.123456

# 'from' ile sadece istediğini al
from math import pi, sqrt
print(pi)       # 3.141592653589793
print(sqrt(25)) # 5.0

# Takma isim (alias)
import datetime as dt
print(dt.date.today())

# Kütüphane kurma
pip install pandas
pip install numpy matplotlib seaborn

# Kurulu kütüphaneleri listeleme
pip list

# Belirli bir versiyon kurma
pip install pandas==2.1.0

# Kütüphaneyi güncelleme
pip install --upgrade pandas

# requirements.txt ile toplu kurulum
pip install -r requirements.txt