Python, basit ve okunabilir sözdizimi ile bilinen, öğrenmesi kolay, genel amaçlı, yorumlanan ve dinamik tipli bir dildir.

Temel Özellikler:

• Okunabilir Sözdizimi: Kod blokları için girintileme (indentation) kullanır, bu da kodu görsel olarak temiz ve anlaşılır kılar.
• Dinamik Tipleme: Değişken tiplerini çalışma zamanında belirler, açıkça tip belirtme zorunluluğu yoktur (tip = "metin", tip = 10 gibi).
• Yorumlanan Dil: Kod, genellikle derlenmeden satır satır yorumlanır (CPython yorumlayıcısı).
• Geniş Standart Kütüphane: Dosya işlemleri, ağ iletişimi, veri yapıları, matematiksel fonksiyonlar gibi birçok temel işlevsellik için zengin bir standart kütüphane sunar.
• Otomatik Bellek Yönetimi: Çöp toplama (garbage collection) mekanizması ile bellek yönetimini otomatikleştirir.

# Python Temel Örnek
def faktoriyel(n):
    """Verilen sayının faktöriyelini hesaplar."""
    if not isinstance(n, int) or n < 0:
        return "Geçersiz giriş"
    sonuc = 1
    for i in range(1, n + 1):
        sonuc *= i
    return sonuc

sayi = 5
print(f"{sayi}! = {faktoriyel(sayi)}") # 5! = 120

isimler = ["Ali", "Veli", "Ayşe"]
for isim in isimler:
    print(f"Merhaba {isim}")
                     

İleri Seviye Özellikler ve Kavramlar:

• List/Dict/Set Comprehensions: Koleksiyonları kısa ve okunabilir bir şekilde oluşturma.
• Generators ve yield: Bellek verimli, isteğe bağlı değer üreten fonksiyonlar.
• Decorators (@): Fonksiyonların veya metotların davranışını değiştiren/genişleten yapılar.
• Lambda Fonksiyonları: Küçük, isimsiz fonksiyonlar.
• Nesne Yönelimli Programlama (OOP): Sınıflar, kalıtım, polimorfizm, kapsülleme tam olarak desteklenir.
• Fonksiyonel Programlama Özellikleri: map, filter, reduce gibi fonksiyonlar, değişmezlik (immutability) prensiplerine uygunluk.
• Modüller ve Paketler: Kodu organize etmek ve yeniden kullanmak için güçlü bir sistem (import, pip).
• Asenkron Programlama (async/await): asyncio kütüphanesi ile I/O ağırlıklı işlemler için asenkron çalışma desteği.

# İleri Seviye Örnek (Comprehension ve Lambda)
sayilar = [1, 2, 3, 4, 5, 6]
cift_kareler = [x**2 for x in sayilar if x % 2 == 0]
print(f"Çift Kareler: {cift_kareler}") # [4, 16, 36]

buyuk_harf = list(map(lambda s: s.upper(), ["a", "b", "c"]))
print(f"Büyük Harfler: {buyuk_harf}") # ['A', 'B', 'C']

# Async Örneği (Konsept)
import asyncio

async def veri_getir(url):
    print(f"{url} adresinden veri getiriliyor...")
    await asyncio.sleep(1) # Ağ isteğini simüle et
    print(f"{url} tamamlandı.")
    return {"data": f"Veri: {url}"}

async def main():
    task1 = asyncio.create_task(veri_getir("site1.com"))
    task2 = asyncio.create_task(veri_getir("site2.com"))
    sonuc1 = await task1
    sonuc2 = await task2
    print(f"Sonuçlar: {sonuc1}, {sonuc2}")

# asyncio.run(main()) # Asenkron fonksiyonu çalıştırma
                     

Kullanım Alanları: Web geliştirme (Django, Flask), veri bilimi, makine öğrenmesi, yapay zeka, otomasyon, scripting, bilimsel hesaplama, oyun geliştirme (Pygame).

JavaScript, web tarayıcılarının temel betik dilidir ve modern web uygulamalarına dinamizm ve etkileşim katmak için vazgeçilmezdir. Node.js sayesinde sunucu tarafında da yaygın olarak kullanılır.

Temel Özellikler:

• İstemci Taraflı Çalışma: Tarayıcı içinde çalışarak DOM'u manipüle eder, olaylara tepki verir, AJAX istekleri yapar.
• Dinamik Tipleme: Değişken tipleri çalışma zamanında belirlenir (Python gibi).
• Prototip Tabanlı OOP: Geleneksel sınıf tabanlı OOP'den farklı olarak nesneler prototipler aracılığıyla kalıtım alır (ES6 sınıfları bu yapıyı soyutlar).
• Asenkron Yapı: Olay döngüsü (event loop) ve callback'ler, Promise'ler, async/await ile asenkron işlemleri (ağ istekleri, zamanlayıcılar) yönetir.
• Geniş Ekosistem: npm aracılığıyla erişilebilen devasa bir kütüphane ve framework ekosistemine sahiptir.

// JavaScript Temel Örnek (Tarayıcı Konsolu)

// Değişkenler (let/const)
let mesaj = "Merhaba JavaScript!";
const PI = 3.14;

// Fonksiyon
function topla(a, b) {
  return a + b;
}

console.log(mesaj);
console.log(topla(5, 8)); // 13

// DOM Manipülasyonu (HTML içinde çalıştırıldığında)
// const baslik = document.getElementById('anaBaslik');
// if (baslik) {
//   baslik.textContent = 'JavaScript ile Değiştirildi!';
//   baslik.style.color = 'blue';
// }

// Olay Dinleyici
// const buton = document.getElementById('tiklaButon');
// if (buton) {
//   buton.addEventListener('click', () => {
//     alert('Butona tıklandı!');
//   });
// }
                     

İleri Seviye Özellikler ve Kavramlar (ES6+):

• let ve const: Blok kapsamlı değişken tanımlama.
• Arrow Functions: Daha kısa fonksiyon sözdizimi ve lexical this.
• Classes: Prototip tabanlı yapıyı kullanan sınıf sözdizimi.
• Template Literals: Kolay string interpolasyonu ve çok satırlı stringler (` `).
• Destructuring: Dizi ve nesne elemanlarını kolayca değişkenlere atama.
• Default Parameters: Fonksiyon parametrelerine varsayılan değerler verme.
• Rest/Spread Operatörleri (...): Değişken sayıda argüman toplama / koleksiyonları yayma.
• Modules (import/export): Kodu organize etmek ve yeniden kullanmak için standart modül sistemi.
• Promises ve async/await: Asenkron işlemleri yönetmek için modern ve okunabilir yöntemler.
• Fetch API: Ağ istekleri yapmak için modern arayüz.
• Yeni Veri Yapıları: Map, Set, Symbol.

// İleri Seviye Örnek (ES6+)

// Destructuring ve Arrow Function
const kisi = { ad: "Zeynep", yas: 28 };
const { ad, yas } = kisi;
const bilgiVer = ({ ad, yas }) => `Ad: ${ad}, Yaş: ${yas}`;
console.log(bilgiVer(kisi)); // Ad: Zeynep, Yaş: 28

// Spread Operatörü
const dizi1 = [1, 2];
const dizi2 = [...dizi1, 3, 4]; // [1, 2, 3, 4]
console.log(dizi2);

// Promise ve async/await (Fetch API ile önceki bölümde örneklendi)
async function kullaniciGetir(id) {
    try {
        const response = await fetch(`https://jsonplaceholder.typicode.com/users/${id}`);
        if (!response.ok) throw new Error("Kullanıcı bulunamadı");
        const user = await response.json();
        return user;
    } catch (err) {
        console.error("Hata:", err);
        return null;
    }
}

// (async () => { // Async IIFE (Immediately Invoked Function Expression)
//     const k = await kullaniciGetir(1);
//     if (k) console.log("Getirilen Kullanıcı:", k.name);
// })();
                     

Kullanım Alanları: Frontend web geliştirme (React, Angular, Vue), backend web geliştirme (Node.js), mobil uygulama geliştirme (React Native, NativeScript), masaüstü uygulamaları (Electron), oyun geliştirme.

React (veya React.js), Facebook tarafından geliştirilen, kullanıcı arayüzleri (UI) oluşturmak için kullanılan popüler bir JavaScript kütüphanesidir (genellikle framework olarak da anılır). Temel felsefesi, UI'ı bileşen (component) adı verilen küçük, yeniden kullanılabilir parçalara ayırmaktır.

Temel Kavramlar:

• Bileşenler (Components): UI'ın bağımsız parçalarıdır. Kendi mantığını ve görünümünü (markup) içerirler. Fonksiyonel bileşenler (fonksiyon kullanarak) veya sınıf bileşenleri (ES6 sınıfı kullanarak) şeklinde olabilirler. Fonksiyonel bileşenler ve Hook'lar (aşağıda) modern React'te daha yaygındır.
• JSX (JavaScript XML): JavaScript içinde HTML benzeri bir sözdizimi kullanarak UI yapısını tanımlamayı sağlar. Tarayıcı tarafından anlaşılması için Babel gibi araçlarla normal JavaScript'e dönüştürülür.
• State (Durum): Bir bileşenin zaman içinde değişebilen verisidir. Genellikle useState Hook'u ile yönetilir. State değiştiğinde React bileşeni otomatik olarak yeniden render eder.
• Props (Properties): Üst bileşenlerden alt bileşenlere veri aktarmak için kullanılan salt okunur (read-only) nesnelerdir.
• Hook'lar (Hooks - React 16.8+): Fonksiyonel bileşenler içinde state (useState) ve diğer React özelliklerini (useEffect - yan etkiler için, useContext - bağlam için vb.) kullanmayı sağlayan özel fonksiyonlardır.
• Virtual DOM: React, performansı optimize etmek için bellekte gerçek DOM'un bir kopyasını (Virtual DOM) tutar. State değiştiğinde, önce Virtual DOM güncellenir, ardından gerçek DOM ile arasındaki farklar hesaplanır (diffing) ve sadece gerekli değişiklikler gerçek DOM'a uygulanır.

Kurulum (Create React App ile):

# Node.js ve npm/yarn kurulu olmalı
npx create-react-app benim-react-uygulamam
cd benim-react-uygulamam
npm start # veya yarn start
                     

Basit Fonksiyonel Bileşen Örneği:

import React, { useState } from 'react';

function SayacButonu(props) {
  // State Hook'u: 'sayac' state değişkeni, 'setSayac' onu güncelleyen fonksiyon
  const [sayac, setSayac] = useState(0); // Başlangıç değeri 0

  const artir = () => {
    setSayac(sayac + 1);
  };

  return (
    

      
{props.etiket || 'Sayaç'}: {sayac}
      Artır
    
  );
}

// Kullanım:
// function App() {
//   return (
//     

//       
React Uygulaması
//       
//        
//     
//   );
// }

// export default App;
                      

React, özellikle tek sayfa uygulamaları (Single Page Applications - SPA) ve karmaşık kullanıcı arayüzleri geliştirmek için güçlü ve esnek bir çözümdür.

Django, Python ile yazılmış, yüksek seviyeli ve "her şey dahil" (batteries-included) bir web framework'üdür. Hızlı, güvenli ve ölçeklenebilir web uygulamaları geliştirmek için ihtiyaç duyulan birçok aracı (ORM, admin paneli, kimlik doğrulama, şablon motoru vb.) bünyesinde barındırır. MVT (Model-View-Template) mimari desenini takip eder.

Temel Kavramlar:

• Model: Veritabanı yapısını tanımlar. Django'nun yerleşik ORM'i (Object-Relational Mapper) sayesinde Python sınıfları (modeller) veritabanı tablolarına eşlenir.
• View (Görünüm - Django'da Controller'a benzer): Gelen HTTP isteklerini alır, gerekli verileri Model üzerinden işler ve uygun bir yanıt (genellikle render edilmiş bir HTML şablonu) döndürür. Fonksiyon tabanlı veya sınıf tabanlı olabilir.
• Template (Şablon): Kullanıcıya gösterilecek HTML yapısını tanımlar. Django'nun kendi şablon dilini kullanır (değişkenler için {{ degisken }}, mantıksal yapılar için {% tag %}).
• URL Dispatcher (Yönlendirici): Gelen URL'leri uygun view fonksiyonlarına/sınıflarına yönlendirir (urls.py dosyaları).
• ORM (Object-Relational Mapper): Veritabanı işlemlerini (CRUD) Python nesneleri üzerinden yapmayı sağlar, SQL yazma ihtiyacını azaltır.
• Admin Arayüzü: Uygulama modellerini yönetmek için otomatik olarak oluşturulan güçlü bir yönetim paneli sunar.
• Form Kütüphanesi: HTML formları oluşturmayı, doğrulamayı ve işlemeyi kolaylaştırır.
• Kimlik Doğrulama Sistemi: Kullanıcı girişi, kaydı, yetkilendirme gibi işlemleri yönetmek için hazır bir sistem sunar.

Kurulum ve Proje Başlatma:

# Sanal ortam oluşturulup aktif edildiği varsayılır
pip install django

django-admin startproject proje_adi . # Projeyi mevcut dizinde başlat
python manage.py migrate # Veritabanı tablolarını oluştur/güncelle
python manage.py startapp uygulama_adi # Proje içinde yeni bir uygulama başlat
python manage.py runserver # Geliştirme sunucusunu başlat
                      

Basit View ve Template Örneği:

# uygulama_adi/views.py
from django.shortcuts import render
from django.http import HttpResponse
import datetime

def anasayfa(request):
    # return HttpResponse("Merhaba Django!")
    simdi = datetime.datetime.now()
    context = {'su_an': simdi, 'kullanici': 'Misafir'}
    return render(request, 'uygulama_adi/anasayfa.html', context)

# proje_adi/urls.py içinde veya uygulama_adi/urls.py içinde konfigürasyon yapılır:
# from django.urls import path
# from uygulama_adi import views
# urlpatterns = [ path('', views.anasayfa, name='anasayfa'), ]

# templates/uygulama_adi/anasayfa.html
# 
# 
# 
# 
#     
Merhaba Django! Kullanıcı: {{ kullanici }}
#     
Şu anki zaman: {{ su_an }}
# 
# 
                     

Django, özellikle veritabanı yoğun, içerik odaklı ve yönetim paneli gerektiren web uygulamaları için güçlü ve hızlı bir geliştirme ortamı sunar.

Özetle Seçim:

• React: Esneklik, geniş ekosistem ve mobil geliştirme (React Native) önemliyse, JavaScript ve JSX ile rahatsanız iyi bir seçim olabilir.
• Angular: Büyük ölçekli, yapılandırılmış kurumsal uygulamalar geliştiriyorsanız, TypeScript'i seviyorsanız ve kapsamlı bir çözüm arıyorsanız uygun olabilir.
• Vue.js: Öğrenme kolaylığı, iyi dokümantasyon ve esneklik arıyorsanız, hem küçük hem de büyük projeler için güçlü bir alternatiftir.

Karar verirken projenin büyüklüğü, takımın tecrübesi, performans gereksinimleri ve uzun vadeli bakım gibi faktörler göz önünde bulundurulmalıdır.

Python'un son sürümleri önemli performans iyileştirmeleri ve geliştirici deneyimini artıran özellikler sunmuştur:

• Hız Artışı (Python 3.11): "Faster CPython" projesi kapsamında yapılan optimizasyonlar sayesinde, Python 3.11, 3.10'a göre %10-60 arasında daha hızlı çalışabilir. Özellikle başlangıç süresi ve fonksiyon çağrıları hızlanmıştır.
• Daha İyi Hata Mesajları (Python 3.11+): Hata mesajları (Traceback) artık hatanın tam olarak hangi ifade veya nesneden kaynaklandığını daha net bir şekilde işaretleyerek hata ayıklamayı kolaylaştırır.

  
  # Eski hata mesajı belirsiz olabilirdi
  # x = {"a": 1}["b"] # KeyError: 'b'
  
  # Yeni hata mesajı (Python 3.11+)
  # x = {"a": 1}["b"]
  #     ~~~~~~~~~~^^^
  # KeyError: 'b'
                              

• Exception Groups ve except* (Python 3.11): Birden fazla bağımsız hatanın aynı anda oluşabileceği durumlarda (örn: asenkron görevler), bu hataları gruplayarak yakalamak ve işlemek için ExceptionGroup ve except* sözdizimi eklendi.
• TOML Desteği (Python 3.11): Standart kütüphaneye tomllib modülü eklenerek TOML (Tom's Obvious, Minimal Language) formatındaki konfigürasyon dosyalarını okuma desteği geldi.
• Type Hinting Gelişmeleri (Sürekli): typing modülüne sürekli yeni özellikler ekleniyor. Örneğin, Self tipi (3.11), TypeAliasType (3.12), Generic sınıflar için yeni sözdizimi (3.12 - PEP 695) gibi geliştirmelerle statik tip kontrolü daha güçlü hale geliyor.

  
  # Python 3.12 - Type Alias ve Generic Sözdizimi (PEP 695)
  type Point = tuple[float, float] # Tip takma adı
  
  def distance(p: Point) -> float:
      # ...
      pass
  
  # Generic fonksiyon
  def first[T](items: list[T]) -> T:
      return items[0]
  
  # Generic sınıf
  class Box[T]:
      def __init__(self, item: T):
          self.item = item
      def get_item(self) -> T:
          return self.item
                               

• f-string İyileştirmeleri (Python 3.12): f-string içinde daha önce izin verilmeyen bazı ifadeler (yorumlar, ters slash'ler, yeniden kullanılan tırnak işaretleri) artık kullanılabilir hale geldi, bu da ifade gücünü artırdı.

Bunlar sadece birkaç örnektir. Her yeni sürüm, dilin yeteneklerini ve geliştirici deneyimini ileriye taşır. Resmi sürüm notlarını ve ilgili PEP (Python Enhancement Proposal) belgelerini takip etmek önemlidir.