Operadores lógicos do Python: Uma introdução prática

Na programação, frequentemente precisamos tomar decisões com base em várias condições. Por exemplo, talvez você queira executar uma determinada ação somente se várias condições forem atendidas simultaneamente. Como alternativa, talvez você queira acionar uma ação alternativa se uma das várias condições for atendida.

O Python oferece um conjunto de operadores lógicos - and, or, not - para que você possa lidar com esses cenários.

Neste tutorial, aprenderemos como funcionam os operadores lógicos do Python e como você pode usá-los na programação e na ciência de dados. Observe que usaremos as palavras em maiúsculas AND, OR e NOT para representar esses operadores conceitualmente. E vamos nos referir às palavras-chave do Python usando esta convenção: and, or, e not.

Se você está procurando um currículo de Python com curadoria, confira este programa de seis cursos de habilidades de programação em Python.

Antes de entrar em detalhes, vamos começar com uma resposta muito breve para você que está com pressa.

Resposta curta: O que são os operadores lógicos do Python?

Os operadores lógicos do Python (and, or, not) são palavras-chave especiais que atuam como conjunções em nosso código, conectando e avaliando várias condições em uma única expressão.

Considere este exemplo:

temperature = 25
is_sunny = True
if temperature > 20 and is_sunny:
    print("It's a perfect day for a picnic!")

It's a perfect day for a picnic!

Aqui, o operador and garante que a mensagem seja impressa somente se both condições forem atendidas: a temperatura está acima de 20 graus and e está ensolarado.

Vejamos outro exemplo usando o operador or:

has_umbrella = False

if is_sunny or has_umbrella:
    print("Let's go for a walk!")

Let's go for a walk!

Nesse caso, sairemos para uma caminhada se estiver ensolarado ou se tivermos um guarda-chuva.

Por fim, o operador not inverte o valor verdadeiro de uma condição:

if not is_sunny:
    print("Maybe we should stay indoors.")

Aqui, a mensagem é impressa somente se não estiver ensolarada.

Os operadores lógicos nos dão uma maneira concisa e poderosa de expressar condições complexas, permitindo que nossos programas tomem decisões com base em vários fatores. Agora, vamos dar uma olhada mais profunda e começar com o operador lógico and.

Python: Os and Operador

Na lógica booleana, a operação AND envolve a comparação de dois valores ou expressões. Ele produz um resultado verdadeiro somente se ambos os valores forem verdadeiros. Se um ou ambos os valores forem falsos, o resultado da operação AND será falso. Aqui está um resumo de como o AND se comporta:

Você pode recriar essa tabela verdade com o operador and do Python:

options = True, False
for a in options:
    for b in options:
        print(f"{a} and {b} gives {a and b}")

True and True gives True
True and False gives False
False and True gives False
False and False gives False

A variável options contém os dois valores booleanos. Os loops for aninhados iteram as opções duas vezes para criar todas as permutações de True e False.

Geralmente, as expressões usadas como operandos para and incluem operadores de comparação ou igualdade:

names = "James", "Bob", "David", "Jane", "Kate", "Mary"
for name in names:
   if len(name) < 5 and name[0] == "J":
      print(name)

Jane

O nome será impresso somente se tiver menos de cinco letras e começar com "J". Ambos os requisitos devem ser atendidos.

Os operadores de comparação e igualdade, como < e ==, são avaliados como True ou False.

No entanto, o operador Python and funciona em qualquer tipo de dados e não apenas nos booleanos True e False. O valor de saída também pode ser qualquer tipo de dados.

Vamos explorar o operador and do Python em mais detalhes nesta seção. Primeiro, discutiremos a veracidade.

Python: verdadeiro e falso

Todo objeto Python pode ser convertido em um tipo booleano usando o built-in bool(). Um objeto é verdadeiro se bool(object) retornar True. Para um objeto falso, bool(object) retorna False.

O operador and do Python analisa a veracidade de seus operandos. Se ambos os operandos forem verdadeiros, o operador and também retornará um valor verdadeiro. Se um ou ambos os operandos forem falsos, and retornará um valor falso. Vamos dar uma olhada em alguns exemplos:

if 42 and "python":
    print("Both operands are truthy")
else:
    print("One or both operands are falsy")

Both operands are truthy

Agora, vamos considerar este exemplo:

if 42 and "":
    print("Both operands are truthy")
else:
    print("One or both operands are falsy")

One or both operands are falsy

E vamos dar uma olhada neste último exemplo:

if 0 and "python":
    print("Both operands are truthy")
else:
    print("One or both operands are falsy")

One or both operands are falsy

Os tipos numéricos, como inteiros e floats, são verdadeiros se forem diferentes de zero e falsos quando iguais a zero. As sequências, assim como as cadeias de caracteres, são verdadeiras quando não são vazias e falsas quando são vazias.

Portanto, somente o primeiro dos três exemplos acima satisfaz a condição de que ambos os operandos devem ser verdadeiros para que o operador and seja avaliado como verdadeiro.

O operador and nem sempre retorna um valor booleano. Uma expressão que inclui and também pode ser avaliada como um dos operandos. Vamos nos aprofundar mais nisso usando os mesmos exemplos que usamos anteriormente. Em vez de usar as expressões and em uma instrução if, nós as avaliaremos diretamente:

print(42 and "python")
print(42 and "")
print(0 and "python")

python

0

Você consegue identificar o que está acontecendo com essas expressões?

Vamos começar com o último dos três exemplos, que tem 0 e "python" como os dois operandos. O operador and está procurando por dois operandos verdadeiros. Como a primeira é 0, ela é falsa. Não é necessário que o programa verifique o segundo operador, pois toda a expressão será falsa, independentemente do valor do segundo operando.

No entanto, o operador and não retorna False. Em vez disso, ele retorna o primeiro operando diretamente. Como o primeiro operando é falso, toda a expressão and é avaliada como falsa. Isso não causa nenhum problema no Python, pois em situações em que o Python requer um valor verdadeiro ou falso, ele pode usar a veracidade de um objeto.

No primeiro exemplo, o primeiro operando é 42, que é verdadeiro. O programa avalia o segundo operando e o retorna. Como o segundo operando é a cadeia de caracteres "python", que é verdadeira, a expressão inteira é avaliada como verdadeira.

No segundo exemplo, o primeiro operando também é 42. Como é verdadeiro, o programa avalia e retorna o segundo operando, que é a string vazia. A string vazia é falsa e, portanto, toda a expressão and é avaliada como falsa.

Quando o primeiro operando é verdadeiro, o operador and sempre retorna o valor do segundo operando, quer o segundo operando seja verdadeiro ou falso.

Quando o primeiro operando é falso, o Python não avalia o segundo operando. Isso é chamado de curto-circuito e é uma forma de avaliação preguiçosa. Você pode confirmar isso com o seguinte código:

0 and 5/0

0

O segundo operando é 5/0, que normalmente geraria um ZeroDivisionError. No entanto, a expressão 5/0 não é avaliada neste exemplo, pois o primeiro operando é falso. A exceção nunca é levantada.

Exemplo: A loja on-line dos programadores

Vamos considerar um exemplo simples que representa um aplicativo da vida real. As transações em uma loja on-line que fornece produtos para programadores são registradas e acessadas por meio de uma API. Os dados são convertidos em uma lista de dicionários. Cada item da lista representa uma transação e cada transação é um dicionário que contém informações relevantes:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]

Cada transação inclui o nome e o preço do item, a quantidade incluída no pedido e se a transação foi bem-sucedida.

Vamos supor que precisamos de transações bem-sucedidas para itens com preço igual ou superior a US$ 100. Podemos usar o operador and para filtrar as linhas de que precisamos:

for item in data:
    if item["Success"] and item["Price"] >= 100:
        print(item)

{'Item': 'Headphones', 'Price': 250, 'Quantity': 1, 'Success': True}

A saída desse código mostra a única transação que atende a ambos os requisitos. Para cada item da lista de transações, a instrução if verifica a veracidade de duas expressões:

• Os valores associados à chave "Success" em cada dicionário são True ou False.
• O operador maior que ou igual a em item["Price"] >= 100 também retorna True ou False.

O livro Python e os cabos não atendem ao requisito de preço, pois custam menos de US$ 100. A máquina de café está acima desse limite de preço, mas essa transação não foi bem-sucedida e, portanto, foi excluída da impressão.

Voltaremos a esse exemplo de loja on-line mais adiante neste tutorial.

Na seção a seguir, vamos nos concentrar no operador or.

Python: Os or Operador

O operador lógico OR na lógica booleana precisa de dois operandos. É avaliado como verdadeiro se pelo menos um dos operandos for verdadeiro:

Podemos recriar essa tabela verdade usando o operador or do Python:

options = True, False
for a in options:
    for b in options:
        print(f"{a} or {b} gives {a or b}")

True or True gives True
True or False gives True
False or True gives True
False or False gives False

Também podemos revisitar o exemplo com nomes de pessoas que exploramos anteriormente, mas substituindo o operador and por um or:

names = "James", "Bob", "David", "Jane", "Kate", "Mary"
for name in names:
    if len(name) < 5 or name[0] == "J":
        print(name)

James
Bob
Jane
Kate
Mary

A declaração if agora contém uma expressão or. Portanto, o loop for imprime todos os nomes que têm menos de cinco letras ou que começam com a letra "J". A string "Jane" atende a ambos os requisitos. Os outros nomes impressos atendem a um dos dois requisitos.

Python or operador: verdadeiro e falso

O operador or também procura valores verdadeiros e falsos, e não apenas os booleanos True e False. Vamos dar uma olhada em alguns exemplos:

if 42 or [10, 20, 30]:
    print("At least one operand is truthy")
else:
    print("None of the operands is truthy")

At least one operand is truthy

Agora vamos considerar este exemplo:

if 42 or []:
    print("At least one operand is truthy")
else:
    print("None of the operands is truthy")

At least one operand is truthy

E vamos considerar também este último exemplo:

if 0 or []:
    print("At least one operand is truthy")
else:
    print("None of the operands is truthy")

None of the operands is truthy

No primeiro exemplo, o número inteiro 42 e a lista não vazia [10, 20, 30] são verdadeiros. Como o operador or precisa que pelo menos um operando seja verdadeiro, a expressão inteira é avaliada como verdadeira.

No segundo exemplo, 42 é verdadeiro, mas a lista vazia [] é falsa, pois é uma sequência vazia. Como um dos dois operandos é verdadeiro, toda a expressão or é avaliada como verdadeira.

No exemplo final, tanto 0 quanto [] são falsos. Portanto, a expressão inteira é avaliada como falsa.

O operador or também usa curto-circuito ao avaliar a expressão para evitar avaliações desnecessárias. Vamos dar uma olhada em alguns exemplos para ilustrar esse ponto:

print(42 or [10, 20, 30])
print(42 or [])
print([] or 42)
print([] or 0)

42
42
42
0

No primeiro exemplo, o primeiro operando é 42, que é verdadeiro. Como o site or exige que apenas um operando seja verdadeiro para determinar a veracidade final de toda a expressão, esse primeiro operando é retornado imediatamente. O segundo operando não é avaliado, pois seu valor não tem efeito sobre o resultado final. O operador or retorna o primeiro operando, 42, e não o booleano True. Em Python, qualquer valor verdadeiro tem o mesmo efeito que o booleano True em situações como as declarações if e while.

No segundo exemplo, o primeiro operando também é 42, e a expressão retorna esse número inteiro mesmo que o segundo operando seja falso.

No terceiro e quarto exemplos, o primeiro operando é a lista vazia, que é falsa. Portanto, o segundo operando é retornado em ambos os casos.

Exemplo: A loja on-line dos programadores

Vamos revisar as transações da loja on-line que vende produtos para programadores. Aqui estão as quatro transações de amostra que estamos usando neste exemplo:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]

Você precisa identificar algumas transações para investigar melhor o comportamento do cliente. Você deseja encontrar as transações que falharam ou que incluem um item com preço abaixo de US$ 75. Como você tem duas condições e só exige que uma transação atenda a pelo menos uma delas, você pode usar o operador or:

for item in data:
    if item["Success"] == False or item["Price"] < 75:
        print(item)

{'Item': 'Python Book', 'Price': 50, 'Quantity': 1, 'Success': True}
{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}

Esse loop for exibe as linhas que correspondem a pelo menos um dos requisitos. O livro Python e os cabos estão incluídos, pois seu preço é inferior a US$ 75. A máquina de café está incluída, pois a transação não foi bem-sucedida.

Há uma maneira alternativa de filtrar as transações malsucedidas, que exploraremos na seção a seguir.

Python: Os not Operador

O operador NOT é diferente de AND e OR, pois requer apenas um operando. NOT converte verdadeiro em falso e vice-versa. Aqui está a tabela verdade para NOT:

Você pode replicar isso usando o operador not do Python:

options = True, False
    for a in options:
        print(f"not {a} evaluates to {not a}")

not True evaluates to False
not False evaluates to True

Python not operador: verdadeiro e falso

Assim como em and e or, o operando usado em not não precisa ser um booleano. Como qualquer objeto é verdadeiro ou falso, qualquer objeto pode ser usado com not.

if not "python":
    print("The `if` statement evaluated as `True`")
else:
    print("The `if` statement evaluated as `False`")

The `if` statement evaluated as `False`

Vejamos também este exemplo:

if not "":
    print("The `if` statement evaluated as `True`")
else:
    print("The `if` statement evaluated as `False`")

The `if` statement evaluated as `True`

Os valores verdadeiros são convertidos para False com o operador not e os valores falsos são convertidos para True.

Ao contrário de and e or, o operador not sempre retorna um objeto booleano:

print(not "python")
print(not "")

False
True

Exemplo: A loja on-line dos programadores

Nas seções anteriores, usamos as transações de uma loja on-line. Neste exemplo, queremos exibir todas as transações malsucedidas. Uma opção é usar o operador de igualdade == para verificar se data["Success"] é igual a False. No entanto, você também pode usar o operador not:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]

for item in data:
    if not item["Success"]:
        print(item)

{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}

Como item["Success"] é igual a False para as transações malsucedidas, não item["Success"] retorna True. Portanto, o loop for imprime as transações malsucedidas:

Na seção a seguir, aprenderemos a combinar vários operadores lógicos em uma única expressão.

Python: Precendência do operador

Nos exemplos mostrados até agora, usamos apenas um dos operadores lógicos em cada instância. Nesta seção, veremos o que acontece quando combinamos mais operadores lógicos em uma única expressão.

Python: and tem precedência sobre or

Continuaremos a trabalhar nas transações da loja on-line que usamos anteriormente. Vamos tentar a seguinte declaração condicional:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]
​
for item in data:
    if item["Price"] > 100 or item["Quantity"] > 2 and item["Success"]:
        print(item)

{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
{'Item': 'Headphones', 'Price': 250, 'Quantity': 1, 'Success': True}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}

A instrução if contém dois operadores lógicos. Antes de investigarmos como o Python lida com essa expressão, vamos dar uma olhada em uma tradução em inglês da declaração if: Se o preço do item for superior a US$ 100 ou a quantidade vendida for maior que dois e a venda for bem-sucedida, imprima o item.

Essa frase é ambígua sem mais sinais de pontuação e ainda pode causar confusão mesmo se adicionarmos mais vírgulas na frase. Por exemplo, a transação com a máquina de café deve ser incluída? O preço do item está acima do limite exigido, mas a transação não foi bem-sucedida.

O Python resolveu essa ambiguidade dando ao operador and precedência sobre o operador or. Isso significa que a expressão and é avaliada primeiro, e seu resultado é usado na expressão or.

Portanto, a expressão item["Quantity"] > 2 and item["Success"] é avaliada primeiro. Essa expressão retorna um valor verdadeiro somente para a transação que inclui cabos. Ele é avaliado como falso para os itens restantes.

O valor da expressão and é então usado com o operador or. A expressão or retorna um valor verdadeiro para qualquer item que retorne verdadeiro para a expressão and - essa foi apenas a transação que incluiu cabos - e para itens com preço superior a US$ 100. Há dois itens com preços acima do limite: a máquina de café e os fones de ouvido.

Python: parênteses e operadores lógicos

No entanto, e se precisarmos de transações com itens com preços acima de US$ 100 ou com uma quantidade acima de dois, mas também quisermos garantir que a transação seja bem-sucedida? Nesse caso, queremos que a expressão or tenha precedência sobre a and para que seja avaliada primeiro. Você pode fazer isso usando parênteses ao redor da expressão or:

for item in data:
    if (item["Price"] > 100 or item["Quantity"] > 2) and item["Success"]:
        print(item)

{'Item': 'Headphones', 'Price': 250, 'Quantity': 1, 'Success': True}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}

Os parênteses adicionais dão precedência à expressão or. A transação da máquina de café não está mais incluída, pois ela avalia falsamente o segundo operando and.

Python: not tem precedência sobre and e or

O operador not tem precedência sobre and e or. Portanto, o not é avaliado antes dos outros dois operadores lógicos.

Vamos considerar a seguinte instrução if, que inclui not e and:

for item in data:
    if not item["Success"] and item["Price"] > 100:
        print(item)

{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}

Como not é avaliado primeiro, essa expressão aplicará primeiro o operador not a item["Success"]. O valor da expressão not é então usado como o primeiro operando na expressão and. Somente a entrada da máquina de café satisfaz essa condição - essa é a única transação que falhou e tem um preço superior a US$ 100.

No entanto, podemos dar precedência ao operador and usando parênteses:

for item in data:
    if not (item["Success"] and item["Price"] > 100):
        print(item)

{'Item': 'Python Book', 'Price': 50, 'Quantity': 1, 'Success': True}
{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}

Nesse caso, a expressão and é avaliada primeiro. Somente a entrada com fones de ouvido é avaliada em True, pois é a única transação bem-sucedida com um preço acima de US$ 100. No entanto, adicionamos um operador not antes da expressão entre parênteses. Portanto, o código gera as três transações restantes.

Em geral, se uma expressão se tornar muito complexa por ter muitos operadores, é melhor dividi-la para torná-la mais legível.

Conclusão

Os operadores lógicos do Python and, or e not são usados extensivamente em uma ampla gama de aplicativos de programação e ciência de dados. Esses operadores reproduzem o comportamento dos operadores lógicos booleanos AND, OR e NOT, amplamente usados em lógica e matemática.

No entanto, os operadores do Python podem aceitar qualquer objeto e não apenas valores booleanos. Os operadores and e or usam avaliação de curto-circuito e retornam um dos operandos como saída.

Os operadores lógicos do Python são ferramentas essenciais para filtrar dados, identificar recursos em conjuntos de dados e criar regras complexas para controlar o fluxo de um programa. Se você quiser saber mais sobre isso, confira este programa de carreira de nove cursos de Analista de dados com Python.