Capítulos 100 a 130
Python é uma linguagem poderosa para o desenvolvimento backend. Frameworks como Flask e Django permitem criar aplicações web robustas que renderizam HTML, manipulam formulários e interagem com bancos de dados.
# Exemplo simples com Flask (app.py)
from flask import Flask, render_template
app = Flask(__name__)
@app.route("/")
def home():
return render_template("index.html")
if __name__ == "__main__":
app.run(debug=True)
Para iniciar com Flask, instale-o via pip e crie um arquivo básico.
# Instalação
pip install flask
# app.py
from flask import Flask
app = Flask(__name__)
@app.route("/")
def home():
return "Olá, Flask!"
if __name__ == "__main__":
app.run()
Um projeto Flask geralmente possui arquivos para a aplicação, templates HTML e estáticos (CSS, JS, imagens).
/* Estrutura de pastas:
project/
│
├── app.py
├── templates/
│ └── index.html
└── static/
├── css/
├── js/
└── images/
Os roteadores definem as URLs que o aplicativo responde. Cada rota é associada a uma função que retorna conteúdo HTML.
from flask import Flask
app = Flask(__name__)
@app.route("/about")
def about():
return "Sobre Nós"
if __name__ == "__main__":
app.run()
@app.route().O Flask utiliza o mecanismo de templates Jinja2 para separar a lógica do backend da apresentação HTML.
from flask import Flask, render_template
app = Flask(__name__)
@app.route("/")
def home():
return render_template("index.html")
render_template() para renderizar arquivos HTML.Você pode passar variáveis do backend para os templates HTML, permitindo conteúdo dinâmico.
from flask import Flask, render_template
app = Flask(__name__)
@app.route("/")
def home():
nome = "João"
return render_template("index.html", nome=nome)
render_template().Flask facilita o processamento de formulários HTML, permitindo a manipulação dos dados enviados pelo usuário.
from flask import Flask, request
app = Flask(__name__)
@app.route("/submit", methods=["GET", "POST"])
def submit():
if request.method == "POST":
nome = request.form["nome"]
return "Olá, " + nome + "!"
return '''
<form method="post">
<label>Nome:</label>
<input type="text" name="nome">
<input type="submit" value="Enviar">
</form>
'''
request.form para acessar os dados enviados via formulário.Flask pode se integrar facilmente com bancos de dados como SQLite, MySQL, PostgreSQL, etc.
import sqlite3
from flask import Flask, render_template
app = Flask(__name__)
def get_db_connection():
conn = sqlite3.connect("database.db")
conn.row_factory = sqlite3.Row
return conn
@app.route("/")
def home():
conn = get_db_connection()
posts = conn.execute("SELECT * FROM posts").fetchall()
conn.close()
return render_template("index.html", posts=posts)
Flask pode ser usado para criar APIs REST que retornam dados em formato JSON.
from flask import Flask, jsonify
app = Flask(__name__)
@app.route("/api/data")
def get_data():
data = {"nome": "João", "idade": 30}
return jsonify(data)
if __name__ == "__main__":
app.run()
jsonify().Django é um framework completo para desenvolvimento web em Python, oferecendo recursos avançados como ORM, autenticação e administração.
# Comando para criar um novo projeto Django:
django-admin startproject meu_projeto
# Estrutura básica do projeto:
meu_projeto/
├── manage.py
└── meu_projeto/
├── settings.py
├── urls.py
└── wsgi.py
No Django, os templates são renderizados usando o motor de templates, que permite a inserção de variáveis e lógica simples.
# Exemplo de view no Django:
from django.shortcuts import render
def home(request):
return render(request, "index.html", {"nome": "João"})
PHP é uma linguagem de script do lado do servidor para gerar conteúdo dinâmico. Os arquivos PHP podem conter HTML misturado com código PHP.
<?php
echo "<h1>Olá, PHP!</h1>";
?>
Você pode inserir código PHP em arquivos HTML para criar páginas dinâmicas. Basta renomear o arquivo para .php e inserir blocos de código PHP.
<!DOCTYPE html>
<html>
<head>
<title>Página Dinâmica</title>
</head>
<body>
<h1>Bem-vindo</h1>
<p>Hoje é: <?php echo date("d/m/Y"); ?></p>
</body>
</html>
PHP facilita a captura e processamento de dados enviados por formulários HTML.
<!-- form.html -->
<form action="processa.php" method="post">
<label for="nome">Nome:</label>
<input type="text" id="nome" name="nome">
<input type="submit" value="Enviar">
</form>
<!-- processa.php -->
<?php
if ($_SERVER["REQUEST_METHOD"] == "POST") {
$nome = $_POST["nome"];
echo "Olá, " . htmlspecialchars($nome) . "!";
}
?>
htmlspecialchars().PHP pode se conectar a bancos de dados MySQL para armazenar e recuperar dados dinamicamente.
<?php
$servername = "localhost";
$username = "usuario";
$password = "senha";
$dbname = "meubanco";
// Cria a conexão
$conn = new mysqli($servername, $username, $password, $dbname);
// Verifica a conexão
if ($conn->connect_error) {
die("Conexão falhou: " . $conn->connect_error);
}
$sql = "SELECT id, nome FROM usuarios";
$result = $conn->query($sql);
if ($result->num_rows > 0) {
while($row = $result->fetch_assoc()) {
echo "id: " . $row["id"]. " - Nome: " . $row["nome"]. "<br>";
}
} else {
echo "0 resultados";
}
$conn->close();
?>
Utilize sessões para armazenar dados temporários entre páginas e cookies para dados persistentes no navegador.
<?php
// Inicia a sessão
session_start();
$_SESSION["usuario"] = "João";
// Definir um cookie
setcookie("cor_favorita", "azul", time() + (86400 * 30)); // expira em 30 dias
?>
session_start() para iniciar uma sessão PHP.setcookie() e podem armazenar dados por um período determinado.Laravel é um framework PHP moderno que facilita o desenvolvimento de aplicações web robustas com uma sintaxe elegante.
# Comando para criar um novo projeto Laravel (via Composer):
composer create-project --prefer-dist laravel/laravel meuProjeto
// Exemplo de rota no Laravel (routes/web.php):
Route::get('/', function () {
return view('welcome');
});
O Blade é o motor de templates do Laravel, permitindo criar layouts reutilizáveis e dinâmicos.
{{-- resources/views/welcome.blade.php --}}
Bem-vindo
Olá, {{ $nome }}!
// Rota (routes/web.php):
Route::get('/', function () {
return view('welcome', ['nome' => 'João']);
});
PHP pode ser utilizado para criar APIs REST que retornam dados em formato JSON.
<?php
header("Content-Type: application/json");
$data = ["nome" => "João", "idade" => 30];
echo json_encode($data);
?>
Utilize AJAX para buscar dados de scripts PHP sem recarregar a página.
/* JavaScript (usando fetch) */
fetch("api.php")
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error("Erro:", error));
É fundamental validar e sanitizar os dados recebidos pelo PHP para evitar ataques (como SQL Injection e XSS).
<?php
$nome = filter_input(INPUT_POST, 'nome', FILTER_SANITIZE_STRING);
if (!$nome) {
die("Nome inválido!");
}
echo "Olá, " . htmlspecialchars($nome) . "!";
?>
filter_input e htmlspecialchars para sanitizar dados.PHP permite fazer upload, leitura e escrita de arquivos no servidor.
<form action="upload.php" method="post" enctype="multipart/form-data">
<label for="fileToUpload">Selecione um arquivo:</label>
<input type="file" name="fileToUpload" id="fileToUpload">
<input type="submit" value="Upload" name="submit">
</form>
enctype="multipart/form-data" para upload de arquivos.É possível integrar HTML com backends em Python e PHP. Por exemplo, uma página HTML pode consumir APIs desenvolvidas em Flask e também ser processada por scripts PHP, seja via AJAX ou por renderização de templates.
<!-- Exemplo de HTML consumindo API Flask e também PHP -->
<!-- A página pode ter AJAX para chamar uma API Flask e, simultaneamente, formularios enviados para um script PHP -->
<form action="processa.php" method="post">
<label>Seu nome:</label>
<input type="text" name="nome">
<input type="submit" value="Enviar para PHP">
</form>
<script>
fetch("https://exemplo-flask-api.com/api/dados")
.then(response => response.json())
.then(data => console.log("Dados do Flask:", data));
</script>
Ambas as linguagens são populares para desenvolvimento backend. Python (com Flask/Django) oferece uma sintaxe moderna e uma vasta gama de bibliotecas, enquanto PHP é amplamente suportado por hospedagens e tem uma longa história no desenvolvimento web.
/* Exemplo ilustrativo: */
Python:
- Frameworks: Flask, Django
- Sintaxe moderna, fácil de ler
PHP:
- Integração nativa com HTML
- Ampla disponibilidade em servidores
Melhore o desempenho de suas aplicações backend com cache, otimização de consultas e boas práticas de programação.
// Exemplo (simulado) de cache com Flask:
@app.route("/dados")
def dados():
cache = get_from_cache("dados")
if cache:
return cache
data = complex_query()
set_in_cache("dados", data)
return data
Aprenda a depurar suas aplicações em Python e PHP utilizando ferramentas como loggers, depuradores e consoles.
// Exemplo de log em Flask:
import logging
logging.basicConfig(level=logging.DEBUG)
app.logger.debug("Mensagem de debug")
Este capítulo mostra como uma única aplicação HTML pode interagir com backends Python e PHP simultaneamente, usando formulários e AJAX.
<!-- HTML integrado: -->
<form action="processa.php" method="post">
<label>Nome:</label>
<input type="text" name="nome">
<input type="submit" value="Enviar para PHP">
</form>
<script>
fetch("https://exemplo-flask-api.com/api/dados")
.then(response => response.json())
.then(data => console.log("Dados do Flask:", data));
</script>
Este capítulo compara as vantagens e desvantagens de usar Python (Flask/Django) e PHP para desenvolvimento backend.
/* Python:
- Sintaxe clara e moderna.
- Grande ecossistema de bibliotecas.
PHP:
- Amplamente suportado em hospedagens.
- Extensa comunidade e recursos. */
Este capítulo aborda estratégias para melhorar a performance e escalabilidade de aplicações backend, seja em Python ou PHP.
/* Estratégias comuns:
- Cache (Redis, Memcached)
- Balanceamento de carga
- Otimização de queries */
Aprenda a utilizar ferramentas de debugging e logging para solucionar problemas em aplicações Python e PHP.
// Exemplo de logging em PHP:
<?php
error_reporting(E_ALL);
ini_set('display_errors', 1);
?>
Revise os conceitos abordados e planeje os próximos passos para aprofundar seus conhecimentos em desenvolvimento backend utilizando Python e PHP.
<!-- Mensagem de Conclusão -->
<h2>Parabéns!</h2>
<p>Você concluiu os conceitos básicos de integração de HTML com backends em Python e PHP. Continue explorando frameworks, APIs e técnicas avançadas.</p>