Python’da is ve == operatörleri arasındaki fark

Python’da is ve == operatörleri farklı soruları yanıtlar. ==, iki nesnenin değer bakımından eşit olup olmadığını; is ise iki değişkenin bellekteki aynı nesneye referans verip vermediğini kontrol eder.

Bu nedenle genel eşitlik karşılaştırmalarında == kullanılır. is ise özellikle None gibi belirli tekil nesneleri kontrol etmek için tercih edilir.

Python’da == ve is arasındaki temel fark nedir?

Sayıların değerlerini karşılaştırmak istediğinde == operatörünü kullanmalısın:

sayi_1 = 25
sayi_2 = 20 + 5

print(sayi_1 == sayi_2)

Beklenen çıktı:

True

İki değişken de 25 değerini temsil ettiği için karşılaştırma True sonucunu verir. Buradaki soru, değişkenlerin aynı nesneyi gösterip göstermediği değil, değerlerinin eşit olup olmadığıdır.

Listeler, değer eşitliği ile nesne kimliği arasındaki farkı daha açık gösterir:

liste_1 = [10, 20, 30]
liste_2 = [10, 20, 30]
liste_3 = liste_1

print(liste_1 == liste_2)
print(liste_1 is liste_2)
print(liste_1 is liste_3)

Beklenen çıktı:

True
False
True

liste_1 ve liste_2 aynı elemanlara sahip oldukları için == karşılaştırması True döndürür. Ancak ayrı ayrı oluşturulmuş iki liste olduklarından liste_1 is liste_2 sonucu False olur. liste_3 ise doğrudan liste_1 nesnesine bağlandığı için kimlik karşılaştırması True verir.

Kısacası “değerleri aynı mı?” sorusunda ==, “tam olarak aynı nesne mi?” sorusunda is kullanılır. is operatörü genel eşitlik kontrolünün alternatifi değildir. Bu ayrımı uygulamalı ve yapılandırılmış biçimde öğrenmek isteyenler için birebir Python yazılım programı, temel kavramları kod yazarak geliştirmeye odaklanır.

None kontrolü neden is None biçiminde yapılır?

None, bir değişkende henüz anlamlı bir değer bulunmadığını veya bir işlemin değer üretmediğini belirtmek için kullanılabilir. Bir değişkenin None olup olmadığını kontrol ederken kimlik karşılaştırması yapılır:

kullanici_adi = None

print(kullanici_adi is None)
print(kullanici_adi is not None)

Beklenen çıktı:

True
False

İlk koşul, değişkenin doğrudan None nesnesini gösterip göstermediğini sorar. İkinci koşul ise değişkenin None dışında bir değere sahip olup olmadığını kontrol eder.

value == None yazımı yerine value is None tercih edilir. Çünkü burada amaç değer eşitliği aramak değil, değişkenin özel olarak None nesnesini gösterdiğini belirlemektir. Böylece kodun niyeti daha açık ifade edilir ve nesnelerin özelleştirilmiş eşitlik davranışlarından etkilenmeyen bir kontrol yapılır.

Ayrıca None; 0, False, boş metin ve boş liste ile aynı değildir:

degerler = [None, 0, False, "", []]

for deger in degerler:
    print(deger is None)

Beklenen çıktı:

True
False
False
False
False

Bu değerlerin bazıları koşul ifadelerinde yanlış değer gibi değerlendirilebilir; ancak yalnızca ilk eleman gerçekten None değeridir. Bu nedenle “değer boş veya yanlış mı?” kontrolüyle “değer None mı?” kontrolünü birbirinden ayırmalısın.

Aynı değere sahip nesneler ile aynı nesne nasıl ayırt edilir?

== iki nesnenin taşıdığı değeri karşılaştırır. is ise iki değişkenin bellekteki aynı nesneyi gösterip göstermediğini kontrol eder. Bu nedenle aynı içeriğe sahip iki ayrı liste için sonuçlar farklı olabilir:

liste_a = [1, 2, 3]
liste_b = [1, 2, 3]

print(liste_a == liste_b)
print(liste_a is liste_b)

Beklenen çıktı:

True
False

Listelerin elemanları aynıdır; bu yüzden == sonucu True olur. Ancak listeler ayrı ayrı oluşturulduğu için aynı nesne değildir ve is sonucu False çıkar.

b = a biçimindeki atama ise yeni bir liste oluşturmaz. b, a değişkeninin gösterdiği nesneye ikinci bir referans verir:

a = ["Python"]
b = a

print(a is b)

b.append("Java")

print(a)
print(b)

Beklenen çıktı:

True
["Python", "Java"]
["Python", "Java"]

Burada a ve b aynı listeyi gösterir. b.append() ile yapılan değişiklik, aynı nesne üzerinden görüldüğü için a değerine de yansır. Bu örnek, nesnenin kimliği ile içeriğinin farklı kavramlar olduğunu açıkça gösterir.

Bir nesnenin kimliğini gözlemlemek için id() kullanılabilir:

a = [10, 20]
b = a

print(id(a) == id(b))

Beklenen çıktı:

True

id() yalnızca iki değişkenin aynı nesneyi gösterip göstermediğini incelemeye yardımcı olur. Dönen kimlik numarasını sabit, taşınabilir veya farklı çalıştırmalarda aynı kalacak bir değer gibi yorumlamamak gerekir.

String ve küçük tamsayı örnekleri neden yanıltıcı olabilir?

String ve küçük tamsayılarla yapılan bazı is karşılaştırmaları True görünebilir:

x = "Python"
y = "Python"

print(x == y)
print(x is y)

sayi_a = 10
sayi_b = 10

print(sayi_a == sayi_b)
print(sayi_a is sayi_b)

Bazı Python uygulamalarında görülebilecek çıktı şöyledir:

True
True
True
True

Bu sonuç, stringlerin veya tamsayıların genel olarak aynı nesne olduğu anlamına gelmez. Uygulamanın nesneleri önbelleklemesi, yeniden kullanması ya da stringleri intern etmesi gözlemi etkileyebilir. Farklı yazım biçimleri, oluşturma yöntemleri veya Python uygulamaları aynı kodda farklı kimlik sonuçları doğurabilir.

Bu nedenle güvenli karar kuralı basittir: Bir değerin eşitliğini kontrol etmek için ==, None gibi özel tekil nesnelerin kimliğini kontrol etmek için is kullanılır. Genel değer karşılaştırmalarını, tesadüfen True görünen kimlik sonuçlarına dayandırmamak gerekir.

“== mı, is mi?” sorusu için karar çerçevesi ve kullanıcı profili örneği

Doğru operatörü seçmek için karşılaştırmanın amacını belirle:

1. İçerik veya değer mi karşılaştırılıyor? == kullan. Metinlerin, sayıların, listelerin ve sözlüklerin değerlerini karşılaştırırken genel tercih budur.
2. Aynı nesne mi aranıyor? is kullan. Bu operatör, iki değişkenin bellekte aynı nesneye işaret edip etmediğini denetler.
3. Özel olarak None mı kontrol ediliyor? is None veya is not None kullan.

Aşağıdaki fonksiyon, verilen profilin mevcut olup olmadığını ve uygulamadaki referans profille aynı nesne olup olmadığını kontrol eder:

def ayni_profil_mi(profil, referans_profil):
    if profil is None:
        return False

    return profil is referans_profil


aktif_profil = {"ad": "Deniz", "rol": "öğrenci"}

print(ayni_profil_mi(None, aktif_profil))

kopya_profil = {"ad": "Deniz", "rol": "öğrenci"}
print(ayni_profil_mi(kopya_profil, aktif_profil))

ayni_referans = aktif_profil
print(ayni_profil_mi(ayni_referans, aktif_profil))

Beklenen çıktı şöyledir:

False
False
True

İlk senaryoda profil None olduğu için sonuç False olur. İkinci senaryodaki sözlük, aktif profille aynı içeriğe sahip olsa da ayrı bir nesnedir. Üçüncü senaryoda ise iki değişken aynı sözlüğe işaret ettiği için sonuç True olur. Konuyu ne kadar kavradığını görmek istersen Python bilgi testiyle seviyeni ölçebilirsin.

Kod incelemesinde yanlış operatör seçimi nasıl teşhis edilir?

• Değer karşılaştırmasında is kullanılmış mı?
  Yanlış: kullanici_adi is "Ada"
  Doğru: kullanici_adi == "Ada"
  Beklenen sonuç, metnin değerine göre belirlenmelidir.
• None kontrolü doğrudan mı?
  Yanlış: profil == None
  Doğru: profil is None
  Bu kullanım, kontrolün nesne kimliğine dayandığını açıkça gösterir.
• Değişkenler aynı nesneyi mi, eşit içerikleri mi temsil ediyor?
  Yanlış: liste1 is liste2
  Doğru: liste1 == liste2
  Amaç iki listenin elemanlarını karşılaştırmaksa == kullanılmalıdır.
• Değiştirilebilir nesne test sırasında güncellenmiş mi?
  Yanıltıcı: yedek = liste
  Daha uygun: yedek = liste.copy()
  İlk kullanım yeni liste oluşturmaz; iki değişken aynı nesneye işaret eder. Kopya gerekiyorsa bunun açıkça oluşturulması gerekir.

Kısacası is operatörünü yalnızca nesne kimliğinin gerçekten önemli olduğu durumlarda kullan. Normal değer, metin, sayı ve koleksiyon karşılaştırmalarında == tercih et.

Sık Sorulan Sorular

Python’da iki listenin içeriği aynıysa neden is sonucu False olabilir?

Çünkü is içerikleri değil, nesne kimliğini karşılaştırır. Ayrı oluşturulan iki liste aynı elemanları taşısa bile farklı nesneler olabilir. İçerikleri karşılaştırmak için == kullanılır.

None kontrolünde == None kullanmak yerine neden is None yazılır?

None özel bir tekil nesneyi temsil eder. Bu nedenle amaç değer eşitliğini değil, değişkenin doğrudan None nesnesine işaret edip etmediğini denetlemektir.

is operatörü string ve sayılarda neden bazen beklenmedik sonuç verir?

Çünkü is, görünen değere değil nesne kimliğine bakar. Aynı görünen metin veya sayılar üzerinden elde edilen sonuçları genel bir eşitlik kuralı olarak kabul etmemek gerekir.

Python’da hangi durumlarda nesne kimliği karşılaştırması gerçekten gereklidir?

None kontrolünde, özel olarak oluşturulmuş tekil işaretçi nesnelerinde veya iki değişkenin aynı değiştirilebilir nesneyi gösterip göstermediğinin bilinmesi gereken durumlarda kimlik karşılaştırması kullanılabilir.

Operatör seçimini sözdizimine göre değil, soruna göre yap: değerleri karşılaştırırken ==, aynı nesneyi ararken is, boş değer durumunu denetlerken is None kullan.