Saya Google-fu telah gagal saya.

Dalam Python, apakah dua tes berikut untuk kesetaraan setara?

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

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

Apakah ini berlaku untuk objek di mana Anda akan membandingkan instance ( listkatakanlah)?

Oke, jadi ini menjawab pertanyaan saya:

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

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

Jadi ==nilai tes mana istes untuk melihat apakah mereka adalah objek yang sama?

isakan kembali Truejika dua variabel menunjuk ke objek yang sama, ==jika objek yang dirujuk oleh variabel sama.

>>> 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

Dalam kasus Anda, tes kedua hanya berfungsi karena Python cache objek integer kecil, yang merupakan detail implementasi. Untuk bilangan bulat yang lebih besar, ini tidak berfungsi:

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

Hal yang sama berlaku untuk string literal:

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

Silakan lihat pertanyaan ini juga.

Ada aturan praktis sederhana untuk memberi tahu Anda kapan harus menggunakan ==atau is.

• ==adalah untuk kesetaraan nilai . Gunakan ketika Anda ingin tahu apakah dua objek memiliki nilai yang sama.
• isadalah untuk referensi kesetaraan . Gunakan ketika Anda ingin tahu apakah dua referensi merujuk ke objek yang sama.

Secara umum, ketika Anda membandingkan sesuatu dengan tipe sederhana, Anda biasanya memeriksa kesetaraan nilai , jadi Anda harus menggunakannya ==. Sebagai contoh, maksud dari contoh Anda mungkin untuk memeriksa apakah x memiliki nilai sama dengan 2 ( ==), bukan apakah xsecara harfiah merujuk ke objek yang sama dengan 2.

Hal lain yang perlu diperhatikan: karena cara kerja implementasi referensi CPython, Anda akan mendapatkan hasil yang tidak terduga dan tidak konsisten jika Anda keliru menggunakan isuntuk membandingkan persamaan referensi pada bilangan bulat:

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

Itulah yang kami harapkan: adan bmemiliki nilai yang sama, tetapi merupakan entitas yang berbeda. Tapi bagaimana dengan ini?

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

Ini tidak konsisten dengan hasil sebelumnya. Apa yang terjadi di sini? Ternyata implementasi referensi objek integer cache Python dalam kisaran -5..256 sebagai contoh tunggal untuk alasan kinerja. Berikut ini contoh yang menunjukkan ini:

>>> 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

Ini adalah alasan lain yang jelas untuk tidak digunakan is: perilaku dibiarkan implementasi ketika Anda salah menggunakannya untuk kesetaraan nilai.

==menentukan apakah nilainya sama, sementara ismenentukan apakah mereka adalah objek yang sama persis.

Apakah ada perbedaan antara ==dan isdalam Python?

Ya, mereka memiliki perbedaan yang sangat penting.

==: periksa untuk kesetaraan - semantik adalah bahwa objek yang setara (yang tidak harus objek yang sama) akan diuji sama. Seperti yang dikatakan dalam dokumentasi :

Operator <,>, ==,> =, <=, dan! = Membandingkan nilai dari dua objek.

is: periksa identitas - semantik adalah bahwa objek (seperti yang tersimpan dalam memori) adalah objek. Sekali lagi, dokumentasi mengatakan :

Operator isdan is notuji untuk identitas objek: x is ybenar jika dan hanya jika xdan yadalah objek yang sama. Identitas objek ditentukan menggunakan id()fungsi. x is not ymenghasilkan nilai kebenaran terbalik.

Dengan demikian, pemeriksaan untuk identitas sama dengan memeriksa kesetaraan ID objek. Itu adalah,

a is b

sama dengan:

id(a) == id(b)

di mana idfungsi builtin yang mengembalikan bilangan bulat yang "dijamin unik di antara objek yang ada secara bersamaan" (lihat help(id)) dan di mana adan bmerupakan objek arbitrer.

Petunjuk Penggunaan Lainnya

Anda harus menggunakan perbandingan ini untuk semantiknya. Gunakan isuntuk memeriksa identitas dan ==untuk memeriksa kesetaraan.

Jadi secara umum, kami gunakan isuntuk memeriksa identitas. Ini biasanya berguna ketika kita memeriksa objek yang seharusnya hanya ada satu kali di memori, disebut sebagai "singleton" dalam dokumentasi.

Gunakan kasing untuk ismemasukkan:

• None
• nilai enum (saat menggunakan Enums dari modul enum)
• biasanya modul
• biasanya objek kelas dihasilkan dari definisi kelas
• biasanya benda fungsi dihasilkan dari definisi fungsi
• hal lain yang seharusnya hanya ada satu kali dalam memori (semua lajang, umumnya
• objek spesifik yang Anda inginkan dengan identitas

Kasus penggunaan biasa untuk ==meliputi:

• angka, termasuk bilangan bulat
• string
• daftar
• set
• kamus
• objek yang bisa diubahsuaikan
• objek kekal bawaan lainnya, dalam banyak kasus

Kasus penggunaan umum, sekali lagi, untuk ==, adalah objek yang ingin mungkin tidak sama objek, melainkan bisa menjadi setara satu

Arah PEP 8

PEP 8, panduan gaya Python resmi untuk perpustakaan standar juga menyebutkan dua kasus penggunaan untukis :

Perbandingan dengan orang lajang seperti Noneharus selalu dilakukan dengan isatau is not, tidak pernah dengan operator kesetaraan.

Juga, berhati-hatilah menulis if xketika Anda benar-benar bermaksud if x is not None- misalnya ketika menguji apakah suatu variabel atau argumen yang defaultnya None diatur ke beberapa nilai lain. Nilai lainnya mungkin memiliki tipe (seperti wadah) yang bisa salah dalam konteks boolean!

Menyimpulkan kesetaraan dari identitas

Jika isbenar, kesetaraan biasanya dapat disimpulkan - secara logis, jika suatu objek itu sendiri, maka ia harus diuji sebagai setara dengan dirinya sendiri.

Dalam banyak kasus, logika ini benar, tetapi ia bergantung pada implementasi __eq__metode khusus. Seperti yang dikatakan para dokter ,

Perilaku default untuk perbandingan kesetaraan ( ==dan !=) didasarkan pada identitas objek. Oleh karena itu, perbandingan kesetaraan contoh dengan identitas yang sama menghasilkan persamaan, dan perbandingan persamaan contoh dengan identitas berbeda menghasilkan ketidaksetaraan. Motivasi untuk perilaku default ini adalah keinginan bahwa semua objek harus refleksif (yaitu x adalah y menyiratkan x == y).

dan untuk kepentingan konsistensi, merekomendasikan:

Perbandingan kesetaraan harus bersifat refleksif. Dengan kata lain, objek identik harus sama dengan:

x is y tersirat x == y

Kita dapat melihat bahwa ini adalah perilaku default untuk objek kustom:

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

Kontrapositif juga biasanya benar - jika sesuatu diuji tidak sama, Anda biasanya dapat menyimpulkan bahwa mereka bukan objek yang sama.

Karena tes untuk kesetaraan dapat disesuaikan, kesimpulan ini tidak selalu berlaku untuk semua jenis.

Pengecualian

Pengecualian yang penting adalah nan- selalu diuji sebagai tidak sama dengan dirinya sendiri:

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

Memeriksa identitas bisa menjadi pemeriksaan yang jauh lebih cepat daripada memeriksa kesetaraan (yang mungkin membutuhkan memeriksa anggota secara rekursif).

Tapi itu tidak bisa menggantikan kesetaraan di mana Anda dapat menemukan lebih dari satu objek sebagai setara.

Perhatikan bahwa membandingkan persamaan daftar dan tupel akan mengasumsikan bahwa identitas objek sama (karena ini adalah pemeriksaan cepat). Ini dapat membuat kontradiksi jika logikanya tidak konsisten - seperti untuk nan:

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

Kisah Peringatan:

Pertanyaannya adalah mencoba untuk menggunakan isuntuk membandingkan bilangan bulat. Anda tidak boleh berasumsi bahwa instance dari integer adalah instance yang sama dengan yang diperoleh dengan referensi lain. Kisah ini menjelaskan mengapa.

Seorang komentator memiliki kode yang mengandalkan fakta bahwa bilangan bulat kecil (-5 hingga 256 inklusif) adalah lajang dalam Python, alih-alih memeriksa kesetaraan.

Wow, ini dapat menyebabkan beberapa bug berbahaya. Saya punya beberapa kode yang memeriksa apakah a adalah b, yang berfungsi seperti yang saya inginkan karena a dan b biasanya angka kecil. Bug hanya terjadi hari ini, setelah enam bulan di produksi, karena a dan b akhirnya cukup besar untuk tidak di-cache. - gwg

Ini berhasil dalam pengembangan. Mungkin telah melewati beberapa unittests.

Dan itu berhasil dalam produksi - sampai kode memeriksa bilangan bulat yang lebih besar dari 256, pada saat itu gagal dalam produksi.

Ini adalah kegagalan produksi yang bisa saja tertangkap dalam tinjauan kode atau mungkin dengan pemeriksa gaya.

Biarkan saya tekankan: jangan gunakan isuntuk membandingkan bilangan bulat.

Apa perbedaan antara isdan ==?

==dan isperbandingannya berbeda! Seperti yang sudah dikatakan orang lain:

• == membandingkan nilai-nilai objek.
• is membandingkan referensi objek.

Dalam nama Python merujuk ke objek, misalnya dalam kasus ini value1dan value2merujuk ke sebuah intinstance yang menyimpan nilai 1000:

value1 = 1000
value2 = value1

Karena value2mengacu pada objek yang sama isdan ==akan memberi True:

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

Dalam contoh berikut ini, nama value1dan value2rujuk ke berbagai intinstance, meskipun keduanya menyimpan bilangan bulat yang sama:

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

Karena nilai yang sama (integer) disimpan ==akan menjadi True, itu sebabnya sering disebut "perbandingan nilai". Namun isakan kembali Falsekarena ini adalah objek yang berbeda:

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

Kapan menggunakan yang mana?

Secara umum isperbandingannya jauh lebih cepat. Itu sebabnya cache CPython (atau mungkin menggunakan kembali akan menjadi istilah yang lebih baik) objek-objek tertentu seperti integer kecil, beberapa string, dll. Tetapi ini harus diperlakukan sebagai detail implementasi yang dapat (bahkan jika tidak mungkin) berubah pada titik mana saja tanpa peringatan.

Anda hanyais boleh menggunakan jika Anda:

• ingin memeriksa apakah dua objek benar-benar objek yang sama (bukan hanya "nilai" yang sama). Salah satu contohnya adalah jika Anda menggunakan objek tunggal sebagai konstanta.

• ingin membandingkan nilai ke konstanta Python . Konstanta dalam Python adalah:

  • None
  • True¹
  • False¹
  • NotImplemented
  • Ellipsis
  • __debug__
  • kelas (misalnya int is intatau int is float)
  • mungkin ada konstanta tambahan dalam modul built-in atau modul pihak ke-3. Misalnya np.ma.maskeddari modul NumPy)

Dalam setiap kasus lain, Anda harus menggunakan== untuk memeriksa kesetaraan.

Bisakah saya menyesuaikan perilaku?

Ada beberapa aspek ==yang belum disebutkan di jawaban lain: Ini bagian dari Python "Model data" . Itu berarti perilakunya dapat dikustomisasi menggunakan __eq__metode ini. Sebagai contoh:

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)))

Ini hanya contoh buatan untuk menggambarkan bahwa metode ini benar-benar disebut:

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

Perhatikan bahwa secara default (jika tidak ada implementasi lain dari __eq__dapat ditemukan di kelas atau kacamata super)__eq__ menggunakan is:

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

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

Jadi, sebenarnya penting untuk diterapkan __eq__jika Anda ingin "lebih" dari sekadar perbandingan referensi untuk kelas khusus!

Di sisi lain Anda tidak dapat menyesuaikan iscek. Itu akan selalu membandingkan hanya jika Anda memiliki referensi yang sama.

Apakah perbandingan ini selalu menghasilkan boolean?

Karena __eq__dapat diimplementasikan kembali atau diganti, itu tidak terbatas untuk mengembalikan Trueatau False. Itu bisa mengembalikan apa saja (tetapi dalam kebanyakan kasus itu harus mengembalikan boolean!)

Misalnya dengan array NumPy ==akan mengembalikan array:

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

Tetapi iscek akan selalu kembali Trueatau False!

¹ Seperti yang Aaron Hall katakan dalam komentar:

Umumnya Anda tidak boleh melakukan apa pun is Trueatau is Falsememeriksa karena orang biasanya menggunakan "pemeriksaan" ini dalam konteks yang secara implisit mengubah kondisi menjadi boolean (misalnya dalam sebuah ifpernyataan). Jadi melakukan is Trueperbandingan dan pemeran boolean implisit adalah melakukan lebih banyak pekerjaan daripada hanya melakukan pemeran boolean - dan Anda membatasi diri Anda untuk boolean (yang tidak dianggap pythonic).

Seperti PEP8 menyebutkan:

Jangan membandingkan nilai boolean dengan Trueatau Falsemenggunakan ==.

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

Mereka sangat berbeda . ismemeriksa identitas objek, sementara== memeriksa kesetaraan (gagasan yang tergantung pada jenis kedua operan).

Hanya kebetulan kebetulan bahwa " is" tampaknya berfungsi dengan benar dengan bilangan bulat kecil (mis. 5 == 4 +1). Itu karena CPython mengoptimalkan penyimpanan bilangan bulat dalam kisaran (-5 hingga 256) dengan membuatnya menjadi lajang . Perilaku ini sepenuhnya tergantung pada implementasi dan tidak dijamin akan dipertahankan dengan segala macam operasi transformatif minor.

Sebagai contoh, Python 3.5 juga membuat singleton string pendek, tetapi mengirisnya mengganggu perilaku ini:

>>> "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

is tes untuk identitas == untuk kesetaraan

Setiap nilai integer (kecil) dipetakan ke nilai tunggal, sehingga setiap 3 identik dan sama. Ini adalah detail implementasi, bukan bagian dari spesifikasi bahasa

Jawaban Anda benar. The isOperator membandingkan identitas dua benda. The ==Operator membandingkan nilai-nilai dua benda.

Identitas objek tidak pernah berubah begitu telah dibuat; Anda mungkin menganggapnya sebagai alamat objek dalam memori.

Anda dapat mengontrol perilaku perbandingan nilai objek dengan mendefinisikan __cmp__metode atau metode perbandingan kaya seperti __eq__.

Lihatlah pertanyaan Stack Overflow operator “is” Python berperilaku tak terduga dengan bilangan bulat .

Sebagian besar intinya adalah bahwa " is" memeriksa untuk melihat apakah mereka adalah objek yang sama, tidak hanya sama satu sama lain (angka di bawah 256 adalah kasus khusus).

Singkatnya, isperiksa apakah dua referensi menunjuk ke objek yang sama atau tidak. ==memeriksa apakah dua objek memiliki nilai yang sama atau tidak.

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 

Seperti yang dikatakan John Feminella, sebagian besar waktu Anda akan menggunakan == dan! = Karena tujuan Anda adalah membandingkan nilai. Saya hanya ingin mengkategorikan apa yang akan Anda lakukan sepanjang waktu:

Ada satu dan hanya satu contoh dari NoneType yaitu Tidak ada yang tunggal. Konsekuensinya foo == Nonedan foo is Noneartinya sama. Namun istes lebih cepat dan konvensi Pythonic akan digunakan foo is None.

Jika Anda melakukan introspeksi atau mengoceh tentang pengumpulan sampah atau memeriksa apakah gadget pemagangan string yang dibuat khusus Anda berfungsi atau semacamnya, maka Anda mungkin memiliki case-use- foonya bar.

Benar dan Salah juga (sekarang) lajang, tetapi tidak ada kasus penggunaan untuk foo == Truedan tidak ada kasus penggunaan untuk foo is True.

Sebagian besar dari mereka sudah menjawab to the point. Sama seperti catatan tambahan (berdasarkan pemahaman dan percobaan saya tetapi tidak dari sumber yang didokumentasikan), pernyataan itu

== jika objek yang dirujuk oleh variabel sama

dari jawaban di atas harus dibaca sebagai

== jika objek yang dirujuk oleh variabel sama dan objek milik tipe / kelas yang sama

. Saya sampai pada kesimpulan ini berdasarkan tes di bawah ini:

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)

Di sini isi daftar dan tupel sama tetapi jenis / kelasnya berbeda.

Perbedaan python antara is dan equals (==)

Operator is mungkin tampak sama dengan operator kesetaraan tetapi tidak sama.

Tanda centang apakah kedua variabel mengarah ke objek yang sama sedangkan tanda == memeriksa apakah nilai kedua variabel tersebut sama.

Jadi jika operator is mengembalikan Benar maka kesetaraan pasti Benar, tetapi sebaliknya mungkin atau mungkin tidak Benar.

Berikut adalah contoh untuk menunjukkan kesamaan dan perbedaannya.

>>> 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.

Ketika orang lain dalam posting ini menjawab pertanyaan secara terperinci, saya akan menekankan terutama perbandingan antara isdan == untuk string yang dapat memberikan hasil yang berbeda dan saya akan mendesak programmer untuk hati-hati menggunakannya.

Untuk perbandingan string, pastikan untuk menggunakan ==daripada is:

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

Di luar:

str is hello
str == hello

Tetapi dalam contoh di bawah ini ==dan isakan mendapatkan hasil yang berbeda:

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

Di luar:

str == hello sam

Kesimpulan:

Gunakan isdengan hati-hati untuk membandingkan antara string