Python

Afinal, por que devo aprender Python para 2020?

O que é Python?

Linguagem de programação de alto nível, o Python foi lançado em 1991 por Guido Van Rossum, possuindo uma tipagem dinâmica.

Com o passar dos anos, o Python conquistou o mercado e tem alcançado programadores fiéis ao redor do mundo, não podendo negar que a linguagem alcançou um patamar elevado e muitos projetos e empresas têm apostado na linguagem em seus novos projetos.

É uma linguagem que prioriza a legibilidade do código, combinando uma sintaxe concisa e clara. Com seus recursos poderosos de sua biblioteca padrão e por muitos módulos e frameworks, apostar no Python em 2020 poderá ser uma excelente escolha, e é isto que veremos neste artigo.

Python - Fundamentos
Curso de Python - Fundamentos
CONHEÇA O CURSO

Principais aplicações do Python

Quando decidimos iniciar uma nova linguagem, nada melhor que conhecer as suas aplicações para, assim, decidir se esta escolha nos levará ao que procuramos.

Com o Python não é diferente, e dentre suas principais aplicações podemos citar:

  • Data Science;
  • Machine Learning;
  • Big Data;
  • Desenvolvimento Web (Django e Flask).
R - Introdução a Data Science
Curso de R - Introdução a Data Science
CONHEÇA O CURSO

Data Science

Data Science, ou Ciência de dados, é uma área voltada ao estudo da análise de dados, ou seja, dada uma quantidade de dados, as análises dos mesmo e as conclusões que serão tiradas a partir da sua extração tem se tornado bastante importante para diversas empresas.

Tende a transformar a grande quantidades de dados brutos em insights de negócios, a fim de auxiliar as empresas em suas tomadas de decisão, atingindo assim melhores resultados.

Em nosso blog já abordamos mais do tema e caso queira saber mais a respeito de “O que é Data Science”, recomendo a leitura.

Nesta área, o Python é uma das principais tecnologias. Muito disso por conta de sua simplicidade e bibliotecas para trabalhar com análise de dados, como o Pandas, uma das principais e mais poderosas do mercado.

R - Introdução ao Machine Learning
Curso de R - Introdução ao Machine Learning
CONHEÇA O CURSO

Machine Learning

Machine Learning, ou em sua tradução livre “Aprendizado de máquina”, é a área da ciência da computação que tem como objetivo a análise de dados que automatiza a construção de modelos analíticos.

Ou seja, faz parte do conceito de inteligência artificial, e estuda os meios para que as máquinas possam realizar tarefas que seriam desempenhadas por pessoas. Baseia-se na ideia que sistemas podem aprender com os dados, identificando padrões e tomando decisões utilizando o mínimo da intervenção humana.

Aqui no blog possuímos o artigo “O que é e como funciona Machine Learning” que vale a pena a leitura.

Assim como o Big Data, o Python é uma das principais tecnologias para trabalhar com Machine Learning, uma área de grande crescente na última década.

Big Data

Big Data é a análise e interpretação de grandes volumes de dados.

É, sem dúvidas, uma ferramenta fundamental para que as empresas possam obter vantagens competitivas em diversas segmentos.

O termo surgiu no final da década de 90, utilizado para nomear quantidades cada vez mais crescentes e não estruturadas de dados que eram gerados a cada segundo. Atualmente, torna-se essencial no mercado, tendo suas ferramentas importantes na definição de estratégias de marketing, visando o aumento da produtividade, reduzindo assim seus custos e auxiliando na tomada de decisão inteligente, gerando valor ao negócio.

Para entender melhor “Big Data: o que é e qual a sua importância?” aqui no blog possuímos um artigo bem completo que te auxiliará a respeito.

Assim como o Data Science e Machine Learning, o Python também está pronto e possui diversas bibliotecas para trabalhar com Big Data, já que estas áreas estão estritamente relacionadas.

Várias são as bibliotecas para trabalhar com Big Data no Python, como a Pandas (citada anteriormente), NumPy, Matplotlib, Scikit-Learn, entre outras.

Django - Fundamentos
Curso de Django - Fundamentos
CONHEÇA O CURSO

Desenvolvimento Web (Django e Flask)

Desenvolvimento web é o termo utilizado para definir sites ou aplicativos que podem ser acessados diretamente pelo navegador web, seja em computadores ou dispositivos móveis.

Além de todas as outras aplicações do Python citadas anteriormente, a linguagem ainda é uma ótima alternativa para a criação de aplicações web de forma simples e poderosa. Para isso, o Python conta com dois dos principais frameworks para desenvolvimento web do mercado, o Django e o Flask.
Com esses dois frameworks, podemos desenvolver aplicações web poderosas e que, com certeza, irá atender todas as demandas do mercado.

Aqui no blog possuímos um artigo sobre os principais Frameworks de desenvolvimento web em Python, “Django e Flask”.

Uso do Python no mercado de trabalho

Apontada pelo Stack Overflow como uma das principais linguagens de programação para o ano de 2019, o Python possui uma grande demanda de trabalho, o que acarreta em diversas vagas de emprego em todo o mundo, e o mantém como uma ótima alternativa para o ano de 2020.

Nas imagens abaixo, podemos ver alguns exemplos de vagas para profissionais com conhecimentos em Python no Brasil.

Podemos concluir que…

Como vimos neste artigo, o Python é uma das principais linguagens para se trabalhar no ano de 2020. Muito disso por conta da sua polivalência, já que é possível utilizá-la nas áreas de Big Data, Machine Learning, Análise de Dados, desenvolvimento web e muitas outras, áreas essas que estão em constante crescimento nos últimos anos e tendem a continuar assim.

Aqui na TreinaWeb, possuímos o mais completo conjunto de cursos para você aprender a desenvolver com Python e sair pronto para o mercado de trabalho.

Manipulando tuplas no Python

Como vimos no artigo “Principais estruturas de dados no Python”, as tuplas são estruturas bastante similares às listas, com apenas uma diferença: os elementos inseridos em uma tupla não podem ser alterados, diferente de uma lista onde podem ser alterados livremente. Sendo assim, em um primeiro momento, podemos pensar em uma tupla como uma lista que não pode ser alterada, mas não é bem assim…

É certo que as tuplas possuem diversas características das listas, porém os usos são distintos. As listas são destinadas a serem sequências homogêneas, enquanto que as Tuplas são estruturas de dados heterogêneas.

Sendo assim, apesar de bastante similares, a tupla é utilizada para armazenar dados de tipos diferentes, enquanto que a lista é para dados do mesmo tipo. No Python, há diversos métodos para manipulação de tuplas, como veremos no decorrer deste artigo.

Python - Collections
Curso de Python - Collections
CONHEÇA O CURSO

Declarando Tuplas

A sintaxe para criação de uma tupla, assim como uma lista, também é bem simples. Ao invés de se utilizar colchetes (listas), são utilizados parênteses, como podemos ver abaixo:

nome_da_tupla1 = (1, 2, 3) #tupla de inteiros
nome_da_tupla2 = (1, "olá", 1.5) #tupla heterogênea

O resultado da execução do código acima pode ser visto no seguinte link: https://onlinegdb.com/r1Jr4CdyI

Contando elementos em uma Tupla

Para verificar a quantidade de elementos existentes em uma tupla, podemos utilizar o método count() e enviando o valor que queremos verificar como parâmetro:

nome_da_tupla1 = (1, 2, 3) #tupla de inteiros

print(nome_da_tupla1.count(1))
nome_da_tupla1 = (1, 1, 2, 3)
print(nome_da_tupla1.count(1))

O resultado da execução acima pode ser visto na imagem abaixo e no seguinte link: https://onlinegdb.com/r13yIDi18

Exibir o índice de um determinado elemento

Para retornar o índice de um determinado elemento em uma tupla, utilizamos o método index(), enviando o valor que queremos pesquisar como parâmetro:

nome_da_tupla1 = (1, 2, 3) #tupla de inteiros

print(nome_da_tupla1.index(3))

O resultado da execução acima pode ser visto na imagem abaixo e no seguinte link: https://onlinegdb.com/Hk1WPvikL

Verificar a existência de um elemento na Tupla

Um outro recurso muito utilizado em tuplas é a verificação da existência de um determinado elemento. Para isso, utilizamos o in do Python, como podemos ver abaixo:

nome_da_tupla1 = (1, 2, 3) #tupla de inteiros

print(2 in nome_da_tupla1)
print(22 in nome_da_tupla1)

O código acima retornará um True caso o elemento seja encontrado e um False caso não (https://onlinegdb.com/B1iB_wiJU):

Considerações finais

Assim como as listas, as tuplas são ótimas formas para armazenamento de elementos, principalmente se você não quer permitir que estes elementos sejam alterados. Neste artigo vimos algumas das principais funcionalidades das tuplas e suas aplicações.

No próximo artigo desta série veremos como manipular outras estruturas de dados com o Python. Até lá 🙂

Manipulando listas no Python

Vimos no último artigo as principais estruturas de dados presentes no Python, dentre elas, as listas, estrutura mais básica do Python.

Basicamente, uma lista é a estrutura de dados mais básica do Python e armazena os dados em sequência, onde cada elemento possui sua posição na lista, denominada de índice. O primeiro elemento é sempre o índice zero e a cada elemento inserido na lista esse valor é incrementado.

No Python, há diversos métodos para manipulação de listas, conforme veremos neste artigo.

Declarando Listas

A declaração de listas no Python é bem simples. Basicamente, devemos informar, entre colchetes ([]) o conteúdo da lista separados em vírgulas (,):

lista_simples_inteiro = [1, 2, 3, 8, 14, 4, 5]
listas_simples_string = ["Olá", "Mundo"]
lista_simples_mesclada = [1, 2, 3, "Olá, mundo", True, 1.5]

Nos exemplos acima, estamos declarando três listas com diferentes tipos de dados. Vale lembrar que uma lista pode conter diferentes tipos de dados, porém não é recomendado a utilização de uma lista para armazenar dados de diferentes tipos em uma mesma estrutura. Nestes casos, a Tupla é a estrutura de dados mais recomendada.

Imprimindo Listas

A impressão de listas no Python é muito simples. Basicamente, utilizamos o método print() e enviamos o nome da lista de queremos imprimir como parâmetro:

lista_simples_inteiro = [1, 2, 3, 8, 14, 4, 5]
listas_simples_string = ["Olá", "Mundo"]
lista_simples_mesclada = [1, 2, 3, "Olá, mundo", True, 1.5]

print(lista_simples_inteiro)
print(listas_simples_string)
print(lista_simples_mesclada)

O resultado da execução do código acima pode ser visto no seguinte link: https://onlinegdb.com/HkKIutU6B:

Inserindo elementos na lista

A inserção de elementos em uma lista pode ser feito por dois métodos, o append() e o insert(). O método append() insere o elemento sempre no final da lista, já o insert() irá inserir o elemento em uma posição específica:

lista_simples_inteiro = [1, 2, 3, 8, 14, 4, 5]

print(lista_simples_inteiro)

# Append()
lista_simples_inteiro.append(6)
print(lista_simples_inteiro)

# Insert()
lista_simples_inteiro.insert(2, 100)
print(lista_simples_inteiro)
Python - Estrutura de dados - Parte 1
Curso de Python - Estrutura de dados - Parte 1
CONHEÇA O CURSO

Com a execução do código acima, teremos o seguinte resultado (https://onlinegdb.com/B1Fr7qUTH):

Pode-se notar que o método append() inseriu o valor 6 no final da lista, já o método insert() inseriu o elemento 100 na posição 2 da lista.

Retornando tamanho da Lista

Para retornar o tamanho de uma lista no Python, podemos utilizar o método len() e passar a lista como parâmetro (https://onlinegdb.com/Bklftc86H):

lista_simples_inteiro = [1, 2, 3, 8, 14, 4, 5]

print(lista_simples_inteiro)

# Len()
print(len(lista_simples_inteiro))

Removendo elementos na lista

Para remover elementos de uma lista, utilizamos o método remove(), passando o elemento que queremos excluir da lista como parâmetro (https://onlinegdb.com/ryWR55U6r):

lista_simples_inteiro = [1, 2, 3, 8, 14, 4, 5]

print(lista_simples_inteiro)

# Remove()
lista_simples_inteiro.remove(5)
print(lista_simples_inteiro)

Dividindo listas

No Python, há duas formas de “cortar” listas. A primeira é utilizando os colchetes ([]) para determinar o intervalo do “corte” e a segunda é utilizando o método slice(), passando o intervalo como parâmetro:

lista_simples_inteiro = [1, 2, 3, 8, 14, 4, 5]

print(lista_simples_inteiro)

print(lista_simples_inteiro[0:4]) # Cortar lista da posição 0 a 4 (sem incluir a 4)
print(lista_simples_inteiro[1:]) # Cortar lista da posição 1 em diante
print(lista_simples_inteiro[:3]) # Cortar lista do início até a posição 3 (sem incluir a 3)
nova_lista = lista_simples_inteiro[:3] # Criar uma nova lista com base no corte de outra lista
print(nova_lista)

intervalo = slice(1, 4) # Cortar a lista a partir da posição 1 até a 4 (sem incluir a 4)
print(lista_simples_inteiro[intervalo])

Conclusão

As listas são uma ótima forma para armazenar elementos, como vimos neste artigo. Saber manipulá-las é fundamental para que possamos desenvolver nossos projetos e utilizar os melhores recursos da linguagem.

Porém, no Python, as listas não são as únicas estruturas de dados existentes. No próximo artigo desta série veremos como manipular uma outra estrutura bastante utilizada, os Sets.

Principais Estruturas de Dados no Python

No Python, podemos utilizar diversos tipos de estruturas de dados. Estas estruturas resolvem um tipo de problema e podem ser úteis em diversas situações. As principais estruturas são as Listas, Sets, Dicionários e Tuplas e neste artigo veremos as diferenças e principais características de cada uma.

Listas

Uma lista é a estrutura de dados mais básica do Python e armazena os dados em sequência, onde cada elemento possui sua posição na lista, denominada de índice. O primeiro elemento é sempre o índice zero e a cada elemento inserido na lista esse valor é incrementado.

No Python, uma lista pode armazenar qualquer tipo de dado primitivo (string, inteiro, float, etc). Na imagem abaixo podemos ver como uma lista se comporta:

Declarando Listas

Para a criação de uma lista no Python, a sintaxe é a seguinte:

nome_da_lista = [] # Criação de uma lista vazia
nome_da_lista = [1, 2, 3] # Criação de uma lista de inteiros
nome_da_lista = [1, "Olá, mundo!", 1.1] # Criação de uma lista com vários tipos diferentes

Podemos também criar listas dentro de outras listas. Essas são chamadas de nested lists e sua sintaxe é a seguinte:

nome_da_lista = ["Olá, mundo",  [1, 2, 3], ["outra_lista"]]

Tuplas

Uma tupla é uma estrutura bastante similar a uma lista, com apenas uma diferença: os elementos inseridos em uma tupla não podem ser alterados, diferente de uma lista onde podem ser alterados livremente. Sendo assim, em um primeiro momento, podemos pensar em uma tupla como uma lista que não pode ser alterada, mas não é bem assim…

É certo que as tuplas possuem diversas características das listas, porém os usos são distintos. As listas são destinadas a serem sequências homogêneas, enquanto que as Tuplas são estruturas de dados heterogêneas.

Sendo assim, apesar de bastante similares, a tupla é utilizada para armazenar dados de tipos diferentes, enquanto que a lista é para dados do mesmo tipo.

Tuplas x Listas

As tuplas possuem algumas vantagens com relação às listas, que são:

  • Como as tuplas são imutáveis, a iteração sobre elas é mais rápida e, consequentemente, possuem um ganho de desempenho com relação às listas;
  • Tuplas podem ser utilizadas como chave para um dicionário, já que seus elementos são imutáveis. Já com a lista, isso não é possível;
  • Se for necessário armazenar dados que não serão alterados, utilize uma tupla. Isso garantirá que esses sejam protegidos de alterações posteriores.

Declarando Tuplas

A sintaxe para criação de uma tupla, assim como uma lista, também é bem simples. Ao invés de se utilizar colchetes (listas), são utilizados parênteses, como podemos ver abaixo:

nome_da_tupla = (1, 2, 3) #tupla de inteiros
nome_da_tupla = (1, "olá", 1.5) #tupla heterogênea

Sets

No Python, os sets são uma coleção de itens desordenada, parcialmente imutável e que não podem conter elementos duplicados. Por ser parcialmente imutável, os sets possuem permissão de adição e remoção de elementos.

Além disso, os sets são utilizados, normalmente, com operações matemáticas de união, interseção e diferença simétrica, conforme veremos nos próximos tópicos.

Desenvolvedor Python Júnior
Formação: Desenvolvedor Python Júnior
Aprenda os principais conceitos do Python (uso de variáveis, estruturas condicionais e estruturas de decisão), como trabalhar com orientação à objetos (métodos, construtores, destrutores, classes, herança, polimorfismo e duck-typing) e estruturas de dados (Listas, Filas, Pilhas, Árvores Binárias, Dicionários, Conjuntos, Tabelas de Espalhamento e Mapas).
CONHEÇA A FORMAÇÃO

Declarando Sets

Para a criação de um set no Python há duas formas: A primeira é bem similar às listas e tuplas, porém utilizando chaves {} para determinar os elementos do set:

nome_do_set = {1, 2, 3, 4}

A segunda é utilizando o método set presente no Python:

nome_do_set = set([1, 2, 3, 4])

Dicionários

No Python, os dicionários são coleções de itens desordenados com uma diferença bem grande quando comparados às outras coleções (lists, sets, tuples, etc): um elemento dentro de um dicionário possui uma chave atrelada a ele, uma espécie de identificador. Sendo assim, é muito utilizado quando queremos armazenar dados de forma organizada e que possuem identificação única (como acontece em bancos de dados).

Um dicionário, portanto, pode ser visto como a figura abaixo:


Onde cada valor é “atrelado” à uma chave, seu identificador. Vale lembrar que, por necessitar que cada valor possua uma chave relacionada a ele, as chaves dos dicionários devem ser únicas para que possam ser acessadas, também, através do seu índice.

As chaves também não são armazenadas em qualquer ordem, elas apenas são associadas aos valores que pertencem.

Declarando Dicionários

Existem duas formas de se criar um dicionário utilizando o Python. A primeira delas é utilizando chaves ( {} ) e separando os elementos das chaves com dois pontos ( : ) e os outros elementos por vírgula ( , ):

nome_do_dicionario = {1: ‘João’, 2: ‘José’}
nome_do_dicionario = {‘nome’: ‘João’, ‘sobrenome’: ‘Silva’}

A segunda forma é utilizando o método dict() com o dicionário sendo passado como parâmetro:

nome_do_dicionario = dict({1: ‘João’, 2: ‘José’})
nome_do_dicionario = dict({‘nome’: ‘João’, ‘sobrenome’: ‘Silva’})

Animou?

No Python, possuímos diversas estruturas prontas para utilizar, como vimos neste artigo, e cada uma resolve um tipo de problema. No próximo artigo, iniciaremos os estudos mais aprofundados de cada uma destas estruturas e como manipulá-las no Python.

Até lá 🙂

Utilizando arquivos estáticos no Flask

No último artigo dessa trilha, vimos como retornar páginas HTML em requisições Flask e, assim, melhorar a interação da nossa aplicação com seu usuário. Porém, normalmente, há o uso de arquivos estáticos (JS, CSS e IMG) para melhorar a aparência das nossas páginas e, consequentemente, a experiência do usuário. Sendo assim, veremos neste artigo como incorporar estes arquivos ao nosso projeto Flask.

Criando diretório dos arquivos estáticos

É uma boa prática adotada pela comunidade que todos os arquivos estáticos de uma aplicação Flask sejam armazenados em um diretório “static” na raiz do projeto e, dentro deste diretório, uma nova pasta contendo os tipos de arquivos estáticos (CSS, JS e IMG), como podemos ver abaixo:


Para este projeto, iremos usar o Bootstrap como CSS. Para isso, realizamos o download do arquivo .min.css do framework (https://getbootstrap.com/docs/4.3/getting-started/download/) e armazenamos no diretório “static/css”, como vimos na imagem acima.

Ao realizar este procedimento, o Flask já estará apto a utilizar este arquivo CSS no projeto, bastando apenas importá-lo em nosso template.

Flask - Fundamentos
Curso de Flask - Fundamentos
CONHEÇA O CURSO

Utilizando arquivos estáticos no template

Agora que já configuramos nosso projeto para armazenar arquivos estáticos, precisamos importá-lo em nosso template. Para isso, é muito simples. O primeiro passo é criar uma tag link no head do arquivo HTML e referenciar nosso arquivo bootstrap.min.css:

Agora, no href do link, indicamos onde se encontra o arquivo estático que queremos utilizar. No nosso caso, ele se encontra em static/css/bootstrap.min.css. Sendo assim, temos que passar, como primeiro parâmetro do método url_for, o diretório raiz dos arquivos estáticos. Após isso, informamos o restante do caminho até o arquivo no atributo filename, como vemos acima.

Agora, já estamos aptos a usar o arquivo do bootstrap em nossos templates e, com isso, personalizar nossas páginas HTML. Utilizando como base o tema Jumbotron do bootstrap, conseguimos criar uma página com todo o poder do framework:

Concluindo

A utilização de arquivos estáticos em projetos Flask é, realmente, muito simples. Apenas precisamos criar um diretório para comportar estes arquivos e importá-los em nossos templates utilizando o método url_for do Jinja2.

Porém, sabemos que o conteúdo de uma página HTML nem sempre é estático. Muitas vezes este conteúdo é enviado pela requisição e exibido no HTML… Bom, como fazer isso? É exatamente o que veremos no próximo artigo desta série 🙂

Retornando páginas HTML em requisições Flask

Sabemos que a principal forma que os usuários possuem para interagir com nossas aplicações web, são utilizando páginas HTML. No Flask, isso não é diferente.

Vimos no artigo anterior como criar nossa primeira app, porém estávamos retornando uma string como resposta de uma requisição. Sendo assim, neste artigo veremos como retornar páginas HTML através dos métodos da nossa aplicação Flask.

Respondendo requisições com HTML

O primeiro passo para retornar uma página HTML como resposta de uma requisição no Flask, é criar o diretório que armazenará estes arquivos. Para isso, criamos um diretório chamado “templates” dentro do projeto. É lá que serão armazenados os arquivos HTML do projeto:



Agora, dentro do diretório “templates”, podemos criar os arquivos HTML do nosso projeto:

Por fim, para retornar a página index.htmlnos métodos do nosso projeto Flask, utilizamos o método render_template(), como podemos ver abaixo:


from flask import Flask, render_template app = Flask(__name__) @app.route("/teste") def index(): return render_template('index.html') if __name__ == "__main__": app.run()
Flask - Fundamentos
Curso de Flask - Fundamentos
CONHEÇA O CURSO

Com isso, ao acessar a rota 127.0.0.1:5000/teste, teremos o seguinte retorno:

Vale lembrar que, por padrão, o Flask irá procurar o arquivo index.htmlno diretório templates do projeto. Caso você queira criá-lo em um diretório com outro nome, você deve passá-lo como parâmetro do construtor do Flask:

from flask import Flask, render_template

app = Flask(__name__, template_folder='templates_folder')

@app.route("/teste")
def index():
  return render_template('index.html')

if __name__ == "__main__":
 app.run()

Isso fará com que todos os templates sejam buscados no diretório templates_folderdo seu projeto (ou qualquer nome que você preferir).

Concluindo…

Como dito acima, as páginas HTML são os principais meios de interação entre um usuário e uma aplicação web. Saber como retorná-las é de extrema importância para qualquer desenvolvedor.

Além disso, o Jinja2 possui diversos recursos para trabalhar com este tipo de arquivo, e é exatamente isso que veremos no próximo artigo desta trilha 🙂

Criando primeira app com Flask

O Flask é um dos principais microframeworks do ecossistema Python e principal concorrente do Django. Já vimos aqui no blog o que é o Flask e quando utilizá-lo ao invés do Django.

Sabendo disso, veremos neste artigo como criar nossa primeira app com Flask e do que vamos precisar para tal tarefa.

Configurando ambiente

Por ser um framework Python, o Flask possui os mesmos requisitos básicos que o Django (possuir o Python instalado e uma IDE para escrever o código). Aqui no blog, já temos um artigo sobre como configurar nosso ambiente de desenvolvimento para o Django, mas que pode ser utilizado para o Flask sem maiores problemas 🙂

Criando Projeto

Com o ambiente de desenvolvimento devidamente configurado, podemos iniciar e criar nossa primeira aplicação com Flask. Para isso, o primeiro passo é criar um projeto com o PyCharm que vai armazenar os arquivos de código da nossa aplicação Flask.

Sendo assim, ao abrir o PyCharm, veremos a seguinte tela:


Dentre as três opções disponíveis, selecionaremos a “Create New Project” para que possamos criar o primeiro projeto com PyCharm. Fazendo isso, seremos redirecionados para a seguinte tela:


Nesta tela, definimos a localização do projeto e onde será armazenada sua virtualenv. Caso você não saiba do que se trata uma virtualenv, falamos sobre ela neste artigo, recomendo fortemente sua leitura 🙂

Costumo armazenar a virtualenv de cada projeto em seu próprio diretório. Assim, cada projeto possuirá sua virtualenv isolada.

Flask - Fundamentos
Curso de Flask - Fundamentos
CONHEÇA O CURSO

Por fim, após indicar o caminho e o nome do projeto, podemos clicar em “Create”. Isso fará com que uma nova janela do PyCharm seja aberta com o seguinte conteúdo:

Instalando o Flask

Com o projeto do PyCharm criado, já podemos criar nossa app Flask. Para isso, o primeiro passo é instalar o pacote em nossa virtualenv. Para isso, o PyCharm possui uma interface gráfica que auxilia todo este processo, localizada em File > Settings > Project Interpreter (se você está utilizando o Windows ou Linux) ou PyCharm > Preferences (se você está utilizando o macOS).



É nesta janela que poderemos adicionar os pacotes à nossa virtualenv. Para isso, clicamos no botão “+” localizado no canto inferior esquerdo da janela, que exibirá uma tela para buscarmos pelo pacote desejado.

Nesta janela, buscamos pelo pacote “Flask” e clicamos em “Install Package”. Após isso, o PyCharm (utilizando o PIP) vai baixar o pacote selecionado e instalar na virtualenv do projeto:


Ao finalizar este processo, podemos fechar a janela e notaremos que o pacote foi instalado com sucesso:


Em conjunto com o Flask, outros 4 pacotes serão instalados, são eles:

  • Click: CLI (Command Line Interface) do Flask. Provê diversos comandos para o desenvolvedor interagir com o Flask.

  • Jinja2: Template Engine utilizado pelo Flask para a criação de suas aplicações. O Jinja2 é uma poderosa ferramenta para criação de páginas HTML em conjunto com códigos Python.

  • MarkupSafe: Pacote responsável por criar escapes de caracteres para utilizá-los em HTML e XML, evitando ataques de injeção na aplicação.

  • Werkzeug: Werkzeug é um conjunto de ferramentas para WSGI, a interface padrão entre aplicações web Python e servidores HTTP para desenvolvimento.

Finalmente, podemos clicar em “OK” na aba “Project Interpreter” que todos os pacotes necessários já estão instalados em nosso projeto.

Criando primeira APP Flask

Com todo o ambiente configurado e os pacotes necessários instalados, podemos iniciar o desenvolvimento da nossa aplicação. Neste artigo, veremos uma aplicação que responde a uma requisição e devolve uma string como resposta. Nos próximos artigos veremos como trabalhar com rotas, templates, bancos de dados, etc…

Por ser um microframework, o Flask não possui uma arquitetura definida. Sendo assim, para criar uma app com o Flask, podemos utilizar um único arquivo (claro que isso não pode acontecer com aplicações maiores).

Portanto, dentro do projeto do PyCharm, criaremos um arquivo chamado app.py e colamos o seguinte conteúdo:

from flask import Flask
app = Flask(__name__)

@app.route("/teste")
def index():
    return 'Olá Mundo!'

if __name__ == "__main__":
    app.run()

Linha a linha, o código acima pode ser entendido da seguinte forma:

  1. Importamos o pacote Flask da nossa virtualenv;

  2. Criamos uma instância do Flask e salvamos na variável app. É essa variável que representa a aplicação Flask que estamos criando;

  3. Definimos que a rota “/” vai executar o método index() do nosso arquivo, que retornará a string “Olá Mundo!”;

  4. Verificamos se o arquivo app.pyestá sendo executado pelo terminal e, caso positivo, iniciamos o servidor do Flask.

Agora, para executar nosso script, clicamos no botão verde ao lado da linha 8 do nosso script e selecionamos a opção “Run ‘app'”:

Ao fazer isso, o servidor do Flask será executado no terminal do próprio PyCharm e uma URL para acessá-lo será exibida:

Clicando na rota disponibilizada, o navegador padrão do computador irá abrir e, ao executar a rota “/teste”, teremos o seguinte retorno:

Conclusão

Vimos neste artigo o quão simples é instalar o Flask e criar nossa primeira app. Nos próximos artigos veremos alguns conceitos mais avançados sobre este ótimo microframework, como seu sistema de templates, rotas, bancos de dados, etc. Te espero lá 🙂

Compartilhando rotas entre apps no Django

Um projeto Django é composto por uma ou mais aplicações, que possui um arquivo de rotas. Agora imagine que tenhamos duas apps com rotas de mesmo nome ou que precisamos executar métodos de uma outra app … Como diferenciar cada rota dentro do projeto e como compartilhar as rotas entre as aplicações de um projeto? É o que veremos neste artigo.

Utilizando namespaces no Django

A compartilhação de rotas entre apps no Django é muito simples. A primeira coisa a se fazer é determinar o namespace daquele arquivo de rotas. Este namespace é o que define de onde a rota pertence (a qual app aquela rota foi criada).

Imagine que você tenha um projeto com duas (ou mais) aplicações e que há rotas nessas aplicações que são compartilhadas entre as apps. Para realizar este “compartilhamento”, precisamos definir o nome do namespace de cada arquivo de rotas. É este nome que identificará de onde a rota será chamada.

Para isso, no arquivo urls.py da app que queremos compartilhar as rotas, definimos a seguinte configuração no app_name:

from django.urls import path
from .views import *

app_name = 'admin_blog'

urlpatterns = [
    path('listar_posts/', listar_posts, name='listar_posts'),
    path('editar_post/<int:id>', editar_post, name='editar_post'),
    path('remover_post/<int:id>', remover_post, name='remover_post'),
    path('cadastrar_post/', cadastrar_post, name='cadastrar_post'),

]

É o conteúdo do app_name que determina como chamaremos as rotas externamente.

Django - Desenvolvimento de APIs REST
Curso de Django - Desenvolvimento de APIs REST
CONHEÇA O CURSO

Além disso, precisamos determinar que o conjunto de rotas da app possui o namespace ‘admin_blog’ no arquivo de rotas do projeto:

urlpatterns = [
    path('admin_blog/', include('admin_blog.urls', namespace='admin_blog')),
  #...
]

Invocando rotas em outras apps com Django

Agora que determinamos a configuração do app_name no arquivo de rotas da aplicação, podemos executá-las externamente. Para isso, a nomenclatura é a seguinte:

nome_definido_no_app_name:nome_da_rota

Sendo assim, se quisermos executar a rota ‘listar_posts’, por exemplo, a partir de um template localizado em outra app, definimos a tag url da seguinte forma:

<li class="nav-item">
    <a class="nav-link" href="{% url 'admin_blog:listar_posts' %}">Admin</a>
</li>

Com isso, a rota a ser executada será do método listar_posts que está definido na outra app do projeto.

O que é Flask?

Escrito em Python e disponível sobre a licença BSD (Licença de código aberto), o Flask é um micro-framework multiplataforma que provê um modelo simples para o desenvolvimento web.

Flask - Fundamentos
Curso de Flask - Fundamentos
CONHEÇA O CURSO

Mas afinal, o que é um Micro-framework?

Já falamos aqui no blog o que é um micro-framework, mas para relembrar:

Um Micro-Framework são Frameworks modularizados que possuem uma estrutura inicial muito mais simples quando comparado a um Framework convencional.

Podemos dizer que o micro-framework é uma versão minimalista destes frameworks, sendo bastante utilizado para criação de microsserviços, como APIs RESTful.

No artigo anterior, fizemos uma comparação de objetos do mundo real para exemplificar o funcionamento de um micro-framework:

Pense em um Micro-Framework como uma peça de lego. Inicialmente, um projeto criado com o micro-framework possui apenas o básico para funcionar, (normalmente, sistema de rotas), porém, ao decorrer do projeto, podem haver necessidades para utilização de outros recursos como, conexão de banco de dados, sistemas de templates, envio de email, etc. A partir desta necessidade, novas bibliotecas são “encaixadas” no projeto, como uma estrutura de lego.

De volta ao Flask…

Lançado em 2010 e desenvolvido por Armin Ronacher, o Flask é um micro-framework destinado principalmente a pequenas aplicações com requisitos mais simples, como por exemplo, a criação de um site básico.

Possui um núcleo simples e expansível que permite que um projeto possua apenas os recursos necessários para sua execução (conforme surja a necessidade, um novo pacote pode ser adicionado para incrementar as funcionalidades da aplicação).

Características do Flask

  • Simplicidade: Por possuir apenas o necessário para o desenvolvimento de uma aplicação, um projeto escrito com Flask é mais simples se comparado aos frameworks maiores, já que a quantidade de arquivos é muito menor e sua arquitetura é muito mais simples.

  • Rapidez no desenvolvimento: Com o Flask, o desenvolvedor se preocupa em apenas desenvolver o necessário para um projeto, sem a necessidade de realizar configurações que muitas vezes não são utilizadas.

  • Projetos menores: Por possuir uma arquitetura muito simples (um único arquivo inicial) os projetos escritos em Flask tendem a ser menores e mais leves se comparados a frameworks maiores.

  • Aplicações robustas: Apesar de ser um micro-framework, o Flask permite a criação de aplicações robustas, já que é totalmente personalizável, permitindo, caso necessário, a criação de uma arquitetura mais definida.

Exemplo de uma aplicação Flask

Abaixo podemos ver um exemplo de uma aplicação em Flask. Podemos notar o quão simples criar uma aplicação web pode ser:

from flask import Flask
app = Flask(__name__)

@app.route("/")
def index():
    return 'Bem-vindo a TreinaWeb!'

if __name__ == "__main__":
    app.run()

Podemos concluir que…

O Flask é uma excelente alternativa para o desenvolvimento de aplicações utilizando o Python. Ele é o principal concorrente do Django, apesar de ser considerado um micro-framework.

Aqui no blog da TreinaWeb fizemos um comparativo entre o Django e o Flask, caso esteja em dúvida em qual framework utilizar, vale a pena a leitura.

Criando o primeiro projeto Django

No artigo anterior vimos como configurar nosso ambiente de desenvolvimento para a criação de projetos Python e Django. Agora, com o ambiente devidamente configurado, veremos como criar o primeiro projeto Django utilizando as ferramentas instaladas 🙂

Criando projeto

O primeiro passo para criarmos nosso projeto com Django é abrir o PyCharm. Ao fazer isso, veremos a seguinte tela:


Dentre as três opções disponíveis, selecionaremos a “Create New Project” para criar o primeiro projeto do PyCharm. Ao fazer isso, seremos redirecionados para a seguinte tela:


Aqui, definimos a localização do projeto e onde será armazenada a virtualenv do mesmo. Se você não sabe o que é uma virtualenv, recomendo a leitura deste artigo.

Costumo armazenar a virtualenv de cada projeto em seu próprio diretório. Assim, cada projeto possuirá sua virtualenv isolada 🙂

Django - Fundamentos
Curso de Django - Fundamentos
CONHEÇA O CURSO

Depois de informar a localização do projeto e criar a virtualenv, podemos clicar em “Create” para que o PyCharm crie o diretório do projeto. No fim do processo, será exibida a seguinte tela:

Instalando o Django

Com o projeto do PyCharm criado, o primeiro passo é instalar o Django em nossa virtualenv. Para isso, o PyCharm possui uma interface gráfica que auxilia todo este processo, localizada em File > Settings > Project Interpreter (se você está utilizando o Windows ou Linux) ou PyCharm > Preferences (se você está utilizando o macOS).



É nesta janela que poderemos adicionar os pacotes à nossa virtualenv. Para isso, clicamos no botão “+” localizado no canto inferior esquerdo da janela, que exibirá uma tela para buscarmos pelo pacote desejado:


Nesta janela, buscamos pelo pacote “Django” e clicamos em “Install Package”. Após isso, o PyCharm (utilizando o PIP) vai baixar o pacote selecionado e instalar na virtualenv do projeto. Ao finalizar este processo, podemos fechar a janela e notaremos que o pacote foi instalado com sucesso:


Agora, voltando ao PyCharm, precisamos criar o projeto utilizando o Django. Para isso, no terminal integrado da IDE, digitamos o seguinte comando:

django-admin startproject primeiro_projeto

O comando acima irá criar um projeto Django chamado “primeiro_projeto” com a seguinte estrutura de pastas:


Basicamente, há quatro arquivos no projeto criado, onde a função de cada um deles pode ser vista abaixo:

  • settings.py: Arquivo para armazenar as configurações gerais do projeto, como os pacotes a serem utilizados, configurações de bancos de dados, localização de arquivos estáticos, etc.
  • urls.py: Arquivo para armazenar as rotas que serão utilizadas no projeto. Este arquivo armazenará as rotas do projeto em geral, é recomendável que cada aplicação do projeto possua um arquivo de rotas específico… Mas não se preocupe, falaremos sobre apps no próximo artigo 🙂
  • wsgi.py: Interface simples e universal para troca de informações entre servidores web e aplicações criadas com Python.
  • manage.py: Arquivo responsável por gerenciar o projeto como um todo. É, basicamente, um CLI para projetos Django.

Executando servidor Django

Com o projeto criado, podemos executar seu servidor de desenvolvimento para verificar se tudo está conforme planejado. Para isso, ainda no terminal do PyCharm, utilizamos o seguinte comando:

python manage.py runserver

Ao executar o comando acima, o servidor do Django será inicializado e poderemos acessá-lo através da rota http://127.0.0.1:8000, conforme é retornado no terminal:


Ao executar a rota citada acima em um navegador, teremos a seguinte página como resposta:


Esta (linda) página indica que a instalação foi feita corretamente e que estamos prontos para desenvolver nossa primeira aplicação com o Django o/

Ficou animado? Então fica ligado que no próximo artigo veremos como criar uma aplicação com o Django e iniciarmos seu desenvolvimento 😀

Até lá!!