Проверка различий в уровне Python

Предположим, что мы хотим, чтобы какой-то блок кода выполнялся, когда оба "a" и "b" равны 5. Тогда мы можем написать так:

if a == 5 and b == 5:
    # do something

Но несколько дней назад я просто невольно написал аналогичную проверку состояния как:

if a == b and b == 5:
    # do something

который заставлял меня думать, есть ли разница между ними? Кроме того, есть еще один способ,

if a == b == 5:
    # do something

Есть ли какая-либо разница, какая-либо разница в терминах процесса оценки или исполнения или времени? а также какой из них лучше или лучше использовать?

Связано ли это с понятием транзитивности?

Ответ 1

Поскольку они в основном эквивалентны, вы также можете подумать о том, как вы читаете/думаете о коде:

if a == 5 and b == 5:
  # do something

можно читать как "если a равно 5 и b равно 5, то do...". Вы должны думать/заключать, что тогда a будет равно b.

Это противоположно следующему примеру:

if a == b and b == 5:
  # do something

Это выглядит как "если a равно b и b, равному 5", и вы должны сделать вывод, что тогда a будет равно 5

Вот почему я предпочитаю последний пример:

if a == b == 5:
  # do something

Если вы знакомы с Python (благодаря Itzkata), сразу становится ясно, что все три вещи должны быть равны (до 5). Если, однако, люди с меньшим опытом работы на Python (но навыки программирования на других языках) видят это, они могут оценить это на

if (a == b) == 5:

который сравнивал бы логический результат первого сравнения с целым числом 5, что не то, что делает Python, и может привести к разным результатам (например, с помощью a=0, b=0: a==b==0 истинно, а (a==b) == 0 не является

руководство говорит:

В Python имеется восемь операций сравнения. Все они имеют тот же приоритет (который выше, чем у булевых операций). Сравнения могут быть скованы произвольно; например, x < y <= z является эквивалентна x < y и y <= z, , за исключением того, что y оценивается только один раз(но в обоих случаях z вообще не оценивается, когда x < y оказывается ложь).

Там может быть даже разница, например, если evaulating b в вашем примере будет иметь побочный эффект.

Что касается транзитивности, вы правы.

Ответ 2

Если у вас есть больше переменных для тестирования, использование all может быть несколько более читаемым:

if all(i==5 for i in [a,b,c,d]):
    # do something

Ответ 3

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

Третье сравнение отличается, однако; так как задействовано немного больше возиться со стеком. Действительно, код

import dis

def comparison_1(a, b):
    if a == 5 and b == 5:
        pass

def comparison_2(a, b):
    if a == b and b == 5:
        pass

def comparison_3(a, b):
    if a == b == 5:
        pass

print("*** First comparison ***")
dis.dis(comparison_1)

print("\n*** Second comparison ***")
dis.dis(comparison_2)

print("\n*** Third comparison ***")
dis.dis(comparison_3)

возвращает

*** First comparison ***
  4           0 LOAD_FAST                0 (a)
              3 LOAD_CONST               1 (5)
              6 COMPARE_OP               2 (==)
              9 POP_JUMP_IF_FALSE       27
             12 LOAD_FAST                1 (b)
             15 LOAD_CONST               1 (5)
             18 COMPARE_OP               2 (==)
             21 POP_JUMP_IF_FALSE       27

  5          24 JUMP_FORWARD             0 (to 27)
        >>   27 LOAD_CONST               0 (None)
             30 RETURN_VALUE        

*** Second comparison ***
  8           0 LOAD_FAST                0 (a)
              3 LOAD_FAST                1 (b)
              6 COMPARE_OP               2 (==)
              9 POP_JUMP_IF_FALSE       27
             12 LOAD_FAST                1 (b)
             15 LOAD_CONST               1 (5)
             18 COMPARE_OP               2 (==)
             21 POP_JUMP_IF_FALSE       27

  9          24 JUMP_FORWARD             0 (to 27)
        >>   27 LOAD_CONST               0 (None)
             30 RETURN_VALUE        

*** Third comparison ***
 12           0 LOAD_FAST                0 (a)
              3 LOAD_FAST                1 (b)
              6 DUP_TOP             
              7 ROT_THREE           
              8 COMPARE_OP               2 (==)
             11 JUMP_IF_FALSE_OR_POP    23
             14 LOAD_CONST               1 (5)
             17 COMPARE_OP               2 (==)
             20 JUMP_FORWARD             2 (to 25)
        >>   23 ROT_TWO             
             24 POP_TOP             
        >>   25 POP_JUMP_IF_FALSE       31

 13          28 JUMP_FORWARD             0 (to 31)
        >>   31 LOAD_CONST               0 (None)
             34 RETURN_VALUE

Ответ 4

Это зависит. Вы можете написать свой собственный __eq__, который позволяет сравнивать себя с целями и вещами:

 class NonNegativeInt(object):
   def __init__(self, value):
     if value < 0:
       raise Exception("Hey, what the...")
     self.value = value

   def __eq__(self, that):
     if isinstance(that, int):
       return self.value == that
     elif isinstance(that, NonNegativeInt):
       return self.value == that.value
     else:
       raise ArgumentError("Not an acceptible argument", "__eq__", that)

который будет работать по-разному в зависимости от сравнения "b" и "a" и "b" с "int". Следовательно, a == b может быть ложным, а a == 5 and b == 5 может быть True.