# Python operatörleri: aritmetik, // ve %, karşılaştırma, and/or/not ve round ile yuvarlama

URL: https://skillaria.top/tr/guides/python/python-operatorleri

Python'da / her zaman float verir, // sonucu aşağı yuvarlayarak tam kısmı, % kalanı, ** ise üssü hesaplar. round(x, n) bankacılık yuvarlamasıyla n basamağa yuvarlar: round(2.5) sonucu 2, round(3.5) sonucu 4'tür; yukarı ve aşağı tam sayıya yuvarlamayı math.ceil ve math.floor, sayının mutlak değerini ise abs yapar.

Python operatörleri değerleri yeni değerlere dönüştüren işaretlerdir: `+` toplar, `//` tam böler, `and` koşulları birleştirir. Aşağıda operatörlerin tam listesi, `/` ile `//` arasındaki fark, `and`, `or`, `not` mantığı ve yuvarlama fonksiyonları — python round, `math.ceil`, `math.floor` ve `abs` — örneklerle anlatılıyor. Tüm örnekleri REPL'e yapıştırıp kendiniz deneyebilirsiniz.

## Python operatörlerinin listesi

Operatörler amaçlarına göre gruplanır. Tabloyu baştan sona ezberlemeniz gerekmez: gerçek kodda en sık aritmetik, karşılaştırma ve mantıksal bağlaçlar kullanılır.

| Grup | Operatörler | Örnek |
| --- | --- | --- |

| Aritmetik | `+ - * / // % **` | `7 // 2` → 3 |

| Karşılaştırma | `== != < > <= >=` | `3 < 5` → True |

| Mantıksal | `and or not` | `not True` → False |

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

| Üyelik | `in`, `not in` | `"ah" in "kahve"` → True |

| Atama | `= += -= *= /= //= %= **=` | `total += 250` |

| Walrus | `:=` | `if (n := len(s)) > 10:` |

| Bit düzeyinde | `& | ^ ~ << >>` | `5 & 3` → 1 |

## Aritmetik operatörler

Toplama, çıkarma ve çarpma okul matematiğindeki gibi çalışır. İfadede en az bir `float` varsa sonuç da `float` olur: `2 + 1.0` sonucu `3.0`. Python'da tam sayılar taşmaz — `2 ** 100` kaç basamak çıkarsa çıksın tam hesaplanır.

```
>>> 250 + 120
370
>>> 12.5 * 3
37.5
>>> 2 ** 10
1024
>>> 2 ** 0.5
1.4142135623730951
```

### Python'da üs alma: ** operatörü

Üs alma iki yıldızla yazılır, `^` ile değil: Python'da `^` bit düzeyinde «özel VEYA» anlamına gelir ve `2 ^ 3` sonucu 8 değil 1'dir. Kesirli üs kök alır: `9 ** 0.5` sonucu `3.0`. Bunun bir de fonksiyon biçimi vardır: `pow(x, y)` aynı işi yapar, üçüncü argümanla kalan da hesaplanabilir: `pow(2, 10, 1000)` sonucu 24'tür.

Önceliğe dikkat edin: `**`, tekli eksiden önce çalışır, bu yüzden `-2 ** 2` sonucu `-4`'tür. Negatif bir sayının karesini istiyorsanız parantez kullanın: `(-2) ** 2`.

## Python'da bölme: /, // ve %

Python'da iki tür bölme vardır ve bu, yeni başlayanlar için sürprizlerin ana kaynağıdır. Normal bölme `/` her zaman `float` döndürür, tam bölünse bile. Tam sayı bölmesi `//` kesirli kısmı atar, `%` ise kalanı verir.

```
>>> 7 / 2
3.5
>>> 8 / 2
4.0
>>> 7 // 2
3
>>> 7 % 2
1
```

### Tam bölme // ve kalan %: uygulamada

`//` ile `%` çifti «kaç tam var, ne kadar kaldı» sorularını çözer. Kursta harcama takipçisi, hassasiyeti kaybetmemek için parayı kuruş olarak tutar ve tutarı lira ile kuruşa böler:

```
kopecks = 125050          # parayı kuruş olarak tutuyoruz
lira = kopecks // 100     # 1250 — tam lira
kurus = kopecks % 100     # 50 — kalan
print(lira, kurus)        # 1250 50

print(40 // 7, "hafta ve", 40 % 7, "gün")   # 5 hafta ve 5 gün
```

İki işlemin sonucunu birlikte veren yerleşik fonksiyon `divmod`'dur: `divmod(125050, 100)` `(1250, 50)` demetini döndürür. Kalan çift-tek kontrolü için de işe yarar: `n % 2 == 0` çift sayılar için doğrudur.

### Negatif sayılar: // aşağı yuvarlar

`//` operatörü kesri sadece atmaz, aşağı, eksi sonsuza doğru yuvarlar. Pozitif sayılarda fark yoktur, negatiflerde vardır. Python'da `%` kalanının işareti bölenin işaretiyle aynıdır; bu yüzden her zaman `a == (a // b) * b + a % b` eşitliği geçerlidir.

```
>>> -7 // 2
-4
>>> -7 % 2
1
>>> int(-7 / 2)     # kesri atar, aşağı yuvarlamaz
-3
```

### Sıfıra bölme: hangi hata çıkar

Üç operatörden herhangi biriyle sıfıra bölmek `ZeroDivisionError` istisnasını fırlatır. Bu hem tam, hem kesirli sayılar için geçerlidir. Bunu `try/except` ile yakalayabilir ya da bölenin sıfır olmadığını önceden kontrol edebilirsiniz.

```
>>> 10 / 0
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
>>> count = 0
>>> avg = 1500 / count if count else 0
>>> avg
0
```

## Karşılaştırma operatörleri

Karşılaştırmalar `True` veya `False` döndürür. Eşitlik iki `==` işaretiyle kontrol edilir, tek `=` ise atamadır. Metinler karakter kodlarına göre karakter karakter karşılaştırılır; bu yüzden `"A" < "a"` doğrudur: büyük harfler küçük harflerden önce gelir.

```
>>> 250 == 250.0
True
>>> 3 != 4
True
>>> 1 < 5 > 0.1 + 0.2 == 0.3
False
```

Karşılaştırma zincirleri, örneğin `0 <= x < 100`, Python'un kullanışlı bir özelliğidir: `and` yazmanız gerekmez. Son satır ise kesirli sayılardaki hata payını hatırlatır: `0.1 + 0.2` sonucu `0.30000000000000004`'tür. Kesirli sayıları `math.isclose(a, b)` ile karşılaştırın, parayı ise kuruş olarak ya da `Decimal` içinde tutun.

## Mantıksal operatörler and, or, not

Python'da mantıksal operatörler `&&` ve `||` gibi simgelerle değil, kelimelerle yazılır. `and` iki taraf da doğruysa doğrudur, `or` taraflardan en az biri doğruysa, `not` değeri tersine çevirir.

| a | b | a and b | a or b | not a |
| --- | --- | --- | --- | --- |

| True | True | True | True | False |

| True | False | False | True | False |

| False | True | False | True | True |

| False | False | False | False | True |

Öncelik sırası: önce `not`, sonra `and`, sonra `or`. `True or False and False` ifadesi `True` sonucunu verir, çünkü `and` önce hesaplanır. Karmaşık koşullarda parantez kullanın — hem sizin, hem ekibinizin işine yarar.

### and ve or aslında ne döndürür

`and` ve `or` her zaman `True` veya `False` döndürmez, operandlardan birini döndürür. `or` ilk doğru değeri (doğru yoksa son değeri), `and` ise ilk yanlış değeri (yanlış yoksa son değeri) verir. Yanlış sayılan değerler: `0`, `0.0`, boş metin, boş koleksiyonlar, `None` ve `False`.

```
>>> name = ""
>>> name or "Misafir"
'Misafir'
>>> 5 and 0
0
>>> not ""
True
```

Değerlendirme tembeldir: sonuç sol taraftan belliyse sağ taraf hesaplanmaz. Bu yüzden `count and total / count`, `count == 0` olduğunda sıfıra bölme hatası vermez. `not` ise diğer ikisinden farklı olarak her zaman `bool` döndürür.

## is ve in operatörleri

`==` değerleri karşılaştırır, `is` ise iki adın aynı nesneyi gösterip göstermediğini kontrol eder. İki ayrı boş sepet eşittir, ama aynı nesne değildir. `is`'in sürekli gerekli olduğu tek yer `None` kontrolüdür: `if x is None`.

```
>>> a = [250, 120]
>>> b = [250, 120]
>>> a == b, a is b
(True, False)
>>> c = a
>>> c is a
True
```

Sayıları ve metinleri `is` ile karşılaştırmayın: bazen iç önbellekleme yüzünden «çalışır», ama sonuç uygulamaya bağlıdır ve Python `x is 5` gibi yapılarda `SyntaxWarning` uyarısı verir.

`in` operatörü üyeliği kontrol eder: bir metinde alt metni, listede öğeyi, sözlükte anahtarı. `not in` ise tersini kontrol eder.

```
>>> "kahve" in "kahve yanında"
True
>>> "yemek" in {"yemek": 450, "taksi": 300}
True
>>> 5 not in [1, 2, 3]
True
```

## Atama operatörleri ve walrus operatörü :=

`+=`, `-=`, `*=`, `//=` ve diğer birleşik operatörler kısaltmadır: `total += 250`, `total = total + 250` anlamına gelir. Python'da `++` ve `--` operatörleri yoktur: `x++` sözdizimi hatası verir.

Walrus operatörü `:=` (adı, iki noktaya benzeyen gözleriyle ve dişleriyle morsa benzediği için verildi) değeri doğrudan bir ifadenin içinde atar. Değeri hem kontrol edip hem sonra kullanmak istediğinizde işe yarar:

```
items = ["kahve", "taksi", "öğle yemeği", "sinema"]
if (n := len(items)) > 3:
    print(f"Çok fazla harcama: {n}")

while (line := input("Tutar: ")) != "":
    print(int(line) * 2)
```

Walrus olmadan `len` fonksiyonunu iki kez çağırmak ya da atamayı ayrı bir satıra koymak gerekirdi. Ama abartmayın: satır okunmaz hale gelirse, normal atama daha iyidir.

## Python'da yuvarlama: round, ceil, floor

Python'da yuvarlama için yerleşik `round` fonksiyonu ve `math` modülünün fonksiyonları vardır. Farklı işleri yaparlar ve bunları karıştırmak sık yapılan bir hatadır.

| Fonksiyon | Ne yapar | 2.5 | -2.5 | 2.7 |
| --- | --- | --- | --- | --- |

| `round(x)` | en yakına, yarıda çifte | 2 | -2 | 3 |

| `math.floor(x)` | aşağı, eksi sonsuza | 2 | -3 | 2 |

| `math.ceil(x)` | yukarı, artı sonsuza | 3 | -2 | 3 |

| `math.trunc(x)`, `int(x)` | kesri atar, sıfıra doğru | 2 | -2 | 2 |

### Python round fonksiyonu ve bankacılık yuvarlaması

`round(x, n)` sayıyı virgülden sonra `n` basamağa yuvarlar; ikinci argüman verilmezse tam sayı (`int`) döndürür. Asıl tuzak şudur: python round yarıyı «bankacılık usulü» yuvarlar — yarıyı en yakın çift sayıya. Bu yüzden `round(2.5)` sonucu 2, `round(3.5)` sonucu 4'tür. Büyük hesaplamalarda yuvarlama hataları böylece tek yöne birikmez.

```
>>> round(2.5), round(3.5)
(2, 4)
>>> round(3.14159, 2)
3.14
>>> round(1250, -2)     # yüzlüklere
1200
>>> round(2.675, 2)     # 2.68 değil: ikili gösterimde 2.67499...
2.67
```

Okulda öğretilen «yarıyı yukarı» yuvarlama gerekiyorsa, örneğin bir fişte, `ROUND_HALF_UP` modlu `Decimal` kullanın. Sayıyı `float` hatasını devralmamak için metin olarak verin:

```
>>> from decimal import Decimal, ROUND_HALF_UP
>>> Decimal("2.5").quantize(Decimal("1"), ROUND_HALF_UP)
Decimal('3')
>>> Decimal("2.675").quantize(Decimal("0.01"), ROUND_HALF_UP)
Decimal('2.68')
```

Kurstan bir kural daha: yuvarlamayı yalnızca çıktıda yapın. Güzel yazdırmak için `round` gerekmez — f-string yeterlidir: `f"{amount:.2f}"` iki basamak gösterir, sayının kendisi ise hassas kalır.

### math.ceil ve math.floor: yukarı ve aşağı yuvarlama

`math.ceil`, «yetmemesi» kabul edilemez olduğunda gerekir: kaç otobüs sipariş edilecek, kaç sayfa çıkacak. `math.floor` ise yalnızca tam birimler sayıldığında kullanılır. İkisi de `int` döndürür.

```
import math

guests = 47
seats = 20
print(math.ceil(guests / seats))   # 3 otobüs
print(math.floor(9.99))            # 9
print(-(-guests // seats))         # 3 — math olmadan ceil, // ile numara
```

`math` modülünde başka yararlı fonksiyonlar da vardır: `math.sqrt` (kök), `math.isclose` (kesirleri karşılaştırma), `math.pi`, `math.gcd`. Python 3.15'te tam sayı matematiği için `math.integer` alt modülü geldi (PEP 791): içinde `comb`, `factorial`, `gcd`, `isqrt`, `lcm`, `perm` bulunur; eski `math.gcd` ve diğerleri çalışmaya devam eder.

## abs fonksiyonu: sayının mutlak değeri

`abs(x)` mutlak değeri — sıfıra olan işaretsiz uzaklığı döndürür. Import gerekmez, fonksiyon yerleşiktir. Tam, kesirli ve hatta karmaşık sayılarla çalışır: `3+4j` için vektörün uzunluğu olan `5.0`'ı döndürür.

```
>>> abs(-250)
250
>>> abs(-12.5)
12.5
>>> budget, spent = 5000, 5320
>>> abs(budget - spent)    # ne kadar sapma var
320
```

Tipik kullanım, yönü dikkate almadan farkı bulmak ve bir tolerans ile karşılaştırmaktır: `abs(a - b) < 0.001`. Kesirli sayılarda `math.isclose` daha güvenilirdir, çünkü sayıların ölçeğini de hesaba katar.

## Operatörlerin önceliği

Bir ifadede birden fazla operatör varsa Python onları önceliğe göre çalıştırır — yüksekten düşüğe:

1. `**`
2. tekli `-x`, `+x`, `~x`
3. `* / // %`
4. `+ -`
5. bit kaydırma ve bit işlemleri
6. karşılaştırmalar, `in`, `is`
7. `not`
8. `and`
9. `or`
10. `:=`

Böylece `2 + 3 * 4` sonucu 14, `(2 + 3) * 4` sonucu 20'dir. Emin değilseniz parantez koyun: fazladan parantezin maliyeti yoktur, ama öncelik hatasını bulmak uzun sürer.

## Operatörlerle ilgili sık yapılan hatalar

| Hata | Ne olur | Doğrusu |
| --- | --- | --- |

| `if x = 5:` | SyntaxError: bu bir atama | `if x == 5:` |

| üs yerine `2 ^ 3` | bit düzeyinde XOR, sonuç 1 | `2 ** 3` |

| `8 / 2` ile tam sayı beklemek | `4.0` alınır | `8 // 2` |

| `x == 1 or 2` | her zaman doğru: `or 2` | `x in (1, 2)` |

| `round(2.5)` ile 3 beklemek | bankacılık yuvarlaması 2 verir | `ROUND_HALF_UP` ile `Decimal` |

| `"5" + 5` | TypeError | `int("5") + 5` |

## Sonuç

En önemli noktalar: `/` her zaman float verir, `//` aşağı yuvarlar, `%` bölenin işaretiyle kalan verir, üs ise `**`'tır. Mantıksal `and`, `or`, `not` kelimelerle yazılır ve tembel değerlendirilir; `is` ise `None` kontrolü için gerekir. Python round yarıyı çifte yuvarlar; yukarı ve aşağı yuvarlama için `math.ceil` ve `math.floor` vardır, sayının mutlak değerini ise `abs` verir. Kursta bu operatörler uygulamada, paranın kuruş olarak tutulduğu harcama takipçisinde işlenir.

## FAQ

**Python'da bir sayıyı virgülden sonra iki basamağa nasıl yuvarlarım?**

round(x, 2) kullanın; sadece güzel göstermek istiyorsanız, sayının değerini değiştirmeyen f"{x:.2f}" f-string'ini kullanın.

**Python'da round(0.5) neden 0 veriyor?**

Çünkü round yarıyı en yakın çift sayıya yuvarlar ve 0 çifttir; aynı şekilde round(1.5) ve round(2.5) sonucu 2'dir.

**Bölmenin tam kısmını Python'da nasıl alırım?**

// operatörüyle: 17 // 5 sonucu 3'tür. Negatif sayılarda aşağı yuvarlar, dolayısıyla -17 // 5 sonucu -4'tür; kesri sıfıra doğru atmak için int(-17 / 5) kullanın.

**Python'da üçlü (ternary) operatör var mı?**

Evet, bu bir koşullu ifadedir: değer_doğruysa if koşul else değer_yanlışsa, örneğin "çift" if n % 2 == 0 else "tek".

**Python'da & ile and arasındaki fark nedir?**

and, tembel değerlendirmeli mantıksal bir operatördür; & ise sayılarda bit düzeyinde VE, kümelerde kesişimdir. Koşullarda if ile birlikte and kullanın.


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