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?")

```

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

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

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)

```