Lógica de Programação e Desenvolvimento Web com Python
Neste documento, você aprenderá conceitos fundamentais sobre lógica de programação, como
trabalhar com APIs e desenvolver aplicações web com Python. Vamos abordar desde o básico até
exemplos mais avançados, com dicas e boas práticas.
1. Variáveis em Python
As variáveis em Python são usadas para armazenar valores. Elas não precisam de tipo declarado
explicitamente, ou seja, Python é uma linguagem de tipagem dinâmica. Ou seja, você pode atribuir
qualquer tipo de dado a uma variável a qualquer momento.
Exemplo de variáveis:
```python
nome = "Carlos" # String
idade = 25 # Inteiro
altura = 1.75 # Float
is_adulto = True # Booleano
```
Você pode usar essas variáveis em expressões, como em:
```python
print(nome) # Imprime "Carlos"
print(idade + 5) # Imprime 30 (25 + 5)
```
2. Controle de Fluxo
O controle de fluxo permite tomar decisões ou repetir blocos de código com base em condições ou
números.
### a) Condicionais (if, elif, else)
Em Python, usamos as estruturas `if`, `elif` (else if) e `else` para tomar decisões.
Exemplo:
```python
idade = 18
if idade >= 18:
print("Você é maior de idade!")
elif idade == 17:
print("Você tem 17 anos!")
else:
print("Você é menor de idade!")
```
### b) Laços de Repetição (for, while)
- `for`: Usado quando sabemos o número de iterações.
- `while`: Usado quando não sabemos quantas iterações precisamos.
Exemplo de `for`:
```python
for i in range(5): # Itera de 0 a 4
print(i)
```
Exemplo de `while`:
```python
contador = 0
while contador < 5: # Enquanto contador for menor que 5
print(contador)
contador += 1 # Incrementa o contador
```
3. Funções em Python
Funções são blocos de código que realizam uma tarefa específica e podem ser reutilizados várias
vezes. Em Python, você define uma função com a palavra-chave `def`.
Exemplo de função:
```python
def saudacao(nome):
return f"Olá, {nome}!"
# Chamando a função
print(saudacao("Carlos"))
```
Função sem parâmetros e sem retorno:
```python
def cumprimentar():
print("Oi, tudo bem?")
cumprimentar()
```
Função com parâmetros:
```python
def soma(a, b):
return a + b
resultado = soma(10, 5)
print(resultado) # Imprime 15
```
4. Classes e Objetos (Orientação a Objetos - POO)
A Programação Orientada a Objetos (POO) é um paradigma de programação baseado em objetos.
Em Python, criamos classes que servem como "modelos" para criar objetos. Objetos são instâncias
de uma classe.
### a) Classes
Uma classe é uma estrutura que define um tipo de objeto. Ela pode ter atributos (dados) e métodos
(funções associadas).
Exemplo de classe:
```python
class Carro:
def __init__(self, modelo, cor): # Método construtor (__init__)
self.modelo = modelo # Atributo
self.cor = cor # Atributo
def ligar(self): # Método
print(f"O {self.modelo} está ligado!")
# Criando um objeto (instância da classe)
meu_carro = Carro("Fusca", "azul")
# Acessando atributos e métodos
print(meu_carro.modelo) # Imprime "Fusca"
meu_carro.ligar() # Imprime "O Fusca está ligado!"
```
### b) Construtores
O método `__init__` é chamado automaticamente quando um objeto é criado. Ele é o construtor da
classe e serve para inicializar os atributos do objeto.
### c) Herança
A herança permite criar uma nova classe a partir de uma classe existente, herdando seus atributos
e métodos. A classe filha pode adicionar novos atributos ou modificar os existentes.
Exemplo de herança:
```python
class CarroEletrico(Carro): # CarroEletrico herda de Carro
def __init__(self, modelo, cor, autonomia):
super().__init__(modelo, cor) # Chama o construtor da classe pai
self.autonomia = autonomia # Novo atributo
def ligar(self):
print(f"O {self.modelo} elétrico está ligado!")
# Criando um objeto da classe filha
meu_carro_eletrico = CarroEletrico("Tesla", "preto", 500)
meu_carro_eletrico.ligar() # Imprime "O Tesla elétrico está ligado!"
```
### d) Encapsulamento
Encapsulamento é o princípio de esconder os detalhes internos do funcionamento de uma classe e
só expor o que é necessário. Em Python, podemos usar o prefixo `__` para tornar um atributo ou
método privado.
Exemplo:
```python
class ContaBancaria:
def __init__(self, saldo):
self.__saldo = saldo # Atributo privado
def deposito(self, valor):
self.__saldo += valor
def retirar(self, valor):
if valor <= self.__saldo:
self.__saldo -= valor
else:
print("Saldo insuficiente!")
def mostrar_saldo(self):
print(f"Saldo: {self.__saldo}")
```
5. Trabalhando com APIs em Python
Uma **API** (Interface de Programação de Aplicações) é uma forma de comunicação entre
diferentes sistemas, permitindo que você envie e receba dados de um serviço externo.
Para consumir APIs em Python, a biblioteca mais comum é a `requests`, que simplifica a
comunicação com servidores HTTP.
### a) Consumindo uma API Externa com Python (HTTP Requests)
Instale a biblioteca `requests`:
```bash
pip install requests
```
Exemplo de consumo de API (GET):
```python
import requests
# URL da API
url = "https://jsonplaceholder.typicode.com/posts"
# Realizando a requisição GET
response = requests.get(url)
# Verificando se a requisição foi bem-sucedida
if response.status_code == 200:
data = response.json()
print(data)
else:
print(f"Erro na requisição: {response.status_code}")
```
### b) Enviando Dados para uma API (POST)
Exemplo de envio de dados para uma API:
```python
import requests
url = "https://jsonplaceholder.typicode.com/posts"
dados = {
"title": "foo",
"body": "bar",
"userId": 1
response = requests.post(url, json=dados)
if response.status_code == 201:
print("Dados enviados com sucesso!")
print(response.json())
else:
print(f"Erro ao enviar dados: {response.status_code}")
```
### c) Autenticação em APIs
Algumas APIs exigem autenticação com tokens.
```python
import requests
url = "https://api.exemplo.com/dados"
token = "seu_token_aqui"
headers = {
"Authorization": f"Bearer {token}"
response = requests.get(url, headers=headers)
if response.status_code == 200:
print(response.json())
else:
print(f"Erro: {response.status_code}")
```
6. Desenvolvimento Web com Python
Para desenvolver uma aplicação web em Python, você pode usar frameworks como **Flask** e
**Django**.
### a) Criando uma Aplicação Web Simples com Flask
Instale o Flask:
```bash
pip install Flask
```
Exemplo básico de aplicação Flask:
```python
from flask import Flask
app = Flask(__name__)
@app.route('/')
def home():
return "Olá, mundo!"
if __name__ == '__main__':
app.run(debug=True)
```
### b) Criando uma API com Flask
```python
from flask import Flask, jsonify
app = Flask(__name__)
@app.route('/api/saudacao')
def saudacao():
return jsonify({"message": "Olá, bem-vindo à API!"})
if __name__ == '__main__':
app.run(debug=True)
```
### c) Enviando Dados para a API com POST (Flask)
```python
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/api/usuario', methods=['POST'])
def criar_usuario():
dados = request.get_json()
nome = dados.get('nome')
idade = dados.get('idade')
return jsonify({"mensagem": f"Usuário {nome} de {idade} anos criado!"})
if __name__ == '__main__':
app.run(debug=True)
```
