Create Booleanos.md

Booleanos.md

@@ -0,0 +1,137 @@
+Os **Booleanos** em Python representam valores de **verdadeiro** ou **falso** e são usados principalmente em comparações e tomadas de decisão (como em estruturas condicionais). Os valores booleanos são representados pelas palavras-chave `True` e `False`, que são equivalentes a 1 e 0, respectivamente.
+
+### 1. Declaração de Valores Booleanos
+
+Valores booleanos são simples e podem ser definidos diretamente como `True` ou `False`.
+
+```python
+# Declaração de variáveis booleanas
+a = True
+b = False
+print(a)  # Saída: True
+print(b)  # Saída: False
+```
+
+### 2. Operadores de Comparação
+
+Os operadores de comparação são usados para comparar valores e retornar `True` ou `False`. Aqui estão os operadores mais comuns:
+
+- `==` : Igual a
+- `!=` : Diferente de
+- `>` : Maior que
+- `<` : Menor que
+- `>=` : Maior ou igual a
+- `<=` : Menor ou igual a
+
+```python
+x = 10
+y = 5
+
+print(x == y)    # False (10 não é igual a 5)
+print(x != y)    # True (10 é diferente de 5)
+print(x > y)     # True (10 é maior que 5)
+print(x <= y)    # False (10 não é menor ou igual a 5)
+```
+
+### 3. Operadores Lógicos
+
+Python tem três operadores lógicos principais: **and**, **or**, e **not**. Eles são usados para combinar expressões booleanas.
+
+- **`and`** : Retorna `True` se ambas as expressões forem `True`.
+- **`or`** : Retorna `True` se pelo menos uma das expressões for `True`.
+- **`not`** : Inverte o valor booleano da expressão (transforma `True` em `False` e vice-versa).
+
+```python
+a = True
+b = False
+
+print(a and b)   # False (ambas as condições precisam ser True)
+print(a or b)    # True (uma das condições é True)
+print(not a)     # False (inverte o valor de True para False)
+```
+
+### 4. Exemplos em Estruturas Condicionais
+
+Os valores booleanos são amplamente usados em estruturas condicionais como `if`, `elif`, e `else` para controlar o fluxo do programa.
+
+```python
+idade = 20
+habilitacao = True
+
+if idade >= 18 and habilitacao:
+    print("Pode dirigir!")
+else:
+    print("Não pode dirigir.")
+# Saída: "Pode dirigir!" pois ambas as condições são verdadeiras.
+```
+
+### 5. Booleanos em Expressões e Tipos de Dados
+
+Em Python, vários tipos de dados podem ser convertidos para valores booleanos. As seguintes regras se aplicam:
+
+- **Valores considerados `False`**: `0`, `None`, strings vazias `""`, listas vazias `[]`, tuplas vazias `()`, dicionários vazios `{}`, e o próprio `False`.
+- **Valores considerados `True`**: Todos os outros valores, incluindo números diferentes de zero, strings não vazias, listas com elementos, etc.
+
+Podemos usar a função `bool()` para verificar o valor booleano de qualquer expressão.
+
+```python
+print(bool(0))         # False
+print(bool(1))         # True
+print(bool(""))        # False
+print(bool("Texto"))   # True
+print(bool([]))        # False
+print(bool([1, 2, 3])) # True
+```
+
+### 6. Exemplo Completo: Validação de Login
+
+Vamos usar booleanos e operadores lógicos para criar um exemplo de validação de login simples. Suponha que temos um sistema que verifica se o usuário e a senha estão corretos.
+
+```python
+# Dados de login corretos
+usuario_correto = "admin"
+senha_correta = "1234"
+
+# Entrada do usuário
+usuario = input("Digite o usuário: ")
+senha = input("Digite a senha: ")
+
+# Verificação
+if usuario == usuario_correto and senha == senha_correta:
+    print("Login bem-sucedido!")
+else:
+    print("Usuário ou senha incorretos.")
+```
+
+### 7. Exemplo Completo: Verificação de Maioridade
+
+Aqui, vamos verificar se uma pessoa tem idade suficiente para votar e para dirigir. Ambos os requisitos usam operadores booleanos.
+
+```python
+idade = int(input("Digite a sua idade: "))
+
+# Verificando condições
+pode_votar = idade >= 16
+pode_dirigir = idade >= 18
+
+print("Pode votar:", pode_votar)      # True ou False com base na idade
+print("Pode dirigir:", pode_dirigir)  # True ou False com base na idade
+```
+
+Se a idade for maior ou igual a 16, `pode_votar` será `True`, e se for maior ou igual a 18, `pode_dirigir` será `True`. Isso torna o código claro e direto ao ponto.
+
+### Resumo dos Operadores e Conceitos de Booleanos
+
+| Operador | Descrição                                          | Exemplo               | Resultado |
+|----------|----------------------------------------------------|-----------------------|-----------|
+| `==`     | Igual a                                            | `5 == 5`             | `True`    |
+| `!=`     | Diferente de                                       | `5 != 3`             | `True`    |
+| `>`      | Maior que                                          | `7 > 3`              | `True`    |
+| `<`      | Menor que                                          | `3 < 7`              | `True`    |
+| `>=`     | Maior ou igual a                                   | `5 >= 5`             | `True`    |
+| `<=`     | Menor ou igual a                                   | `3 <= 5`             | `True`    |
+| `and`    | Retorna `True` se ambas as condições forem `True`  | `True and False`     | `False`   |
+| `or`     | Retorna `True` se pelo menos uma condição for `True` | `True or False`  | `True`    |
+| `not`    | Inverte o valor booleano                           | `not True`           | `False`   |
+
+Os booleanos são essenciais em Python para controle de fluxo e tomada de decisões, tornando o código mais dinâmico e adaptável a várias condições.