Neste artigo
- O que são operadores relacionais e lógicos?
- Como funcionam o E, o OU e o NÃO?
- Como usar operadores relacionais e lógicos em Python, PHP e C?
- Qual operador é avaliado primeiro?
- Como negar uma condição composta?
- O que é avaliação em curto-circuito?
- Aí você pergunta: posso escrever 0 <= nota <= 10, como na matemática?
- Quais são os erros mais comuns com operadores relacionais e lógicos?
- Agora é com você!
Operadores relacionais comparam dois valores e respondem verdadeiro ou falso. Operadores lógicos juntam essas respostas em uma só, com as ideias de “e”, “ou” e “não”. É com eles que se escrevem as condições de um programa.
Toda estrutura condicional e todo laço de repetição dependem de uma condição, e você já escreveu várias sem pensar muito nelas. O resultado de uma condição é do tipo lógico, um dos quatro tipos de dados básicos. E, assim como os operadores aritméticos, estes também têm uma ordem de precedência.
Pense na portaria de um show. O segurança faz duas perguntas: “Tem mais de 18 anos?” e “Está com o ingresso?”. Cada pergunta só admite sim ou não. Para entrar, as duas respostas precisam ser sim. Já na fila preferencial, basta uma: ser idoso ou estar com criança de colo. No primeiro caso, as respostas foram ligadas por “e”. No segundo, por “ou”. O computador faz as mesmas perguntas e as combina do mesmo jeito.

O que são operadores relacionais e lógicos?
| Significado | Python | PHP | C |
|---|---|---|---|
| igual | == | == | == |
| diferente | != | != | != |
| maior e menor | > e < | > e < | > e < |
| maior ou igual e menor ou igual | >= e <= | >= e <= | >= e <= |
| E | and | && | && |
| OU | or | || | || |
| NÃO | not | ! | ! |
Os relacionais são iguais nas três linguagens. Os lógicos mudam de roupa: Python usa palavras em inglês, e PHP e C usam símbolos. ATENÇÃO: a igualdade é escrita com dois sinais, ==. Um sinal só é atribuição.
Como funcionam o E, o OU e o NÃO?
- E: o resultado é verdadeiro somente se as duas condições forem verdadeiras.
- OU: o resultado é verdadeiro se pelo menos uma das condições for verdadeira. Ele só é falso quando as duas são falsas.
- NÃO: inverte. O que era verdadeiro vira falso, e o que era falso vira verdadeiro.
A forma organizada de mostrar isso é a tabela-verdade, que lista todas as combinações possíveis.

Uma diferença em relação à fala do dia a dia: o OU da programação inclui o caso em que as duas condições são verdadeiras. Quem é idoso e está com criança de colo também entra na fila preferencial.
Como usar operadores relacionais e lógicos em Python, PHP e C?
O programa faz as comparações da portaria, imprime a tabela-verdade, testa um intervalo e termina com dois pontos que costumam confundir: a precedência entre E e OU, e a negação de uma condição composta.
Python:
# Operadores relacionais e lógicos: comparações e combinações de condições
def texto(valor):
return "verdadeiro" if valor else "falso"
idade = 20
tem_ingresso = False
# relacionais: comparam dois valores e respondem verdadeiro ou falso
print("idade >= 18:", texto(idade >= 18))
print("idade == 20:", texto(idade == 20))
print("idade != 20:", texto(idade != 20))
print("idade < 12:", texto(idade < 12))
# lógicos: combinam respostas
print("maior de idade E tem ingresso:", texto(idade >= 18 and tem_ingresso))
print("maior de idade OU tem ingresso:", texto(idade >= 18 or tem_ingresso))
print("NÃO tem ingresso:", texto(not tem_ingresso))
# tabela-verdade
print("A B A e B A ou B")
for a in [True, False]:
for b in [True, False]:
print("%-10s %-10s %-10s %s" % (texto(a), texto(b), texto(a and b), texto(a or b)))
# intervalo: a nota está entre 0 e 10?
nota = 7.5
print("nota entre 0 e 10:", texto(nota >= 0 and nota <= 10))
# desconto para menores de 12 ou a partir de 60 anos
print("tem desconto aos 20 anos:", texto(idade < 12 or idade >= 60))
# precedência: o E é avaliado antes do OU
print("verdadeiro ou falso e falso:", texto(True or False and False))
print("(verdadeiro ou falso) e falso:", texto((True or False) and False))
# negar um E é o mesmo que negar cada parte e trocar por OU
iguais = 0
for a in [True, False]:
for b in [True, False]:
if (not (a and b)) == ((not a) or (not b)):
iguais += 1
print("não (A e B) igual a (não A) ou (não B):", iguais, "de 4 casos")
PHP:
<?php
// Operadores relacionais e lógicos: comparações e combinações de condições
function texto(bool $valor): string {
return $valor ? "verdadeiro" : "falso";
}
$idade = 20;
$tem_ingresso = false;
// relacionais: comparam dois valores e respondem verdadeiro ou falso
echo "idade >= 18: " . texto($idade >= 18) . "\n";
echo "idade == 20: " . texto($idade == 20) . "\n";
echo "idade != 20: " . texto($idade != 20) . "\n";
echo "idade < 12: " . texto($idade < 12) . "\n";
// lógicos: combinam respostas
echo "maior de idade E tem ingresso: " . texto($idade >= 18 && $tem_ingresso) . "\n";
echo "maior de idade OU tem ingresso: " . texto($idade >= 18 || $tem_ingresso) . "\n";
echo "NÃO tem ingresso: " . texto(!$tem_ingresso) . "\n";
// tabela-verdade
echo "A B A e B A ou B\n";
foreach ([true, false] as $a) {
foreach ([true, false] as $b) {
printf("%-10s %-10s %-10s %s\n", texto($a), texto($b), texto($a && $b), texto($a || $b));
}
}
// intervalo: a nota está entre 0 e 10?
$nota = 7.5;
echo "nota entre 0 e 10: " . texto($nota >= 0 && $nota <= 10) . "\n";
// desconto para menores de 12 ou a partir de 60 anos
echo "tem desconto aos 20 anos: " . texto($idade < 12 || $idade >= 60) . "\n";
// precedência: o E é avaliado antes do OU
echo "verdadeiro ou falso e falso: " . texto(true || false && false) . "\n";
echo "(verdadeiro ou falso) e falso: " . texto((true || false) && false) . "\n";
// negar um E é o mesmo que negar cada parte e trocar por OU
$iguais = 0;
foreach ([true, false] as $a) {
foreach ([true, false] as $b) {
if ((!($a && $b)) == ((!$a) || (!$b))) {
$iguais++;
}
}
}
echo "não (A e B) igual a (não A) ou (não B): $iguais de 4 casos\n";
C:
/* Operadores relacionais e lógicos: comparações e combinações de condições */
#include <stdio.h>
#include <stdbool.h>
const char *texto(bool valor) {
return valor ? "verdadeiro" : "falso";
}
int main(void) {
int idade = 20;
bool tem_ingresso = false;
bool valores[] = {true, false};
/* relacionais: comparam dois valores e respondem verdadeiro ou falso */
printf("idade >= 18: %s\n", texto(idade >= 18));
printf("idade == 20: %s\n", texto(idade == 20));
printf("idade != 20: %s\n", texto(idade != 20));
printf("idade < 12: %s\n", texto(idade < 12));
/* lógicos: combinam respostas */
printf("maior de idade E tem ingresso: %s\n", texto(idade >= 18 && tem_ingresso));
printf("maior de idade OU tem ingresso: %s\n", texto(idade >= 18 || tem_ingresso));
printf("NÃO tem ingresso: %s\n", texto(!tem_ingresso));
/* tabela-verdade */
printf("A B A e B A ou B\n");
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
bool a = valores[i], b = valores[j];
printf("%-10s %-10s %-10s %s\n", texto(a), texto(b), texto(a && b), texto(a || b));
}
}
/* intervalo: a nota está entre 0 e 10? */
double nota = 7.5;
printf("nota entre 0 e 10: %s\n", texto(nota >= 0 && nota <= 10));
/* desconto para menores de 12 ou a partir de 60 anos */
printf("tem desconto aos 20 anos: %s\n", texto(idade < 12 || idade >= 60));
/* precedência: o E é avaliado antes do OU */
printf("verdadeiro ou falso e falso: %s\n", texto(true || false && false));
printf("(verdadeiro ou falso) e falso: %s\n", texto((true || false) && false));
/* negar um E é o mesmo que negar cada parte e trocar por OU */
int iguais = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
bool a = valores[i], b = valores[j];
if ((!(a && b)) == ((!a) || (!b))) {
iguais++;
}
}
}
printf("não (A e B) igual a (não A) ou (não B): %d de 4 casos\n", iguais);
return 0;
}
Saída:
idade >= 18: verdadeiro idade == 20: verdadeiro idade != 20: falso idade < 12: falso maior de idade E tem ingresso: falso maior de idade OU tem ingresso: verdadeiro NÃO tem ingresso: verdadeiro A B A e B A ou B verdadeiro verdadeiro verdadeiro verdadeiro verdadeiro falso falso verdadeiro falso verdadeiro falso verdadeiro falso falso falso falso nota entre 0 e 10: verdadeiro tem desconto aos 20 anos: falso verdadeiro ou falso e falso: verdadeiro (verdadeiro ou falso) e falso: falso não (A e B) igual a (não A) ou (não B): 4 de 4 casos
Mesma saída nas três linguagens. Foque no conceito, e não na linguagem!

Qual operador é avaliado primeiro?
Nas três linguagens, as contas aritméticas vêm antes das comparações, as comparações vêm antes do E, e o E vem antes do OU. A posição do NÃO muda: em C e em PHP, ele é aplicado antes das comparações; em Python, depois delas. Por isso, para negar uma comparação, coloque-a entre parênteses, como em não (x == y).
É por isso que a expressão verdadeiro ou falso e falso deu verdadeiro. O E foi resolvido antes: falso e falso dá falso. Depois, verdadeiro ou falso dá verdadeiro. Com parênteses em volta do OU, o resultado mudou para falso.
Sacou? Quando misturar E e OU na mesma condição, coloque parênteses. O compilador de C chega a sugerir isso: ao compilar o programa do artigo com os avisos ligados, ele mostra warning: suggest parentheses around ‘&&’ within ‘||’.
Como negar uma condição composta?
A última linha da saída confere uma equivalência útil: negar “A e B” dá o mesmo resultado que “não A ou não B”. O programa testou as 4 combinações, e as 4 bateram.
Na prática: o contrário de “tem mais de 18 e tem ingresso” não é “tem menos de 18 e não tem ingresso”. É “tem menos de 18 ou não tem ingresso”. Basta falhar em uma das exigências para ficar de fora.
O que é avaliação em curto-circuito?
É a economia que as três linguagens fazem: a avaliação para assim que o resultado já é conhecido. Se a primeira parte de um E é falsa, o resultado é falso, e a segunda parte não é avaliada. Se a primeira parte de um OU é verdadeira, o resultado é verdadeiro, e a segunda parte também não é avaliada.
Para enxergar isso, a função abaixo avisa toda vez que é chamada.
Python:
# Curto-circuito: a segunda condição só é avaliada quando faz falta
def avaliar(nome, valor):
print(" avaliou", nome)
return valor
print("A falso, A e B:")
r = avaliar("A", False) and avaliar("B", True)
print("A verdadeiro, A e B:")
r = avaliar("A", True) and avaliar("B", True)
print("A verdadeiro, A ou B:")
r = avaliar("A", True) or avaliar("B", False)
print("A falso, A ou B:")
r = avaliar("A", False) or avaliar("B", False)
# uso prático: a primeira condição protege a segunda
divisor = 0
seguro = divisor != 0 and 10 / divisor > 2
print("divisor 0, teste protegido:", "verdadeiro" if seguro else "falso")
PHP:
<?php
// Curto-circuito: a segunda condição só é avaliada quando faz falta
function avaliar(string $nome, bool $valor): bool {
echo " avaliou $nome\n";
return $valor;
}
echo "A falso, A e B:\n";
$r = avaliar("A", false) && avaliar("B", true);
echo "A verdadeiro, A e B:\n";
$r = avaliar("A", true) && avaliar("B", true);
echo "A verdadeiro, A ou B:\n";
$r = avaliar("A", true) || avaliar("B", false);
echo "A falso, A ou B:\n";
$r = avaliar("A", false) || avaliar("B", false);
// uso prático: a primeira condição protege a segunda
$divisor = 0;
$seguro = $divisor != 0 && 10 / $divisor > 2;
echo "divisor 0, teste protegido: " . ($seguro ? "verdadeiro" : "falso") . "\n";
C:
/* Curto-circuito: a segunda condição só é avaliada quando faz falta */
#include <stdio.h>
#include <stdbool.h>
bool avaliar(const char *nome, bool valor) {
printf(" avaliou %s\n", nome);
return valor;
}
int main(void) {
bool r;
printf("A falso, A e B:\n");
r = avaliar("A", false) && avaliar("B", true);
printf("A verdadeiro, A e B:\n");
r = avaliar("A", true) && avaliar("B", true);
printf("A verdadeiro, A ou B:\n");
r = avaliar("A", true) || avaliar("B", false);
printf("A falso, A ou B:\n");
r = avaliar("A", false) || avaliar("B", false);
(void) r;
/* uso prático: a primeira condição protege a segunda */
int divisor = 0;
bool seguro = divisor != 0 && 10 / divisor > 2;
printf("divisor 0, teste protegido: %s\n", seguro ? "verdadeiro" : "falso");
return 0;
}
Saída:
A falso, A e B: avaliou A A verdadeiro, A e B: avaliou A avaliou B A verdadeiro, A ou B: avaliou A A falso, A ou B: avaliou A avaliou B divisor 0, teste protegido: falso
Ver a animação do curto-circuito

A última linha mostra para que isso serve. Com divisor igual a zero, a conta 10 / divisor daria erro. Mas ela vem depois de divisor != 0, que é falso. A divisão nunca é executada. Quem diria… A ordem em que você escreve as condições pode evitar um erro.
Aí você pergunta: posso escrever 0 <= nota <= 10, como na matemática?
Só em Python. E aqui mora uma armadilha, porque as três linguagens reagem de formas diferentes à mesma escrita.
Em Python, as comparações podem ser encadeadas, e o resultado é o esperado:
# Python: comparações podem ser encadeadas
print(1 < 5 < 3)
print(0 <= 7.5 <= 10)
print("10" == 10)
Saída:
False True False
Em C, a expressão 1 < 5 < 3 compila e dá a resposta errada:
/* C: o resultado de uma comparação é o inteiro 1 ou 0 */
#include <stdio.h>
int main(void) {
printf("%d %d\n", 5 > 3, 5 < 3);
printf("%d\n", 1 < 5 < 3);
return 0;
}
Saída:
1 0 1
ATENÇÃO: em C, o resultado de uma comparação é o inteiro 1 (verdadeiro) ou 0 (falso). A expressão é resolvida da esquerda para a direita: 1 < 5 dá 1, e depois 1 < 3 dá 1. O programa responde “verdadeiro” para uma frase que é falsa. O compilador avisa: comparisons like ‘X<=Y<=Z’ do not have their mathematical meaning.
Em PHP, a mesma expressão nem roda:
Parse error: syntax error, unexpected token "<"
A forma que funciona nas três é a do programa principal: duas comparações ligadas por E, como em nota >= 0 e nota <= 10.
O PHP tem ainda uma particularidade na igualdade. O operador == compara depois de converter os tipos. O operador ===, com três sinais, só dá verdadeiro se o valor e o tipo forem iguais.
<?php
// PHP: == compara depois de converter; === compara valor e tipo
var_dump("10" == 10);
var_dump("10" === 10);
var_dump("1" == "01");
var_dump("1" === "01");
var_dump(0 == "a");
Saída:
bool(true) bool(false) bool(true) bool(false) bool(false)
O texto “10” é igual ao número 10 para o ==, mas não para o ===. O manual do PHP recomenda o === na maioria dos casos. Em Python, a terceira linha do exemplo anterior mostra que “10” == 10 é falso: não há conversão.
Quais são os erros mais comuns com operadores relacionais e lógicos?
- Usar = no lugar de ==. Um sinal atribui. Dois sinais comparam.
- Encadear comparações fora do Python. Em C, 1 < 5 < 3 dá verdadeiro. Use duas comparações com E.
- Trocar E por OU. “Entre 0 e 10” é nota >= 0 E nota <= 10. Com OU, qualquer número passaria.
- Esquecer a precedência. O E é avaliado antes do OU. Use parênteses.
- Negar só uma parte. O contrário de “A e B” é “não A ou não B”.
- Repetir pela metade. A expressão idade == 18 ou 19 não faz o que parece. O certo é idade == 18 ou idade == 19.
- Confiar no == do PHP entre tipos diferentes. Prefira o ===.
- Colocar primeiro a condição que pode dar erro. A condição que protege vem antes.
Agora é com você!
No papel:
- Com x = 7 e y = 3, diga o resultado de: x > 5 e y > 5; x > 5 ou y > 5; não (x == y).
- Monte a tabela-verdade de “A e (não B)”.
- Escreva o contrário de “idade >= 18 ou acompanhado” sem usar o NÃO na frente da expressão inteira.
No computador:
- Escreva a condição que diz se um ano está no século XXI (de 2001 a 2100) e teste com 2000, 2001, 2100 e 2101.
- Um cinema dá meia-entrada para quem tem menos de 12 anos, 60 anos ou mais, ou é estudante. Programe e teste com quatro pessoas diferentes.
- Use a função avaliar do artigo para descobrir quantas vezes ela é chamada em A ou B ou C quando só C é verdadeiro.
Tente sozinho, sem pedir a resposta pronta para ninguém, nem para a IA!
Até o próximo artigo!
Confiança Sempre!!!
Fontes:
- Manual do PHP, Operadores de Comparação, com a lista de operadores, a diferença entre igual e idêntico, a comparação entre texto numérico e número e a recomendação do operador de três sinais.
- Manual do PHP, Operadores Lógicos, com o resultado de cada operador lógico e os exemplos de avaliação em curto-circuito.
- Manual do PHP, Precedência de Operadores, com a ordem entre aritméticos, comparações, E e OU.
- Documentação do Python, Expressions, com as comparações encadeadas, os operadores and, or e not, o curto-circuito e a precedência (em inglês).
- Instituto Federal do Rio Grande do Norte, Fundamentos de Programação, Operadores e Expressões, com os operadores relacionais e lógicos e a precedência entre eles, da negação ao OU (PDF, slides de aula).
- Instituto Federal do Paraná, Lógica de Programação, Operadores, com os operadores lógicos E, OU e de negação, usados em expressões condicionais (PDF, slides de aula).
- Universidade Tecnológica Federal do Paraná, notas de aula de Linguagem C, com a regra de que valores diferentes de zero são verdadeiros em C e a tabela da verdade (documento de aula).
- Universidade Federal de Santa Catarina, Curso de Programação C, Operadores, com os operadores lógicos usados para formar condições mais complexas a partir de condições simples (slides de aula).
- Universidade Federal do Vale do São Francisco, Introdução à Linguagem C, com a hierarquia dos operadores relacionais e lógicos (PDF, slides de aula).
- Os exemplos foram executados em Python 3.13, PHP 8.3 e GCC 13.

Continue a conversa