Operadores lógicos

Na lição anterior, vimos como comparar valores individuais usando os operadores de comparação. Aprendemos também que com eles podemos verificar se um número está entre dois valores com expressões como 1 < x < 10.

Nesse caso, duas comparações são feitas ao mesmo tempo: conferimos tanto se 1 < x e se x < 10. Se as duas comparações forem verdadeiras, o valor True era retornado:

1x = 5
2print(1 < x < 10)   # 5 é maior que 1 E menor que 10? sim!
3
4# Saída:
5# True

Agora, vamos dar um passo além!

Os operadores lógicos

O Python permite combinar várias condições ao mesmo tempo e é aí que entram os operadores lógicos.

Esses operadores são usados para conectar expressões e trazem resultados em valores booleanos (True ou False). Eles nos ajudam a tomar decisões mais complexas, unindo comparações e expressões.

Em Python, temos três operadores lógicos:

Vamos ver cada um deles em ação.

O operador and

Representa o E lógico em português. Ele é usado quando queremos verificar se todas as expressões avaliadas são verdadeiras.

Por exemplo, se a primeira expressão é verdadeira E a segunda também é verdeira, recebemos True como resultado:

1x = 5
2y = 8
3
4print(x > 0 and y > 0)
5
6# Saída:
7# True

Se qualquer uma das expressões for falsa, o resultado será False.

Uma situação da vida real que pode ajudar a visualizar é quando você quer acessar alguma conta online, como entrar no seu e-mail. Isso só é possível se duas condições forem verdadeiras: você digitou o endereço de e-mail correto E a senha correta.

1email_correto = True
2senha_correta = True
3
4print(email_correto and senha_correta)  # ambas precisam ser verdadeiras
5
6# Saída:
7# True

Se uma delas estiver errada, o acesso é negado.

1email_correto = True
2senha_correta = False
3
4print(email_correto and senha_correta)  # ambas precisam ser verdadeiras
5
6# Saída:
7# False

Uma maneira comum de visualizar todas as possíveis saídas para operadores lógicos é através do que chamamos de tabela‑verdade.

Para facilitar, vamos usar as mesmas variáveis que usamos acima na tabela para vermos se o usuário deveria conseguir acessar a conta (email_correto and senha_correta é True) ou não (email_correto and senha_correta é False):

O operador or

Representa o OU lógico. Ele é usado quando queremos que pelo menos uma das condições seja verdadeira para que o resultado também seja True.

1x = 4
2
3print(x < 5 or x > 10)
4
5# Saída:
6# True

Aqui, x é menor que 5. Mesmo não sendo maior que 10, pelo menos uma das condições é verdadeira, então o resultado é True.

Mas se nenhuma das condições for verdadeira, o resultado muda para False:

1x = 6
2print(x < 5 or x > 10)
3
4# Saída:
5# False

Uma situação da vida real seria uma promoção de loja que oferece desconto se o cliente for estudante ou tiver um cupom de fidelidade. Basta uma dessas condições ser verdadeira para que o desconto seja aplicado:

1is_estudante = False
2tem_cupom = True
3
4print(is_estudante or tem_cupom)
5
6# Saída:
7# True

Veja a tabela‑verdade que mostra todos os resultados possíveis com o or:

O operador not

Representa a negação lógica. Ele inverte o valor de uma expressão:

• o que é True vira False;
• o que é False vira True.

Observe:

1x = 5
2comparacao = x > 3    # 5 é maior que 3, então é True.
3
4print(not comparacao)   # mas aqui o not inverte o resultado!
5
6# Saída:
7# False

Para deixar mais intuitivo, imagine um interruptor de lâmpada inteligente que acende somente quando o ambiente NÃO está claro:

1esta_claro = False
2acender_luz = not esta_claro
3
4print(acender_luz)
5
6# Saída:
7# True

Ou seja, se esta_claro for False, então acender_luz, que é o mesmo que not esta_claro, será True e a luz acende automaticamente. É como dizer: "Não está claro? Não. Então acenda a luz!"

Veja como isso se representa em uma tabela‑verdade:

Um ponto de atenção é que o and e or precisam de pelo menos duas expressões para funcionarem. Você compara se isso E/OU aquilo são verdadeiros ou falsos. No caso do not, ele atua sobre uma única expressão mesmo que essa expressão única tenha várias expressões dentro dela. O operador vai considerar só o resultado booleano para devolver o oposto:

1x = 12
2print(not(x > 3 and x < 10))
3
4# Saída:
5# True

Aqui, vamos resolver primeiro a expressão dentro dos parênteses: x > 3 é True e x < 10 é False. Dessa forma, x > 3 and x < 10 é False e not(False) é True.

Combinando operadores

O not não é o único operador que pode ser combinado com outros. O and e o or também podem formar expressões mais complexas:

1x = 7
2print((x > 0 and x < 10) or x == 100)
3
4# Saída:
5# True

Aqui, o Python primeiro avalia o que está dentro dos parênteses e depois aplica o or. Como x está entre 0 e 10, a expressão dentro do parêntese é True, e o or mantém esse resultado como True.

Um bom exemplo disso seria um caixa eletrônico que libera o saque se a conta estiver ativa E houver saldo suficiente, OU se o cartão for de emergência, o que permite o saque. Essa combinação mostra como operadores podem trabalhar juntos para expressar regras mais completas.

---

Os operadores lógicos são a base do raciocínio em programação. Logo veremos como eles são aplicados em estruturas de decisão para deixar o código ainda mais inteligente.