Black Jack

Comparações

O Python oferece os seguintes operadores de comparação básicos:

Todos eles têm a mesma prioridade (que é maior que a das operações Boolean, mas menor que a das operações aritméticas ou bit a bit).

Comparação entre tipos de dados diferentes

Objetos de tipos diferentes (exceto tipos numéricos) nunca são considerados iguais por padrão. Instâncias não idênticas de uma class também não serão consideradas iguais, a menos que a class defina métodos especiais de comparação avançada que personalizam o comportamento padrão de comparação de object. A personalização por meio de rich comparisons será abordada em um exercício seguinte. Para obter (muito) mais detalhes sobre esse tópico, consulte Comparações de valores na documentação do Python.

Os tipos numéricos são (em sua maioria) uma exceção a essa regra de correspondência de tipos. Um integer pode ser considerado igual a um float (ou um octal igual a um hexadecimal), desde que os tipos possam ser convertidos implicitamente para a comparação.

Para os outros tipos numéricos da biblioteca padrão do Python (complex, decimal, fractions), os operadores de comparação são definidos onde "fazem sentido" (onde a conversão implícita não altera o resultado), mas lançam um TypeError se os objetos subjacentes não puderem ser convertidos com precisão para a comparação. Para mais informações sobre as regras que o Python usa para conversão numérica, consulte conversões aritméticas na documentação do Python.

>>> import fractions

# A string cannot be converted to an int.
>>> 17 == '17'
False

# An int can be converted to float for comparison.
>>> 17 == 17.0
True

# The fraction 6/3 can be converted to the int 2
# The int 2 can be converted to 0b10 in binary.
>>> 6/3 == 0b10
True

# An int can be converted to a complex number with a 0 imaginary part.
>>> 17 == complex(17)
True

# The fraction 2/5 can be converted to the float 0.4
>>> 0.4 == 2/5
True

>>> complex(2/5, 1/2) == complex(0.4, 0.5)
True

Qualquer comparação ordenada de um número com um tipo NaN (não é um número) é False. Um efeito colateral confuso da definição de NaN do Python é que NaN nunca é igual a NaN na comparação.

>>> x = float('NaN')

>>> 3 < x
False

>>> x < 3
False

# NaN never compares equal to NaN
>>> x == x
False

Comparação de strings

Diferentemente dos números, as strings (str) são comparadas lexicograficamente, usando seus pontos de código Unicode individuais (o resultado de passar cada ponto de código da str para a função embutida ord(), que retorna um int). Se todos os pontos de código das duas strings coincidirem e estiverem na mesma ordem, as duas strings serão consideradas iguais. Essa comparação é feita de forma "aos pares": primeiro com primeiro, segundo com segundo, e assim por diante. No Python 3.x, str e bytes não podem ser convertidos/comparados diretamente.

>>> 'Python' > 'Rust'
False

>>> 'Python' > 'JavaScript'
True

# Examples with Mandarin.
# hello < goodbye
>>> '你好' < '再见'
True

# ord() of first characters
>>> ord('你'), ord('再')
(20320, 20877)

# ord() of second characters
>>> ord('好'), ord('见')
(22909, 35265)

# And with Korean words.
# Pretty < beautiful.
>>> '예쁜' < '아름다운'
False

>>> ord('예'), ord('아')
(50696, 50500)

Encadeamento de comparações

Os operadores de comparação podem ser encadeados arbitrariamente, ou seja, podem ser usados em qualquer combinação e com qualquer comprimento. Observe que a avaliação de uma expressão acontece de left para right.

Como exemplo, x < y <= z é equivalente a x < y and y <= z, exceto que y é avaliado apenas uma vez. Nos dois casos, z não é avaliado de forma alguma quando x < y é considerado False. Isso costuma ser chamado de short-circuit evaluation: a avaliação para se o valor de verdade da expressão já tiver sido determinado.

O Short circuiting é suportado por vários operadores Boolean, funções e também pelo encadeamento de comparações no Python. Diferentemente de muitas outras linguagens de programação, incluindo C, C++, C# e Java, expressões encadeadas como a < b < c no Python têm uma interpretação matemática convencional e precedência.

>>> x = 2
>>> y = 5
>>> z = 10

>>> x < y < z
True

>>> x < y > z
False

>>> x > y < z
False

Comparação de identidade de objetos

Os operadores is e is not testam a identidade do objeto, em oposição ao valor do objeto. A identidade de um objeto nunca muda após a criação e pode ser obtida com a função id().

<apple> is <orange> resulta em True se e somente se id(<apple>) == id(<orange>). <apple> is not <orange> produz o inverso.

Devido ao seu status de singleton, None e NotImplemented devem sempre ser comparados a itens usando is e is not. Consulte a documentação de referência do Python sobre comparações de valores e o PEP8 para mais detalhes sobre essa convenção.

>>> my_fav_numbers = [1, 2, 3]

>>> your_fav_numbers = my_fav_numbers

>>> my_fav_numbers is your_fav_numbers
True

# The returned id will differ by system and python version.
>>> id(my_fav_numbers)
4517478208

# your_fav_numbers is only an alias pointing to the original my_fav_numbers object.
# Assigning a new name does not create a new object.
>>> id(your_fav_numbers)
4517478208


>>> my_fav_numbers is not your_fav_numbers
False

>>> my_fav_numbers is not None
True

>>> my_fav_numbers is NotImplemented
False

Comparações de pertinência

Os operadores in e not in testam a pertinência. <fish> in <soup> resulta em True se <fish> for um membro de <soup> (se <fish> for um subconjunto de <soup> ou estiver contido nele), e resulta em False caso contrário. <fish> not in <soup> retorna a negação, ou o oposto de <fish> in <soup>.

Para os tipos string e bytes, <name> in <fullname> é True se e somente se <name> for uma substring de <fullname>.

# A set of lucky numbers.
>>> lucky_numbers = {11, 22, 33}
>>> 22 in lucky_numbers
True

>>> 44 in lucky_numbers
False

# A dictionary of employee information.
>>> employee = {'name': 'John Doe', 
                'id': 67826, 'age': 33, 
                'title': 'ceo'}

# Checking for the membership of certain keys.
>>> 'age' in employee
True

>>> 33 in employee
False

>>> 'lastname' not in employee
True

# Checking for substring membership
>>> name = 'Super Batman'
>>> 'Bat' in name
True

>>> 'Batwoman' in name
False