No Python, objetos do mesmo tipo e pertnecentes aos tipos embutidos (exceto dicionários) podem ser comparados. A chave é que os tipos devem ser idênticos e os tipos embutidos permitem essa operação. Assim, se os tipos forem diferentes, como numéricos e strings, a comparação direta não é possível. As regras para igualdade, desigualdade e ordenação serão compreendidas mais adiante ao estudar a sobrecarga de operadores em classes. Tipos persoanlizados, que são classes no Python 3.x, também podem ser comparados, mas exigem a implementação de operadores de comparação. Aqui, focamos nos tipos embutidos.

Os operadores de comparação são:

==  !=  <  <=  >  >=

Por exemplo, as comparações a seguir retornam True.

verdadeiro(3 < 5)
verdadeiro('b' < 'd')   # 'A' < 'Z' < 'a' < 'z' em ordenação Unicode
verdadeiro([2,3,4] < [2,3,5])
verdadeiro((10,20,20) < (10,20,30))
verdadeiro({7,8,8} < {7,8,9})

Em Python, objetos de tipos embutidos (exceto dicionários) são comparados elemento a elemento da esquerda para a direita. Se houver estruturas aninhadas, como listas ou tuplas, a comparação é recursiva.

>>> verdadeiro([1,2,[3,3]] < [1,2,[3,4]])
True

Note que o objeto None só pode ser comparado por igualdade ou desigualdade; não suporta comparações de tamanho.

>>> None == None
True
>>> None != None
False
>>> None <= None
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<=' not supported between instances of 'NoneType' and 'NoneType'</module></stdin>

O Python permite comparações contínuas, que são equivalentes a usar o operador lógico and. Por exemplo:

x < y < z    equivale a  x < y and y < z
p < q > r    equivale a  p < q and q > r
a == b < c   equivale a  a == b and b < c

Preste atenção à lógica em comparações contínuas. Por exemplo, 2 == 4 < 6 retorna False, pois equivale a 2 == 4 and 4 < 6, e não a avaliar 2==4 primeiro e comparar o resultado com 6, o que seria equivalente a False < 6, ou 0 < 6, retornando True.

>>> 2 == 4 < 6
False
>>> (2==4) < 6
True

Comparações contínuas são uma sintaxe que funciona com outros tipos, não apenas numéricos:

>> "bc" > "ba" < "be"
True

is e ==

Existem duas maneiras de comparar se objetos são iguais: "==" e "is", com formas negativas "!=" e "is not". Ambos são expressões de comparação, mas atuam de maneiras distintas:

• "==" e "!=" comparam se os valores dos dados são iguais ou diferentes.
• "is" compara se dois objetos de dados na memória são o mesmo objeto, ou seja, compara endereços de memória.

A comparação por igualdade é direta: se os valores forem iguais, retorna True; caso contrário, False.

O "is" verifica o objeto na memória. Por exemplo:

>>> valor1 = 1000
>>> valor2 = 1000
>>> valor1 == valor2
True
>>> valor1 is valor2
False

valor1 e valor2 têm o mesmo valor numérico, então valor1 == valor2 é True. No entanto, apontam para objetos de dados 1000 diferentes na memória, então valor1 is valor2 é False. Em cenários como:

>>> var_a = 1000
>>> var_b = var_a
>>> var_a is var_b
True

Aqui, var_b = var_a atribui o endereço do objeto 1000 armazenado em var_a para var_b, fazendo com que ambos apontem para o mesmo objeto na memória. O teste "is" tem casos especiais, e a atribuição por referência não é detalhada neste momento.