DEV Community: Leandro Duarte

Padrões de Projetos Comportamentais

Leandro Duarte — Wed, 26 Jul 2023 16:02:07 +0000

Resumo

Este artigo tem como propósito investigar os Padrões de Projeto Comportamentais, os quais podem ser aplicados em projetos de desenvolvimento de software. Tais padrões representam abordagens cientificamente fundamentadas para promover a implementação de códigos limpos, bem estruturados e de fácil compreensão. Além disso, abordaremos a relevância da reutilização de código como um dos principais objetivos decorrentes da adoção desses padrões. Demonstra-se que a aplicação de qualquer um desses padrões viabiliza a concepção de sistemas completos com maior eficiência, exigindo menos linhas de código e fomentando uma organização mais eficaz.

Palavras-chave: Orientação a Objetos, Padrões de Projeto, GoF

Introdução

Cada profissional envolvido no desenvolvimento de softwares adota suas próprias abordagens para organizar e alcançar a finalização do produto desejado. No entanto, por trás desse processo, há uma relevante convenção respaldada pela comunidade internacional, a qual fornece diretrizes valiosas sobre a construção adequada de cada sistema. Ao acatar essas recomendações e adotar boas práticas, alcançaremos um nível de desenvolvimento em que nossos códigos se tornarão altamente reutilizáveis e facilmente compreensíveis.

O principal objetivo da utilização desses padrões é, justamente, promover a organização em nossos projetos. Visto que nem sempre atuamos de forma isolada, uma excelente comunicação e organização são fundamentais para o sucesso de projetos em equipe. Ao adotar essas práticas, facilitamos a colaboração, possibilitando um ambiente propício para uma construção conjunta eficiente.

Manutenções e adições são temidas por inúmeros desenvolvedores, uma vez que algo pequeno como a adição de um novo objeto ou edição do mesmo se torne um grande problema no futuro. Uma vez que será necessário mexer em dezenas de outros arquivos para algo que poderia ser feito com maior produtividade se houvessem boas práticas inseridas no projeto.

Os Padrões

Existem diversas opções de padrões que podem e devem ser adotados pelos desenvolvedores. Neste tópico, serão abordados detalhadamente esses padrões, além de serem apresentados exemplos concretos de suas aplicações em projetos reais. É importante ressaltar que, de acordo com as particularidades de cada projeto, é necessário ajustar a lógica de implementação, uma vez que cada empreendimento possui necessidades e funcionalidades distintas.

A aplicação de, pelo menos, um desses padrões durante o desenvolvimento possibilita prevenir futuras dores de cabeça. Ao escolher estrategicamente e adotar tais padrões, os desenvolvedores podem mitigar problemas potenciais e simplificar a manutenção do sistema no futuro. A reflexão acerca da escolha e implementação dessas práticas resultará em benefícios significativos para o sucesso do projeto.

Quais são?

Teremos um post para cada um deles, mas os principais são:

Padrão Strategy (Estratégia): Permite definir uma família de algoritmos, encapsular cada um deles e torná-los intercambiáveis. Isso permite que o cliente escolha o algoritmo a ser usado sem modificar o código do cliente.
Padrão Observer (Observador): Define uma dependência um-para-muitos entre objetos, de modo que, quando um objeto muda de estado, todos os seus dependentes são notificados e atualizados automaticamente.
Padrão Chain of Responsibility (Corrente de Responsabilidade): Permite que você envie uma solicitação ao longo de uma cadeia de objetos. Cada objeto na cadeia pode tratar a solicitação ou passá-la para o próximo objeto na cadeia.
Padrão Command (Comando): Encapsula uma solicitação como um objeto, permitindo que você parametrize clientes com diferentes solicitações, enfileire ou registre solicitações e suporte operações reversíveis (desfazer).
Padrão Template Method (Método Template): Define o esqueleto de um algoritmo em uma operação, mas permite que as subclasses redefinam etapas específicas desse algoritmo sem alterar sua estrutura.
Padrão State (Estado): Permite que um objeto altere seu comportamento quando seu estado interno muda. Parece que o objeto mudou sua classe.
Padrão Interpreter (Intérprete): Fornece uma maneira de avaliar a gramática ou expressão de uma linguagem.
Padrão Visitor (Visitante): Permite adicionar novas operações a uma estrutura de objetos existente sem modificar essa estrutura.
Padrão Mediator (Mediador): Define um objeto que centraliza a comunicação entre objetos em um sistema. Os objetos se comunicam por meio do mediador, em vez de se comunicarem diretamente entre si.
Padrão Memento (Memorando): Permite que você capture e restaure o estado interno de um objeto sem expor sua estrutura interna.

Experimente meu game de Dragon Ball no Scratch

Leandro Duarte — Fri, 21 Jul 2023 14:09:21 +0000

Experimente meu jogo feito dentro do scratch!

Foi um projeto desenvolvido como tarefa para um curso na edX e gostaria de apresentar a vocês essa maravilha de projeto.

Ainda falta muita coisa, mas já dá pra notar que pode se tornar algo bem bacana no futuro. Vou adicionando outros recursos, personagens, assets com o passar do tempo e vou atualizando aqui dentro do DEV

Espero que goste da trilha sonora! ~~SINTA A NOSTALGIA~~

Aqui está o link para jogarem:
https://scratch.mit.edu/projects/770653435/

E se você tiver algum feedback, deixe abaixo aqui. Caso queira contribuir de alguma maneira, basta entrar em contato comigo pelo email: duartewgo@gmail.com

Espero que tenham gostado! ~~BRIGADUH!~~

Discussão: Como você se vê no futuro?

Leandro Duarte — Thu, 20 Jul 2023 23:59:06 +0000

Fala devs, tudo bem? Hoje o post sai um pouco dos tradicionais tutoriais e vai para uma discussão bem séria.

Essa pergunta é muito comum em entrevistas de empregos e normalmente sempre temos aquela resposta padrão de: quero crescer profissionalmente, quero aumentar minha "senioridade".

Nesse post, não vale dar essas respostas clichês. Eu quero saber o que você realmente pensa sobre o seu futuro. Você tem algum objetivo? Se sim, compartilhe aí pra nós e diga os "passos" que você pretende dar para chegar nesse objetivo.. hahaha!

Bora começar! 🚀

🐍 Práticas recomendadas para testes de unidade em Python 🧪

Leandro Duarte — Mon, 15 May 2023 14:06:05 +0000

Introdução

Os testes de unidade são uma parte essencial do processo de desenvolvimento de software, permitindo que os desenvolvedores verifiquem se suas unidades de código (funções, classes, métodos) estão funcionando corretamente. Em Python, existem várias práticas recomendadas que podem melhorar a eficácia e a qualidade dos testes de unidade. Aqui estão exemplificada as 5 primeiras. O restante irei apenas citar, mas é importante que você possa procurar sobre o assunto em outras fontes.

1️⃣ - Estrutura de Testes

Python oferece diversas bibliotecas populares para testes de unidade, como o unittest, pytest e nose. Essas estruturas fornecem uma série de recursos úteis, como assertivas, fixtures e relatórios de testes.

A seguir um exemplo com pytest

# test_calculadora.py
import pytest

def soma(a, b):
    return a + b

def test_soma():
    assert soma(2, 3) == 5
    assert soma(0, 0) == 0
    assert soma(-1, 1) == 0

def test_soma_negativos():
    assert soma(-5, -7) == -12
    assert soma(-10, 10) == 0
    assert soma(-2, 2) == 0

Neste exemplo, temos um módulo chamado test_calculadora.py que contém duas funções de teste: test_soma() e test_soma_negativos(). Essas funções são identificadas pelo prefixo "test_" e serão reconhecidas e executadas pelo pytest.

Cada função de teste contém uma ou mais assertivas, que verificam se os resultados da função soma() estão corretos. Se todas as assertivas passarem, o teste é considerado bem-sucedido. Caso contrário, uma falha será relatada, indicando que algo está errado no código.

Para executar esses testes, você precisa ter o pytest instalado em seu ambiente. Em seguida, você pode executar o pytest no diretório que contém o arquivo de teste. O pytest encontrará automaticamente todas as funções de teste e as executará:

$ pytest

O pytest fornecerá um relatório de execução dos testes, indicando quais testes passaram e quais falharam.

Essa é apenas uma pequena amostra do uso da biblioteca pytest para testes de unidade em Python. Ela oferece muitos recursos adicionais, como fixtures (para configurações pré e pós-teste), parâmetros de teste parametrizados, captura de exceções esperadas e muito mais. Com o pytest, você pode escrever testes concisos, legíveis e eficazes para garantir a qualidade do seu código.

2️⃣ - Testes Independentes

Cada teste deve ser independente e não depender do resultado de outros testes. Isso ajuda a isolar problemas e torna os testes mais confiáveis.

Aqui está um exemplo que demonstra a escrita de testes independentes usando a biblioteca unittest em Python:

import unittest

def soma(a, b):
    return a + b

class TestCalculadora(unittest.TestCase):
    def test_soma_positivos(self):
        resultado = soma(2, 3)
        self.assertEqual(resultado, 5)

    def test_soma_negativos(self):
        resultado = soma(-5, -7)
        self.assertEqual(resultado, -12)

    def test_soma_zero(self):
        resultado = soma(0, 0)
        self.assertEqual(resultado, 0)

Neste exemplo, temos uma classe de teste chamada TestCalculadora, que herda da classe unittest.TestCase. Dentro dessa classe, temos três métodos de teste: test_soma_positivos(), test_soma_negativos() e test_soma_zero().

Cada método de teste é independente e não depende dos resultados de outros testes. Cada um deles chama a função soma() com diferentes argumentos e verifica se o resultado é o esperado usando a assertiva self.assertEqual().

Para executar esses testes usando a estrutura de testes unittest, você pode criar um arquivo separado com o seguinte código:

import unittest

# Importe a classe de teste
from test_calculadora import TestCalculadora

# Carregue os testes da classe
suite = unittest.TestLoader().loadTestsFromTestCase(TestCalculadora)

# Crie um TestRunner
runner = unittest.TextTestRunner()

# Execute os testes
result = runner.run(suite)

Ao executar esse arquivo, você verá o resultado dos testes, indicando se cada um passou ou falhou. Cada teste é executado de forma independente, garantindo que problemas em um teste não afetem os resultados dos outros testes.

Ao escrever testes independentes, você pode ter confiança de que cada teste está sendo executado em um contexto isolado, o que torna os testes mais confiáveis e facilita a identificação e correção de problemas específicos.

3️⃣ - Nome descritivos aos testes

Escolha nomes significativos para seus testes, descrevendo o comportamento que eles estão testando. Isso facilita a identificação de problemas quando os testes falham e ajuda a documentar a intenção do teste.

Aqui está um exemplo que ilustra a escolha de nomes significativos para os testes, descrevendo o comportamento que eles estão testando:

import unittest

def adicionar(a, b):
    return a + b

class TestCalculadora(unittest.TestCase):
    def test_adicionar_numeros_positivos(self):
        resultado = adicionar(2, 3)
        self.assertEqual(resultado, 5)

    def test_adicionar_numeros_negativos(self):
        resultado = adicionar(-5, -7)
        self.assertEqual(resultado, -12)

    def test_adicionar_numero_positivo_e_negativo(self):
        resultado = adicionar(10, -5)
        self.assertEqual(resultado, 5)

Neste exemplo, temos uma classe de teste chamada TestCalculadora que contém três métodos de teste: test_adicionar_numeros_positivos(), test_adicionar_numeros_negativos() e test_adicionar_numero_positivo_e_negativo().

Cada método de teste possui um nome descritivo que indica claramente o comportamento sendo testado. Por exemplo, o método test_adicionar_numeros_positivos() verifica se a função adicionar() retorna o resultado correto ao adicionar dois números positivos. Da mesma forma, os outros métodos de teste descrevem o comportamento específico sendo testado.

Ao escolher nomes significativos para os testes, fica mais fácil identificar qual aspecto do código está sendo testado quando ocorre uma falha. Além disso, esses nomes ajudam a documentar a intenção do teste, permitindo que outros desenvolvedores compreendam rapidamente o que está sendo testado e qual é o resultado esperado.

Isso torna os testes mais legíveis, facilita a manutenção e melhora a clareza da documentação associada aos testes.

4️⃣ - Use mocks e stubs

Quando um código depende de recursos externos, como bancos de dados ou APIs, é recomendado o uso de mocks ou stubs para simular essas dependências durante os testes. Isso torna os testes mais rápidos e independentes de fatores externos.

Aqui está um exemplo que demonstra o uso de mocks para simular uma dependência externa durante os testes:

import unittest
from unittest.mock import MagicMock

class API:
    def get_data(self):
        # Lógica para obter dados de uma API externa
        pass

def processar_dados_da_api(api):
    dados = api.get_data()
    # Lógica para processar os dados recebidos da API
    return dados

class TestProcessamento(unittest.TestCase):
    def test_processar_dados_da_api(self):
        # Criação do mock da API
        mock_api = MagicMock()
        mock_api.get_data.return_value = {'valor': 42}

        # Execução do código que depende da API
        resultado = processar_dados_da_api(mock_api)

        # Verificação do resultado
        self.assertEqual(resultado, {'valor': 42})

Neste exemplo, temos uma classe API que representa uma dependência externa, como uma API que retorna dados. Em seguida, temos uma função processar_dados_da_api() que depende dessa API para obter e processar os dados.

Durante o teste, criamos um mock da classe API usando MagicMock da biblioteca unittest.mock. Configuramos o retorno do método get_data() do mock para simular os dados que seriam obtidos da API real.

Ao chamar a função processar_dados_da_api() com o mock da API, estamos simulando o comportamento da dependência externa durante o teste, sem precisar realmente fazer uma chamada à API real. Isso torna o teste mais rápido, independente de recursos externos e não está sujeito a falhas ou variações externas.

Em seguida, podemos verificar se o resultado do processamento está correto usando as assertivas apropriadas, como self.assertEqual().

O uso de mocks ou stubs para simular dependências externas é uma prática recomendada ao testar código que depende de recursos externos, como bancos de dados, APIs, serviços web, entre outros. Isso permite que você isole o código que está sendo testado e torne os testes mais rápidos, previsíveis e independentes de fatores externos.

5️⃣ - Cubra diferentes casos de teste

Cubra diferentes casos de teste: Certifique-se de criar casos de teste que cubram todas as ramificações do código, incluindo casos de teste positivos e negativos. Isso ajuda a identificar erros e aumenta a confiabilidade do código testado.

Aqui está outro exemplo que demonstra a cobertura de diferentes casos de teste, incluindo casos positivos e negativos:

import unittest

def validar_idade(idade):
    if idade < 0:
        raise ValueError("A idade não pode ser negativa")
    elif idade < 18:
        return "Menor de idade"
    else:
        return "Maior de idade"

class TestValidacaoIdade(unittest.TestCase):
    def test_idade_positiva_menor(self):
        resultado = validar_idade(15)
        self.assertEqual(resultado, "Menor de idade")

    def test_idade_positiva_maior(self):
        resultado = validar_idade(25)
        self.assertEqual(resultado, "Maior de idade")

    def test_idade_zero(self):
        resultado = validar_idade(0)
        self.assertEqual(resultado, "Menor de idade")

    def test_idade_negativa(self):
        with self.assertRaises(ValueError):
            validar_idade(-10)

Neste exemplo, temos uma função validar_idade() que recebe uma idade como parâmetro e retorna uma string indicando se a idade é "Menor de idade" ou "Maior de idade". Ela inclui verificações para lidar com idades negativas.

A classe de teste TestValidacaoIdade contém quatro métodos de teste diferentes:

test_idade_positiva_menor() verifica se a função validar_idade() retorna corretamente "Menor de idade" para uma idade positiva abaixo de 18.
test_idade_positiva_maior() verifica se a função validar_idade() retorna corretamente "Maior de idade" para uma idade positiva igual ou acima de 18.
test_idade_zero() verifica se a função validar_idade() retorna corretamente "Menor de idade" para uma idade igual a zero.
test_idade_negativa() verifica se a função validar_idade() lança corretamente uma exceção ValueError ao receber uma idade negativa.

Esses casos de teste cobrem diferentes cenários relacionados à validação da idade. Eles incluem idades positivas menores e maiores de 18, além de abordar os casos de idade igual a zero e idades negativas.

Ao criar casos de teste que abrangem essas ramificações do código, podemos identificar possíveis erros e garantir que o código seja confiável em diferentes cenários. Isso aumenta a cobertura de testes e a confiabilidade do código testado.

6️⃣ - Automatize os testes:

Integre os testes de unidade em um pipeline de integração contínua (CI) para garantir que eles sejam executados regularmente. Isso ajuda a detectar problemas rapidamente e a evitar regressões no código.

7️⃣ - Aplique o princípio do "AAA":

A estrutura de teste deve seguir o padrão "Arrange, Act, Assert" (Preparar, Agir, Verificar). Na seção "Arrange", defina o ambiente de teste e configure os objetos necessários. Na seção "Act", invoque o código a ser testado. E na seção "Assert", verifique se o resultado está correto.

8️⃣ - Aproveite os recursos de assertivas:

Utilize as assertivas fornecidas pela estrutura de testes para verificar se os resultados são os esperados. Isso inclui assertivas de igualdade, exceções lançadas, presença de elementos em listas, entre outros.

9️⃣ - Execute testes de forma rápida e frequente:

É importante executar os testes de unidade com frequência, preferencialmente após cada alteração no código. Isso ajuda a identificar problemas o mais cedo possível e a manter a confiabilidade do código.

🔟 - Mantenha uma cobertura de testes adequada:

Acompanhe a cobertura dos testes para garantir que seu código esteja adequadamente testado. Existem ferramentas, como o coverage, que podem ajudar a medir a cobertura do código testado. Busque manter uma cobertura abrangente, cobrindo o máximo possível do código.

1️⃣1️⃣ - Refatore os testes conforme necessário:

À medida que o código evolui, os testes também devem ser atualizados. Se ocorrerem mudanças significativas no código, verifique se os testes ainda são relevantes e os atualize, se necessário.

1️⃣2️⃣ - Documente seus testes:

É útil fornecer uma documentação clara dos testes de unidade. Descreva o propósito de cada teste, os casos de teste cobertos e as expectativas de resultados. Isso facilita a compreensão e a manutenção dos testes no futuro.

1️⃣3️⃣ - Compartilhe seus testes:

Se você está trabalhando em um projeto de código aberto ou em equipe, compartilhar seus testes é uma prática recomendada. Isso permite que outros desenvolvedores vejam como usar sua funcionalidade e possam contribuir com melhorias ou correções.

1️⃣4️⃣ - Execute testes em diferentes ambientes:

Considere a execução de testes de unidade em diferentes ambientes, como diferentes sistemas operacionais ou versões do Python, para garantir a portabilidade e a compatibilidade do código.

1️⃣5️⃣ - Utilize ferramentas de análise estática:

Além dos testes de unidade, considere o uso de ferramentas de análise estática de código, como o pylint ou flake8, para identificar possíveis problemas ou más práticas no código.

Finalização

Lembre-se de que os testes de unidade são apenas uma parte do processo de garantia de qualidade de software. É importante complementá-los com outros tipos de testes, como testes de integração e testes de aceitação, para obter uma cobertura abrangente e confiável do código.

Ao seguir essas práticas recomendadas, você estará no caminho certo para escrever testes de unidade eficientes e de alta qualidade em Python. Eles ajudarão a melhorar a robustez do seu código, facilitarão a manutenção e aumentarão a confiança na funcionalidade do software desenvolvido.

Hello World com Django

Leandro Duarte — Fri, 12 May 2023 13:58:24 +0000

Introdução

Eu sei que você já ouviu falar desse belíssimo framework e tenha tido no mínimo uma curiosidadezinha para entender como ele realmente funciona. Nesse post nós iremos partir do absoluto ZERO.

Requisitos

Definiremos os requisitos, mas antes de você começar a suar as mãos achando que talvez você não seja apto, calma! Os requisitos são para o seu computador e ambiente de desenvolvimento!

1º Preparar nosso ambiente de desenvolvimento:

Aqui nós simplesmente vamos fazer o que normalmente fazemos em cada projeto Python! Vamos criar um diretório principal e criarmos o nosso Ambiente Virtual. Para isso, esteja no diretório que você quer iniciar o seu projeto e no terminal digite:

python -m venv env

Feito isso, basta dar:

Linux

source ./env/bin/activate

Windows

./env/bin/activate.ps1

2º Instalar o Django nesse novo Ambiente Virtual

Aqui nós iremos fazer a instalação de django através do gerenciador de pacotes do python pip. Basta digitarmos no terminal:

pip install django

3º Iniciarmos um Projeto Django

Vamos então dar inicio ao nosso novo projeto em Django, o primeiro de muitos! Basta no mesmo terminal digitar:

django-admin startproject nome_do_projeto .

Agora, o Django deve ter criado uma estrutura parecida com essa abaixo:

nome_do_projeto/
    __init__.py
    settings.py
    urls.py
    asgi.py
    wsgi.py
manage.py

E você está a um passo de dar início ao desenvolvimento Web, mas ainda temos algumas pendências, configurações que precisamos fazer.

Iniciando o primeiro Aplicativo

Espera, mas nós já não tínhamos feito o nosso aplicativo no passo anterior?

Na verdade não! O que nós fizemos anteriormente é a criação de um projeto. Um projeto em Django nada mais é do que um amontoado de configurações e aplicativo. Entenda que com Django você pode ter várias aplicações rodando em um mesmo projeto e essa é a beleza da coisa! Na própria documentação do Django há essa explicação e eu vou deixá-la para que você possa entender melhor!

Diferença entre app x projeto -> Qual é a diferença entre um projeto e um aplicativo? Um aplicativo é um aplicativo da web que faz algo – por exemplo, um sistema de blog, um banco de dados de registros públicos ou um pequeno aplicativo de pesquisa. Um projeto é uma coleção de configurações e aplicativos para um determinado site. Um projeto pode conter vários aplicativos. Um aplicativo pode estar em vários projetos.

Agora que estamos entendido entre a diferença de app x projeto nós iremos então finalmente dar inicio a nossa aplicação. Precisamos entender que nossa aplicação tem que possuir um diretório no mesmo local que o arquivo manage.py

python manage.py startapp nome_app

Feito o comando agora nós temos algo bem interessante aqui. Temos uma estrutura completa de um projeto e outra estrutura completa de nosso aplicativo. A documentação recomenda alguns passos antes de fazer o que iremos. Mas eu acredito que seja fundamental que a cada novo aplicativo você faça isso. Vá para a pasta do seu nome_do_projeto/settings.py e procure pela variável INSTALLED_APPS. Nela você vai adicionar a seguinte str:

INSTALLED_APPS = [
    "**nome_app**",
    'django.contrib.admin',
    ...
]

E agora fizemos então a integração do nosso app ao nosso projeto! Quero que toda vez que você dar um startapp você volte e faça isso!

Criando a primeira view

É importante entendermos que cada URL que o usuário acessar ele precisa ver algo não é? Talvez apresentar uma imagem, um post de blog ou quem sabe nós queiramos apenas deixar uma mensagem para algum visitante daquela URL. Na view, nós vamos definir o que acontecerá quando o usuário acessar uma determinada URL. Aqui eu não quero que você se preocupe em como será a sua URL, apenas no que aparecerá ao usuário.

Partindo dessa lógica, vamos abrir o arquivo nome_app/views.py e vamos criar fazer o seguinte import:

from django.shortcuts import render, HttpResponse

E logo em seguida vamos criar uma função chamada index que vai retornar um HttpResponse

def index(request):
    return HttpResponse("Olá, Mundo!")

Pronto, criamos nossa view! E agora, como eu consigo que meu usuário veja essa view?

Criando URLs dos aplicativos e das views

Aqui há um ponto muito importante a ser feito! É a criação das nossas URLS e você precisa separar esse processo em duas etapas:

1º Criando a URL do nosso app

Cada app precisa ter uma url própria! E para isso precisamos ir em nome_do_projeto/urls.py e inserir dois novos elemento:

from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path("nome_app", include("nome_app.urls", namespace="nome_app"))
]

Com isso nós fizemos a integração do nosso aplicativo ao nosso projeto e agora todas as urls de nosso aplicativo terão um .../nome_app/.... Isso é importante tendo em vista que nós queremos que cada aplicativo seja único e diferenciável! Isso ajuda até mesmo no clean code e futuros debugs.

2º Criando a URL para nossa primeira view

Lembra que nós criamos a primeira view mas eu te pedi para não se preocupar em como o usuário acessasse aquela view? Agora eu vou te pedir o oposto! Vamos criar então um endereço único para essa view a fim de aprendizagem, e claro, para que você possa realmente dizer: EU CRIEI O MEU PRIMEIRO SITE COM DJANGO. Para isso, basta criar um arquivo na raiz do seu nome_app chamado urls.py. Dentro do seu arquivo escreva:

from django.urls import path
from . import views

app_name = "nome_app"

urlpatterns = [
    path("/index", views.index, name="index")
]

E agora pronto! Tudo conectado e perfeitamente solidificado! Você criou o seu primeiro site com Django e tem uma rota única para acessar um Olá Mundo

Basta digitar no terminal:

python manage.py runserver

Feito isso, clique no link gerado pelo seu terminal e acrescente:

Ex:

http://127.0.0.1:8000/nome_app/index

Foi capaz de ver o seu Hello World? Então meus parabéns! Daqui para frente, você só tem a crescer! Há muito mais coisas e possibilidades que você pode e deve fazer! Mas eu espero ter ajudado!

Se quer mais tutoriais básicos ou até mesmo avançados, deixe seu comentário que podemos prosseguir com o nosso projeto e quem sabe criar uma grande aplicação com Django!

Até logo!!!!!!

Como fazer upload de fotos de perfil de usuários do seu app Flask para um serviço de hospedagem gratuito

Leandro Duarte — Mon, 10 Apr 2023 19:48:10 +0000

Em muitos aplicativos web, é comum permitir que os usuários carreguem fotos de perfil. No entanto, armazenar essas fotos em um servidor pode consumir muito espaço de armazenamento e pode ser lento para os usuários carregarem. É por isso que muitos desenvolvedores optam por fazer o upload dessas fotos diretamente para a nuvem.

Neste post, vou explicar como você pode usar o Cloudinary para fazer o upload de fotos de perfil do usuário do Flask diretamente para a nuvem. Você também aprenderá como salvar a URL da imagem do Cloudinary em uma coluna chamada "foto de perfil" na tabela do usuário.

Passo 1: Configurar o Cloudinary

A primeira coisa que você precisa fazer é se inscrever no Cloudinary e configurá-lo para o seu aplicativo. Depois de se inscrever, você receberá um nome de usuário, uma chave de API e uma chave secreta que você usará para autenticar suas solicitações de upload.

Mas calma, faremos isso passo a passo para que você entenda!

Primeiro, como supracitado criaremos a nossa conta no site da Cloudinary clicando aqui

Agora é com você! Crie sua conta conforme a sua necessidade. Eu, pelo menos, usei o meu GitHub para tal e achei que foi uma decisão sábia, uma vez que economizei tempo! ~~E tempo é dinheiro emmm~~

Feita a sua conta, deixe a primeira tela lá! Ela é importante, mas nós faremos outro processo aqui: a instalação do Cloudinary no seu aplicativo Python!

Para instalar a biblioteca Python do Cloudinary, você pode usar o seguinte comando no terminal do seu aplciativo (Lembre-se de estar no mesmo venv do seu aplicativo!):

pip install cloudinary

Agora que você realizou os processos acima, criaremos um arquivo na raiz do seu projeto Flask chamado config.py. Nele, colocaremos exatamente isso:

import cloudinary
import cloudinary.uploader
import cloudinary.api

cloudinary.config(
  cloud_name = "you_cloud_name",
  api_key = "you_api_key",
  api_secret = "you_api_secret"
)

Onde estiver you_*, você substituirá pelos dados que obteve na criação da sua conta no Cloudinary. Esses dados estão exatamente como no print abaixo. ~~E é claro que os meus você não irá ver haha!~~

Agora falta bem pouquinho para você integrar de vez a sua nuvem do Cloudinary ao seu aplicativo Flask! No arquivo onde estão suas rotas, você fará as seguintes importações:

import cloudinary
import config

Pronto, o seu aplicativo está totalmente integrado! Agora é só você fazer o upload das fotos dos seus usuários para a nuvem! E fazer isso é extremamente simples! Supondo que você já tenha uma coluna no seu banco de dados assim:

foto_perfil = database.Column(database.String(50), nullable=False)

Na sua rota em que o usuário modifica a foto dele, você deve fazer algo parecido com:

# upa a foto para o cloudinary
response = cloudinary.uploader.upload(form.foto_perfil.data)

# muda a coluna foto_perfil do usuario
usuario.foto_perfil = response['public_id']

Sim, isso mesmo! Dessa forma, o Cloudinary irá definir um nome para a imagem (sem repetir algum já existente) e você irá integrar esse nome na coluna foto_perfil do usuário.

E para chamar essa imagem é algo extremamente simples. No HTML, basta você fazer algo como:

<img src="{{ 'https://res.cloudinary.com/dsfomdqni/image/upload/' ~ usuario.foto_perfil }}">

OBSERVAÇÃO

Lembrando que usei algumas variáveis aqui que podem estar diferentes para o seu projeto. usuario e foto_perfil podem estar diferente para você! Cabe a você a transformação dessas variáveis de acordo com o seu projeto! Eu estou aqui para ajudar e contribuir, caso você ainda tenha dificuldades para essa integração, basta comentar abaixo que eu irei te ajudar

Bônus

Eu suponho que você queira ter uma foto como default no seu sistema! ~~Para aqueles usuarios chatos que não trocam a foto de perfil~~ Para usuários que não usam foto de perfil! Faça upload de uma foto padrão para o Cloudinary e a nomeie como default. E deixe para que toda vez que um usuário for criado seja dado um valor a coluna foto_perfil chamado default. A foto que você pode usar como default pode ser essa abaixo!

Se você usa o FlaskSQL Alchemy basta ter no seu arquivo de models algo como:

foto_perfil = database.Column(database.String(50), nullable=False, default="default.png")

Independência tecnológica: Por que o Brasil precisa urgentemente de seu próprio sistema operacional baseado em Linux?

Leandro Duarte — Sun, 09 Apr 2023 13:40:15 +0000

Recentemente, conheci a distribuição Linux HarmoniKR OS, desenvolvida na Coreia do Sul e baseada no Linux Mint. Essa descoberta me levou a questionar a possibilidade de o Brasil ter seu próprio sistema operacional reconhecido e incentivado pelo governo.

Desenvolver um sistema operacional próprio seria uma iniciativa importante para o país, tornando-o mais independente de tecnologias e avanços externos. Além disso, permitiria reduzir os custos de licenciamento, uma vez que estaríamos falando de sistemas open source, que em sua maioria são gratuitos.

Países interessados em manter a autonomia tecnológica e evitar a dependência de softwares comerciais desenvolvidos fora de suas fronteiras utilizam sistemas abertos ou versões compatíveis desenvolvidas autonomamente. A China desenvolveu o Kylin OS, e a Rússia criou o Astra Linux, ambos baseados no Linux e reconhecidos pelos governos locais.

Adotar uma versão própria de sistema operacional a partir de uma distribuição Linux permitiria ao Brasil superar a desconfiança existente em relação à existência de backdoors criados por serviços de inteligência estrangeiros nos softwares produzidos em seus países de origem. Além disso, essa iniciativa estaria alinhada com a Estratégia Nacional de Defesa, permitindo a aquisição de tecnologia de uso dual pela indústria nacional.

Em resumo, a iniciativa de criar um sistema operacional brasileiro baseado em Linux pode ser extremamente importante para o país. Isso garantiria a autonomia tecnológica, reduziria os custos de licenciamento e estaria alinhada com a Estratégia Nacional de Defesa. O Brasil tem um grande potencial para se tornar um líder tecnológico na região, e o desenvolvimento de um sistema operacional próprio seria um passo significativo nessa direção.

Bônus: Quem sabe o nome poderia ser Amazônia OS ou quem sabe um Tupi OS haha!

Como utilizar o Python para análise de dados

Leandro Duarte — Thu, 06 Apr 2023 14:11:22 +0000

Se você está interessado em análise de dados, uma das ferramentas mais populares para realizar essa tarefa é o Python. Com a sua sintaxe simples e grande variedade de bibliotecas, o Python se tornou uma das linguagens mais utilizadas na análise de dados em todo o mundo. Neste artigo, vamos dar uma olhada em algumas das bibliotecas mais utilizadas no Python para análise de dados e como utilizá-las.

O Pandas é uma biblioteca popular para a análise de dados em Python. Ele oferece várias ferramentas de manipulação de dados, como filtragem, agregação e transformação, além de permitir a importação de dados de várias fontes. O Pandas também oferece funcionalidades para visualização de dados e para a manipulação de séries temporais.

O Matplotlib é uma biblioteca de visualização de dados em Python. Ele permite a criação de gráficos de linha, barras, dispersão e muitos outros tipos de gráficos. O Matplotlib é altamente personalizável e permite que você controle muitos aspectos do gráfico, incluindo títulos, legendas, cores e fontes.

O NumPy é uma biblioteca para computação científica em Python. Ele oferece funcionalidades para trabalhar com arrays multidimensionais e para realizar operações matemáticas em grandes conjuntos de dados. O NumPy é amplamente utilizado na análise de dados e em outras áreas da ciência de dados.

O Scikit-learn é uma biblioteca para aprendizado de máquina em Python. Ele oferece vários algoritmos de aprendizado de máquina, como regressão linear, regressão logística e árvores de decisão. O Scikit-learn também oferece funcionalidades para pré-processamento de dados e avaliação de modelos.

O Seaborn é uma biblioteca de visualização de dados em Python. Ele oferece uma interface mais simples do que o Matplotlib para a criação de gráficos estatísticos avançados, como gráficos de distribuição, gráficos de densidade e gráficos de correlação. O Seaborn também é altamente personalizável e permite que você controle muitos aspectos do gráfico.

Conclusão

O Python oferece uma grande variedade de bibliotecas para análise de dados e é uma das linguagens mais populares para essa tarefa. O Pandas, o Matplotlib, o NumPy, o Scikit-learn e o Seaborn são apenas algumas das bibliotecas disponíveis. Com essas ferramentas em mãos, você estará bem equipado para realizar análises de dados avançadas em Python.

Bônus

Como bônus, vou falar sobre uma ferramenta que é simplesmente incrível para análises de dados em Python: o Jupyter. Ele é capaz de unir código, texto e visualizações em um único local, tornando a apresentação de dados muito mais fácil e interativa. Com o Jupyter, é possível criar notebooks que contêm o código para a análise de dados, juntamente com textos explicativos e visualizações dos resultados. Isso torna mais fácil para outras pessoas entenderem e reproduzirem o trabalho. Além disso, o Jupyter oferece funcionalidades para testar e depurar o código diretamente no notebook, permitindo experimentar diferentes abordagens de análise de dados. É realmente uma ferramenta indispensável para qualquer pessoa que trabalha com análise de dados em Python. Então, se você quiser impressionar seus clientes ou empregadores com apresentações incríveis de dados, o Jupyter é a escolha certa!

Como melhorar a legibilidade do código

Leandro Duarte — Mon, 03 Apr 2023 19:53:17 +0000

Como desenvolvedores, escrevemos código para expressar nossas ideias e soluções de maneira lógica e clara. No entanto, muitas vezes nos deparamos com o problema de que o nosso código pode ser difícil de ler e entender, tanto para nós mesmos quanto para outros desenvolvedores. Felizmente, há algumas práticas simples que podemos adotar para melhorar a legibilidade do nosso código.

Escolha nomes descritivos para variáveis, funções e classes: Nomes claros e concisos para as coisas que estamos definindo em nosso código tornam muito mais fácil entender o que está acontecendo em cada linha.
Mantenha uma estrutura consistente: Adotar um padrão consistente para a organização do código (como a indentação, espaçamento e nomenclatura) faz com que o código seja mais fácil de seguir e entender.
Quebre o código em blocos lógicos: Isso ajuda a dividir o código em partes menores e mais gerenciáveis. Por exemplo, se tivermos uma função grande, podemos dividi-la em várias funções menores para facilitar o entendimento.
Comente o código: Adicionar comentários explicando o que o código está fazendo (e por que está fazendo isso) pode ser extremamente útil para outras pessoas que podem estar lendo nosso código.
Simplifique a lógica: Às vezes, podemos nos perder em estruturas complicadas ou condições if/else confusas. Em vez disso, podemos simplificar a lógica tanto quanto possível para tornar o código mais fácil de entender.
Use espaços em branco: Adicionar espaços em branco entre as linhas e blocos de código pode ajudar a tornar o código mais legível.
Evite repetição: Usar loops e funções para evitar repetição de código pode tornar o código mais conciso e fácil de entender.
Mantenha o código atualizado: À medida que o código evolui e muda, é importante manter tudo atualizado e limpo. Isso pode evitar problemas de legibilidade no futuro.

Melhorar a legibilidade do código não só torna a vida dos outros desenvolvedores mais fácil, mas também torna nosso próprio trabalho mais eficiente e menos propenso a erros. Ao seguir essas práticas simples, podemos escrever código que é fácil de ler, entender e manter.

Como ter a sua primeira contribuição no GitHub garantida

Leandro Duarte — Thu, 30 Mar 2023 13:41:22 +0000

Como ter a sua primeira contribuição garantida

Se você está começando no mundo da programação e ainda não teve a chance de contribuir para um projeto no GitHub, não se preocupe. É normal sentir-se um pouco intimidado com o processo, mas com as ferramentas certas e um pouco de conhecimento, você pode garantir a sua primeira contribuição.

O primeiro passo é entender como funciona o processo de contribuição para um projeto no GitHub. A maioria dos projetos tem um arquivo README.md que explica o propósito e as regras de contribuição. Certifique-se de ler atentamente este arquivo antes de fazer qualquer alteração. Em seguida, procure as issues (problemas) no repositório. As issues são as tarefas que precisam ser resolvidas no projeto. Você pode procurar por issues com a tag "good first issue" (boa primeira tarefa) ou "help wanted" (ajuda necessária). Essas tags indicam que a tarefa é adequada para novos contribuidores.

O próximo passo é aprender mais sobre o GIT e o GitHub. O GIT é uma ferramenta de controle de versão que permite que você trabalhe em um projeto sem interferir no trabalho de outras pessoas. O GitHub é uma plataforma que permite que os usuários hospedem e colaborem em projetos usando o GIT. Para começar, crie uma conta no GitHub e baixe o GIT para o seu computador.

Agora que você está familiarizado com o processo de contribuição e com as ferramentas necessárias, é hora de encontrar um projeto para contribuir. O First Contribuitions é um projeto perfeito para quem está começando. Ele tem como objetivo ajudar novos contribuidores a se acostumarem com o processo de contribuição para projetos no GitHub. Você pode encontrar o repositório do First Contribuitions aqui:

First Contribuitions

O repositório First Contribuitions tem uma lista de tarefas simples que você pode realizar para ajudar no projeto. Para começar, escolha uma tarefa que você se sinta confortável em realizar. Em seguida, siga os passos descritos abaixo dos arquivos do repositório. Certifique-se de seguir as instruções cuidadosamente para garantir que sua contribuição seja aceita.

Lembre-se de que a primeira contribuição pode parecer intimidante, mas é uma ótima maneira de aprender mais sobre programação e colaboração em projetos. Com as ferramentas certas e um pouco de conhecimento, você pode garantir a sua primeira contribuição e começar a fazer a diferença no mundo da programação. Boa sorte!

Lembrando que qualquer dúvida eu estou aqui a disposição.

OBS: Não esqueçam de seguir o passo a passo do repositório. E desde já, quero parabenizar aos corajosos que foram fazer sua primeira contribuição. É apenas o começo de uma longa e incrível carreira. Desejo sucesso a todos vocês, iniciantes ou não. Aos tímidos eu desejo coragem e resiliência. Não se deixem serem intimidados por uma tecnologia, vão e enfrentem como verdadeiros heróis!

CREDITOS: Imagem retirada de: Da2K