Como Utilizar/Corrigir Python - Explicado: O Python não está incluso

[

Operadores “in” e “not in” do Python: Verificação de Membros

Os operadores in e not in do Python permitem que você determine rapidamente se um determinado valor está ou não está presente em uma coleção de valores. Esse tipo de verificação é comum na programação e é geralmente conhecido como um teste de associação em 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.
Dar suporte para in e not in em suas próprias classes.

# Código-fonte: // Link para download

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

Às vezes, você precisa descobrir se um valor está presente em uma coleção de valores ou não. 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 um teste de associação.

Considere a seguinte função is_member():

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

Vamos ver essa função em ação com alguns exemplos:

>>> numbers = [1, 2, 3, 4, 5]
>>> is_member(3, numbers)
True
>>> is_member(6, numbers)
False

>>> names = ['Alice', 'Bob', 'Charlie']
>>> is_member('Alice', names)
True
>>> is_member('David', names)
False

Nesses exemplos, a função is_member() é usada para verificar se um número ou um nome está presente em uma lista de números ou nomes, respectivamente. A função retorna True se o valor estiver presente e False caso contrário.

Agora, vamos explorar os operadores in e not in, que são a maneira mais simples e elegante de realizar os testes de associação no Python.

Usando os Operadores `in` e `not in` com Diferentes Tipos de Dados

Os operadores in e not in são operadores de associação que podem ser usados com diferentes tipos de dados no Python. Eles permitem que você verifique se um valor está presente em uma determinada coleção ou não.

Listas, Tuplas e Intervalos

Listas, tuplas e intervalos são sequências no Python e podem ser verificadas usando os operadores in e not in. Veja alguns exemplos:

>>> numbers = [1, 2, 3, 4, 5]
>>> 3 in numbers
True
>>> 6 in numbers
False

>>> fruits = ('apple', 'banana', 'cherry')
>>> 'banana' in fruits
True
>>> 'orange' in fruits
False

>>> sequence = range(0, 10, 2)
>>> 4 in sequence
True
>>> 5 in sequence
False

Nesses exemplos, os operadores in e not in são usados para verificar se um determinado valor está presente em uma lista, tupla ou intervalo. Eles retornam True se o valor estiver presente e False caso contrário.

Strings

Em Python, as strings são sequências de caracteres e também podem ser verificadas usando os operadores in e not in. Veja alguns exemplos:

>>> text = 'Hello, world!'
>>> 'world' in text
True
>>> 'Python' in text
False

Nesses exemplos, os operadores in e not in são usados para verificar se uma determinada substring está presente em uma string. Eles retornam True se a substring estiver presente e False caso contrário.

Geradores

Os geradores são objetos especiais no Python que produzem um valor de cada vez, em vez de armazenar todos os valores em memória. Você pode verificar a associação com geradores usando os operadores in e not in. Veja um exemplo:

>>> generator = (x for x in range(10))
>>> 7 in generator
True
>>> 15 in generator
False

Nesse exemplo, o operador in é usado para verificar se um determinado valor está presente no gerador. Ele retorna True se o valor estiver presente e False caso contrário. É importante observar que, após um valor ser consumido de um gerador, ele não pode ser verificado novamente, pois o gerador avança para os próximos valores.

Dicionários e Conjuntos

Os dicionários e conjuntos são coleções no Python e também podem ser verificados usando os operadores in e not in. Veja alguns exemplos:

>>> person = {'name': 'Alice', 'age': 30, 'city': 'New York'}
>>> 'name' in person
True
>>> 'gender' in person
False

>>> numbers = {1, 2, 3, 4, 5}
>>> 3 in numbers
True
>>> 6 in numbers
False

Nesses exemplos, os operadores in e not in são usados para verificar se uma determinada chave está presente em um dicionário ou se um determinado valor está presente em um conjunto. Eles retornam True se a chave ou o valor estiver presente e False caso contrário.

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

Os operadores in e not in do Python são muito poderosos e podem ser usados para várias finalidades, como substituir operadores encadeados ou realizar testes de associação eficientes.

Substituindo Operadores Encadeados

Os operadores in e not in podem substituir facilmente os operadores encadeados or em alguns casos. Veja um exemplo:

>>> numbers = [1, 2, 3, 4, 5]
>>> 3 in numbers or 6 in numbers
True
>>> 6 in numbers or 7 in numbers
False

>>> names = ['Alice', 'Bob', 'Charlie']
>>> 'Alice' in names or 'David' in names
True
>>> 'David' in names or 'Eve' in names
False

Nesse exemplo, os operadores in e not in são usados para verificar se um determinado valor está presente em uma lista. Os operadores encadeados or são usados para combinar várias verificações em uma única expressão, retornando True se qualquer uma das verificações for verdadeira e False caso contrário.

Usando os operadores in e not in, podemos simplificar essas verificações encadeadas da seguinte maneira:

>>> numbers = [1, 2, 3, 4, 5]
>>> 3 in numbers or 6 in numbers
True
>>> 6 in numbers or 7 in numbers
False

>>> names = ['Alice', 'Bob', 'Charlie']
>>> 'Alice' in names or 'David' in names
True
>>> 'David' in names or 'Eve' in names
False

Essa forma mais legível e concisa de escrever as verificações de associação pode tornar seu código mais fácil de entender e manter.

Escrevendo Testes de Associação Eficientes

Ao realizar testes de associação em uma coleção, é importante considerar o desempenho do seu código. Usar os operadores in e not in é uma maneira eficiente de realizar esses testes.

Em vez de iterar manualmente sobre a coleção e comparar cada valor com o valor alvo, você pode usar os operadores in e not in para realizar a verificação de associação de forma mais rápida e direta.

Por exemplo, considere o seguinte trecho de código:

numbers = [1, 2, 3, 4, 5]
value = 3

is_present = False
for number in numbers:
    if number == value:
        is_present = True
        break

if is_present:
    print(f"{value} is present")
else:
    print(f"{value} is not present")

Nesse exemplo, você itera manualmente sobre a lista de números e verifica se o número está presente. Se o valor estiver presente, a variável is_present é definida como True e o loop é interrompido. Em seguida, você verifica o valor de is_present para determinar se o valor está presente ou não.

Você pode simplificar esse trecho de código usando o operador in da seguinte maneira:

numbers = [1, 2, 3, 4, 5]
value = 3

if value in numbers:
    print(f"{value} is present")
else:
    print(f"{value} is not present")

Nesse exemplo, o operador in é usado para verificar se o valor está presente na lista de números. Se o valor estiver presente, a mensagem adequada é exibida. Caso contrário, outra mensagem é exibida. Essa forma simplificada é mais curta e mais eficiente em termos de tempo de execução.

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

Além dos operadores in e not in, Python também fornece uma função equivalente chamada operator.contains().

Essa função pode ser usada para realizar testes de associação de forma semelhante ao operador in. Veja um exemplo:

import operator

numbers = [1, 2, 3, 4, 5]
value = 3

if operator.contains(numbers, value):
    print(f"{value} is present")
else:
    print(f"{value} is not present")

Nesse exemplo, a função operator.contains() é usada para verificar se o valor está presente na lista de números. A função retorna True se o valor estiver presente e False caso contrário.

A função operator.contains() pode ser útil em algumas situações em que você precisa passar uma função como argumento, como em expressões lambda.

Suportando Testes de Associação em Classes Definidas pelo Usuário

Você também pode fornecer suporte para os operadores in e not in em suas próprias classes definidas pelo usuário, implementando os métodos especiais __contains__() e __iter__(). Veja um exemplo:

class Range:
    def __init__(self, start, end):
        self.start = start
        self.end = end

    def __contains__(self, value):
        return self.start <= value <= self.end

    def __iter__(self):
        return iter(range(self.start, self.end + 1))

my_range = Range(1, 10)

print(5 in my_range)  # True
print(15 in my_range)  # False

for number in my_range:
    print(number)

Nesse exemplo, a classe Range representa um intervalo de números. O método __contains__() verifica se um determinado valor está presente no intervalo e retorna True ou False de acordo. O método __iter__() retorna um iterador que itera sobre o intervalo de números.

Essa implementação permite que você use os operadores in e not in com objetos da classe Range e também permite que você itere sobre os valores do intervalo.

Conclusão

Os operadores in e not in do Python são uma ferramenta poderosa para realizar testes de associação em uma coleção de valores. Eles fornecem uma maneira eficiente e concisa de verificar se um valor está presente ou não, seja em listas, strings, dicionários ou até mesmo em suas próprias classes personalizadas.

Ao usar esses operadores, você pode melhorar a legibilidade e a eficiência do seu código Python, tornando-o mais fácil de entender e manter. Portanto, considere sempre o uso dos operadores in e not in ao realizar testes de associação em suas aplicações Python.