Valores lógicos

Suponha que expressemos uma dúvida como "Hoje é dia 23?". Considerando a lógica clássica, esta dúvida admite apenas dois possíveis resultados: verdade ou falso. Caso esta sentença seja verdadeira, dizemos que seu valor lógico é verdade. Em caso contrário dizemos que o valor lógico é falso.

Em Python há o tipo de dado "bool" que expressa exatamente esta situação, sendo estes valores representados pelas palavras inglesas True e False. Estes valores podem ser utilizados de forma similar ao que fizemos com números e strings.

# Assim como os números e os strings, os valores lógicos pode ser atribuído a variáveis e impressos
a = True
b = False
print(a, b)

Operadores Relacionais

Os operadores relacionais servem para relacionar valores, no sentido de compará-los. No caso de números, por exemplo, os operadores relacionais clássicos permitem verificar se dois números são:

Operação	Operador relacional
iguais	==
diferentes	!=
um maior que o outro	>
um menor que o menor	<
maior ou igual	>=
menor ou igual	<=

Note que o resultado de uma expressão envolvendo operadores relacionais é sempre um valor lógico verdade ou falso (True ou False, em Python).

# Verificando se um valor é maior ou igual a 10
x = 4
print(x >= 10)

# Verificando se um número é par
y = 14
eh_par = y % 2 == 0
print(eh_par)

# Verificar se os valores denotados pelas duas variáveis são iguais
x == y

# Verificar se os valores denotados pelas duas variáveis são diferentes
x != y

# Verificar se o valor de x é maior que o valor de y 
x > y

# Verificar se o valor de x é menor que o valor de y 
x < y

# Verificar se o valor de x é maior ou igual ao valor de y 
x >= y

# Verificar se o valor de x é menor ou igual ao valor de y 
x <= y

Operadores ou Conectivos Lógicos

Duas expressões que denotem valores lógicos podem ser combinadas por meio dos conectivos lógicos E, OU, e NÃO.

Conjunção: E (∧)

• a > 5 ∧ b = 7

Nesta expressão temos duas subexpressões relacionais:

• p: a > 5
• q: b = 7

cada uma delas resultando num valor lógico (Verdade ou Falso). Estes valores lógicos são, então, combinados por meio do conectivo lógico E (conjunção), cujo resultado é expresso na tabela abaixo:

Em Python esta expressão pode ser expressa por:

• a > 5 and b == 7

#Em Python esta expressão pode ser expressa por:
a = 10
b = 3
resultado = a > 5 and b == 7
print(resultado)

Disjunção: OU (∨)

• a > 5 ∨ b < 7

Nesta expressão temos duas subexpressões relacionais:

• p: a > 5
• q: b < 7

cada uma delas resultando num valor lógico (Verdade ou Falso). Estes valores lógicos são, então, combinados por meio do conectivo lógico OU (disjunção), cujo resultado é expresso na tabela abaixo:

#Em Python esta expressão pode ser expressa por:
a = 10
b = 3
resultado = a > 5 or b < 7
print(resultado)

Negação: NÃO (~)

• ~V = F
• ~F = V

# Operador de negação em Python
a = 3
b = not (a > 15)
print(b)

# Para
a = 4

# a expressão abaixo é válida em Python (pode não ser válida em outras linguagens)
print(3 <= a < 5)

# expressão equivalente a:
print(3 <= a and a < 5)

Ordem de avaliação dos operadores

Se numa mesma expressão houver mais de um tipo de operador, eles são resolvidos segundo a prevalência abaixo:

1. Operadores aritméticos
2. Operadores relacionais
3. Operadores lógicos

# Operadores aritméticos precedem os relacionais
a = 5
b = 3

a < b * 3 # expressão equivalente:  a < (b * 3)

# Operadores relacionais precedem os lógicos
a = 5
b = 0

a > 3 and b < 1 # expressão equivalente:  (a > 3) and (b < 1)

# Expressão mista

a = 5
b = 3

a + 2 * 7 > b + 5 and b * 2 == a ** 3 + 2

#expressao equivalente: ( (a + 2 * 7) > (b + 5) ) and ( (b * 2) == (a ** 3 + 2) )

Resumo da ordem de avaliação de alguns operadores (os mais usuais)

Lista completa na documentação de Python.

Nível	Categoria	Operadores
7 (mais alto)	aritmético	**
6	aritmético	*,/,//,%
5	aritmético	+,-
4	relacional	==,!=,<=,>=,>,<, in, not in
3	lógico	not
2	lógico	and
1 (mais baixo)	lógico	or

Leis de De Morgan

1ª) ~(p ∧ q) = ~p ∨ ~q

p	q	p ∧ q	~(p ∧ q)	~p	~q	~p ∨ ~q
V	V	V	F	F	F	F
V	F	F	V	F	V	V
F	V	F	V	V	F	V
F	F	F	V	V	V	V

2ª) ~(p ∨ q) = ~p ∧ ~q

p	q	p ∨ q	~(p ∨ q)	~p	~q	~p ∧ ~q
V	V	V	F	F	F	F
V	F	V	F	F	V	F
F	V	V	F	V	F	F
F	F	F	V	V	V	V

# Exemplo da 1ª lei de De Morgan: ~(p ∧ q) = ~p ∨ ~q
a = 5
b = 3

p = a > 3
q = b < 1

e1 = not(p and q)
e2 = not p or not q
print(e1, e2)

# Exemplo da 2ª lei de De Morgan: ~(p ∨ q) = ~p ∧ ~q
a = 5
b = 3

p = a > 3
q = b < 1

e1 = not(p or q)
e2 = not p and not q
print(e1, e2)