Operator Precedence ve Assosiyatiflik: Parantezsiz Doğru Kod Yazma Sanatı

Tam Precedence Tablosu (en yüksekten düşüğe)#

• Parantez en üstte — her zaman önce evaluate edilir.
• **
  sağ assosiyatif:
  2**3**2 == 2**(3**2) == 2**9 == 512
  (NOT
  (2**3)**2 == 64
  ).
• Aritmetik > shift > bitwise > comparison > logical.
• and
  >
  or
  .
• Comparison'lar chain edilebilir (Modül 2/Ders 10).

Klasik kurallar — okul matematiği#

# Çarpma > Toplama
print(5 + 3 * 2)         # 11 (NOT 16)
print((5 + 3) * 2)       # 16

# Üs > unary
print(-2 ** 2)           # -4 (NOT 4!)
# Çünkü: -(2 ** 2) = -4
# Eğer (-2)**2 istiyorsan parantez gerek

print((-2) ** 2)         # 4

# ** sağ assosiyatif
print(2 ** 3 ** 2)       # 512 = 2**(3**2) = 2**9
print((2 ** 3) ** 2)     # 64

# Bölme türleri aynı seviye, sol assosiyatif
print(20 / 4 / 2)        # 2.5 = (20 / 4) / 2

# Modulus aynı seviye
print(10 % 6 % 4)        # 0 = (10 % 6) % 4 = 4 % 4 = 0

Aldatıcı durumlar — şüphe duyduğunda parantez#

1. Bit AND ile karşılaştırma#

# 🚫 Beklenmedik
x = 5
if x & 1 == 1:
    print("Tek sayı")
# Aslında: if x & (1 == 1):
#       = if x & True:
#       = if x & 1:  → True (x bit 0 = 1)

# Doğru çalışıyor gibi görünüyor — ama farklı sayılarda farklı sonuç
y = 4
if y & 1 == 1:
    print("Tek sayı")    # 0 (False)
# Aslında: y & (1 == 1) = y & 1 = 0 — doğru

# Bu örnekte tesadüfen doğru çalıştı — ama mantık yanlış
# 'x & 1 == 1' diye düşünüyorsun, '(x & 1) == 1' demek
# Python ise x & (1 == 1) yapıyor — '==' precedence > '&'

# ✅ Açık
if (x & 1) == 1:
    print("Tek")

2. Walrus + comparison#

# 🚫
if (n := len(items) > 10):
    print(f"n = {n}")
# Beklenen: n = len(items)
# Aslında: n = (len(items) > 10) → True/False
# n bool!

# ✅
if (n := len(items)) > 10:
    print(f"n = {n}")
# Burada n int olarak atanıyor, sonra > 10 karşılaştırılıyor

3.

not

ile

in

#

# 🚫
if not x in lst:
    ...
# Çalışıyor ama anlam: (not x) in lst — yanlış mantıksal yapı

# ✅
if x not in lst:
    ...
# 'not in' tek operator (compound)

# Gerçi bu örnekte ikisi de aynı sonuç çoğu zaman ama
# semantic farklı — okuyana 'not in' daha açık

4. Conditional expression iç içe#

# 🚫 Okunmaz
result = a if cond1 else b if cond2 else c

# Aslında nasıl evaluate ediliyor:
# result = a if cond1 else (b if cond2 else c)
# Yani: cond1 ise a, değilse (cond2 ise b, değilse c)

# ✅ Daha açık
if cond1:
    result = a
elif cond2:
    result = b
else:
    result = c

# Veya match
match (cond1, cond2):
    case (True, _): result = a
    case (False, True): result = b
    case _: result = c

5.

and

/

or

öncelik sırası#

# 🚫
if x or y and z:
    ...
# Aslında: if x or (y and z):
#       and > or olduğu için y and z önce

# Eğer (x or y) and z istiyordun:
if (x or y) and z:
    ...

6.

=

(atama) ve

==

karışmaz#

Assosiyatiflik — sol mu sağ mı?#

# Sol assosiyatif (most operators)
20 - 5 - 3      # = (20 - 5) - 3 = 15 - 3 = 12 (NOT 20 - (5-3) = 18)

10 / 2 / 5      # = (10/2) / 5 = 5 / 5 = 1.0

# Sağ assosiyatif — özel: ** ve atama
2 ** 3 ** 2     # = 2 ** (3 ** 2) = 2 ** 9 = 512

a = b = c = 5   # = a = (b = (c = 5))  — sağ assosiyatif
                # Tüm değişkenler 5

Comparison chaining — özel davranış#

# 0 < x < 10 — chain (Modül 2/Ders 10)
# Bu sol veya sağ değil; özel chaining kuralı

a < b < c           # = (a < b) and (b < c) — short-circuit
a == b == c         # = (a == b) and (b == c)

Pratik kural: Parantez ne zaman?#

Minimal parantez (matematik tarzı)#

result = a + b * c            # tabii ki çarpma önce
mask = ~bits & 0xFF            # bit op'lar normal sıra

Defensif parantez (savunmacı)#

result = a + (b * c)           # gereksiz ama net
mask = (~bits) & 0xFF          # gereksiz ama net

1. Bit op + comparison:
   (x & 1) == 1
2. Bit op + bit op (& ve |):
   (a & b) | c
   — "a AND b ile or c" mu, "a AND (b or c)" mu? Belirsiz olmasın.
3. and/or karışık:
   (x or y) and z
4. Walrus + comparison:
   (n := len(x)) > 10
5. Nested ternary: kullanma, elif yaz.
6. Üs alma + minus:
   (-2) ** 2
   veya
   -(2 ** 2)
   — niyetin neyse.

Debug aracı —

ast

modülü ile precedence görmek#

import ast

# Şu ifade nasıl parse oluyor?
code = "x & 1 == 1"
tree = ast.parse(code, mode="eval")
print(ast.dump(tree, indent=2))

Expression(
  body=BinOp(
    left=Name(id='x'),
    op=BitAnd(),
    right=Compare(
      left=Constant(value=1),
      ops=[Eq()],
      comparators=[Constant(value=1)]
    )
  )
)

Daha okunabilir: ast.unparse#

# Python 3.9+
import ast
code = "x & 1 == 1"
tree = ast.parse(code, mode="eval")

# ast.unparse aynı ifadeyi yazıyor — ama parse tree'sine göre
# Ama bu örnekte aynı görünüyor
print(ast.unparse(tree))   # x & 1 == 1

# Daha karmaşık:
code = "a or b and c"
tree = ast.parse(code, mode="eval")
print(ast.unparse(tree))   # a or b and c — Python original
# Anlamı: a or (b and c) — and > or

Bu derste neler kazandın?#