Operador de não igualdade do Python: Desbloqueando o poder da comparação

Name

Oluwaseun Adeojo

Updated on 01/05/2023

Como programador, os operadores de comparação são uma parte essencial do seu arsenal. Um desses operadores em Python é o operador de não igualdade, que permite comparar dois valores ou objetos para determinar se eles são diferentes. Nesta dissertação, vamos mergulhar nos mistérios do operador de não igualdade em Python, explorar como ele funciona no Python 2 e 3, entender seu uso com objetos personalizados e aprender sobre as diferenças entre != e <>. Pelo caminho, também discutiremos como usar f-strings com o operador de não igualdade.

Quer criar rapidamente Visualização de dados a partir de Pandas Dataframe do Python sem código?

PyGWalker é uma biblioteca Python para Análise Exploratória de Dados com Visualização. PyGWalker (opens in a new tab) pode simplificar seu fluxo de trabalho de análise de dados e visualização de dados do Jupyter Notebook, transformando seu Pandas Dataframe (e Polars Dataframe) em uma interface do usuário estilo Tableau para exploração visual.

(opens in a new tab)

O que é o operador de não igualdade em Python?

O operador de não igualdade em Python é representado pelo símbolo !=. Ele compara dois valores ou objetos e retorna True se eles não forem iguais e False caso contrário. Este operador é particularmente útil em declarações if e loops for para controlar o fluxo do seu programa com base na comparação de diferentes valores.

Como o operador de não igualdade funciona no Python 2 e Python 3?

No Python 2 e 3, o operador de não igualdade se comporta de forma semelhante. No entanto, existem algumas diferenças sutis. No Python 2, você pode usar tanto != quanto o operador descontinuado <> para comparações de não igualdade. No Python 3, o operador <> foi removido e somente o operador != é suportado. Usar o operador <> no Python 3 resultará em um SyntaxError.

Ao comparar valores de diferentes tipos de dados no Python 2, o interpretador emprega tipagem dinâmica e tenta converter os valores para um tipo de dados comum. No Python 3, uma linguagem fortemente tipada, o interpretador levantará um TypeError se você tentar comparar tipos de dados incompatíveis.

Podemos usar o operador de não igualdade com objetos personalizados?

Sim, é possível usar o operador de não igualdade com objetos personalizados em Python. Na programação orientada a objetos, as classes definem tipos de objeto personalizados. Para usar o operador de não igualdade com objetos personalizados, é necessário substituir o método __ne__() na definição da sua classe. Este método é responsável por determinar se duas instâncias do objeto personalizado não são iguais. Aqui está um exemplo:

class MyClass:
    def __init__(self, val):
        self.val = val
    
    def __ne__(self, other):
        return self.val != other.val
 
a = MyClass(1)
b = MyClass(2)
print(a != b)  # True
```Traduza o seguinte MDX com frontmatter para o português brasileiro:
 
```python
class MyClass:
    def __init__(self, value):
        self.value = value
 
    def __ne__(self, other):
        return self.value != other.value
 
obj1 = MyClass(42)
obj2 = MyClass(42)
print(obj1 != obj2)  # Saída: Falso

Qual a diferença entre != e <> em Python?

Como mencionado anteriormente, != e <> são ambos operadores de "não igual" em Python 2, sendo que <> está obsoleto. Embora os dois operadores funcionem de forma semelhante, <> não é suportado no Python 3 e o seu uso resultará em um SyntaxError. É recomendável utilizar o operador != para comparações de "não igual" tanto no Python 2 quanto no Python 3 para consistência e compatibilidade.

Podemos usar f-strings com o operador de "não igual" em Python?

F-strings, introduzidos no Python 3.6, são uma maneira poderosa de incorporar expressões em literais de string. Podemos utilizar f-strings com o operador de "não igual" para criar strings dinâmicas baseadas no resultado de uma comparação de "não igual". Veja um exemplo:

num1 = 42
num2 = 24
result = f"{num1} não é igual a {num2}: {num1 != num2}"
print(result)  # Saída: 42 não é igual a 24: True

Neste exemplo, utilizamos uma f-string para exibir o resultado da comparação de "não igual" entre num1 e num2. A f-string avalia a expressão dentro das chaves, {num1 != num2}, e insere o resultado (True, neste caso) na string.

Exemplos do operador de "Não Igual" em Python

Agora que entendemos o operador de "não igual" em Python, vamos explorar alguns exemplos com diversos tipos de dados:

Com Strings

string1 = "maçã"
string2 = "banana"
print(string1 != string2)  # Saída: True

Com Inteiros

num1 = 5
num2 = 7
print(num1 != num2)  # Saída: True

Com Objetos Personalizados

class MyClass:
    def __init__(self, value):
        self.value = value
 
    def __ne__(self, other):
        return self.value != other.value
 
obj1 = MyClass("maçã")
obj2 = MyClass("banana")
print(obj1 != obj2)  # Saída: True

Em uma declaração "if"

num = 42
if num != 0:
    print("O número não é zero.")  # Saída: O número não é zero.

Com None

value = None
print(value != 42)  # Saída: True

Operador de "não igual" em Python vs is not

Ambos o operador de "não igual" e is not podem ser utilizados para comparações, mas eles servem para propósitos diferentes. O operador de "não igual" (!=) verifica se dois valores são diferentes, enquanto is not verifica se dois objetos são diferentes instâncias, mesmo que seus valores sejam iguais. Por exemplo:

num1 = 42
num2 = 42
print(num1 != num2)  # Saída: False
print(num1 is not num2)  # Saída: False

Neste caso, tanto != quando is not retornam False, porque os valores são iguais e as variáveis referenciam o mesmo objeto inteiro.

Conclusão

O operador de "não igual" em Python é uma ferramenta versátil e poderosa para comparar valores e controlar o fluxo de seus programas. Compreender o seu uso com diferentes tipos de dados, suas diferenças entre o Python 2 e 3, e como utilizá-lo com objetos personalizados e f-strings o tornará um desenvolvedor Python mais experiente. Continue explorando e experimentando com o operador de "não igual", e não se esqueça de conferir nossos outros tutoriais Python para aprimorar suas habilidades!

FAQ

1. O que significa != em Python? Em Python, != é o operador de desigualdade e é usado para verificar se dois valores não são iguais. Ele retorna True se os valores forem diferentes e False caso contrário.

2. O que são == e != em Python? Em Python, == é o operador de igualdade e é usado para verificar se dois valores são iguais. Já != é o operador de desigualdade e é usado para verificar se dois valores não são iguais.

3. É possível usar o símbolo ≠ em Python? Não, o símbolo ≠ não é diretamente suportado em Python. Em vez disso, você pode usar o operador != para verificar a desigualdade entre dois valores.

4. Qual é a diferença entre != e is not em Python? Tanto != quanto is not são usados para verificar a desigualdade em Python. No entanto, há uma diferença sutil entre eles. O operador != compara os valores dos operandos, enquanto o operador is not compara as identidades dos objetos. Na maioria dos casos, você usaria != para comparar valores, mas is not pode ser usado para comparar identidades de objetos, especialmente ao lidar com objetos mutáveis como listas ou dicionários.