Booleanos em Python - #06
Tags: python, programming, tutorial, beginners
Published: 2022-04-21 19:04:02

{% youtube https://youtu.be/b-tWaGyz7u4 %}

## Introdução

Enquanto valores numéricos possuem uma infinidade de valores possíveis, os valores booleanos só possuem dois valores possíveis: **verdadeiro (True) ou falso (False)**.

Neste capítulos vamos explorar as variáveis e valores booleanos e as operações que podemos executar com estes valores.


## Valores Booleanos

Variáveis booleanas só podem receber como valores **True** ou **False**. Atenção, o primeiro caractere é em letra maiúscula, T ou F, e um erro será gerado se você não respeitar esta regra.

```python
#Valores booleanos True ou False
>>> autorizado = True
>>> autorizado
True

>>> autorizado = False
>>> autorizado
False

>>> autorizado = true
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'true' is not defined. Did you mean: 'True'?
```

## Operadores relacionais

Os operadores relacionais são operadores que retornam um valor **booleano**, e utilizados para comparar valores.

<table>
  <tr>
   <td><em>Operadores Relacionais</em>
   </td>
   <td><em>Representação</em>
   </td>
   <td><em>Exemplo</em>
   </td>
  </tr>
  <tr>
   <td><em>igual</em>
   </td>
   <td><em>==</em>
   </td>
   <td><em>if (A == B) :</em>
   </td>
  </tr>
  <tr>
   <td><em>diferente</em>
   </td>
   <td><em>!=</em>
   </td>
   <td><em>if (A != B) :</em>
   </td>
  </tr>
  <tr>
   <td><em>maior</em>
   </td>
   <td><em>></em>
   </td>
   <td><em>if (A > B) : </em>
   </td>
  </tr>
  <tr>
   <td><em>menor que</em>
   </td>
   <td><em>&lt;</em>
   </td>
   <td><em>if (A &lt; B) :</em>
   </td>
  </tr>
  <tr>
   <td><em>maior ou igual a </em>
   </td>
   <td><em>>=</em>
   </td>
   <td><em>if (A >= B) :</em>
   </td>
  </tr>
  <tr>
   <td><em>menor ou igual a </em>
   </td>
   <td><em>&lt;=</em>
   </td>
   <td><em>if (A &lt;= B) :</em>
   </td>
  </tr>
</table>

```python
#Operadores Relacionais em ação
>>> name = "Joao"

>>> name == "Joao"
True

>>> name == "Jose"
False

>>> 12 > 3
True

>>> 12 != 11
True

>>> 22 <= 22
True

>>> -1 < 0
True
```
O operador == é a igualdade lógica, ele analisa se dois valores são iguais, retornando verdadeiro ou falso. É diferente do operador de atribuição =, que atribui o valor para a variável.

Os operadores == (igual) e != (diferente) são capazes de comparar valores de diferentes tipos de dados, por exemplo, comparar um número com uma **string**. Enquanto os outros operadores só podem ser utilizados na comparação entre números, que podem ser inteiros e de ponto flutuante, ou na comparação entre **strings**.

As **_strings_** possuem a classificação alfabética, isso significa que a ordem alfabética define se uma palavra é maior, menor que outra. Letras minúsculas são “maiores” que as maiúsculas e _strings_ numéricas são menores que “letras”.

Finalmente, valores **_booleanos_**, podem ser considerados numéricos. Em _Python_, o valor **False** é igual a zero e qualquer outro valor é **True**.

Veja alguns exemplos:

```python
#Operadores Relacionais e tipos de dados
>>> 12 == "12"
False

>>> 12 != "12"
True

>>> 15.0 == 15
True

>>> 3 > 2.999
True

>>> "casa" > "abacate"
True

>>> "aviao" >= "abacaxi"
True

>>> "aviao" > "A"
True

>>> "Aviao" > "a"
False

>>> "1" > "a"
False

>>> "0" > "A"
False

>>> "1" < "A"
True

>>> "A" < "a"
True

>>> True ==  1
True

>>> False == 0
True

>>> True == 1.0
True

>>> True == 1.0
True

>>> False == 0
True

>>> True > -2
True

>>> False > -2
True

>>> True > False
True
```

### O valor None

Em _Python_, temos um valor especial “**_None_**”. Ele é utilizado quando definimos uma variável mas não queremos armazenar nenhum valor.

O valor **_None_** pode ser utilizado na igualdade lógica.

```python
#Valor None
>>> idade = None
>>> print(idade)
None

>>> print(idade == None)
True
```

É uma prática comum, definirmos nossas variáveis no início do nosso código e atribuir o valor **_None_** quando não temos os valores a serem utilizados. Desta forma, fica fácil de identificar quais variáveis você tem em sua aplicação.

## Operadores lógicos

Operadores lógicos são operadores que utilizam somente valores **_booleanos_**. 

Como operadores lógicos, temos a **conjunção (and), a disjunção (or) , o ou exclusivo (^) e a negação (_not_)**.

<table>
  <tr>
   <td><em>Operadores Lógicos</em>
   </td>
   <td><em>Representação</em>
   </td>
   <td><em>Exemplo</em>
   </td>
  </tr>
  <tr>
   <td><em>conjunção (e)</em>
   </td>
   <td><em>and</em>
   </td>
   <td><em>A and B</em>
   </td>
  </tr>
  <tr>
   <td><em>disjunção (ou)</em>
   </td>
   <td><em>or</em>
   </td>
   <td><em>A or B</em>
   </td>
  </tr>
  <tr>
   <td><em>ou exclusivo (xor)</em>
   </td>
   <td><em>^</em>
   </td>
   <td><em>A ^ B </em>
   </td>
  </tr>
  <tr>
   <td><em>negação (não)</em>
   </td>
   <td><em>not</em>
   </td>
   <td><em>not A</em>
   </td>
  </tr>
</table>

O operador de negação é o único que possui somente um operando, uma variável ou valor.

### Conjunção ou o “E” lógico (_and_)

A conjunção é o nosso “e” lógico, veja a expressão:
* Se for sábado **E** chover, ficarei em casa assistindo filme.

Quando esta expressão é verdadeira? Quais condições devem ocorrer para que eu fique em casa assistindo filme? Ora, para ficar em casa assistindo filme, tem que ser sábado E estar chovendo. Ambas devem ser satisfeitas! 

Se tomarmos:
* variável A = hoje é sábado
* variável B = está chovendo

E os possíveis valores para **_A_** (verdadeiro ou falso) e para **B** (verdadeiro ou falso), podemos montar a seguinte tabela (denominada tabela-verdade) com todas as possibilidades e possíveis valores para o **and**.

<table>
  <tr>
   <td><em>Variável A</em>
   </td>
   <td><em>Variável B</em>
   </td>
   <td><em>and</em>
   </td>
  </tr>
  <tr>
   <td><strong><em>Verdade</em></strong>
   </td>
   <td><strong><em>Verdade</em></strong>
   </td>
   <td><strong><em>Verdade</em></strong>
   </td>
  </tr>
  <tr>
   <td><em>Verdade</em>
   </td>
   <td><em>Falso</em>
   </td>
   <td><em>Falso</em>
   </td>
  </tr>
  <tr>
   <td><em>Falso</em>
   </td>
   <td><em>Verdade</em>
   </td>
   <td><em>Falso</em>
   </td>
  </tr>
  <tr>
   <td><em>Falso</em>
   </td>
   <td><em>Falso</em>
   </td>
   <td><em>Falso</em>
   </td>
  </tr>
</table>

**CONCLUSÃO: uma conjunção, (_A and B_), é verdadeira somente se ambos os valores forem verdadeiros. Somente se _A_ é verdadeiro e _B_ é verdadeiro**.

### Disjunção ou o “OU” lógico (or)

A disjunção ou o “ou” lógico é diferente do “ou” falado no português. Veja a seguinte sentença:
* Quando vou ao trabalho OU de trem OU de ônibus, levo meu almoço.

Analisando a expressão acima, quando vou ao trabalho de trem, levarei meu almoço. Assim como, quando vou ao trabalho de ônibus, também levo meu almoço. Mas a sutileza é que se AMBOS forem verdadeiros, eu também levarei meu almoço.

Representando:
* variável A = vou de trem
* variável B = vou de ônibus

Teremos a seguinte tabela verdade, para o operador OU (or)

<table>
  <tr>
   <td><em>Variável A</em>
   </td>
   <td><em>Variável B</em>
   </td>
   <td><em>or</em>
   </td>
  </tr>
  <tr>
   <td><em>Verdade</em>
   </td>
   <td><em>Verdade</em>
   </td>
   <td><em>Verdade</em>
   </td>
  </tr>
  <tr>
   <td><em>Verdade</em>
   </td>
   <td><em>Falso</em>
   </td>
   <td><em>Verdade</em>
   </td>
  </tr>
  <tr>
   <td><em>Falso</em>
   </td>
   <td><em>Verdade</em>
   </td>
   <td><em>Verdade</em>
   </td>
  </tr>
  <tr>
   <td><strong><em>Falso</em></strong>
   </td>
   <td><strong><em>Falso</em></strong>
   </td>
   <td><strong><em>Falso</em></strong>
   </td>
  </tr>
</table>

**CONCLUSÃO: uma disjunção, (_A or B_),  é verdadeira se pelo menos um dos valores for verdadeiro, seja A, seja B ou ambos**.

### Ou exclusivo (^)

O “ou” exclusivo é mais próximo do “ou” falado no português, ele só retorna verdade se somente uma condição é verdadeira. Veja a seguinte sentença:
* Ou João está trabalhando ou João está descansando

Representando:
* variável A = João está trabalhando
* variável B =  João está descansando

Teremos a seguinte tabela verdade, para o operador OU-EXCLUSIVO (^)

<table>
  <tr>
   <td><em>Variável A</em>
   </td>
   <td><em>Variável B</em>
   </td>
   <td><em>^</em>
   </td>
  </tr>
  <tr>
   <td><strong><em>Verdade</em></strong>
   </td>
   <td><strong><em>Verdade</em></strong>
   </td>
   <td><strong><em>Falso</em></strong>
   </td>
  </tr>
  <tr>
   <td><em>Verdade</em>
   </td>
   <td><em>Falso</em>
   </td>
   <td><em>Verdade</em>
   </td>
  </tr>
  <tr>
   <td><em>Falso</em>
   </td>
   <td><em>Verdade</em>
   </td>
   <td><em>Verdade</em>
   </td>
  </tr>
  <tr>
   <td><strong><em>Falso</em></strong>
   </td>
   <td><strong><em>Falso</em></strong>
   </td>
   <td><strong><em>Falso</em></strong>
   </td>
  </tr>
</table>

**CONCLUSÃO: o ou-exclusivo, (_A ^ B_),  é verdadeiro se somente um dos valores for verdadeiro, seja A ou B**.

### Negação (_not_)

O operador de negação é um inversor de valor booleano. Ele transforma um valor **_verdadeiro_** em **_falso_** e vice-versa.

Sua tabela verdade é mais simples, porque utiliza somente um operando.

<table>
  <tr>
   <td><em>Variável A</em>
   </td>
   <td><em>!A</em>
   </td>
  </tr>
  <tr>
   <td><em>Verdade</em>
   </td>
   <td><em>Falso</em>
   </td>
  </tr>
  <tr>
   <td><em>Falso</em>
   </td>
   <td><em>Verdade</em>
   </td>
  </tr>
</table>

## Imprimindo os operadores lógicos

O programa abaixo imprime os valores possíveis do operador _and_.

```python
#Exemplo - and.py
print(True and True)
print(True and False)
print(False and True)
print(False and False)
```

```
#Saída - and.py
True
False
False
False
```

<table>
  <tr>
   <td>Agora é a sua vez!
   </td>
  </tr>
  <tr>
   <td>Implemente os valores possíveis para os outros operadores lógicos e salve os arquivos:
<ul>

<li>or (or.py)

<li>^ (xor.py)

<li>not (not.py)
</li>
</ul>
   </td>
  </tr>
  <tr>
   <td>
   </td>
  </tr>
</table>

## Usando operadores relacionais e lógicos

Como vimos, os operadores relacionais retornam como resultado valores booleanos e sabemos que operadores lógicos operam sobre valores booleanos. Desta forma, é comum escrevermos programas com expressões mais complexas, envolvendo operadores relacionais e lógicos.

Observe os exemplos abaixo e tente entender a lógica envolvida no cálculo do resultado:

```python
#Expressões com operadores lógicos, relacionais e matemáticos.
>>> (10 > 7) or (5 < 4)
True

>>> (10 > 7) and (5 < 4)
False

>>> not (10 > 7)
False

>>> (2 * 5 % 2 == 0)
True

>>> (2 * 3 <= 5) and (2**3 > 10) or not(5 == 3)
True
```

Os operadores matemáticos tem maior precedência que os operadores relacionais, que por sua vez são executados antes dos operadores lógicos. 

Em expressões lógicas, o **_not_** tem prioridade de execução, seguido respectivamente pelo **_and_** e o **_or_**.

## Erros comuns

Não é possível comparar números com **string**, com os operadores >, >=, &lt;, &lt;=.
```python
#Não utilize >, >=, <, <= para comparar números com strings
>>> 1 > "1"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '>' not supported between instances of 'int' and 'str'
```