---
title: 'İşleçler ve İfadeler'
source: 'https://academia.sh/tr/kurslar/programlama-temelleri/islecler-ve-ifadeler'
course: 'Programlama Temelleri'
language: tr
updated: '2026-08-17T18:08:26+00:00'
license: 'CC BY-SA 4.0'
---

# İşleçler ve İfadeler

Aritmetik, karşılaştırma ve mantıksal işleçler; öncelik, birleşme yönü ve kısa devre değerlendirme.

İlk derste bir mantık hatası örneği verilmişti: `olcum_1 + olcum_2 / 2` ifadesi
beklenen ortalamayı vermiyordu. Hata, işleçlerin hangi sırayla uygulandığını bilmemekten
kaynaklanıyordu.

Bu ders o kuralları tanımlar. Kurallar dilden dile küçük farklarla tekrarlanır; ortak
olan, önceliğin matematikteki alışkanlıkla uyumlu olmasıdır.

## Aritmetik İşleçler

| İşleç | Anlam | Örnek | Sonuç |
|---|---|---|---|
| `+` | toplama | `12 + 18` | 30 |
| `-` | çıkarma | `18 - 12` | 6 |
| `*` | çarpma | `6 * 7` | 42 |
| `/` | gerçel bölme | `7 / 2` | 3.5 |
| `//` | tam bölme | `7 // 2` | 3 |
| `%` | kalan | `7 % 2` | 1 |
| `**` | üs alma | `2 ** 10` | 1024 |

Kalan işleci, göründüğünden daha sık kullanılır: bir sayının çift olup olmadığı
(`n % 2 == 0`), bir sayacın belirli aralıklarla döngüye girmesi ve değerlerin sabit
sayıda kovaya dağıtılması hep bu işleçle yazılır.

## Karşılaştırma İşleçleri

Karşılaştırma işleçleri mantıksal değer üretir: `==`, `!=`, `<`, `>`, `<=`, `>=`.

Eşitlik sınamasının `==` ile yazılması, atamanın `=` ile yazılmasından ayırt edilmek
içindir. İkisinin karıştırılması, bazı dillerde geçerli ama yanlış bir program üretir;
bu yüzden birçok dil atamayı koşul içinde yasaklar.

Önceki derste kurulan ayrım burada da geçerlidir: `==` içerik eşitliğini, `is`
(veya karşılığı) aynı nesne olup olmadığını sınar.

Bazı diller karşılaştırmaların zincirlenmesine izin verir:

```python
olcum = 12
print(0 < olcum < 100)          # True  — iki karşılaştırma ve mantıksal 've'
```

Bu yazım okunabilirdir ancak evrensel değildir; çoğu dilde aynı ifade beklenenden farklı
sonuç verir, çünkü önce `0 < olcum` hesaplanır ve sonucu `100` ile karşılaştırılır.

## Mantıksal İşleçler

Üç mantıksal işleç, koşulları birleştirir:

| $a$ | $b$ | `a and b` | `a or b` | `not a` |
|---|---|---|---|---|
| yanlış | yanlış | yanlış | yanlış | doğru |
| yanlış | doğru | yanlış | doğru | doğru |
| doğru | yanlış | yanlış | doğru | yanlış |
| doğru | doğru | doğru | doğru | yanlış |

Tablo, önceki kurstaki bit düzeyi VE/VEYA tablolarının aynısıdır. Fark, bu işleçlerin
bitler üzerinde değil, tüm ifade üzerinde çalışmasıdır.

## Kısa Devre Değerlendirme

Mantıksal işleçlerin ayırt edici bir davranışı vardır: sonuç belli olduğunda sağ taraf
**hiç değerlendirilmez**.

- `and` işlecinde sol taraf yanlışsa, sonuç yanlıştır; sağ tarafa bakılmaz.
- `or` işlecinde sol taraf doğruysa, sonuç doğrudur; sağ tarafa bakılmaz.

Bu, yalnızca bir hız eniyilemesi değil, bir programlama aracıdır: sağ tarafın
çalışabilmesi için gereken koşul, sola yazılarak güvenceye alınır.

```python
bolen = 0

# Sol taraf yanlış olduğu için bölme hiç yapılmaz; hata oluşmaz.
if bolen != 0 and 10 / bolen > 1:
    print("büyük")
else:
    print("koşul sağlanmadı")      # koşul sağlanmadı

olcumler = []

# Sol taraf doğru olduğu için ilk elemana erişilmez.
if len(olcumler) == 0 or olcumler[0] > 10:
    print("boş veya ilk ölçüm büyük")   # boş veya ilk ölçüm büyük
```

İki koşulun sırası değiştirilirse programlar çalışma zamanı hatası verir. Koşul sırası,
bu nedenle üslup değil doğruluk meselesidir.

## Öncelik ve Birleşme Yönü

**Öncelik**, farklı işleçlerden hangisinin önce uygulanacağını; **birleşme yönü**, aynı
öncelikteki işleçlerin hangi yönde gruplanacağını belirler.

Yüksekten alçağa doğru sık kullanılan öncelik sırası:

| Sıra | İşleçler |
|---|---|
| 1 | `()` gruplama |
| 2 | `**` üs alma |
| 3 | tekil `-` (işaret) |
| 4 | `*`, `/`, `//`, `%` |
| 5 | `+`, `-` |
| 6 | karşılaştırmalar |
| 7 | `not` |
| 8 | `and` |
| 9 | `or` |

```python
print(2 + 3 * 4)          # 14   — çarpma önce
print((2 + 3) * 4)        # 20   — gruplama önceliği değiştirir
print(2 ** 3 ** 2)        # 512  — üs alma sağdan sola: 2 ** (3 ** 2)
print(-2 ** 2)            # -4   — üs alma tekil eksiden önce: -(2 ** 2)
print(10 - 3 - 2)         # 5    — çıkarma soldan sağa: (10 - 3) - 2
print(True or False and False)   # True — 'and' önce
```

İlk dersteki mantık hatası bu tabloyla açıklanır: `olcum_1 + olcum_2 / 2` ifadesinde
bölme dördüncü sırada, toplama beşinci sıradadır; bölme önce yapılır.

Pratik kural: öncelik kurallarını bilmek gerekir, ancak okuyucunun da bilmesine
güvenmemek gerekir. Karışıklık ihtimali olan yerde parantez kullanmak, kuralı bilmenin
yerine geçmez — onu görünür kılar.

## Bileşik Atama

Bir değişkenin kendi değeri üzerinden güncellenmesi o kadar sık yazılır ki, diller bunun
için kısa bir yazım sunar:

```python
toplam = 0
toplam = toplam + 12       # açık yazım
toplam += 18               # bileşik atama: aynı işlem
print(toplam)              # 30

sayac = 10
sayac -= 1                 # 9
sayac *= 2                 # 18
sayac //= 5                # 3
print(sayac)               # 3
```

Bileşik atama bir işleç değil, bir yazım kısaltmasıdır: `a += b` ifadesi `a = a + b`
anlamına gelir. Kısaltmanın iki yararı vardır — değişken adı bir kez yazılır (yanlış ada
atama olasılığı düşer) ve okuyucu, güncellemenin aynı değişken üzerinde olduğunu tek
bakışta görür.

Değiştirilebilir tiplerde bu eşdeğerlik incelir: bazı dillerde bileşik atama yeni bir
nesne üretmek yerine var olan nesneyi yerinde günceller. Paylaşılan bir listede bu fark
gözlenebilir sonuçlar doğurur; ayrım, değiştirilemezlik konusunda kurulan kuralın uzantısıdır.

Bir uyarı: bileşik atama da bir deyimdir, ifade değildir. Değeri yoktur; başka bir
ifadenin içine yerleştirilemez.

## Aynı İşleç, Farklı Anlam

Bir işlecin anlamı, uygulandığı tiplere bağlıdır:

```python
print(3 + 4)              # 7        — sayısal toplama
print("3" + "4")          # 34       — dizgi birleştirme
print([1, 2] + [3])       # [1, 2, 3] — liste birleştirme
print("ab" * 3)           # ababab   — yineleme
```

Aynı simgenin farklı tiplerde farklı işlem yapması **işleç aşırı yükleme** olarak
adlandırılır. Kolaylık sağlar; buna karşılık, tipi yanlış varsayan kod sessizce beklenmedik
sonuç üretebilir. Kullanıcıdan alınan bir değerin sayı mı dizgi mi olduğu bilinmeden
yapılan `+` işlemi, bunun tipik örneğidir.

Bu, sonraki dersin konusuna doğrudan bağlanır: değerin tipi beklenenden farklıysa ne
yapılır?

## Özet

- Aritmetik işleçler arasında tam bölme ve kalan, sayısal problemlerde sık kullanılır.
- Karşılaştırma işleçleri mantıksal değer üretir; `==` içerik eşitliğini sınar, atama
  değildir.
- `and`, `or` ve `not` koşulları birleştirir; doğruluk tabloları bit düzeyi
  karşılıklarıyla aynıdır.
- Kısa devre değerlendirmede sonuç belli olduğunda sağ taraf çalıştırılmaz; koşul sırası
  doğruluğu etkiler.
- Öncelik hangi işlecin önce uygulanacağını, birleşme yönü aynı öncelikteki işleçlerin
  gruplanmasını belirler; üs alma sağdan sola birleşir.
- Aynı işleç farklı tiplerde farklı anlam taşıyabilir.

## Sonraki Adım

Bir ifadede farklı tipler karşılaştığında ne olur? Sayıya dizgi eklenebilir mi, gerçel
sayı tam sayıya nasıl çevrilir ve bu çevirilerde ne kaybedilir? Sonraki ders tip
dönüşümünü ve kayıplı dönüşümün sonuçlarını ele alacak.