Benim Google-fu beni başarısız oldu.

Python'da eşitlik için aşağıdaki iki test eşdeğer midir?

n = 5
# Test one.
if n == 5:
    print 'Yay!'

# Test two.
if n is 5:
    print 'Yay!'

Bu, örnekleri ( listsözde) karşılaştıracağınız nesneler için geçerli mi?

Tamam, bu yüzden soruma şu cevaplar geliyor:

L = []
L.append(1)
if L == [1]:
    print 'Yay!'
# Holds true, but...

if L is [1]:
    print 'Yay!'
# Doesn't.

Öyleyse ==testler, istestlerin aynı nesne olup olmadığını görmek için nerede değer veriyor?

isTrueiki değişken aynı nesneyi gösteriyorsa, ==değişkenler tarafından atıfta bulunulan nesneler eşitse geri döner .

>>> a = [1, 2, 3]
>>> b = a
>>> b is a 
True
>>> b == a
True

# Make a new copy of list `a` via the slice operator, 
# and assign it to variable `b`
>>> b = a[:] 
>>> b is a
False
>>> b == a
True

Sizin durumunuzda, ikinci test sadece Python küçük bir tamsayı nesnesini önbelleğe aldığından çalışır, bu da bir uygulama detayıdır. Daha büyük tamsayılar için bu çalışmaz:

>>> 1000 is 10**3
False
>>> 1000 == 10**3
True

Aynı şey dizgi değişmezleri için de geçerlidir:

>>> "a" is "a"
True
>>> "aa" is "a" * 2
True
>>> x = "a"
>>> "aa" is x * 2
False
>>> "aa" is intern(x*2)
True

Lütfen bu soruya da bakınız .

==Veya ne zaman kullanılacağını size söyleyecek basit bir kural vardır is.

• ==içindir değer eşitliği . İki nesnenin aynı değere sahip olup olmadığını bilmek istediğinizde kullanın.
• isiçin bir referans eşitlik . İki referansın aynı nesneyi gösterip göstermediğini bilmek istediğinizde kullanın.

Genel olarak, bir şeyi basit bir türle karşılaştırırken, genellikle değer eşitliğini kontrol edersiniz, bu yüzden kullanmalısınız ==. Örneğin, örneğinizin amacı muhtemelen 2'nin aynı nesneye atıfta ==bulunmadığını değil, x'in 2 ( ) değerine eşit olup olmadığını kontrol xetmektir.

Dikkat edilmesi gereken başka bir şey: CPython referans uygulamasının çalışma şekli nedeniyle is, tamsayılarda referans eşitliğini karşılaştırmak için yanlışlıkla kullanırsanız beklenmedik ve tutarsız sonuçlar alırsınız :

>>> a = 500
>>> b = 500
>>> a == b
True
>>> a is b
False

Beklediğimiz hemen hemen budur: ave baynı değere sahip, ancak farklı varlıklar. Peki ya bu?

>>> c = 200
>>> d = 200
>>> c == d
True
>>> c is d
True

Bu önceki sonuçla tutarsız. Burada neler oluyor? Python, -5..256 aralığındaki tamsayı nesnelerini performans nedenleriyle tekil örnekler olarak önbelleğe alır. İşte bunu gösteren bir örnek:

>>> for i in range(250, 260): a = i; print "%i: %s" % (i, a is int(str(i)));
... 
250: True
251: True
252: True
253: True
254: True
255: True
256: True
257: False
258: False
259: False

Bu, kullanılmaması gereken bir diğer açık nedendir is: davranış, değer eşitliği için yanlışlıkla kullandığınızda uygulamalara bırakılır.

==değerlerin eşit isolup olmadığını, tam olarak aynı nesne olup olmadığını belirler.

Arasında bir fark var mı ==ve isPython?

Evet, çok önemli bir farkları var.

==: eşitliği kontrol edin - anlambilim, eşdeğer nesnelerin (mutlaka aynı nesne olması gerekmez) eşit olarak test edileceğidir. Gibi belgeler diyor :

<,>, ==,> =, <= ve! = İşleçleri iki nesnenin değerlerini karşılaştırır.

is: Kimlik kontrol - semantik (bellekte tutulan) bir amacı da bulunmaktadır olan nesne. Yine, belgeler diyor ki :

İşleçler isve is notnesne kimliği testi: x is yyalnızca xve yaynı nesne ise ve doğruysa doğrudur . Nesne kimliği id()fonksiyon kullanılarak belirlenir . x is not yters doğruluk değeri verir.

Böylece, kimlik kontrolü, nesnelerin kimliklerinin eşitliğini kontrol etmekle aynıdır. Yani,

a is b

aynıdır:

id(a) == id(b)

id"eşzamanlı olarak varolan nesneler arasında benzersiz olması garanti edilen" bir tamsayı döndüren yerleşik işlev nerede (bkz. help(id)) ve isteğe bağlı nesneler nerede ave bvardır.

Diğer Kullanım Talimatları

Bu karşılaştırmaları anlambilimleri için kullanmalısınız. isKimliği ve ==eşitliği kontrol etmek için kullanın .

Genel olarak, iskimliği kontrol etmek için kullanırız . Bu genellikle, yalnızca bir kez bellekte bulunması gereken ve belgelerde "singleton" olarak adlandırılan bir nesneyi kontrol ederken kullanışlıdır.

Kullanım örnekleri isşunları içerir:

• None
• enum değerleri (enum modülünden Enum'lar kullanılırken)
• genellikle modüller
• genellikle sınıf tanımlarından kaynaklanan sınıf nesneleri
• genellikle işlev tanımlarından kaynaklanan işlev nesneleri
• bellekte sadece bir kez olması gereken her şey (genellikle tüm tektonlar)
• kimlikle istediğiniz belirli bir nesne

Her zamanki kullanım örnekleri ==şunları içerir:

• tamsayılar dahil sayılar
• Teller
• listeleri
• kümeler
• sözlükleri
• özel değiştirilebilir nesneler
• çoğu zaman yerleşik yerleşik olmayan nesneler, çoğu durumda

Genel kullanım örneği, yine, ==istediğiniz nesne aynı nesne olmayabilir, bunun yerine eşdeğer bir nesne olabilir

PEP 8 yol tarifi

Standart kütüphane için resmi Python stil rehberi olan PEP 8 ayrıca aşağıdakiler için iki kullanım durumundanis bahseder :

Gibi tektonlarla karşılaştırmalar Nonedaima eşitlik operatörleri ile isveya is notasla yapılmamalıdır .

Ayrıca, if xgerçekten demek istediğinizde yazmamaya dikkat edin if x is not None- örneğin, varsayılan olarak bir değişkenin veya bağımsız değişkenin None başka bir değere ayarlanıp ayarlanmadığını test ederken . Diğer değer, bir boole bağlamında yanlış olabilecek bir türe (kap gibi) sahip olabilir!

Eşitliği kimlikten çıkarmak

Eğer isdoğruysa, eşitlik olabilir genellikle çıkarılabilir - bir nesnenin kendisine ise mantıksal olarak, o zaman kendisine eşdeğer olarak test etmelidir.

Çoğu durumda bu mantık doğrudur, ancak __eq__özel yöntemin uygulanmasına dayanır . Gibi dokümanlar demek,

Eşitlik karşılaştırması ( ==ve !=) için varsayılan davranış , nesnelerin kimliğine dayanır. Dolayısıyla, aynı kimliğe sahip örneklerin eşitlik karşılaştırması eşitlikle sonuçlanır ve farklı kimliklere sahip örneklerin eşitlik karşılaştırması eşitsizliğe yol açar. Bu varsayılan davranış için bir motivasyon, tüm nesnelerin refleksif olma arzusudur (yani x, y = x y anlamına gelir).

ve tutarlılık için şunları tavsiye eder:

Eşitlik karşılaştırması dönüşlü olmalıdır. Başka bir deyişle, özdeş nesneler eşittir:

x is y ima x == y

Bunun özel nesneler için varsayılan davranış olduğunu görebiliriz:

>>> class Object(object): pass
>>> obj = Object()
>>> obj2 = Object()
>>> obj == obj, obj is obj
(True, True)
>>> obj == obj2, obj is obj2
(False, False)

Kontraseptif de genellikle doğrudur - eğer bir şey eşit değilse test ederse, genellikle aynı nesne olmadıklarını çıkarabilirsiniz.

Eşitlik testleri özelleştirilebildiğinden, bu çıkarım tüm tipler için her zaman geçerli değildir.

Bir istisna

Dikkate değer bir istisna nan- her zaman kendine eşit olmadığı test eder:

>>> nan = float('nan')
>>> nan
nan
>>> nan is nan
True
>>> nan == nan           # !!!!!
False

Kimlik kontrolü, eşitliği kontrol etmekten çok daha hızlı bir kontrol olabilir (üyelerin tekrar tekrar kontrol edilmesini gerektirebilir).

Ancak, eşit olarak birden fazla nesne bulabileceğiniz eşitlik yerine kullanılamaz.

Liste ve grupların eşitliğinin karşılaştırılmasının, nesnelerin kimliğinin eşit olduğunu varsayacağını unutmayın (çünkü bu hızlı bir kontroldür). Bu, mantık tutarsızsa çelişkiler yaratabilir - olduğu gibi nan:

>>> [nan] == [nan]
True
>>> (nan,) == (nan,)
True

Dikkatli Bir Masal:

Soru, istam sayıları karşılaştırmak için kullanmaya çalışıyor . Bir tamsayı örneğinin başka bir başvuru tarafından alınan örnekle aynı olduğunu varsaymamalısınız. Bu hikaye nedenini açıklıyor.

Bir yorumcunun eşitliği kontrol etmek yerine küçük tamsayıların (-5 ila 256 dahil) Python'da tekton olduğuna güvenen bir kodu vardı.

Vay be, bu bazı sinsi böceklere yol açabilir. Ben a ve b genellikle küçük sayılar olduğundan istediğim gibi çalıştı b b, kontrol bazı kod vardı. Böcek sadece bugün, altı ay üretimden sonra oldu, çünkü a ve b nihayet önbelleğe alınamayacak kadar büyüktü. - gwg

Geliştirmede çalıştı. Bazı birim testlerden geçmiş olabilir.

Ve üretimde çalıştı - kod 256'dan büyük bir tamsayı kontrol edene kadar, bu noktada üretimde başarısız oldu.

Bu, kod incelemesinde veya muhtemelen bir stil denetleyicisiyle yakalanmış olabilecek bir üretim hatasıdır.

Vurgulayayım: tamsayıları karşılaştırmak için kullanmayın is.

Arasındaki fark nedir isve ==?

==ve isfarklı karşılaştırma vardır! Diğerlerinin söylediği gibi:

• == nesnelerin değerlerini karşılaştırır.
• is nesnelerin referanslarını karşılaştırır.

Python adlarında nesnelere, örneğin bu durumda value1ve değeri saklayan value2bir intörneğe başvurunuz 1000:

value1 = 1000
value2 = value1

Çünkü value2aynı nesneyi ifade eder isve ==şunları verir True:

>>> value1 == value2
True
>>> value1 is value2
True

Aşağıdaki örnekte, her ikisi de aynı tamsayıyı depolasa bile , adlar value1ve value2farklı intörneklere bakın :

>>> value1 = 1000
>>> value2 = 1000

Aynı değer (tamsayı) depolanacağından ==, Truebuna genellikle "değer karşılaştırması" denir. Ancak bunlar farklı nesneler olduğu için isgeri dönecektir False:

>>> value1 == value2
True
>>> value1 is value2
False

Hangisi ne zaman kullanılır?

Genellikle isçok daha hızlı bir karşılaştırma. İşte en niçin CPython önbelleğe (ya da belki Yeniden kullanılmamış daha iyi terim olurdu) küçük vb tamsayılar, bazı dizeleri, Ama bu şekilde ele alınmalıdır gibi bazı nesneleri uygulama ayrıntı bu uyarı olmadan herhangi bir noktada olabilir (hatta olası ise) değişim.

Sen olmalıdır yalnızca kullanmakis eğer:

• iki nesnenin gerçekten aynı nesne olup olmadığını kontrol etmek istiyorum (sadece aynı "değer" değil). Eğer bir örnek olabilir Eğer sabit olarak bir tekil nesne kullanın.

• bir değeri bir Python sabiti ile karşılaştırmak istiyorum . Python'daki sabitler:

  • None
  • True¹
  • False¹
  • NotImplemented
  • Ellipsis
  • __debug__
  • sınıflar (örneğin int is intveya int is float)
  • yerleşik modüllerde veya 3. taraf modüllerde ek sabitler olabilir. Örneğin np.ma.masked, NumPy modülünden)

Diğer her durumda== eşitliği kontrol etmek için kullanmalısınız .

Davranışı özelleştirebilir miyim?

==Bunun diğer cevaplarda daha önce bahsedilmeyen bir yönü var: Pythons "Veri modeli" nin bir parçası . Bu, davranışının __eq__yöntem kullanılarak özelleştirilebileceği anlamına gelir . Örneğin:

class MyClass(object):
    def __init__(self, val):
        self._value = val

    def __eq__(self, other):
        print('__eq__ method called')
        try:
            return self._value == other._value
        except AttributeError:
            raise TypeError('Cannot compare {0} to objects of type {1}'
                            .format(type(self), type(other)))

Bu, yöntemin gerçekten çağrıldığını gösteren yapay bir örnektir:

>>> MyClass(10) == MyClass(10)
__eq__ method called
True

Varsayılan olarak ( __eq__sınıfta veya üst sınıflarda başka bir uygulama bulunamazsa) şunu __eq__kullanır is:

class AClass(object):
    def __init__(self, value):
        self._value = value

>>> a = AClass(10)
>>> b = AClass(10)
>>> a == b
False
>>> a == a

Bu nedenle __eq__, özel sınıflar için yalnızca referans karşılaştırmadan "daha fazla" istiyorsanız uygulamak gerçekten önemlidir !

Öte yandan isçekleri özelleştiremezsiniz . Her zaman karşılaştırır sadece aynı başvuru varsa.

Bu karşılaştırmalar her zaman bir boole döndürür mü?

Çünkü __eq__yeniden hayata veya geçersiz olabilir, bunun karşılığında sınırlı değil Trueya False. Bir şey döndürebilir (ancak çoğu durumda bir boole döndürmelidir!).

Örneğin NumPy dizileriyle ==bir dizi döndürülür:

>>> import numpy as np
>>> np.arange(10) == 2
array([False, False,  True, False, False, False, False, False, False, False], dtype=bool)

Ancak isçekler her zaman geri döner Trueveya False!

¹ Aaron Hall'un yorumlarda belirttiği gibi:

Genellikle herhangi bir denetim yapmamalısınız is Trueya da is Falsekontrol etmemelisiniz çünkü biri normalde bu "kontrolleri" koşulu dolaylı olarak bir boole (örneğin bir ififadede) dönüştüren bir bağlamda kullanır . Dolayısıyla, is Truekarşılaştırmayı ve örtük boole dökümünü yapmak, yalnızca boolean dökümünü yapmaktan daha fazla iş yapmaktır - ve kendinizi booleanlarla (pitonik olarak kabul edilmez) sınırlandırırsınız.

PEP8'in belirttiği gibi:

Boolean değerleri ile Trueveya Falsekullanarak karşılaştırmayın ==.

Yes:   if greeting:
No:    if greeting == True:
Worse: if greeting is True:

Bunlar tamamen farklı . eşitliği (iki işlenenin türüne bağlı bir kavram) isdenetlerken, nesne kimliğini ==kontrol eder.

" is" Küçük tamsayılarla doğru çalışıyor gibi görünen şanslı bir tesadüf (örn. 5 == 4 + 1). Çünkü CPython, tamsayıların (-5 ila 256) aralığını tekton haline getirerek optimize eder . Bu davranış tamamen uygulamaya bağlıdır ve her türlü küçük dönüştürücü işlem altında korunacağı garanti edilmez.

Örneğin, Python 3.5 de kısa dizeleri tek tek yapar, ancak dilimlemek bu davranışı bozar:

>>> "foo" + "bar" == "foobar"
True
>>> "foo" + "bar" is "foobar"
True
>>> "foo"[:] + "bar" == "foobar"
True
>>> "foo"[:] + "bar" is "foobar"
False

https://docs.python.org/library/stdtypes.html#comparisons

iskimlik ==testleri eşitlik testleri

Her (küçük) tamsayı değeri tek bir değere eşlenir, böylece her 3 aynı ve eşittir. Bu bir uygulama detayıdır, dil spesifikasyonunun bir parçası değildir

Cevabınız doğru. isOperatör iki nesne kimliğinin karşılaştırır. ==Operatör iki nesne değerlerini karşılaştırır.

Bir nesnenin kimliği oluşturulduktan sonra asla değişmez; bunu nesnenin bellekteki adresi olarak düşünebilirsiniz.

Bir __cmp__yöntem veya zengin bir karşılaştırma yöntemi tanımlayarak nesne değerlerinin karşılaştırma davranışını denetleyebilirsiniz __eq__.

Stack Overflow sorusuna bir göz atın Python'un “is” operatörü tamsayılarla beklenmedik şekilde davranıyor .

Çoğunlukla kaynayan şey, " is" sadece birbiriyle aynı değil, aynı nesne olup olmadığını kontrol eder (256'nın altındaki sayılar özel bir durumdur).

Özetle, isiki referansın aynı nesneyi gösterip göstermediğini kontrol eder. ==iki nesnenin aynı değere sahip olup olmadığını kontrol eder.

a=[1,2,3]
b=a        #a and b point to the same object
c=list(a)  #c points to different object 

if a==b:
    print('#')   #output:#
if a is b:
    print('##')  #output:## 
if a==c:
    print('###') #output:## 
if a is c:
    print('####') #no output as c and a point to different object 

John Feminella'nın dediği gibi, çoğu zaman == ve! = Kullanacaksınız çünkü amacınız değerleri karşılaştırmaktır. Sadece zamanın geri kalanında ne yapacağınızı sınıflandırmak istiyorum:

NoneType'ın bir ve yalnızca bir örneği vardır, yani Yok bir singleton'dur. Sonuç olarak foo == Noneve foo is Noneaynı anlama gelir. Ancak istest daha hızlıdır ve Pythonic kuralı kullanmaktır foo is None.

Çalışırken veya suchlike bazı iç gözlem yaparak veya çöp toplama ile mucking veya özel olarak oluşturulmuş dize gadget staj alıp almadığını kontrol ediyorsanız için, o zaman muhtemelen kullanım senaryosunu sahip fooolduğu bar.

True ve False da (şimdi) singleton'lardır, ancak bunun için bir kullanım-durumu foo == Trueyoktur foo is True.

Çoğu zaten bu noktaya cevap verdi. Ek bir not olarak (benim anlayışım ve denemelerime dayanarak belgelenmiş bir kaynaktan değil)

== değişkenler tarafından atıfta bulunulan nesneler eşitse

Yukarıdaki cevaplar şu şekilde okunmalıdır:

== değişkenler tarafından atıfta bulunulan nesneler eşitse ve aynı tür / sınıfa ait nesneler

. Aşağıdaki sonuca dayanarak bu sonuca vardım:

list1 = [1,2,3,4]
tuple1 = (1,2,3,4)

print(list1)
print(tuple1)
print(id(list1))
print(id(tuple1))

print(list1 == tuple1)
print(list1 is tuple1)

Burada liste ve demet içeriği aynıdır, ancak tür / sınıf farklıdır.

Eşittir ve eşittir python farkı (==)

İs operatörü eşitlik operatörü ile aynı görünebilir, ancak aynı değildir.

Her iki değişkenin de aynı nesneyi gösterip göstermediğini denetlerken == işareti iki değişkenin değerlerinin aynı olup olmadığını denetler.

Eğer is operatörü True döndürürse, eşitlik kesinlikle doğrudur, ancak tam tersi doğru olabilir veya olmayabilir.

İşte benzerliği ve farkı gösteren bir örnek.

>>> a = b = [1,2,3]
>>> c = [1,2,3]
>>> a == b
True
>>> a == c
True
>>> a is b
True
>>> a is c
False
>>> a = [1,2,3]
>>> b = [1,2]
>>> a == b
False
>>> a is b
False
>>> del a[2]
>>> a == b
True
>>> a is b
False

Tip: Avoid using is operator for immutable types such as strings and numbers, the result is unpredictable.

Bu yazıdaki diğer insanlar soruyu ayrıntılı olarak yanıtlarken, temel olarak farklı sonuçlar verebilecek dizeler arasındaki ve karşılaştırmaları vurgulayacağım ve programcıları dikkatli bir şekilde kullanmaya teşvik ediyorum.is==

Dize Karşılaştırma için, kullandığınızdan emin olun ==yerine is:

str = 'hello'
if (str is 'hello'):
    print ('str is hello')
if (str == 'hello'):
    print ('str == hello')

Dışarı:

str is hello
str == hello

Ancak aşağıdaki örnekte ==ve isfarklı sonuçlar alacaksınız:

str = 'hello sam'
    if (str is 'hello sam'):
        print ('str is hello sam')
    if (str == 'hello sam'):
        print ('str == hello sam')

Dışarı:

str == hello sam

Sonuç:

isDizeleri karşılaştırmak için dikkatli kullanın