# Python kopya kağıdı: sözdizimi, komutlar ve yerleşik fonksiyonlar tablolarda

URL: https://skillaria.top/tr/guides/python/python-hizli-rehber

Python sözdizimi bloklarını süslü parantez yerine dört boşluklu girintilerle belirler. Temeller: tür bildirmeden değişkenler, if/elif/else koşulları, for ve while döngüleri, def ile fonksiyonlar ve print, len, range, input, type gibi yerleşik fonksiyonlar ile metin, liste ve sözlük metotları.

Bu Python kopya kağıdı ilk aylarda elinizin altında olması gereken her şeyi tek sayfada toplar: Python sözdizimi, döngüler, yerleşik fonksiyonlar, metin, liste ve sözlük metotları ve terminal komutları. Her tablo, doğrudan REPL'e yapıştırılabilecek çalışan örneklerle hazırlanmış kısa bir referanstır.

## Python sözdiziminin temelleri

Dilin en önemli özelliği: bloklar parantezle değil, girintiyle belirlenir. İki nokta üst üste içeren satırdan sonra (`if`, `for`, `def`, `class`) gelen satırlar 4 boşlukla içeride yazılır. Sekme ve boşluk karıştırmak yasaktır — `IndentationError` alırsınız.

| Yapı | Örnek | Açıklama |
| --- | --- | --- |

| Yorum | `# metin` | # işaretinden satır sonuna kadar olan her şey yok sayılır |

| Değişken | `age = 25` | tür bildirilmez, değer belirler |

| Çoklu atama | `a, b = 1, 2` | açma; değer takası: `a, b = b, a` |

| Çıktı | `print("Merhaba", name)` | argümanlar boşlukla ayrılır |

| Girdi | `s = input("Ad: ")` | her zaman metin döndürür |

| f-string | `f"{name}: {price:.2f}"` | ifadelerin yerine konması ve biçimlendirme |

| Tür ipucu | `count: int = 0` | IDE ve denetleyiciler için ipucu, çalışma anında denetlenmez |

| Boş blok | `pass` | sözdiziminin gövde istediği yerde yer tutucu |

| İçe aktarma | `from math import sqrt` | bir modülü ya da içindeki adı bağlama |

### Veri türleri

| Tür | Değişmez değer | Değiştirilebilir |
| --- | --- | --- |

| `int` | `42`, `1_000_000` | hayır |

| `float` | `3.14`, `1e-3` | hayır |

| `bool` | `True`, `False` | hayır |

| `str` | `"metin"`, `'metin'`, `"""çok satırlı"""` | hayır |

| `list` | `[1, 2, 3]` | evet |

| `tuple` | `(1, 2)`, `(1,)` | hayır |

| `dict` | `{"a": 1}` | evet |

| `set` | `{1, 2}`, boş olanı — `set()` | evet |

| `NoneType` | `None` | — |

### Operatörler

| Grup | Operatörler | Örnek → sonuç |
| --- | --- | --- |

| Aritmetik | `+ - * / // % **` | `7 // 2` → 3, `7 % 2` → 1, `2 ** 10` → 1024 |

| Karşılaştırma | `== != < > <= >=` | `1 < x < 10` — karşılaştırma zinciri |

| Mantık | `and or not` | `x or "varsayılan"` |

| Üyelik | `in`, `not in` | `"a" in "abc"` → True |

| Özdeşlik | `is`, `is not` | `x is None` |

| Atama | `+= -= *= /=`, `:=` | `if (n := len(s)) > 10: ...` |

## Koşullar ve eşleştirme

```
if score >= 90:
    grade = "A"
elif score >= 70:
    grade = "B"
else:
    grade = "C"

status = "yetişkin" if age >= 18 else "çocuk"   # koşullu (üçlü) ifade

match command:
    case "start":
        print("Başlatıldı")
    case "stop" | "exit":
        print("Durduruldu")
    case _:
        print("Bilinmeyen komut")
```

Yanlış (False) sayılan değerler: `False`, `None`, `0`, boş metin ve boş koleksiyonlar. Bu yüzden `if len(items) > 0` yerine doğrudan `if items` yazılır.

## Python'da döngüler: for ve while sözdizimi

### for döngüsü

Python for döngüsü sözdizimi: `for değişken in dizi:` ve girintili gövde. Döngü her yinelenebilir nesneyi — metni, listeyi, sözlüğü, dosyayı, `range` sonucunu — gezebilir.

```
for i in range(5):              # 0 1 2 3 4
    print(i)

for i in range(10, 0, -2):      # 10 8 6 4 2
    print(i)

for i, fruit in enumerate(["elma", "armut"], start=1):
    print(i, fruit)

for name, score in zip(names, scores):
    print(name, score)

for key, value in prices.items():
    print(key, value)
```

### while döngüsü

```
attempts = 3
while attempts > 0:
    password = input("Parola: ")
    if password == "secret":
        print("Giriş yapıldı")
        break
    attempts -= 1
else:
    print("Denemeler bitti")   # break olmadan döngü bittiyse çalışır
```

| Komut | Ne yapar |
| --- | --- |

| `break` | döngüden erken çıkar |

| `continue` | sonraki yinelemeye geçer |

| döngünün `else`'i | döngü `break` olmadan biterse çalışır |

| `range(stop)`, `range(start, stop, step)` | sayı dizisi, `stop` dahil değildir |

### Liste üreteçleri (comprehension)

```
squares = [x ** 2 for x in range(10)]
evens = [x for x in numbers if x % 2 == 0]
lengths = {word: len(word) for word in words}
unique = {c.lower() for c in text}
total = sum(x * x for x in range(100))   # üreteç ifadesi
```

## Fonksiyonlar

```
def greet(name: str, greeting: str = "Merhaba") -> str:
    """Selamlama metnini döndürür."""
    return f"{greeting}, {name}!"

def total(*args, **kwargs):
    return sum(args), kwargs

square = lambda x: x * x
print(greet("Ayşe"))                  # Merhaba, Ayşe!
print(greet("Ayşe", greeting="Selam"))  # Selam, Ayşe!
```

| Öğe | Anlamı |
| --- | --- |

| `def f(a, b=1)` | varsayılan değerli parametre |

| `*args` | istenen sayıda konumsal argüman (demet) |

| `**kwargs` | istenen sayıda adlandırılmış argüman (sözlük) |

| `return` | değer döndürür; yoksa fonksiyon `None` döndürür |

| `lambda x: ...` | tek ifadelik kısa isimsiz fonksiyon |

| `global`, `nonlocal` | dış kapsamdaki bir değişkeni değiştirme |

Değiştirilebilir varsayılan değer kullanmayın, örneğin `def f(items=[])`: liste bir kez oluşturulur ve çağrılar arasında birikir. Doğrusu `items=None` yazıp içeride `if items is None: items = []` kullanmaktır.

## Yerleşik Python fonksiyonları

Python'un yerleşik fonksiyonları içe aktarma gerektirmeden kullanılabilir. Hemen hemen her betikte görülen temel fonksiyonlar bunlardır.

| Fonksiyon | Ne yapar | Örnek → sonuç |
| --- | --- | --- |

| `print()` | değerleri yazdırır | `print(1, 2, sep="-")` → 1-2 |

| `input()` | klavyeden metin okur | `int(input())` |

| `len()` | koleksiyonun ya da metnin uzunluğu | `len("abc")` → 3 |

| `type()` | nesnenin türü | `type(3.0)` → <class 'float'> |

| `isinstance()` | tür kontrolü | `isinstance(5, int)` → True |

| `int() float() str() bool()` | tür dönüşümü | `int("42")` → 42 |

| `list() tuple() set() dict()` | koleksiyon oluşturma | `list("ab")` → ['a', 'b'] |

| `range()` | sayı aralığı | `list(range(3))` → [0, 1, 2] |

| `enumerate()` | (indeks, öğe) çiftleri | `list(enumerate("ab"))` → [(0, 'a'), (1, 'b')] |

| `zip()` | dizileri çiftler halinde birleştirir | `list(zip([1, 2], "ab"))` → [(1, 'a'), (2, 'b')] |

| `sum() min() max()` | toplam, en küçük, en büyük | `max([3, 7, 1])` → 7 |

| `abs() round()` | mutlak değer ve yuvarlama | `round(3.14159, 2)` → 3.14 |

| `sorted()` | sıralanmış yeni liste | `sorted(words, key=len, reverse=True)` |

| `reversed()` | tersten yineleyici | `list(reversed([1, 2]))` → [2, 1] |

| `map() filter()` | fonksiyonu uygula / süz | `list(map(str, [1, 2]))` → ['1', '2'] |

| `any() all()` | en az biri / hepsi doğru | `all(x > 0 for x in nums)` |

| `open()` | dosya açar | `open("a.txt", encoding="utf-8")` |

| `help() dir()` | yardım ve özellik listesi | `help(str.split)`, `dir(list)` |

| `id() hash()` | nesnenin kimliği ve özeti | `hash("a")` |

Her zaman yanınızda bulunabilecek en kullanışlı Python referansı REPL'deki `help()` fonksiyonudur: `help(dict)` sözlüğün tüm metotlarını açıklamalarıyla gösterir, `dir(obj)` ise kullanılabilir adların listesini verir.

## Metin (string) metotları

Python'da metin değiştirilemez: her metot yeni bir metin döndürür. Dilimleme listelerdekiyle aynı çalışır: `s[1:4]`, `s[::-1]` — tersine çevirme.

| Metot | Örnek → sonuç |
| --- | --- |

| `upper() lower()` | `"Py".upper()` → 'PY' |

| `capitalize() title()` | `"hello world".title()` → 'Hello World' |

| `strip() lstrip() rstrip()` | `" hi \n".strip()` → 'hi' |

| `split(sep)` | `"a,b,c".split(",")` → ['a', 'b', 'c'] |

| `join(iterable)` | `"-".join(["a", "b"])` → 'a-b' |

| `replace(old, new)` | `"kalem".replace("a", "o")` → 'kolem' |

| `find() index()` | `"hello".find("l")` → 2; yoksa -1 (`index` ile hata) |

| `count()` | `"banana".count("a")` → 3 |

| `startswith() endswith()` | `"file.py".endswith(".py")` → True |

| `isdigit() isalpha() isspace()` | `"123".isdigit()` → True |

| `removeprefix() removesuffix()` | `"test_a".removeprefix("test_")` → 'a' |

| `zfill() center() ljust()` | `"7".zfill(3)` → '007' |

| `format()` | `"{} + {}".format(1, 2)` → '1 + 2' |

## Liste komutları

Liste değiştirilebilir, sıralı bir koleksiyondur. Metotların çoğu listeyi yerinde değiştirir ve `None` döndürür, bu yüzden `a = a.sort()` sık yapılan bir hatadır.

| İşlem | Ne yapar | Örnek |
| --- | --- | --- |

| `append(x)` | sona ekler | `a.append(4)` |

| `extend(iter)` | tüm öğeleri ekler | `a.extend([5, 6])` |

| `insert(i, x)` | indekse göre araya ekler | `a.insert(0, "first")` |

| `remove(x)` | değerin ilk geçtiği yeri siler | `a.remove(3)` |

| `pop(i)` | öğeyi siler ve döndürür (varsayılan: son) | `last = a.pop()` |

| `clear()` | listeyi temizler | `a.clear()` |

| `index(x)` | ilk geçtiği indeks | `a.index("b")` |

| `count(x)` | geçme sayısı | `a.count(1)` |

| `sort()` | yerinde sıralar | `a.sort(key=str.lower)` |

| `reverse()` | yerinde tersine çevirir | `a.reverse()` |

| `copy()` | yüzeysel kopya | `b = a.copy()` |

| `del a[i]` | indeks ya da dilime göre siler | `del a[1:3]` |

| Dilimler | `a[start:stop:step]` | `a[-1]` — son öğe, `a[:3]` — ilk üç |

## Sözlük komutları

| İşlem | Ne yapar | Örnek |
| --- | --- | --- |

| `d[key]` | anahtarın değeri; anahtar yoksa `KeyError` | `d["name"]` |

| `get(key, default)` | değer ya da yedek değer | `d.get("age", 0)` |

| `d[key] = value` | ekler ya da değiştirir | `d["city"] = "Ankara"` |

| `keys() values() items()` | anahtarlar, değerler, çiftler | `for k, v in d.items():` |

| `update()` | başka bir sözlükle birleştirir | `d.update({"a": 1})` |

| `d1 | d2` | birleştirilmiş yeni sözlük | `merged = defaults | user` |

| `pop(key, default)` | siler ve değeri döndürür | `d.pop("tmp", None)` |

| `popitem()` | en son eklenen çifti siler | `d.popitem()` |

| `setdefault(key, value)` | değeri döndürür; anahtar yoksa oluşturur | `d.setdefault("tags", []).append("py")` |

| `key in d` | anahtarın varlığını kontrol eder | `if "name" in d:` |

| `dict.fromkeys()` | anahtarlardan tek değerli sözlük | `dict.fromkeys("abc", 0)` |

| `len(d)`, `del d[key]` | boyut ve silme | `del d["old"]` |

### Demetler ve kümeler

| İşlem | Örnek → sonuç |
| --- | --- |

| Demeti açma | `x, y = (3, 4)` |

| Kümeye ekleme | `s.add(5)`, silme — `s.discard(5)` |

| Birleşim / kesişim | `{1, 2} | {2, 3}` → {1, 2, 3}; `{1, 2} & {2, 3}` → {2} |

| Fark | `{1, 2} - {2}` → {1} |

| Listeden tekrarları silme | `list(dict.fromkeys(items))` — sırayı koruyarak |

## İstisnalar ve dosyalar

```
try:
    number = int(input("Sayı: "))
except ValueError as err:
    print("Bu bir sayı değil:", err)
else:
    print("Başarılı")
finally:
    print("Her zaman çalışır")

with open("data.txt", "w", encoding="utf-8") as f:
    f.write("satır\n")

with open("data.txt", encoding="utf-8") as f:
    for line in f:
        print(line.rstrip())
```

| İstisna | Ne zaman oluşur |
| --- | --- |

| `SyntaxError`, `IndentationError` | sözdizimi ya da girinti hatası |

| `NameError` | ad tanımlı değil (yazım hatası) |

| `TypeError` | uygun olmayan türle işlem: `"1" + 1` |

| `ValueError` | tür doğru, ama değer yanlış: `int("abc")` |

| `IndexError`, `KeyError` | böyle bir indeks ya da anahtar yok |

| `FileNotFoundError` | dosya bulunamadı |

| `ZeroDivisionError` | sıfıra bölme |

## Sınıflar

```
from dataclasses import dataclass

class Dog:
    def __init__(self, name: str):
        self.name = name

    def bark(self) -> str:
        return f"{self.name}: Hav!"

@dataclass
class Point:
    x: float
    y: float

print(Dog("Karabaş").bark())   # Karabaş: Hav!
print(Point(1, 2))             # Point(x=1, y=2)
```

## Yerleşik Python modülleri

Standart kütüphane yorumlayıcıyla birlikte kurulur — yalnızca `import` yazmanız yeterli.

| Modül | Ne için | Örnek |
| --- | --- | --- |

| `math` | matematik | `math.sqrt(16)` → 4.0 |

| `random` | rastgele sayılar | `random.randint(1, 6)`, `random.choice(items)` |

| `datetime` | tarih ve saat | `datetime.date.today()` |

| `pathlib` | yollar ve dosyalar | `Path("data").glob("*.csv")` |

| `os`, `sys` | sistem, ortam değişkenleri, argümanlar | `os.environ.get("HOME")`, `sys.argv` |

| `json` | JSON okuma ve yazma | `json.loads(text)`, `json.dumps(obj, ensure_ascii=False)` |

| `csv` | CSV tabloları | `csv.DictReader(f)` |

| `collections` | Counter, defaultdict, deque | `Counter("banana").most_common(1)` → [('a', 3)] |

| `itertools` | kombinasyonlar ve yineleyici zincirleri | `itertools.chain(a, b)` |

| `re` | düzenli ifadeler | `re.findall(r"\d+", s)` |

| `time` | beklemeler ve süre ölçümü | `time.sleep(1)`, `time.perf_counter()` |

| `asyncio` | eşzamansız kod | `asyncio.run(main())` |

Python 3.15 ile tembel içe aktarma (PEP 810) geldi: `lazy import pandas as pd` modülün yüklenmesini ona ilk erişene kadar erteler; ağır bağımlılıkları olan bir betik belirgin biçimde daha hızlı başlar.

## Terminalde Python komutları

«Python komutları» için ayrı bir arama grubu vardır: yorumlayıcıyı başlatma ve kütüphane kurma komutları. Windows'ta `python3` yerine genellikle `python` ya da `py` yazılır.

| Komut | Ne yapar |
| --- | --- |

| `python3 --version` | sürümü gösterir |

| `python3` | etkileşimli konsolu (REPL) açar (çıkış — `exit()`) |

| `python3 script.py` | dosyayı çalıştırır |

| `python3 -c "print(2 + 2)"` | tek satır çalıştırır |

| `python3 -m venv .venv` | sanal ortam oluşturur |

| `source .venv/bin/activate` / `.venv\Scripts\activate` | ortamı etkinleştirir (Linux, macOS / Windows) |

| `python3 -m pip install requests` | paket kurar |

| `pip list`, `pip freeze > requirements.txt` | paket listesi ve kaydetme |

| `pip install -r requirements.txt` | dosyadaki bağımlılıkları kurar |

| `python3 -m http.server 8000` | geçerli klasörde basit bir web sunucusu |

| `uv init`, `uv add requests`, `uv run main.py` | uv yöneticisiyle proje, bağımlılık ve çalıştırma |

## Yeni başlayanların sık yaptığı hatalar

- **Karşılaştırmada `=` kullanmak** — koşulda `==` gerekir; tek `=` atamadır.
- **Unutulan iki nokta üst üste** — `if`, `for`, `def` sonrasında `SyntaxError` verir.
- **Metin ile sayıyı toplamak**: `"Yaş: " + 25` hatalıdır, `f"Yaş: {25}"` yazın.
- **Dönerken listeyi değiştirmek** — `for x in a[:]` ile kopyasını dönün ya da yeni bir liste oluşturun.
- **`input()` metin döndürür** — aritmetik için `int()` ya da `float()` ile sarın.

## Sonuç

Python sözdizimi girintilere, iki noktalara ve küçük bir yapı setine dayanır: koşullar, for ve while döngüleri, fonksiyonlar, sınıflar. Bunlara yirmi kadar yerleşik fonksiyon ile metin, liste ve sözlük metotlarını eklediğinizde günlük işlerin büyük bölümünü çözersiniz. Kopya kağıdını saklayın; tablolar alışkanlık haline gelince modüllere ve eşzamansızlığa geçin — bunların hepsi «Python 3.15: sıfırdan uzmanlığa» kursunda adım adım, uygulamalı olarak anlatılıyor.

## FAQ

**Python'da girinti için kaç boşluk bırakmalıyım?**

PEP 8 standardına göre her seviye için 4 boşluk. Önemli olan, bütün blokta tutarlı olmak ve sekmelerle karıştırmamak.

**Liste ile demet (tuple) arasındaki fark nedir?**

Liste değiştirilebilir; eklenebilir ve yerinde sıralanabilir. Demet değiştirilemez; bu yüzden sözlük anahtarı olarak ve sabit değer kümeleri için uygundur.

**Bir nesnenin tüm metotlarını Python içinde nasıl görürüm?**

Ad listesi için dir(obj), açıklama için help(obj) çağırın — örneğin help(str) tüm metin metotlarını gösterir.

**sort() ile sorted() arasındaki fark nedir?**

list.sort() listenin kendisini sıralar ve None döndürür; sorted() fonksiyonu ise yeni bir liste döndürür ve herhangi bir yinelenebilir koleksiyonla çalışır.

**Python'da satır sonunda noktalı virgül gerekir mi?**

Hayır. Noktalı virgül aynı satırda birden fazla komut için kullanılabilir, ama normal kodda her komut yeni bir satırda yazılır.


---
Source: Skillaria.Top (https://skillaria.top)