3.7 Testes lógicos

Poder fazer qualquer tipo de operação lógica é um dos motivos pelos quais programar nos deixar mais eficientes. Dê bastante atenção a elas, pois usaremos comparações lógicas o tempo todo!

Uma operação lógica nada mais é do que um teste que retorna verdadeiro ou falso. No R (e em outras linguagens de programação), esses valores dois valores recebem uma classe especial: logical.

O verdadeiro no R vai ser representado pelo valor TRUE e o falso pelo valor FALSE. Esses nomes no R são reservados, isto é, você não pode chamar nenhum objeto de TRUE ou FALSE.

TRUE <- 1
## Error in TRUE <- 1 : invalid (do_set) left-hand side to assignment

Checando a classe desses valores, vemos que são lógicos6. Eles são os únicos possíveis valores dessa classe.

class(TRUE)
## [1] "logical"
class(FALSE)
## [1] "logical"

Agora que conhecemos o TRUE e FALSE, podemos explorar os teste lógicos. Começando pelo mais simples: vamos testar se um valor é igual ao outro. Para isso, usamos o operador ==.

# Testes com resultado verdadeiro
1 == 1
## [1] TRUE
"a" == "a"
## [1] TRUE

# Testes com resultado falso
1 == 2
## [1] FALSE
"a" == "b"
## [1] FALSE

Também podemos testar se dois valores são diferentes. Para isso, usamos o operador !=.

# Testes com resultado falso
1 != 1
## [1] FALSE
"a" != "a"
## [1] FALSE

# Testes com resultado verdadeiro
1 != 2
## [1] TRUE
"a" != "b"
## [1] TRUE

Para comparar se um valor é maior que outro, temos à disposição 4 operadores:

# Maior
3 > 3
## [1] FALSE
3 > 2
## [1] TRUE

# Maior ou igual
3 > 4
## [1] FALSE
3 >= 3
## [1] TRUE

# Menor 
3 < 3
## [1] FALSE
3 < 4
## [1] TRUE

# Menor ou igual
3 < 2
## [1] FALSE
3 <= 3
## [1] TRUE

Um outro operador muito útil é o %in%. Com ele, podemos verificar se um valor está dentro de um conjunto de valores (vetor).

3 %in% c(1, 2, 3)
## [1] TRUE
"a" %in% c("b", "c")
## [1] FALSE

Nós começamos essa seção dizendo que usaremos testes lógicos o tempo todo. O motivo para isso é que eles fazem parte de uma operação muito comum na manipulação de base de dados: os filtros.

No Excel, por exemplo, quando você filtra uma planilha, o que está sendo feito por trás é um teste lógico.

Falamos anteriormente que cada coluna das nossas bases de dados será representada dentro do R como um vetor. O comportamento que explica a importância dos testes lógicos na hora de filtrar uma base está ilustrado abaixo:

minha_coluna <- c(1, 3, 0, 10, -1, 5, 20)

minha_coluna > 3
## [1] FALSE FALSE FALSE  TRUE FALSE  TRUE  TRUE

minha_coluna[minha_coluna > 3]
## [1] 10  5 20

Muitas coisas aconteceram aqui, vamos por partes.

Primeiro, na operação minha_coluna > 3 o R fez um excelente uso do comportamento de reciclagem. No fundo, o que ele fez foi transformar (reciclar) o valor 3 no vetor c(3, 3, 3, 3, 3, 3, 3) e testar se c(1, 3, 0, 10, -1, 5, 20) > c(3, 3, 3, 3, 3, 3, 3).

Como os operadores lógicos também são vetorizados (fazem operações elemento a elemento), os testes realizados foram 1 > 3, 3 > 3, 0 > 3, 10 > 3, -1 > 3, 5 > 3 e, finalmente, 20 > 3. Cada um desses testes tem o seu próprio resultado. Por isso a saída de minha_coluna > 3 é um vetor de verdadeiros e falsos, respectivos a cada um desses 7 testes.

A segunda operação traz a grande novidade aqui: podemos usar os valores TRUE e FALSE para selecionar elementos de um vetor!

A regra é muito simples: retornar as posições que receberem TRUE, não retornar as posições que receberem FALSE. Portanto, a segunda operação é equivalente a:

minha_coluna[c(FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE)]
## [1] 10  5 20

O vetor lógico filtra o vetor minha_coluna, retornando apenas os valores maiores que 3, já que foi esse o teste lógico que fizemos.

Essa é a mágica que acontece por trás de filtros no R. Na prática, não precisaremos usar colchetes, não lembraremos da reciclagem e nem veremos a cara dos TRUE e FALSE. Mas conhecer esse processo é muito importante, principalmente para encontrar problemas de código ou de base.

A seguir, apresentamos uma tabela com os principais operadores lógicos:

Para finalizar, listamos na tabela abaixo os principais operadores lógicos.

Operador Descrição
x < y x menor que y?
x <= y x menor ou igual a y?
x > y x maior que y?
x >= y x maior ou igual a y?
x == y x igual a y?
x != y x diferente de y?
!x Negativa de x
x | y x ou y são verdadeiros?
x & y x e y são verdadeiros?
x %in% y x percente a y?
xor(x, y) x ou y são verdadeiros (apenas um deles)?

Por fim, veja algumas diferenças entre comparações lógicas no SQL e no R:

  • Igualdade: no SQL é só um sinal de igual: 2 = 1. No R são dois: 2 == 1.
  • Diferença: no SQL, usamos <>. No R usamos !=.
  • Negação: em vez de usar a palavra NOT igual ao SQL, usamos ! no R. Por exemplo, id not in ('1', '2', '3') fica !(id %in% c(1, 2, 3)).

  1. Também conhecidos como valores binários ou booleanos↩︎


Curso-R