Algoritmos

Operadores relacionais e lógicos: a portaria do seu programa

Capa do artigo Operadores relacionais e lógicos: a portaria do seu programa
Leitura com foco

Entenda o contexto.
Leve para a prática.

Neste artigo
  1. O que são operadores relacionais e lógicos?
  2. Como funcionam o E, o OU e o NÃO?
  3. Como usar operadores relacionais e lógicos em Python, PHP e C?
  4. Qual operador é avaliado primeiro?
  5. Como negar uma condição composta?
  6. O que é avaliação em curto-circuito?
  7. Aí você pergunta: posso escrever 0 <= nota <= 10, como na matemática?
  8. Quais são os erros mais comuns com operadores relacionais e lógicos?
  9. 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.

História em quadrinhos em três quadros na portaria de um show: o segurança pergunta se a pessoa tem mais de 18 anos e se está com o ingresso; com duas respostas sim, ela pode entrar
O operador “e” na portaria: só entra quem responde sim às duas perguntas.

O que são operadores relacionais e lógicos?

SignificadoPythonPHPC
igual======
diferente!=!=!=
maior e menor> e <> e <> e <
maior ou igual e menor ou igual>= e <=>= e <=>= e <=
Eand&&&&
OUor||||
NÃOnot!!
Os operadores relacionais (quatro primeiras linhas) e os lógicos (três últimas).

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.

Tabela-verdade dos operadores E, OU e NÃO: o E só é verdadeiro quando A e B são verdadeiros, o OU só é falso quando os dois são falsos e o NÃO inverte o valor
Com duas condições, existem quatro combinações. A tabela mostra o resultado de cada uma.

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!

Avaliação de idade maior ou igual a 18 e tem_ingresso com idade 20 e sem ingresso: a comparação dá verdadeiro, o ingresso é falso e o resultado de verdadeiro e falso é falso
Primeiro cada comparação é resolvida. Só depois o operador lógico junta os resultados.

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
Animação da avaliação em curto-circuito: com E, se A é falso, B não é avaliado; com OU, se A é verdadeiro, B não é avaliado
Quando a primeira condição já decide o resultado, a segunda fica de fora.

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:

Compartilhe este artigo

Sobre quem escreve

Walmir Silva

Olá! Sou Walmir, engenheiro de software com MBA em Engenharia de Software e o cérebro por trás do GrowthCode e autor do livro "Além do Código".

Se você acha que programação é apenas sobre escrever código, prepare-se para expandir seus horizontes. Aqui, nós vamos além do código e exploramos as interseções fascinantes entre tecnologia, negócios, artes e filosofia.

Você está em busca de crescimento na carreira? Quer se destacar em um mercado competitivo? Almeja uma vida mais rica em conhecimento e realização? Então você chegou ao lugar certo. No GrowthCode, oferecemos insights profundos, estratégias comprovadas e um toque de sabedoria filosófica para catalisar seu crescimento pessoal e profissional.

Ver todos os artigos →

Continue a conversa

Compartilhe sua perspectiva

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Guardamos o IP e o navegador de quem comenta por 6 meses, para barrar spam e porque o Marco Civil da Internet pede a guarda dos registros de acesso por esse prazo. Veja como tratamos seus dados.

Encontre sua próxima resposta

O que você quer aprender?

Preferências de cookies

Os cookies opcionais começam desligados. Você pode mudar a escolha a qualquer momento por esta tela.

NecessáriosSempre ativos

Guardam a sua escolha de cookies e o código do registro dela, e mantêm o site funcionando. Não são usados para publicidade.

Contam visitas e mostram como o site é usado: Google Analytics e Microsoft Clarity, carregados pelo Google Tag Manager.

Exibem anúncios do Google AdSense sem personalização. Os cookies desta categoria limitam a repetição dos anúncios e medem o resultado deles.

Usa a sua navegação para escolher anúncios e formar públicos de anúncio: anúncios do Google escolhidos pelos seus interesses e os indicadores do Google no Analytics. Desligado, os anúncios aparecem sem personalização. Depende de Publicidade.

Também é possível bloquear cookies nas configurações do navegador. Detalhes na Política de privacidade.