Como usar o operador 'not in' no Python?

Operadores “in” e “not in” do Python: Verificando a Associação

Introdução

Os operadores in e not in do Python permitem que você determine rapidamente se um determinado valor faz ou não parte de uma coleção de valores. Esse tipo de verificação é comum na programação e é geralmente conhecido como teste de associação no Python. Portanto, esses operadores são conhecidos como operadores de associação.

Neste tutorial, você aprenderá a:

Realizar testes de associação usando os operadores in e not in
Usar in e not in com diferentes tipos de dados
Trabalhar com operator.contains(), a função equivalente ao operador in
Fornecer suporte para in e not in em suas próprias classes

Começando com os Testes de Associação no Python

Às vezes, você precisa descobrir se um valor está presente ou não em uma coleção de valores. Em outras palavras, você precisa verificar se um determinado valor é ou não um membro de uma coleção de valores. Esse tipo de verificação é comumente conhecido como teste de associação.

Possivelmente, a maneira natural de realizar esse tipo de verificação é iterar sobre os valores e compará-los com o valor-alvo. Você pode fazer isso com a ajuda de um loop for e uma declaração condicional.

Considere a seguinte função is_member():

def is_member(valor, iteravel):
    for item in iteravel:
        if valor is item or valor == item:
            return True
    return False

Esta função recebe dois argumentos, o valor-alvo valor e uma coleção de valores, que é genericamente chamada de iterável. O loop itera sobre o iterável enquanto a declaração condicional verifica se o valor é igual ao valor atual. Observe que a condição verifica a igualdade de valor com o operador is ou com o operador de igualdade (==). Esses são ligeiramente diferentes, mas cumprem a função de verificar a associação do valor.

Utilizando os operadores “in” e “not in” com diferentes tipos de dados

Os operadores in e not in são versáteis e podem ser aplicados a diferentes tipos de dados no Python. A seguir, veremos como usá-los com listas, tuplas, strings, geradores, dicionários e conjuntos.

Listas, Tuplas e Intervalos

Para verificar se um valor está presente em uma lista, tupla ou intervalo, você pode usar os operadores in e not in da seguinte forma:

frutas = ['maçã', 'banana', 'laranja']

print('maçã' in frutas)  # Output: True
print('uva' not in frutas)  # Output: True

Nesse caso, o operador in verifica se o valor 'maçã' está presente na lista frutas, e o operador not in verifica se o valor 'uva' não está presente na lista. Ambas as expressões retornarão True.

Strings

Assim como nas listas, tuplas e intervalos, também é possível usar os operadores in e not in para verificar a associação de um valor em uma string:

frase = 'Olá, mundo!'

print('mundo' in frase)  # Output: True

Geradores

Os geradores são estruturas de dados que geram valores sob demanda. Para verificar se um valor está associado a um gerador, podemos usar os operadores in e not in da seguinte maneira:

def gerar_numeros(maximo):
    for i in range(maximo):
        yield i

numeros = gerar_numeros(5)

print(2 in numeros)  # Output: True
print(10 not in numeros)  # Output: True

Nesse caso, o operador in verifica se o valor 2 é gerado pelo gerador numeros, enquanto o operador not in verifica se o valor 10 não é gerado pelo gerador.

Dicionários e Conjuntos

Nos dicionários, podemos verificar a associação de chaves usando os operadores in e not in:

contatos = {'João': '12345', 'Maria': '67890'}

print('João' in contatos)  # Output: True
print('Carlos' not in contatos)  # Output: True

Nesse exemplo, o operador in verifica se a chave 'João' está presente no dicionário contatos, enquanto o operador not in verifica se a chave 'Carlos' não está presente no dicionário.

Nos conjuntos, podemos verificar a associação de elementos da seguinte forma:

numeros = {1, 2, 3, 4, 5}

print(3 in numeros)  # Output: True
print(6 not in numeros)  # Output: True

Nesse caso, o operador in verifica se o valor 3 está presente no conjunto numeros, enquanto o operador not in verifica se o valor 6 não está presente no conjunto.

Colocando em Ação os Operadores “in” e “not in” do Python

Os operadores in e not in do Python são frequentemente utilizados para substituir o uso de operadores lógicos encadeados, como o or. Em vez de escrever condições longas com vários operadores or, você pode usar os operadores in ou not in para simplificar o código.

Aqui está um exemplo:

nome = 'Maria'

if nome == 'João' or nome == 'Pedro' or nome == 'Maria':
    print('Bem-vindo!')

Este código verifica se o valor da variável nome é igual a 'João', 'Pedro' ou 'Maria'. No entanto, podemos reescrever o código da seguinte forma:

nome = 'Maria'

if nome in {'João', 'Pedro', 'Maria'}:
    print('Bem-vindo!')

Nesse caso, estamos usando o operador in para verificar se o valor da variável nome está presente no conjunto {'João', 'Pedro', 'Maria'}. Esse código é mais conciso e legível.

Usando a função operator.contains() para Testes de Associação

Além dos operadores in e not in, o módulo operator do Python também fornece a função contains() como uma alternativa para realizar testes de associação. A função contains() tem a mesma funcionalidade do operador in.

Aqui está um exemplo de como usar a função contains():

import operator

frutas = ['maçã', 'banana', 'laranja']

print(operator.contains(frutas, 'maçã'))  # Output: True
print(operator.contains(frutas, 'uva'))  # Output: False

Nesse caso, estamos usando a função contains() para verificar se a fruta 'maçã' está presente na lista frutas e se a fruta 'uva' não está presente.

Oferecendo Suporte para Testes de Associação em Classes Definidas pelo Usuário

Se você estiver trabalhando com classes definidas pelo usuário, poderá oferecer suporte para testes de associação, implementando os métodos especiais __contains__() ou __iter__() na sua classe.

O método __contains__() permite que você defina o comportamento do operador in para objetos dessa classe. Por exemplo, se a classe representar uma estrutura de dados personalizada, você pode definir como verificar a associação de um valor específico nessa estrutura.

Aqui está um exemplo de implementação da classe CustomList com o método __contains__():

class CustomList:
    def __init__(self):
        self.values = []

    def __contains__(self, value):
        return value in self.values

    def add_value(self, value):
        self.values.append(value)

my_list = CustomList()
my_list.add_value(1)
my_list.add_value(2)
my_list.add_value(3)

print(2 in my_list)  # Output: True
print(4 not in my_list)  # Output: True

Nesse exemplo, a classe CustomList armazena os valores em uma lista interna. O método __contains__() verifica a associação de um valor na lista values da classe.

Conclusão

Neste tutorial, você aprendeu como testar a associação de um valor usando os operadores in e not in do Python. Esses operadores são úteis para verificar se um valor está presente ou não em uma coleção de valores. Além disso, você viu como usá-los com diferentes tipos de dados, como listas, tuplas, strings, geradores, dicionários e conjuntos. Também exploramos como substituir operadores lógicos encadeados por in e not in para tornar o código mais conciso. Por fim, discutimos o uso da função operator.contains() e como oferecer suporte para testes de associação em classes definidas pelo usuário.

Agora que você está familiarizado com os operadores in e not in, você pode utilizá-los em suas aplicações Python para verificar associações de valores de forma mais eficiente.