Python Karşılaştırma Operatörleri
Python’da eşitlik, eşitsizlik ve büyüklük karşılaştırmaları için kullanılan operatörleri öğrenin.
Python'da karşılaştırma (veya ilişkisel) operatörleri, iki değeri veya ifadeyi birbiriyle kıyaslamak için kullanılır. Bu operatörlerin sonucunda her zaman bir Boolean değer (ya `True` ya da `False`) döner.
İşte Python'daki başlıca karşılaştırma operatörleri:
---
### 1. Eşitlik Operatörleri
#### `==` (Eşit mi?)
* **Anlamı:** İki operandın değerlerinin birbirine eşit olup olmadığını kontrol eder.
* **Kullanım:** `sol_operand == sag_operand`
* **Dönüş:** Değerler eşitse `True`, değilse `False`.
* **Örnekler:**
```python
print(5 == 5) # True
print(10 == 20) # False
print("Merhaba" == "Merhaba") # True
print("Elma" == "Armut") # False
print(1 == 1.0) # True (Değerler eşit kabul edilir, farklı tipler olsa da)
print([1, 2] == [1, 2]) # True (Listelerin elemanları ve sırası aynıysa)
print((1, 2) == (2, 1)) # False (Demetlerin sırası önemlidir)
```
#### `!=` (Eşit Değil mi?)
* **Anlamı:** İki operandın değerlerinin birbirine eşit olup olmadığını kontrol eder. `==` operatörünün tam tersidir.
* **Kullanım:** `sol_operand != sag_operand`
* **Dönüş:** Değerler eşit değilse `True`, eşitse `False`.
* **Örnekler:**
```python
print(5 != 10) # True
print(10 != 10) # False
print("Python" != "python") # True (Büyük/küçük harf farkı önemlidir)
print(1 != 1.0) # False (Değerler eşit olduğu için)
```
---
### 2. İlişkisel Operatörler
#### `<` (Küçük mü?)
* **Anlamı:** Sol operandın sağ operanddan küçük olup olmadığını kontrol eder.
* **Kullanım:** `sol_operand < sag_operand`
* **Dönüş:** Sol operand küçükse `True`, değilse `False`.
* **Örnekler:**
```python
print(10 < 20) # True
print(20 < 10) # False
print(10 < 10) # False
print('a' < 'b') # True (Lexicographical - sözlük sırasına göre)
print('apple' < 'banana') # True
```
#### `>` (Büyük mü?)
* **Anlamı:** Sol operandın sağ operanddan büyük olup olmadığını kontrol eder.
* **Kullanım:** `sol_operand > sag_operand`
* **Dönüş:** Sol operand büyükse `True`, değilse `False`.
* **Örnekler:**
```python
print(20 > 10) # True
print(10 > 20) # False
print(10 > 10) # False
print('z' > 'x') # True
```
#### `<=` (Küçük veya Eşit mi?)
* **Anlamı:** Sol operandın sağ operanddan küçük veya eşit olup olmadığını kontrol eder.
* **Kullanım:** `sol_operand <= sag_operand`
* **Dönüş:** Sol operand küçük veya eşitse `True`, değilse `False`.
* **Örnekler:**
```python
print(10 <= 20) # True
print(10 <= 10) # True
print(20 <= 10) # False
```
#### `>=` (Büyük veya Eşit mi?)
* **Anlamı:** Sol operandın sağ operanddan büyük veya eşit olup olmadığını kontrol eder.
* **Kullanım:** `sol_operand >= sag_operand`
* **Dönüş:** Sol operand büyük veya eşitse `True`, değilse `False`.
* **Örnekler:**
```python
print(20 >= 10) # True
print(10 >= 10) # True
print(10 >= 20) # False
```
---
### 3. Kimlik Operatörleri
Bu operatörler, iki değişkenin bellekte aynı nesneye referans edip etmediğini kontrol eder. `==` operatöründen farklı olarak, değer eşitliğinden ziyade nesne *kimliğini* kontrol ederler.
#### `is` (Aynı nesne mi?)
* **Anlamı:** İki operandın bellekte aynı nesneye referans edip etmediğini kontrol eder.
* **Kullanım:** `sol_operand is sag_operand`
* **Dönüş:** Aynı nesneye referans ediyorlarsa `True`, etmiyorlarsa `False`.
* **Örnekler:**
```python
a = [1, 2, 3]
b = [1, 2, 3]
c = a
print(a == b) # True (değerleri eşit)
print(a is b) # False (bellekte farklı nesneler)
print(a is c) # True (c, a ile aynı nesneye referans ediyor)
x = None
y = None
print(x is y) # True (None tekil bir nesnedir)
print(x is None) # True (None kontrolü için yaygın ve önerilen yöntem)
# Python küçük tamsayıları optimize edebilir (interning)
num1 = 5
num2 = 5
print(num1 is num2) # True (Python genellikle küçük tamsayıları önbelleğe alır)
num3 = 1000
num4 = 1000
print(num3 is num4) # False (Genellikle bu kadar büyük tamsayıları önbelleğe almaz)
```
#### `is not` (Aynı nesne değil mi?)
* **Anlamı:** İki operandın bellekte aynı nesneye referans etmediğini kontrol eder. `is` operatörünün tam tersidir.
* **Kullanım:** `sol_operand is not sag_operand`
* **Dönüş:** Aynı nesneye referans etmiyorlarsa `True`, ediyorlarsa `False`.
* **Örnekler:**
```python
a = [1, 2, 3]
b = [4, 5, 6]
print(a is not b) # True
```
---
### 4. Üyelik Operatörleri
Bu operatörler, bir değerin bir koleksiyon (dizi, liste, demet, küme, sözlük vb.) içinde olup olmadığını kontrol eder.
#### `in` (İçinde mi?)
* **Anlamı:** Sol operandın sağ operand olan koleksiyonun içinde olup olmadığını kontrol eder.
* **Kullanım:** `deger in koleksiyon`
* **Dönüş:** Değer koleksiyonun içindeyse `True`, değilse `False`.
* **Örnekler:**
```python
liste = [10, 20, 30, 40]
print(20 in liste) # True
print(50 in liste) # False
metin = "Python Programlama"
print("Programlama" in metin) # True
print("Java" in metin) # False
sozluk = {'a': 1, 'b': 2}
print('a' in sozluk) # True (Sözlük anahtarlarını kontrol eder)
print(1 in sozluk) # False (Değerleri değil, anahtarları arar)
```
#### `not in` (İçinde değil mi?)
* **Anlamı:** Sol operandın sağ operand olan koleksiyonun içinde olmadığını kontrol eder. `in` operatörünün tam tersidir.
* **Kullanım:** `deger not in koleksiyon`
* **Dönüş:** Değer koleksiyonun içinde değilse `True`, içindeyse `False`.
* **Örnekler:**
```python
liste = [10, 20, 30, 40]
print(50 not in liste) # True
print(20 not in liste) # False
```
---
### Önemli Notlar ve İpuçları
1. **Boolean Sonuç:** Tüm karşılaştırma operatörleri `True` veya `False` döndürür. Bu, `if` döngüleri, `while` döngüleri ve mantıksal operatörlerle (`and`, `or`, `not`) birlikte koşullu mantık oluşturmak için temeldir.
2. **Veri Tipleri:** Python'da `==` operatörü farklı sayısal tipleri (örn. `int` ve `float`) değer bazında karşılaştırabilir (`1 == 1.0` -> `True`). Ancak, farklı mantıksal tipler için (örn. `int` ve `str`) katıdır (`1 == '1'` -> `False`).
3. **Float Sayılarla Dikkat:** Kayar noktalı (float) sayılarla eşitlik kontrolü, bilgisayarın float sayıları bellekte temsil etme şekli nedeniyle bazen beklenmedik sonuçlar verebilir (örn. `0.1 + 0.2 == 0.3` bazen `False` olabilir). Bu tür durumlarda `math.isclose()` fonksiyonunu kullanmak daha güvenlidir.
```python
import math
print(0.1 + 0.2 == 0.3) # Muhtemelen False (hassasiyet farkı nedeniyle)
print(math.isclose(0.1 + 0.2, 0.3)) # True (tolerans dahilinde kontrol eder)
```
4. **Operatör Zincirleme:** Python, karşılaştırma operatörlerinin zincirlenmesine izin verir. Örneğin, `a < b < c` ifadesi `(a < b) and (b < c)` olarak değerlendirilir.
```python
x = 10
print(1 < x < 20) # True (1 < 10 ve 10 < 20 olduğu için)
print(5 < x < 8) # False (10 < 8 yanlış olduğu için)
```
5. **String Karşılaştırması:** Dizeler, karakterlerin ASCII/Unicode değerlerine göre *lexicographical* (sözlük sırası) olarak karşılaştırılır. Büyük harfler genellikle küçük harflerden önce gelir (örn. `'A' < 'a'` -> `True`).
6. **Koleksiyon Karşılaştırması:**
* **Listeler ve Demetler:** Elemanlar ve sıraları aynıysa eşit kabul edilir.
* **Kümeler:** Elemanlar aynıysa (sıra önemli değil) eşit kabul edilir.
* **Sözlükler:** Anahtar-değer çiftleri aynıysa (sıra önemli değil) eşit kabul edilir.
Bu detaylı açıklama, Python'da karşılaştırma operatörlerini doğru ve etkin bir şekilde kullanmanıza yardımcı olacaktır.
Son Paylaşımlar
-
Python Temelleri Genel Tekrar
14:39:24 - 13/12/2025 -
Python Performans İpuçları
14:38:59 - 13/12/2025 -
Python’da Temiz Kod Yazma
14:38:28 - 13/12/2025 -
Python Mini Proje: Sayı Tahmin Oyunu
14:37:58 - 13/12/2025 -
Python Mini Proje: Hesap Makinesi
14:37:31 - 13/12/2025