# Lógica da Programação em Python
## Aula 02
:::success
**Prof** Edson Belem de Souza Junior
**Celular/Whatsapp:** (21) 98199-0108
**E-mail:** profedsonbelem@gmail.com
**Aula:** 13/03/2024
**Turma:**
**Site:** https://www.edsonbelemtreinamento.com.br/
**Blog**: https://edsonbelemtreinamento.com.br/blog/
**Youtube:** https://www.youtube.com/@EdsonBelemTreinamento
**Instagram:** https://www.instagram.com/edson_belem_treinamento/
:::
.
.
.
## Programas para Insralar:
- Visual Code - https://code.visualstudio.com/download
- Draw.io - https://www.drawio.com/
- Python -
## Regra da programação estruturada:
1. inicio
2. declare
3. leia
4. processe
5. escreva
6. fim
# Python
A linguagem Python é uma linguagem de programação de alto nível, interpretada e de propósito geral. Ela foi criada por Guido van Rossum e teve sua primeira versão lançada em 1991. Python se destaca pela sua simplicidade, legibilidade e facilidade de aprendizado.
.
.
.
## **Tipos de Dados em Python:**
Python possui diversos tipos de dados embutidos, alguns dos principais são:
* **Números**: Inteiros (int), números de ponto flutuante (float), números complexos (complex).
* **Texto**: Strings (str), que são sequências de caracteres.
* **Booleanos**: Booleanos (bool), que podem ser True ou False.
* **Sequências**: Listas (list), tuplas (tuple), e intervalos (range).
* **Mapeamentos**: Dicionários (dict), que são coleções de pares chave-valor.
* **Conjuntos**: Conjuntos (set), que são coleções não ordenadas de itens únicos.
.
.
.
## **Variáveis em Python:**
Variáveis em Python são usadas para armazenar valores de diferentes tipos de dados. Elas são criadas quando um valor é atribuído a elas. Não é necessário declarar explicitamente o tipo de uma variável em Python, pois a linguagem é dinamicamente tipada. Isso significa que o tipo da variável é inferido automaticamente com base no valor atribuído a ela. Por exemplo:
```python=
# Exemplo de variáveis em Python
idade = 25 # uma variável do tipo int
nome = "Maria" # uma variável do tipo str
altura = 1.75 # uma variável do tipo float
ativo = True # uma variável do tipo bool
```
```python=
print(type(idade)) # Saída: <class 'int'>
print(type(nome)) # Saída: <class 'str'>
print(type(altura)) # Saída: <class 'float'>
print(type(ativo)) # Saída: <class 'bool'>
```
.
.
.
## Operadores:
Em Python, os operadores são símbolos especiais que realizam operações em operandos (valores ou variáveis). Reconhecer os operadores e suas relações de precedência é importante para entender como as expressões são avaliadas e executadas.
Aqui estão alguns dos operadores mais comuns em Python:
* **Operadores Aritméticos**: Realizam operações matemáticas básicas, como adição, subtração, multiplicação, divisão e exponenciação. Por exemplo: +, -, *, /, **.
* **Operadores de Comparação**: Comparam dois valores e retornam um resultado booleano (True ou False). Por exemplo: == (igual), != (diferente), >, <, >=, <=.
* **Operadores Lógicos**: São usados para combinar expressões booleanas. Os principais operadores lógicos em Python são and, or e not.
* **Operadores de Atribuição**: São usados para atribuir valores a variáveis. O operador de atribuição básico em Python é =. Além disso, existem operadores de atribuição combinados, como +=, -=, *=, /=, etc.
* **Operadores de Identidade**: Verificam se dois objetos têm a mesma identidade (mesmo endereço de memória). Os operadores de identidade em Python são is e is not.
* **Operadores de Associação**: Verificam se um valor está presente em uma sequência. Os operadores de associação em Python são in e not in.
A relação de precedência dos operadores determina a ordem em que eles são avaliados em uma expressão. Por exemplo, em uma expressão matemática como 2 + 3 * 4, o operador de multiplicação (*) tem precedência sobre o operador de adição (+), então a multiplicação é realizada antes da adição. No entanto, você pode usar parênteses para alterar a ordem de avaliação e definir explicitamente a precedência.
```python=
resultado = 2 + 3 * 4
# Primeiro é realizada a multiplicação e depois a adição (resultado = 14)
resultado = (2 + 3) * 4
# Os parênteses definem a precedência, então primeiro é
# realizada a adição e depois a multiplicação (resultado = 20)
```
.
.
.
## Entradas e saidas em Python
Em Python, existem várias formas de entrada e saída de dados, que permitem que um programa interaja com o usuário, leia dados de arquivos ou se comunique com outros sistemas. Abaixo, descrevo algumas das principais formas de entrada e saída de dados em Python:
**Entrada de Dados:**
1. **Função `input()`:** A função `input()` é usada para solicitar entrada do usuário durante a execução do programa. Ela exibe uma mensagem opcional para o usuário e aguarda que o usuário insira um valor a partir do teclado. Por exemplo:
```python
nome = input("Digite seu nome: ")
```
2. **Arquivos:** Os programas Python podem ler dados de arquivos usando as funções `open()` para abrir um arquivo e `read()`, `readline()`, `readlines()` para ler o conteúdo do arquivo. Por exemplo:
```python
with open('arquivo.txt', 'r') as arquivo:
conteudo = arquivo.read()
```
3. **Argumentos de Linha de Comando:** Os programas Python podem receber argumentos da linha de comando quando são executados a partir de um terminal ou prompt de comando. Os argumentos podem ser acessados usando o módulo `sys` ou a biblioteca `argparse`.
**Saída de Dados:**
1. **Função `print()`:** A função `print()` é usada para exibir dados na saída padrão (geralmente o console). Ela aceita múltiplos argumentos e os exibe separados por espaços. Por exemplo:
```python
print("Olá, mundo!")
```
2. **Arquivos:** Os programas Python podem escrever dados em arquivos usando as funções `open()` com o modo de escrita (`'w'`, `'a'`, etc.) e `write()` para escrever conteúdo em um arquivo. Por exemplo:
```python
with open('saida.txt', 'w') as arquivo:
arquivo.write("Este é um exemplo de saída em um arquivo.")
```
3. **Redirecionamento de Saída:** No ambiente de linha de comando, a saída de um programa Python pode ser redirecionada para um arquivo usando o operador `>` ou `>>`. Por exemplo:
```bash
python programa.py > saida.txt
```
4. **Formatação de Strings:** Python oferece várias maneiras de formatar strings para exibir dados de forma mais organizada, incluindo o método `format()` e as f-strings (format strings). Por exemplo:
```python
nome = "Alice"
idade = 30
print("Nome: {}, Idade: {}".format(nome, idade))
# ou
print(f"Nome: {nome}, Idade: {idade}")
```
Essas são algumas das formas comuns de entrada e saída de dados em Python. A escolha da técnica adequada depende dos requisitos do programa e do contexto de uso.
.
.
.
## Exemplo Prático:
**pessoa.py**
```python=
class Pessoa:
def __init__(self, nome, idade):
self.nome = nome
self.idade = idade
def mostrar_dados(self):
print("Nome:", self.nome)
print("Idade:", self.idade)
# Criar uma instância da classe Pessoa
pessoa1 = Pessoa("João", 30)
# Mostrar e imprimir os dados da pessoa
pessoa1.mostrar_dados()
```
.
.
.
**calculadora.py**
```python=
class Calculadora:
def __init__(self):
pass
def adicao(self, num1, num2):
return num1 + num2
def subtracao(self, num1, num2):
return num1 - num2
def multiplicacao(self, num1, num2):
return num1 * num2
def divisao(self, num1, num2):
if num2 != 0:
return num1 / num2
else:
return "Erro: divisão por zero"
# Exemplos de uso da classe Calculadora
calc = Calculadora()
# Adição
resultado_adicao = calc.adicao(5, 3)
print("Resultado da adição:", resultado_adicao)
# Subtração
resultado_subtracao = calc.subtracao(10, 4)
print("Resultado da subtração:", resultado_subtracao)
# Multiplicação
resultado_multiplicacao = calc.multiplicacao(6, 2)
print("Resultado da multiplicação:", resultado_multiplicacao)
# Divisão
resultado_divisao = calc.divisao(20, 5)
print("Resultado da divisão:", resultado_divisao)
# Tentativa de divisão por zero
resultado_divisao_zero = calc.divisao(10, 0)
print("Resultado da divisão por zero:", resultado_divisao_zero)
```
.
.
.
**usuario.py**
```python=
class Usuario:
def __init__(self, nome, ativo=False):
self.nome = nome
self.ativo = ativo
def ativar(self):
self.ativo = True
def desativar(self):
self.ativo = False
def status(self):
if self.ativo:
print(f"O usuário {self.nome} está ativo.")
else:
print(f"O usuário {self.nome} está inativo.")
# Criando uma instância da classe Usuario
usuario1 = Usuario("Alice")
# Verificando o status inicial do usuário
usuario1.status() # Saída: O usuário Alice está inativo.
# Ativando o usuário
usuario1.ativar()
# Verificando o status do usuário após ativar
usuario1.status() # Saída: O usuário Alice está ativo.
# Desativando o usuário
usuario1.desativar()
# Verificando o status do usuário após desativar
usuario1.status() # Saída: O usuário Alice está inativo.
```
Sign in with Wallet
Connect another wallet