Строгое сравнение

Ваш подход действительно будет проверять как значение, так и тип. В Python нет другого оператора.

Это было сказано, во многих случаях это не то, что вы хотите – в философии Питона любой объект, который ведет себя как утка, следует рассматривать как утку. Вам часто не нужны только словари, вы хотите «объекты, подобные отображению», и так далее – пока объект может использоваться для конкретной задачи, тогда код должен его принять.

Равный компаратор Python является строгим, за исключением случаев сравнения 1 с True и 0 с False, и не имеет значения, имеет ли значение для 1 или 0 тип float, decimal.Decimal или long. Ноль любого числового типа, например, 0, 0L, 0.0, 0j всегда False. (Обратите внимание, что все остальное, переданное в bool, равно True. См. Проверка значения истины в Python .) 1 любого типа, кроме сложного (1L, 1.0, 1), всегда True.

В Python:

 0 == '0' # False 0 == '0' and type(0) == type('0') # False, compare short circuits 0 == '' # False 0 == '' and type(0) == type('') # False, compare short circuits 1 == True and type(1) == type(True) # False, makes a difference here 1 == True # True, also true if 1 was 1.00, etc.. 0 == False # True False == None # False 0 == bool(None) # True 

Когда первое сравнение возвращает False, второе не оценивается, следовательно, это короткие замыкания, потому что 0 и все остальное равно 0. Это необязательно, но применимо только при сравнении 1 с True в строке 6.

В JavaScript:

 0 == '0' //true 0 === '0' //false 0 == '' //true 0 === '0' //false 1 === true //false 1 == true //true 0 == false //true false == null //false 0 == !!(null) //true 

Итак, самое близкое к JavaScript === в Python:

 a == b and type(a) == type(b) 

Но только нужно будет использовать в случае логического сравнения с 1 или 0, что маловероятно. Если вы ожидаете, что значение будет либо числовым, либо логическим, вы можете исправить свой код. Ошибка новобранец – это нечто подобное:

 a = 0.0 # a valid value, lets assume it comes from a source that can also return None and we have no control over that. # Should be: # if a not None: if a: # a is cast to bool, bool(0.0) is False print "do something here..." 

Просто, чтобы прояснить некоторую путаницу, хорошо знать о Python's – это оператор. Python имеет оператор a, который возвращает True, если обе стороны от него связаны с одним и тем же объектом, иначе он возвращает False. При использовании строковых литералов время жизни объектов относится только к экземпляру инструкции. Таким образом, выполнение на строковых литералах безопасно, поскольку, если они одинаковы, они назначаются одному и тому же объекту. Это также относится к другим неизменяемым типам, таким как bool, и ко всем типам номеров:

 0 is '0' # False 0 is False # False 0 is 0 # True 

Это не гарантируется при сравнении двух переменных или переменной и литерала.

Когда вы создаете два пустых списка, вы получаете два разных объекта, поэтому возвращает False:

 x = [] y = [] x is y # False 

Но в этом случае эти переменные ссылаются на один и тот же список и будут продолжать делать это до тех пор, пока они не будут повторно назначены, или глубокая копия сделана из одного из другого:

 x = y = [] x is y # True x.append(1) x is y # True x = [1, ] x is y # False, even though the value is same 

Оператор is сравнивает тождества объектов, выполняет следующие действия:

 id('0') == id(0) 

Поэтому, если оба объекта ссылаются на одну и ту же память, они ссылаются на один и тот же объект и поэтому должны быть одинаковыми.

Следует избегать строгих сравнений, если вы не хотите проверить, ссылаются ли оба объекта на одну и ту же память.

Как следует из ответа Саймона, философия Питона о равенстве отличается от JavaScript, и нет необходимости в строгом компараторе равенства. Компаратор равенства Python не свободен, как JavaScripts == но в то же время его не совсем то же самое, что === .

Вы должны быть в порядке с компаратором равенства Python, пока его ясно, что нуль любого числового типа (0, 0L, 0.0, 0j) всегда равен False и 1 любого числового типа, кроме комплексных чисел (1, 1L, 1.0 ) правда.

Равный компаратор Python по большей части всегда строг.

Например:

питон

 0 == '0' # False 0 == '' # False 

Javascript

 0 == '0' //True 0 === '0' //False 0 == '' //True 0 === '0' //False 

Вы также можете использовать операторский модуль, если хотите быть строгим. https://docs.python.org/2/library/operator.html

 >>> import operator >>> operator.eq(True, 1) True >>> operator.is_(True, 1) False 

Некоторые из ответов здесь неверны. Например, Python не будет различать некоторые типы для целей некоторых сравнений.

Например:

 >>> 1 == 1.0 True >>> operator.eq(1, 1.0) True >>> operator.is_(1, 1.0) False 

Работает лучше, чем eq (или ==), но зависит от переменной, являющейся указателем на одно и то же значение, что означает, что вам не нужно много дел.

Если вы хотите углубляться, реализуя это коротко, что-то вроде этого: http://code.activestate.com/recipes/384122/ позволит вам «вроде» построить своих собственных операторов.