Python SQLite
Finalizando a web api

Tutorial: Web Services em Python para Todas as Tabelas da Loja de Açaí

Neste tutorial, aprenderemos a criar uma API REST simples em Python utilizando o Flask para consumir as tabelas do banco de dados de uma loja de açaí. Serão abordadas as tabelas:

  • Clientes
  • Produtos
  • Materiais
  • Vendas
  • Consumo

Utilizaremos os verbos HTTP GET, POST, PUT e DELETE para realizar operações de leitura, criação, atualização e exclusão dos registros.


Requisitos

  • Python 3 instalado
  • Pacote Flask (instalável via pip install flask)
  • Banco de dados SQLite (loja_acai.db) já criado com as tabelas definidas conforme o tutorial anterior.

Estrutura das Tabelas

Para referência, veja abaixo a estrutura básica de cada tabela:


-- Clientes:
CREATE TABLE clientes (
  id_cliente INTEGER PRIMARY KEY AUTOINCREMENT,
  nome TEXT NOT NULL,
  telefone TEXT,
  email TEXT
);

-- Produtos:
CREATE TABLE produtos (
  id_produto INTEGER PRIMARY KEY AUTOINCREMENT,
  nome TEXT NOT NULL,
  preco REAL NOT NULL
);

-- Materiais:
CREATE TABLE materiais (
  id_material INTEGER PRIMARY KEY AUTOINCREMENT,
  nome TEXT NOT NULL,
  custo REAL
);

-- Vendas:
CREATE TABLE vendas (
  id_venda INTEGER PRIMARY KEY AUTOINCREMENT,
  id_cliente INTEGER,
  data_venda TEXT,
  total REAL,
  FOREIGN KEY (id_cliente) REFERENCES clientes(id_cliente)
);

-- Consumo:
CREATE TABLE consumo (
  id_consumo INTEGER PRIMARY KEY AUTOINCREMENT,
  id_venda INTEGER,
  id_produto INTEGER,
  quantidade INTEGER,
  FOREIGN KEY (id_venda) REFERENCES vendas(id_venda),
  FOREIGN KEY (id_produto) REFERENCES produtos(id_produto)
);

Com as tabelas criadas, já podemos construir nossa API.


Código Completo do Web Service

O código a seguir implementa os endpoints para cada uma das tabelas, seguindo o mesmo padrão para facilitar a manutenção e a compreensão:


from flask import Flask, request, jsonify, abort
import sqlite3

app = Flask(__name__)
DATABASE = 'loja_acai.db'  # Nome do banco de dados SQLite

def get_db():
    """Retorna uma conexão com o banco de dados configurada para retornar dicionários."""
    conn = sqlite3.connect(DATABASE)
    conn.row_factory = sqlite3.Row
    return conn

# ===================== Clientes =====================

@app.route('/clientes', methods=['GET'])
def get_clientes():
    conn = get_db()
    clientes = conn.execute("SELECT * FROM clientes").fetchall()
    conn.close()
    return jsonify([dict(row) for row in clientes])

@app.route('/clientes/<int:id>', methods=['GET'])
def get_cliente(id):
    conn = get_db()
    cliente = conn.execute("SELECT * FROM clientes WHERE id_cliente = ?", (id,)).fetchone()
    conn.close()
    if cliente is None:
        abort(404)
    return jsonify(dict(cliente))

@app.route('/clientes', methods=['POST'])
def create_cliente():
    if not request.json or 'nome' not in request.json:
        abort(400)
    cliente = {
        'nome': request.json['nome'],
        'telefone': request.json.get('telefone', ''),
        'email': request.json.get('email', '')
    }
    conn = get_db()
    cur = conn.cursor()
    cur.execute("INSERT INTO clientes (nome, telefone, email) VALUES (?, ?, ?)",
                (cliente['nome'], cliente['telefone'], cliente['email']))
    conn.commit()
    cliente['id_cliente'] = cur.lastrowid
    conn.close()
    return jsonify(cliente), 201

@app.route('/clientes/<int:id>', methods=['PUT'])
def update_cliente(id):
    if not request.json:
        abort(400)
    campos = []
    valores = []
    for campo in ['nome', 'telefone', 'email']:
        if campo in request.json:
            campos.append(f"{campo} = ?")
            valores.append(request.json[campo])
    if not campos:
        abort(400)
    valores.append(id)
    conn = get_db()
    conn.execute(f"UPDATE clientes SET {', '.join(campos)} WHERE id_cliente = ?", valores)
    conn.commit()
    conn.close()
    return jsonify({'result': True})

@app.route('/clientes/<int:id>', methods=['DELETE'])
def delete_cliente(id):
    conn = get_db()
    conn.execute("DELETE FROM clientes WHERE id_cliente = ?", (id,))
    conn.commit()
    conn.close()
    return jsonify({'result': True})

# ===================== Produtos =====================

@app.route('/produtos', methods=['GET'])
def get_produtos():
    conn = get_db()
    produtos = conn.execute("SELECT * FROM produtos").fetchall()
    conn.close()
    return jsonify([dict(row) for row in produtos])

@app.route('/produtos/<int:id>', methods=['GET'])
def get_produto(id):
    conn = get_db()
    produto = conn.execute("SELECT * FROM produtos WHERE id_produto = ?", (id,)).fetchone()
    conn.close()
    if produto is None:
        abort(404)
    return jsonify(dict(produto))

@app.route('/produtos', methods=['POST'])
def create_produto():
    if not request.json or 'nome' not in request.json or 'preco' not in request.json:
        abort(400)
    produto = {
        'nome': request.json['nome'],
        'preco': request.json['preco']
    }
    conn = get_db()
    cur = conn.cursor()
    cur.execute("INSERT INTO produtos (nome, preco) VALUES (?, ?)",
                (produto['nome'], produto['preco']))
    conn.commit()
    produto['id_produto'] = cur.lastrowid
    conn.close()
    return jsonify(produto), 201

@app.route('/produtos/<int:id>', methods=['PUT'])
def update_produto(id):
    if not request.json:
        abort(400)
    campos = []
    valores = []
    for campo in ['nome', 'preco']:
        if campo in request.json:
            campos.append(f"{campo} = ?")
            valores.append(request.json[campo])
    if not campos:
        abort(400)
    valores.append(id)
    conn = get_db()
    conn.execute(f"UPDATE produtos SET {', '.join(campos)} WHERE id_produto = ?", valores)
    conn.commit()
    conn.close()
    return jsonify({'result': True})

@app.route('/produtos/<int:id>', methods=['DELETE'])
def delete_produto(id):
    conn = get_db()
    conn.execute("DELETE FROM produtos WHERE id_produto = ?", (id,))
    conn.commit()
    conn.close()
    return jsonify({'result': True})

# ===================== Materiais =====================

@app.route('/materiais', methods=['GET'])
def get_materiais():
    conn = get_db()
    materiais = conn.execute("SELECT * FROM materiais").fetchall()
    conn.close()
    return jsonify([dict(row) for row in materiais])

@app.route('/materiais/<int:id>', methods=['GET'])
def get_material(id):
    conn = get_db()
    material = conn.execute("SELECT * FROM materiais WHERE id_material = ?", (id,)).fetchone()
    conn.close()
    if material is None:
        abort(404)
    return jsonify(dict(material))

@app.route('/materiais', methods=['POST'])
def create_material():
    if not request.json or 'nome' not in request.json:
        abort(400)
    material = {
        'nome': request.json['nome'],
        'custo': request.json.get('custo', 0.0)
    }
    conn = get_db()
    cur = conn.cursor()
    cur.execute("INSERT INTO materiais (nome, custo) VALUES (?, ?)",
                (material['nome'], material['custo']))
    conn.commit()
    material['id_material'] = cur.lastrowid
    conn.close()
    return jsonify(material), 201

@app.route('/materiais/<int:id>', methods=['PUT'])
def update_material(id):
    if not request.json:
        abort(400)
    campos = []
    valores = []
    for campo in ['nome', 'custo']:
        if campo in request.json:
            campos.append(f"{campo} = ?")
            valores.append(request.json[campo])
    if not campos:
        abort(400)
    valores.append(id)
    conn = get_db()
    conn.execute(f"UPDATE materiais SET {', '.join(campos)} WHERE id_material = ?", valores)
    conn.commit()
    conn.close()
    return jsonify({'result': True})

@app.route('/materiais/<int:id>', methods=['DELETE'])
def delete_material(id):
    conn = get_db()
    conn.execute("DELETE FROM materiais WHERE id_material = ?", (id,))
    conn.commit()
    conn.close()
    return jsonify({'result': True})

# ===================== Vendas =====================

@app.route('/vendas', methods=['GET'])
def get_vendas():
    conn = get_db()
    vendas = conn.execute("SELECT * FROM vendas").fetchall()
    conn.close()
    return jsonify([dict(row) for row in vendas])

@app.route('/vendas/<int:id>', methods=['GET'])
def get_venda(id):
    conn = get_db()
    venda = conn.execute("SELECT * FROM vendas WHERE id_venda = ?", (id,)).fetchone()
    conn.close()
    if venda is None:
        abort(404)
    return jsonify(dict(venda))

@app.route('/vendas', methods=['POST'])
def create_venda():
    if not request.json or 'id_cliente' not in request.json or 'data_venda' not in request.json or 'total' not in request.json:
        abort(400)
    venda = {
        'id_cliente': request.json['id_cliente'],
        'data_venda': request.json['data_venda'],
        'total': request.json['total']
    }
    conn = get_db()
    cur = conn.cursor()
    cur.execute("INSERT INTO vendas (id_cliente, data_venda, total) VALUES (?, ?, ?)",
                (venda['id_cliente'], venda['data_venda'], venda['total']))
    conn.commit()
    venda['id_venda'] = cur.lastrowid
    conn.close()
    return jsonify(venda), 201

@app.route('/vendas/<int:id>', methods=['PUT'])
def update_venda(id):
    if not request.json:
        abort(400)
    campos = []
    valores = []
    for campo in ['id_cliente', 'data_venda', 'total']:
        if campo in request.json:
            campos.append(f"{campo} = ?")
            valores.append(request.json[campo])
    if not campos:
        abort(400)
    valores.append(id)
    conn = get_db()
    conn.execute(f"UPDATE vendas SET {', '.join(campos)} WHERE id_venda = ?", valores)
    conn.commit()
    conn.close()
    return jsonify({'result': True})

@app.route('/vendas/<int:id>', methods=['DELETE'])
def delete_venda(id):
    conn = get_db()
    conn.execute("DELETE FROM vendas WHERE id_venda = ?", (id,))
    conn.commit()
    conn.close()
    return jsonify({'result': True})

# ===================== Consumo =====================

@app.route('/consumo', methods=['GET'])
def get_consumo():
    conn = get_db()
    consumos = conn.execute("SELECT * FROM consumo").fetchall()
    conn.close()
    return jsonify([dict(row) for row in consumos])

@app.route('/consumo/<int:id>', methods=['GET'])
def get_consumo_item(id):
    conn = get_db()
    consumo = conn.execute("SELECT * FROM consumo WHERE id_consumo = ?", (id,)).fetchone()
    conn.close()
    if consumo is None:
        abort(404)
    return jsonify(dict(consumo))

@app.route('/consumo', methods=['POST'])
def create_consumo():
    if not request.json or 'id_venda' not in request.json or 'id_produto' not in request.json or 'quantidade' not in request.json:
        abort(400)
    consumo = {
        'id_venda': request.json['id_venda'],
        'id_produto': request.json['id_produto'],
        'quantidade': request.json['quantidade']
    }
    conn = get_db()
    cur = conn.cursor()
    cur.execute("INSERT INTO consumo (id_venda, id_produto, quantidade) VALUES (?, ?, ?)",
                (consumo['id_venda'], consumo['id_produto'], consumo['quantidade']))
    conn.commit()
    consumo['id_consumo'] = cur.lastrowid
    conn.close()
    return jsonify(consumo), 201

@app.route('/consumo/<int:id>', methods=['PUT'])
def update_consumo(id):
    if not request.json:
        abort(400)
    campos = []
    valores = []
    for campo in ['id_venda', 'id_produto', 'quantidade']:
        if campo in request.json:
            campos.append(f"{campo} = ?")
            valores.append(request.json[campo])
    if not campos:
        abort(400)
    valores.append(id)
    conn = get_db()
    conn.execute(f"UPDATE consumo SET {', '.join(campos)} WHERE id_consumo = ?", valores)
    conn.commit()
    conn.close()
    return jsonify({'result': True})

@app.route('/consumo/<int:id>', methods=['DELETE'])
def delete_consumo(id):
    conn = get_db()
    conn.execute("DELETE FROM consumo WHERE id_consumo = ?", (id,))
    conn.commit()
    conn.close()
    return jsonify({'result': True})

if __name__ == '__main__':
    app.run(debug=True)

Entendendo os Verbos HTTP Utilizados

Nesta API, utilizamos os seguintes métodos HTTP:

  • GET: Recupera dados dos registros. Por exemplo, GET /clientes retorna todos os clientes e GET /clientes/<id> retorna um cliente específico.
  • POST: Cria um novo registro. Por exemplo, POST /produtos espera dados em JSON para criar um novo produto.
  • PUT: Atualiza um registro existente. Por exemplo, PUT /materiais/<id> atualiza as informações do material indicado.
  • DELETE: Remove um registro do banco. Exemplo: DELETE /vendas/<id> remove a venda informada.

Como Executar e Testar a API

Siga os passos abaixo para executar e testar a API:

  1. Salve o código em um arquivo, por exemplo, app.py.
  2. Verifique se o banco de dados loja_acai.db existe e está configurado com as tabelas apresentadas.
  3. Instale o Flask, se ainda não o fez: pip install flask
  4. Execute o aplicativo: python app.py
  5. Utilize ferramentas como Postman ou curl para testar cada endpoint.

Conclusão

Este tutorial demonstrou como criar web services em Python para consumir as tabelas de um banco de dados SQLite da loja de açaí, abrangendo as tabelas Clientes, Produtos, Materiais, Vendas e Consumo. Ao utilizar o Flask e os principais verbos HTTP, você obteve uma API REST simples e modular, facilitando a integração com outras aplicações.

Experimente testar cada endpoint e ajustar o código conforme as necessidades do seu projeto!

Python SQLite
Exemplo prático de Python para loja Açaí

Tutorial: Web Services em Python para a Tabela Clientes

Neste tutorial, vamos criar uma API REST simples em Python utilizando o Flask para consumir a tabela Clientes de um banco de dados SQLite. Você aprenderá como utilizar os principais verbos HTTP (GET, POST, PUT e DELETE) para realizar operações de leitura, criação, atualização e exclusão de registros.


Requisitos

  • Python 3 instalado
  • Pacote Flask (instalável via pip install flask)
  • Banco de dados SQLite já criado com a tabela clientes

Estrutura da Tabela Clientes

Considere que a tabela clientes foi criada com a seguinte estrutura:


CREATE TABLE clientes (
  id_cliente INTEGER PRIMARY KEY AUTOINCREMENT,
  nome TEXT NOT NULL,
  telefone TEXT,
  email TEXT
);

Código do Web Service

O código a seguir implementa uma API REST utilizando Flask. Ele define uma rota para cada operação (GET, POST, PUT e DELETE) na tabela clientes:


from flask import Flask, request, jsonify, abort
import sqlite3

app = Flask(__name__)
DATABASE = 'loja_acai.db'  # Nome do banco de dados SQLite

def get_db():
    """Abre uma conexão com o banco de dados e define o row_factory para retornar dicts."""
    conn = sqlite3.connect(DATABASE)
    conn.row_factory = sqlite3.Row
    return conn

# 1. GET /clientes - Retorna todos os clientes
@app.route('/clientes', methods=['GET'])
def get_clientes():
    conn = get_db()
    clientes = conn.execute("SELECT * FROM clientes").fetchall()
    conn.close()
    return jsonify([dict(row) for row in clientes])

# 2. GET /clientes/&lt;id&gt; - Retorna um cliente específico
@app.route('/clientes/&lt;int:id&gt;', methods=['GET'])
def get_cliente(id):
    conn = get_db()
    cliente = conn.execute("SELECT * FROM clientes WHERE id_cliente = ?", (id,)).fetchone()
    conn.close()
    if cliente is None:
        abort(404)
    return jsonify(dict(cliente))

# 3. POST /clientes - Cria um novo cliente
@app.route('/clientes', methods=['POST'])
def create_cliente():
    if not request.json or 'nome' not in request.json:
        abort(400)
    cliente = {
        'nome': request.json['nome'],
        'telefone': request.json.get('telefone', ''),
        'email': request.json.get('email', '')
    }
    conn = get_db()
    cur = conn.cursor()
    cur.execute("INSERT INTO clientes (nome, telefone, email) VALUES (?, ?, ?)",
                (cliente['nome'], cliente['telefone'], cliente['email']))
    conn.commit()
    cliente['id_cliente'] = cur.lastrowid
    conn.close()
    return jsonify(cliente), 201

# 4. PUT /clientes/&lt;id&gt; - Atualiza um cliente existente
@app.route('/clientes/&lt;int:id&gt;', methods=['PUT'])
def update_cliente(id):
    if not request.json:
        abort(400)
    campos = []
    valores = []
    for campo in ['nome', 'telefone', 'email']:
        if campo in request.json:
            campos.append(f"{campo} = ?")
            valores.append(request.json[campo])
    if not campos:
        abort(400)
    valores.append(id)
    conn = get_db()
    conn.execute(f"UPDATE clientes SET {', '.join(campos)} WHERE id_cliente = ?", valores)
    conn.commit()
    conn.close()
    return jsonify({'result': True})

# 5. DELETE /clientes/&lt;id&gt; - Remove um cliente
@app.route('/clientes/&lt;int:id&gt;', methods=['DELETE'])
def delete_cliente(id):
    conn = get_db()
    conn.execute("DELETE FROM clientes WHERE id_cliente = ?", (id,))
    conn.commit()
    conn.close()
    return jsonify({'result': True})

if __name__ == '__main__':
    app.run(debug=True)

Entendendo os Verbos HTTP

Neste exemplo, utilizamos os seguintes métodos HTTP:

  • GET: Utilizado para recuperar dados. Temos dois endpoints:
    • GET /clientes – retorna todos os clientes;
    • GET /clientes/<id> – retorna um cliente específico.
  • POST: Utilizado para criar um novo recurso. O endpoint POST /clientes recebe dados no formato JSON para inserir um novo cliente.
  • PUT: Utilizado para atualizar um recurso existente. O endpoint PUT /clientes/<id> recebe os campos que devem ser atualizados do cliente informado.
  • DELETE: Utilizado para remover um recurso. O endpoint DELETE /clientes/<id> exclui o cliente com o id informado.

Como Executar e Testar a API

Siga os passos abaixo para executar e testar a API:

  1. Salve o código em um arquivo, por exemplo, app.py.
  2. Certifique-se de que o banco de dados loja_acai.db existe e contém a tabela clientes.
  3. Instale o Flask se ainda não o fez: pip install flask
  4. Execute o aplicativo: python app.py
  5. Acesse os endpoints utilizando ferramentas como Postman ou o curl via linha de comando.

Conclusão

Este tutorial apresentou de forma didática como criar web services em Python para a tabela clientes utilizando Flask, explorando os verbos HTTP básicos necessários para a manipulação dos dados (GET, POST, PUT e DELETE). Essa estrutura pode ser facilmente expandida para incluir outras tabelas e funcionalidades em seu projeto.

Experimente testar e modificar os endpoints para adaptar à sua aplicação.

Python
Programação Orientado a Objetos em Python

A programação orientada a objetos (POO) é um paradigma de programação que organiza o código em “objetos” – estruturas que combinam dados (atributos) e comportamentos (métodos). Python, por ser uma linguagem multiparadigma, possui um suporte robusto à POO, permitindo que desenvolvedores criem aplicações mais organizadas, reutilizáveis e de fácil manutenção. Neste artigo, abordaremos os principais princípios da orientação a objetos: encapsulamento, herança, polimorfismo e abstração, apresentando exemplos didáticos para cada um.


1. Conceitos Básicos de Orientação a Objetos

Antes de explorarmos os princípios, vamos relembrar dois conceitos fundamentais:

  • Classe: É um “molde” ou “projeto” que define os atributos (dados) e os métodos (funções) que seus objetos terão.
  • Objeto: É uma instância de uma classe. Cada objeto possui seu próprio estado, representado pelos valores dos atributos.

Exemplo simples de classe e objeto em Python:

class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade

    def apresentar(self):
        print(f"Olá, meu nome é {self.nome} e tenho {self.idade} anos.")

# Criação de objetos
p1 = Pessoa("Alice", 30)
p2 = Pessoa("Bruno", 25)

p1.apresentar()  # Saída: Olá, meu nome é Alice e tenho 30 anos.
p2.apresentar()  # Saída: Olá, meu nome é Bruno e tenho 25 anos.

2. Princípios da Orientação a Objetos

2.1 Encapsulamento

Encapsulamento é o mecanismo que agrupa dados e métodos que operam sobre esses dados dentro de uma mesma unidade (classe), restringindo o acesso direto a alguns componentes. Isso ajuda a proteger o estado interno do objeto e permite modificar a implementação interna sem afetar a interface pública.

Exemplo de encapsulamento com atributos privados:

class ContaBancaria:
    def __init__(self, saldo_inicial):
        self.__saldo = saldo_inicial  # Atributo privado

    def depositar(self, valor):
        if valor > 0:
            self.__saldo += valor
            print(f"Depósito de R${valor} realizado com sucesso.")

    def sacar(self, valor):
        if 0 < valor <= self.__saldo:
            self.__saldo -= valor
            print(f"Saque de R${valor} realizado com sucesso.")
        else:
            print("Saldo insuficiente ou valor inválido.")

    def mostrar_saldo(self):
        print(f"Saldo atual: R${self.__saldo}")

# Uso da classe
conta = ContaBancaria(1000)
conta.depositar(500)
conta.sacar(300)
conta.mostrar_saldo()

# A tentativa de acesso direto ao atributo privado resultará em erro:
# print(conta.__saldo)  -> AttributeError

No exemplo acima, o atributo __saldo é privado e não pode ser acessado diretamente fora da classe. Os métodos depositar, sacar e mostrar_saldo formam a interface pública para interagir com esse dado.


2.2 Herança

Herança permite que uma classe herde atributos e métodos de outra, promovendo a reutilização de código e a criação de hierarquias. A classe que herda é chamada de subclasse ou classe derivada, enquanto a classe de onde se herda é chamada de superclasse ou classe base.

Exemplo de herança:

class Veiculo:
    def __init__(self, marca, modelo):
        self.marca = marca
        self.modelo = modelo

    def exibir_info(self):
        print(f"Marca: {self.marca}, Modelo: {self.modelo}")

# Classe derivada que herda de Veiculo
class Carro(Veiculo):
    def __init__(self, marca, modelo, portas):
        super().__init__(marca, modelo)  # Chama o construtor da superclasse
        self.portas = portas

    def exibir_info(self):
        super().exibir_info()
        print(f"Portas: {self.portas}")

# Uso das classes
veiculo = Veiculo("Genérico", "Modelo X")
veiculo.exibir_info()

print("----")

carro = Carro("Toyota", "Corolla", 4)
carro.exibir_info()

Aqui, a classe Carro herda de Veiculo e adiciona o atributo portas, além de sobrescrever o método exibir_info para incluir informações específicas do carro.


2.3 Polimorfismo

Polimorfismo é a capacidade de diferentes classes responderem de forma específica à mesma mensagem (método). Ou seja, métodos com o mesmo nome podem ter implementações diferentes em classes distintas.

Exemplo de polimorfismo:

class Animal:
    def emitir_som(self):
        pass  # Método abstrato, sem implementação

class Cachorro(Animal):
    def emitir_som(self):
        print("Au Au")

class Gato(Animal):
    def emitir_som(self):
        print("Miau")

# Função que recebe um objeto do tipo Animal e chama emitir_som
def fazer_animal_emitir_som(animal):
    animal.emitir_som()

# Uso do polimorfismo
cachorro = Cachorro()
gato = Gato()

fazer_animal_emitir_som(cachorro)  # Saída: Au Au
fazer_animal_emitir_som(gato)      # Saída: Miau

Apesar dos objetos Cachorro e Gato serem instâncias de classes diferentes, ambos implementam o método emitir_som. Assim, a função fazer_animal_emitir_som pode receber qualquer objeto derivado de Animal e executar o método correspondente.


2.4 Abstração

Abstração consiste em ocultar os detalhes de implementação e mostrar apenas a funcionalidade essencial ao usuário. Em Python, podemos utilizar classes abstratas para definir métodos que devem ser implementados por suas subclasses. A biblioteca abc (Abstract Base Classes) facilita a criação de classes abstratas.

Exemplo de abstração usando o módulo abc:

from abc import ABC, abstractmethod

class FormaGeometrica(ABC):
    @abstractmethod
    def calcular_area(self):
        pass

class Quadrado(FormaGeometrica):
    def __init__(self, lado):
        self.lado = lado

    def calcular_area(self):
        return self.lado ** 2

class Circulo(FormaGeometrica):
    def __init__(self, raio):
        self.raio = raio

    def calcular_area(self):
        import math
        return math.pi * (self.raio ** 2)

# Tentativa de instanciar a classe abstrata gera erro:
# forma = FormaGeometrica()  -> TypeError

# Uso das classes concretas
quadrado = Quadrado(4)
circulo = Circulo(3)

print(f"Área do quadrado: {quadrado.calcular_area()}")  # Saída: 16
print(f"Área do círculo: {circulo.calcular_area():.2f}")  # Saída: valor aproximado

No exemplo, FormaGeometrica é uma classe abstrata que define o método calcular_area como abstrato. As classes Quadrado e Circulo implementam esse método de acordo com suas fórmulas específicas.


Conclusão

A orientação a objetos em Python oferece uma maneira estruturada e intuitiva de organizar o código. Ao utilizar os princípios de encapsulamento, herança, polimorfismo e abstração, os desenvolvedores podem criar sistemas mais robustos, modulares e fáceis de manter. Esperamos que os exemplos apresentados neste artigo ajudem a compreender melhor esses conceitos e inspirem a aplicação deles em seus projetos!

Python
Debugando em Python

O debug de script em python é bem simples.

Entre o seguinte import, no bloco que quer debugar.

import pdb

Para inserir um ponto de parada use o comando.

pdb.set_trace()

Desta forma é possível realizar um debug por linha de comando semelhante ao gdb do c.

Para rodar o python em modo debug use o comando:,

python -m pdb [script.py]

Irei em momento oportuno mostrar maiores detalhes desta técnica.

IA Python
Keras – Topologia

Topologia baseada em empilhamento

Modelo sequencial

  • Densa – Totalmente conectada
  • Embedding –
  • Dropout – Remove conexões aleatórias

Função de ativação

Cada camada tem uma função de ativação.

Entre elas:

  • relu – camadas intermediarias ou ocultas, pois mostra os valores reais.
  • sigmoid – Te da um valor de probabilidade 0-1

Hiper parâmetros

Afeta a performace da rede.

  • LOSS – função de perda (mean_squared_error)
  • Optimizer – Otimizador de ajuste de pesos da rede. ADAM (stochastic gradient descent)
  • Metrics – Metrica de previsão para apurar se esta certo.

Exemplo de modelo

modelo = Sequental()

modelo.add(tipo)

modelo.add(Dropout(0.2))

modelo.add(tipo)

modelo.add(Dropout(0.2))

modelo.add(tipo)

modelo.add(Dropout(0.2))

Tipos:

#camadas intermediarias

Dense(output_dim=10, input_dim=X_train.shape[1], activation=’relu’))

#Camada de finalização

Dense(output_dim=10, input_dim=X_train.shape[1], activation=’sigmoid’))

C/C++ Desenvolvimento de Software Python
Desenvolvimento com KINECT

No primeiro artigo, apresentei a instalação do kinect no ubuntu.

Artigo tratando o kinect no ubuntu

Agora iremos falar e mostrar um pouco sobre seu desenvolvimento.

GITHUB do Projeto

O projeto do libfreenect fica neste repositório.

https://github.com/OpenKinect/libfreenect.git

Site do Projeto

https://openkinect.org/wiki/Low_Level

Meu GITHUB

Ja os meus conjuntos de testes, inclusive os apresentados nos artigos relacionados, podem ser vistos, neste repositório.

https://github.com/marcelomaurin/kinect

Instalação de desenvolvimento

O processo de instalação completo foi visto no artigo anterior, porem para efeito de desenvolvimento os pacotes necessários são:

sudo apt install libudev-dev
sudo apt install libglfw3-dev
sudo apt install freeglut3-dev
sudo apt install libfreenect-dev

Sendo os 3 pacotes iniciais, apenas apoio, e o libfreenect-dev realmente a lib necessária.

Hello World da Biblioteca

Neste primeiro projeto, pouca coisa faremos, apenas iremos compilar identificando o device.

#include <stdio.h>
#include <stdlib.h>
#include <libfreenect.h>

freenect_context *f_ctx;
freenect_device *f_dev;
int user_device_number = 0; // Normalmente 0 se você tiver apenas um Kinect

void depth_cb(freenect_device *dev, void *v_depth, uint32_t timestamp) {
    // Callback para dados de profundidade - não usado neste exemplo
}

void rgb_cb(freenect_device *dev, void *rgb, uint32_t timestamp) {
    // Salva uma imagem RGB capturada pelo Kinect
    FILE *image = fopen("output_image.ppm", "wb");
    if (image == NULL) {
        printf("Erro ao abrir o arquivo para escrita\n");
        return;
    }
    fprintf(image, "P6\n# Kinect RGB test\n640 480\n255\n");
    fwrite(rgb, 640*480*3, 1, image);
    fclose(image);
    printf("Imagem salva como output_image.ppm\n");

    // Depois de salvar a imagem, podemos sair do loop principal
    freenect_stop_video(dev);
    freenect_close_device(dev);
    freenect_shutdown(f_ctx);
    exit(0);
}

int main() {
    if (freenect_init(&f_ctx, NULL) < 0) {
        printf("freenect_init() falhou\n");
        return 1;
    }

    if (freenect_open_device(f_ctx, &f_dev, user_device_number) < 0) {
        printf("Não foi possível abrir o dispositivo\n");
        freenect_shutdown(f_ctx);
        return 1;
    }

    freenect_set_depth_callback(f_dev, depth_cb);
    freenect_set_video_callback(f_dev, rgb_cb);
    freenect_set_video_mode(f_dev, freenect_find_video_mode(FREENECT_RESOLUTION_MEDIUM, FREENECT_VIDEO_RGB));

    freenect_start_video(f_dev);

    while (freenect_process_events(f_ctx) >= 0) {
        // Processa eventos do Kinect até que a captura de imagem seja concluída
    }

    return 0;
}

Neste exemplo o programa pega o kinect e tira uma foto, salvando na maquina local.

Vamos entender o código.

A freenect_init inicia a api.

A próxima função freenect_open_device, abre o device conforme o número que estiver descrito. Isso permite abrir mais de um kinect na mesma maquina.

As funções freenect_set_depth_callback e freenect_set_video_callback criam funções de callback, para controle, se voce não sabe o que é leia este artigo:

A função freenect_set_video_mode indica os parâmetros de resolução.

Por ultimo a função freenect_start_video, dá inicio ao kinect que aciona o callback quando pronto.

Makefile

Criamos aqui o arquivo de compilação do projeto.

CC=gcc
CFLAGS=-c -Wall -I/usr/include/libfreenect
LDFLAGS=-L/usr/lib/x86_64-linux-gnu -lfreenect
SOURCES=kinect.c
OBJECTS=$(SOURCES:.c=.o)
EXECUTABLE=kinect

all: $(SOURCES) $(EXECUTABLE)

$(EXECUTABLE): $(OBJECTS) 
	$(CC) $(OBJECTS) -o $@ $(LDFLAGS)

.c.o:
	$(CC) $(CFLAGS) $< -o $@

clean:
	rm -f $(OBJECTS) $(EXECUTABLE)

Perceba aqui que o pulo do gato neste makefile, é a inclusão da pasta /usr/lib/x86_64-linux-gnu que é onde a lib se encontra. Bem como a /usr/include/libfreenect que é onde o header se encontra.

Compilando o projeto

Para compilar esse projeto, é necessário apenas rodar o script na pasta src do ubuntu:

make all

Compilando o projeto

Rodando o programa

Agora iremos rodar o programa, isso é a parte mais simples.

Ao rodar, ele captura uma foto, e salva, conforme apresentado.

Foto capturada pelo kinect.

Python
Criando uma matriz de confusão no python

Para criar uma matriz de confusão no python, usaremos as bibliotecas do scikit-learn, para tanto, precisaremos instalar.

pip install scikit-learn

Segue abaixo o código, onde faremos a matriz de confusão.

from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

# Valores reais (verdadeiros)
y_true = [2, 0, 2, 2, 0, 1]

# Valores previstos pelo modelo
y_pred = [0, 0, 2, 2, 0, 2]

# Gerar a matriz de confusão
conf_matrix = confusion_matrix(y_true, y_pred)

# Imprimir a matriz de confusão
print("Matriz de Confusão:")
print(conf_matrix)

# Para uma visualização melhor, você pode usar a biblioteca Seaborn para plotar a matriz de confusão
plt.figure(figsize=(10,7))
sns.heatmap(conf_matrix, annot=True, fmt="d")
plt.xlabel('Valores Previstos')
plt.ylabel('Valores Verdadeiros')
plt.title('Matriz de Confusão')
plt.show()

No código acima, podemos ver dois vetores, y_true, y_pred, onde os valores obtidos na leitura dos itens estão no vetor y_pred.

A matriz de referencia, é posta no y_true.

Por fim criamos a matriz de confusão:

conf_matrix = confusion_matrix(y_true, y_pred)

Criação da matriz de confusão

MNote2 Python
MNote2 – 2.31

Estamos trabalhando muito nessa versão 2.31.

Entre as mudanças

  • Fizemos a incorporação e melhoria do MQuery, onde reestilizamos vários itens.
  • Finalizamos os ajustes no windows das pesquisas no Mysql usando o MQuery.
  • Inclusão da função de embelazamento assistido, com a IA .
  • Melhorias significantes do uso da IA, com captura de codigo.
  • Incorporação de fonte em andamento do IMGJSON, responsável pela fabricação de Json de treinamento para redes neurais.
  • Incorporação de caminho das Libs no config para desenvolvimento em Linux/Windows/ARM
  • Divisão do CONFIG em abas, para maior entendimento do projeto.

Ainda há um longo caminho em busca do ideal.

O MNote ainda é um projeto embrionário , e tem ainda muito a avançar.

Estamos direcionando o MNote2 para ser uma opção de Desenvolvimento Python.

Para isso muitos outros recursos e funcionalidades ainda devem ser desenvolvidas.

Acompanhe o desenvolvimento desta ferramenta.

SCREEN SHOTS

Tela principal do MNote, com código do próprio fonte.

Tela do MQuery, com acesso a banco de dados Mysql apenas no Windows garantido, o processo do linux ainda esta em desenvolvimento.

Exemplo de uso integrado com OpenAI

Fragmento de codigo , préviamente separado.

Construção e teste de WebAPI

Analise dos resultados.

Com log de comunicação

Melhoria estéticas do config, com aprimoramento e inclusão de caminhos de Libs.

Python
Python – Implementando aplicações modulares

O Python é uma das linguagens mais simples e intuitivas já criadas, por este motivo, amplamente utilizada por muitos desenvolvedores de diversas áreas. No entanto, à medida que os projetos crescem e se tornam mais complexos, manter o código organizado e de fácil manutenção pode ser um desafio.

Muitas vezes criamos projetos simples, que ganham complexidade e volume a medida que novos recursos ou funcionalidades são agregados.

Em um dado momento temos que repensar o projeto, reorganizando-o de forma a torna-lo mais legível.

Por Que Seguir Boas Práticas?

A manutenção de projetos é um estado de arte a parte do desenvolvimento. Criar projetos de sucesso, é apenas 50% do trabalho, pois um programa precisa ser gerido e mantido por anos. Então garantir que tais mudanças sejam implementadas, faz parte do trabalho de qualquer bom programador.

A colaboração – A muitos anos atras os programadores sonhavam ser Michelangelo, onde fariam e escreveriam obras de arte icônicas, que somente eles os manteriam. Isso mudou. A produção de software se industrializou, tornando um negócio de muitos, e a colaboração na codificação faz parte da vida de qualquer programador, nos dias atuais.

Melhora na organização de códigos, não só ajuda a entender o projeto de forma global, como tambem a não criar redundancias lógicas. Colocando em risco o projeto.

Como fazer isso

Estarei apresentando aqui, uma breve descrição de como separar os códigos em Python.

Módulos

Módulos são um conjunto de arquivos, contidos em uma pasta, que possuem uma hierarquia vinculada a este módulo. São muito úteis, pois conseguimos agrupar tais fontes a um conjunto comum.

Para criar um módulo, simplesmente criamos uma pasta, e adicionamos dentro deste o arquivo. __init__.py.

Adicionaremos outros arquivos .py conforme nossa necessidade.

Para carregar um codigo de um dado modulo, faremos no programa principal a seguinte chamada:

from meumodulo import meufonte

De forma geral o módulo deverá estar em uma subpasta do seu fonte principal.

Existem variações para criação de módulos, porem a forma mais simples de sua criação , foi descrita aqui.

Programação é feita com tijolos de conhecimento, um único tijolo não te torna um programador, assim como um tijolo não vira uma casa. Porem cada tijolo de conhecimento é importante para compor um grande programador.