Se você está mergulhando no mundo do big data, provavelmente, já ouviu falar no termo PySpark.

O PySpark é uma ferramenta que permite gerenciar e analisar grandes conjuntos de dados de uma maneira mais fácil. Neste artigo, veremos o básico do PySpark, seus benefícios e como você pode começar a usá-lo.

O que é o PySpark?

PySpark é a API do Python para Apache Spark, um framework de processamento de big data.

O PySpark é feito para trabalhar com processamento de dados em grande escala e tarefas de aprendizado de máquina. Com o PySpark, você pode escrever aplicações Spark usando o Python.

Uma das razões principais para usar o PySpark é a velocidade. O PySpark pode processar dados muito mais rápido que os frameworks tradicionais de processamento de dados. Isso ocorre porque o PySpark distribui as tarefas entre várias máquinas, tornando-o incrivelmente eficiente.

Outra vantagem é a facilidade de uso. Se você tem familiaridade com o Python, vai achar o PySpark fácil de aprender. Ele usa sintaxes e bibliotecas do Python bastante conhecidas, fazendo com que você torne seu trabalho mais rápido.

Escalabilidade é outro benefício chave do PySpark. Esteja você trabalhando com um conjunto de dados pequeno ou gigante, o PySpark consegue dar conta de tudo.

O PySpark escala de uma única máquina para um conjunto de milhares de máquinas. Isso significa que você pode começar pequeno e expandir à medida que seus dados expandem.

O PySpark também trabalha bem com outras ferramentas de big data como o Hadoop e o Apache Hive. Isso o torna uma escolha versátil para tarefas de engenharia de dados.

Como trabalhar com o PySpark

Agora, vamos falar sobre como começar a usar o PySpark.

Antes de começar, você deve ter o Python e Java instalados em seu sistema. Você também precisará instalar o Apache Spark. Você pode baixá-lo diretamente do site oficial do Spark.

Tendo concluído esses pré-requisitos, você pode instalar o PySpark usando o pip, o instalador de pacotes do Python.

pip install pyspark

Após instalar o PySpark, você pode começar a usá-lo para processar dados.

Você pode criar uma sessão do Spark, que é o ponto de partida para qualquer aplicação Spark. A partir disso, você pode carregar seus dados em um DataFrame do Python.

Um DataFrame é uma coleção de dados distribuída em colunas nomeadas. DataFrames são parecidos com tabelas em um banco de dados, tornando mais fácil a manipulação de dados.

Você pode realizar várias operações em DataFrames, como filtragem, agrupamento e agregação de dados. O PySpark fornece uma grande quantidade de funções para ajudar você com essas tarefas.

Para dar um gostinho do PySpark, vamos examinar um exemplo simples.

Digamos que você tenha um arquivo CSV com alguns dados. Você pode carregar esses dados em um DataFrame e realizar operações básicas nele.

Primeiro, crie uma sessão:

from pyspark.sql import SparkSessionspark = SparkSession.builder.appName("exemplo").getOrCreate()

Depois, carregue seu arquivo CSV em um DataFrame:

df = spark.read.csv("caminho/para/o/arquivo.csv", header=True, inferSchema=True)

Você pode realizar operações nesse DataFrame. Por exemplo, para filtrar dados onde uma coluna específica tem certo valor, você pode usar:

filtered_df = df.filter(df["nome_da_coluna"] == "valor")

Você também pode agrupar os dados de uma coluna e calcular agregados, como o valor médio de outra coluna:

grouped_df = df.groupBy("nome_da_coluna").agg({"outra_coluna": "media"})

Esses são apenas alguns exemplos do que você pode fazer com o PySpark. A biblioteca é muito poderosa e oferece diversas funções para auxiliar você a processar e analisar seus dados.

Conclusão

Concluindo, o PySpark é uma ferramenta fantástica para qualquer pessoa trabalhando com big data. Ele é rápido, fácil de usar, escalável e trabalha bem com outras ferramentas de big data.

Aprendendo PySpark, você pode destravar o potencial máximo do Apache Spark e levar suas habilidades de processamento de dados para o próximo nível.

Então, dê uma chance ao PySpark. Você vai se impressionar com o quanto que ele pode fazer. Espero que você tenha gostado desse artigo. Para mais artigos sobre IA, visite turingtalks.ai.

Escrito por: Harshit Tyagi

A tecnologia se tornou um ativo nas finanças. As instituições financeiras estão agora evoluindo para empresas de tecnologia, em vez de se concentrarem apenas nos aspectos financeiros do setor.

Os algoritmos matemáticos trazem inovação e rapidez. Eles podem nos ajudar a obter uma vantagem competitiva no mercado.

A velocidade e a frequência das transações financeiras, juntamente com os grandes volumes de dados, têm atraído muita atenção para a tecnologia por parte de todas as grandes instituições financeiras.

A negociação algorítmica ou quantitativa é o processo de concepção e desenvolvimento de estratégias de negociação com base em análises matemáticas e estatísticas. É uma área extremamente sofisticada das finanças.

Este tutorial serve como um guia para iniciantes em negociação quantitativa com Python. Você achará este artigo muito útil se for:

1. Um estudante ou alguém que aspira a se tornar um analista quantitativo (quant) em um fundo ou banco.
2. Alguém que planeja iniciar seu próprio negócio de negociação quantitativa.

Neste artigo, abordaremos os seguintes tópicos:

• Princípios básicos de ações e negociação
• Extração de dados da API da Quandl
• Análise exploratória de dados sobre preços de ações
• Médias móveis
• Formulação de uma estratégia de negociação com Python
• Visualização do desempenho da estratégia

Antes de mergulharmos nos detalhes e na dinâmica dos dados de preços de ações, primeiro precisamos entender os princípios básicos das finanças. Se você já está familiarizado com finanças e com a maneira como as negociações funcionam, pode pular esta seção e passar para a próxima.

O que são ações? O que é a negociação de ações?

Ações

Uma ação é a representação de uma participação na propriedade de uma corporação, emitida por um determinado valor. É um tipo de título financeiro que estabelece sua reivindicação sobre os ativos e o desempenho de uma empresa.

Uma organização ou empresa emite ações para arrecadar mais fundos/capital com o objetivo de expandir e se envolver em mais projetos. Essas ações ficam então disponíveis ao público e são compradas e vendidas.

Negociação de ações e estratégia de negociação

O processo de compra e venda de ações existentes e previamente emitidas é chamado de negociação de ações. Existe um preço pelo qual uma ação pode ser comprada e vendida. Esse preço continua a flutuar dependendo da demanda e da oferta no mercado de ações.

Dependendo do desempenho e das medidas tomadas pela empresa, os preços das ações podem subir ou descer, mas o movimento do preço das ações não se limita ao desempenho da empresa.

Os negociadores pagam dinheiro em troca de participação na empresa, esperando fazer negociações lucrativas e vender as ações a um preço mais alto.

Outra técnica importante que os negociadores seguem é a venda a descoberto. Isso envolve pegar emprestado ações e vendê-las imediatamente, na esperança de comprá-las posteriormente a um preço mais baixo, devolvê-las ao credor e obter a margem de lucro.

Assim, a maioria dos negociadores segue um plano e um modelo para negociar. Isso é conhecido como estratégia de negociação.

Negociadores quantitativos em fundos hedge e bancos de investimento projetam e desenvolvem essas estratégias de negociação e estruturas para testá-las. Isso requer um profundo conhecimento em programação e compreensão das linguagens necessárias para construir sua própria estratégia.

Python é uma das linguagens de programação mais populares usadas, junto com C++, Java, R e MATLAB. Está sendo amplamente adotada em todas as áreas, especialmente em ciência de dados, devido à sua sintaxe fácil, grande comunidade e suporte de terceiros.

Você precisará estar familiarizado com Python e estatísticas para aproveitar ao máximo este tutorial. Certifique-se de revisar seus conhecimentos em Python e verificar os fundamentos das estatísticas (texto em inglês).

Extraindo dados da API da Quandl

Para extrair dados de preços de ações, usaremos a API da Quandl. Antes, porém, vamos configurar o ambiente de trabalho. Veja como:

1. No seu terminal, crie um diretório para o projeto (nomeie-o como quiser):

mkdir <nome_do_diretorio>

1. Certifique-se de ter o Python 3 e o virtualenv instalados em sua máquina.
2. Crie um virtualenv de Python 3 usando virtualenv <nome_do_env> e ative-o usando source <nome_do_env>/bin/activate.
3. Agora, instale o Jupyter Notebook usando o pip, e digite pip install jupyter-notebook no terminal.
4. Da mesma maneira, instale os pacotes pandas, quandl e numpy.
5. Abra o seu jupyter-notebook pelo terminal

Agora, o seu notebook deve estar rodando no localhost, como mostra a captura de tela abaixo:

Você pode criar seu primeiro notebook clicando no menu suspenso New (Novo) à direita. Certifique-se de ter criado uma conta na Quandl (texto em inglês). Siga os passos mencionados aqui (texto em inglês) para criar sua chave de API.

Uma vez que você esteja pronto, vamos mergulhar de cabeça:

# importando os pacotes necessários

import pandas as pd
import quandl as q

O Pandas será o pacote mais exaustivamente utilizado neste tutorial, pois faremos muitas manipulações de dados e plotagens.

Depois que os pacotes forem importados, faremos solicitações à API do Quandl usando o pacote Quandl:

# define a chave da API
q.ApiConfig.api_key = "<API key>"

# envia uma solicitação GET para consultar os preços de fechamento diário das
# ações da Microsoft de 1º de janeiro de 2010 a 1º de janeiro de 2019

msft_data = q.get("EOD/MSFT", start_date="2010-01-01", end_date="2019-01-01")

# visualizar as primieras 5 linhas dos dataframe

msft_data.head()

Aqui temos os dados de preços de fechamento diário das ações EOD (de end of the day, em inglês) da Microsoft dos últimos 9 anos. Tudo o que você precisava fazer era chamar o método get do pacote Quandl e fornecer o símbolo da ação, MSFT, e o período de tempo dos dados que você precisa. Isso foi realmente simples, não foi? Vamos avançar para entender e explorar esses dados mais a fundo.

Análise exploratória em dados de preços de ações

Com os dados em mãos, a primeira coisa que devemos fazer é entender o que eles representam e que tipo de informação eles trazem.

Imprimindo as informações do DataFrame, podemos ver tudo que ele contém:

Como visto na captura de tela acima, o DataFrame contém DatetimeIndex, o que significa que estamos lidando com dados de séries temporais.

Um índice pode ser considerado como uma estrutura de dados que nos ajuda a modificar ou referenciar os dados. Dados de séries temporais são uma sequência de registros instantâneos de preços tirados em intervalos de tempo consecutivos e igualmente espaçados.

Na negociação, os dados de preços de fechamento diário capturam o movimento de certos parâmetros sobre uma ação, como o preço da ação, ao longo de um período especificado de tempo, com pontos de dados registrados em intervalos regulares.

Terminologia importante

Olhando para outras colunas, vamos tentar entender o que cada coluna representa:

• Open/Close  —  captura o preço de abertura/fechamento das ações
• Adj_Open/Adj_Close — um preço de abertura/fechamento ajustado é o preço de uma ação em qualquer dia de negociação que foi revisado para incluir quaisquer distribuições de dividendos, desdobramentos de ações e outras ações corporativas que ocorreram a qualquer momento antes da abertura do dia seguinte.
• Volume — registra o número de ações que estão sendo negociadas em qualquer dia de negociação.
• High/Low — rastreia o preço mais alto e o mais baixo da ação durante um determinado dia de negociação.

Essas são as colunas importantes nas quais vamos focar neste momento.

Podemos aprender sobre as estatísticas resumidas dos dados, que nos mostram o número de linhas, média, máximo, desvios padrão e assim por diante. Tente executar a seguinte linha de código na célula do IPython:

msft_data.describe()

resample()

O método resample() do Pandas é usado para facilitar o controle e a flexibilidade na conversão de frequência dos dados de séries temporais. Podemos especificar os intervalos de tempo para reamostrar (mudar a frequência de amostragem) os dados para mensal, trimestral ou anual, além de realizar a operação necessária sobre eles.

msft_data.resample('M').mean()

Essa é uma maneira interessante de analisar o desempenho das ações em diferentes períodos de tempo.

Calculando retornos

O retorno financeiro é simplesmente o dinheiro ganho ou perdido em um investimento. Um retorno pode ser expressado nominalmente como a variação no valor de um investimento ao longo do tempo. Pode ser calculado como a porcentagem derivada da razão entre o lucro e o investimento.

Temos o pct_change() à nossa disposição para esse propósito. Aqui está como você pode calcular os retornos:

# Importa o pacote do numpy
import numpy as np

# atribui 'Adj_Close' a 'daily_close'
daily_close = msft_data[['Adj_Close']]

# retorna como variação em percentual
daily_return = daily_close.pct_change()

# substitui valores NA por 0
daily_return.fillna(0, inplace=True)

print(daily_return)

Isso imprimirá os retornos que a ação vem gerando diariamente. Multiplicando o número por 100, você obterá a mudança percentual.

A fórmula usada em pct_change() é:

Retorno = {(Preço em t) — (Preço em t-1)} / {Preço em t-1}

Agora, para calcular retornos mensais, tudo que precisa fazer é:

mdata = msft_data.resample('M').apply(lambda x: x[-1])

monthly_return = mdata.pct_change()

Após reamostrar os dados para meses (considerando apenas os dias úteis), podemos obter o último dia de negociação no mês usando a função apply().

apply() recebe uma função e a aplica a cada linha da série Pandas. A função lambda é uma função anônima em Python que pode ser definida sem um nome e só aceita expressões no seguinte formato:

Lambda: espressão

Por exemplo, lambda x: x * 2 é uma função lambda. Aqui, x é o argumento e x * 2 é a espressão avaliada e retornada.

Médias móveis no mercado financeiro

O conceito de médias móveis vai estabelecer a base para nossa estratégia de negociação baseada em momentum.

No campo financeiro, os analistas frequentemente têm que avaliar métricas estatísticas continuamente ao longo de uma janela de tempo móvel, o que é chamado de cálculos de janela móvel.

Vamos ver como podemos calcular a média móvel ao longo de uma janela de 50 dias e deslizar a janela por 1 dia.

rolling()

Esta é a função mágica que faz os truques para nós:

# atribuindo os preços de fechamento ajustados a
adj_pricesadj_price = msft_data['Adj_Close']

# calcular a média móvel
mav = adj_price.rolling(window=50).mean()

# imprime o result
print(mav[-10:])

Você verá a média móvel em uma janela de 50 dias (aproximadamente 2 meses). As médias móveis ajudam a suavizar qualquer flutuação ou pico nos dados, proporcionando uma curva mais suave para o desempenho da empresa.

Podemos traçar um gráfico e ver a diferença:

# importa o pacote matplotlib para visualizar o gráfico
import matplotlib.pyplot as plt

adj_price.plot()

Você pode traçar o gráfico da média móvel:

mav.plot()

Você também pode ver a diferença por si mesmo, como os picos nos dados são suavizados para fornecer uma ideia geral sobre o desempenho da ação.

Formulando uma estratégia de negociação

Aqui vem a parte final e mais interessante: desenhar e criar a estratégia de negociação. Este será um guia passo a passo para desenvolver uma estratégia de Cruzamento de Média Móvel Simples (Simple Moving Average Crossover - SMAC) baseada em momentum.

Estratégias baseadas em momentum são fundamentadas em um indicador técnico que capitaliza a continuidade da tendência do mercado. Compramos valores mobiliários que mostram uma tendência de alta e vendemos a descoberto valores mobiliários que mostram uma tendência de baixa.

A estratégia SMAC é uma estratégia de momentum bem conhecida. É uma estratégia apenas de compra. Aqui, o momentum é o retorno total da ação, incluindo os dividendos, nos últimos n meses. Esse período de n meses é chamado de período de observação.

Existem 3 principais tipos de períodos de observação: curto prazo, médio prazo e longo prazo. Precisamos definir 2 diferentes períodos de observação de uma série temporal específica.

Um sinal de compra é gerado quando a média móvel (ou média móvel simples) de período curto ultrapassa a média móvel de período longo. Um sinal de venda ocorre quando a média móvel de período curto cai abaixo da média móvel de período longo.

Agora, vamos ver como será o código para essa estratégia:

# passo 1: inicialize os períodos de observação curto e longo.

short_lb = 50
long_lb = 120

# passo 2: Inicialize um novo DataFrame chamado signal_df 
#          com uma coluna de sinal.

signal_df = pd.DataFrame(index=msft_data.index)
signal_df['signal'] = 0.0

# Passo 3: crie uma média móvel simples curta 
#          sobre o período de observação curto.

signal_df['short_mav'] = msft_data['Adj_Close'].rolling(window=short_lb,                                     min_periods=1, center=False).mean()

# Passo 4: crie uma média móvel simples longa 
#          sobre o período de observação longo.

signal_df['long_mav'] = msft_data['Adj. Close'].rolling(window=long_lb, min_periods=1, center=False).mean()

# Passo 5: gere os sinais com base na declaração condicional.

signal_df['signal'][short_lb:] = np.where(signal_df['short_mav'][short_lb:] > signal_df['long_mav'][short_lb:], 1.0, 0.0)

# Passo 6: crie as ordens de negociação com base na coluna de posições.

signal_df['positions'] = signal_df['signal'].diff()
signal_df[signal_df['positions'] == -1.0]

Vamos ver o que está acontecendo aqui. Criamos 2 períodos de observação. O período de observação curto, short_lb, é de 50 dias, e o período de observação mais longo para a média móvel longa é definido como long_lb de 120 dias.

Criamos um DataFrame projetado para capturar os sinais. Esses sinais são gerados sempre que a média móvel curta cruza a média móvel longa usando np.where. Ele atribui 1.0 para verdadeiro e 0.0 se a condição for falsa.

As colunas positions no DataFrame nos informam se há um sinal de compra, um sinal de venda, ou se deve-se manter a posição. Basicamente, estamos calculando a diferença na coluna de sinais em relação à linha anterior usando diff.

Lá, temos nossa estratégia implementada em apenas 6 passos usando o Pandas. Fácil, não é?

Agora, vamos tentar visualizar isso usando o Matplotlib. Tudo que precisamos fazer é inicializar um gráfico, adicionar os preços de fechamento ajustados, as médias móveis curtas e longas ao gráfico. Em seguida, fazemos o gráfico (plot) dos sinais de compra e venda usando a coluna de posições no signal_df acima:

# Inicialize o gráfico usando plt.
fig = plt.figure()

# Adicione um subgráfico e rótulo para o eixo y.
plt1 = fig.add_subplot(111,  ylabel='Preço em $')

msft_data['Adj. Close'].plot(ax=plt1, color='r', lw=2.)

# Plote as médias móveis de curto e longo prazo.
signal_df[['short_mav', 'long_mav']].plot(ax=plt1, lw=2., figsize=(12,8))

# Plotando os sinais de venda.
plt1.plot(signal_df.loc[signal_df.positions == -1.0].index,
			signal_df.short_mav[signal_df.positions == -1.0],'v',
            	markersize=10, color='k')

# Plotando os sinais de compra.
plt1.plot(signal_df.loc[signal_df.positions == 1.0].index,
			signal_df.short_mav[signal_df.positions == 1.0],
			'^',
          	markersize=10, color='m')

Executando as células acima no Jupyter Notebook resultaria em um gráfico como o abaixo:

Agora, você pode ver claramente que sempre que a linha azul (média móvel curta) ultrapassa e vai além da linha laranja (média móvel longa), há um marcador rosa para cima indicando um sinal de compra.

Um sinal de venda é indicado por um marcador preto para baixo sempre que houver uma queda da média móvel curta (short_mav) abaixo da média móvel longa (long_mav).

Visualize o desempenho da estratégia no Quantopian

O Quantopian (texto em inglês) é uma plataforma alimentada por Zipline que possui diversos casos de uso. Você pode escrever seus próprios algoritmos, acessar dados gratuitos, testar sua estratégia, contribuir para a comunidade e colaborar com o Quantopian se precisar de capital.

Escrevemos um algoritmo para testar nossa estratégia de SMA e aqui estão os resultados:

Aqui está uma explicação das métricas acima:

• Total return: é a porcentagem total de retorno do portfólio desde o início até o final do backtest.
• Specific return: é a diferença entre os retornos totais do portfólio e os retornos comuns.
• Common return: são retornos atribuíveis a fatores de risco comuns. Existem 11 fatores de risco setoriais e 5 de estilo que compõem esses retornos. Os gráficos de Exposição Setorial e Exposição de Estilo na seção de Risco fornecem mais detalhes sobre esses fatores.
• Sharpe: é o sharpe ratio de 6 meses consecutivos. É uma medida de investimento ajustada ao risco. É calculado dividindo os retornos excedentes do portfólio sobre a taxa livre de risco pelo desvio padrão do portfólio.
• Max Drawdown: é a maior queda de todo o movimento do pico ao ponto mais baixo na história do portfólio.
• Volatility: é o desvio padrão dos retornos do portfólio.

Parabéns! Você implementou com sucesso sua estratégia de trading quantitativo.

Para onde ir a partir daqui?

Agora que seu algoritmo está pronto, você precisará realizar backtests dos resultados e avaliar as métricas que mapeiam o risco (texto em inglês) envolvido na estratégia e na ação. Novamente, você pode usar o BlueShift e o Quantopian para aprender mais sobre backtesting e estratégias de negociação (textos dos links em inglês).

Recursos adicionais

Quantra (texto em inglês) é uma criação da QuantInsti. Com uma variedade de cursos gratuitos e pagos ministrados por especialistas na área, a Quantra oferece um guia completo sobre diversas estratégias de negociação, tanto básicas quanto avançadas.

• Curso de Ciência de Dados  (texto em inglês) — eles lançaram um curso introdutório sobre Ciência de Dados que ajuda a construir uma base sólida para projetos na área.
• Curso de Negociação para iniciantes (texto em inglês)  — desde negociação por momentum até estratégias de negociação baseadas em aprendizado de máquina e deep learning (aprendizagem profunda), pesquisadores renomados no mundo da negociação, como o Dr. Ernest P. Chan, são os autores desses cursos especializados.

Recursos gratuítos

Para aprender mais sobre algoritmos de negociação, confira esses blogs:

• Quantstart  (texto em inglês) — eles abrangem uma ampla gama de algoritmos de backtesting, guias para iniciantes e muito mais.
• Investopedia (texto em inglês) — tudo o que você deseja saber sobre investimentos e finanças.
• Quantivity (texto em inglês)  — explicações matemáticas detalhadas dos algoritmos, bem como suas vantagens e desvantagens.

Warren Buffet diz que lê cerca de 500 páginas por dia, o que indica que a leitura é essencial para ter sucesso na área de finanças.

Embarque nesta jornada de negociação e você poderá levar uma vida cheia de emoção, paixão e matemática.

Ciência de Dados com Harshit

Com este canal, estou planejando lançar uma série de vídeos que cobrirá todo o espaço da ciência de dados (em inglês). Aqui está o motivo pelo qual você deve se inscrever no canal (texto em inglês):

• Essas séries abordarão todos os tutoriais de qualidade necessários sobre cada um dos tópicos e subtópicos, como fundamentos de Python para Ciência de Dados (texto em inglês).
• Explicações matemáticas e derivações (texto em inglês) sobre o porquê fazemos o que fazemos em aprendizagem de máquina e Deep Learning.
• Podcasts com Cientistas de Dados e Engenheiros (texto em inglês) do Google, Microsoft, Amazon etc., além de CEOs de grandes empresas orientadas por dados.
• Projetos e instruções para implementar os tópicos aprendidos até agora. Saiba mais sobre novas certificações, bootcamps e recursos para conquistar essas certificações, como o Exame de Certificação de Desenvolvedor TensorFlow do Google (texto em inglês).

Se este tutorial foi útil, confira meus cursos de ciência de dados e aprendizagem de máquina na Wiplane Academy (texto em inglês). Eles são abrangentes, porém compactos, ajudando a construir uma base sólida de trabalho para mostrar.

Diga não ao pip install na linha de comando! Esta é uma maneira alternativa de instalar TensorFlow em sua máquina local em 3 etapas.

Por que estou escrevendo isso?

Brinquei com o pip install com múltiplas configurações por várias horas, tentando descobrir como configurar corretamente meu ambiente do Python para o TensorFlow e o Keras.

Pouco antes de desistir, descobri isso…

"Um dos principais benefícios da instalação do TensorFlow usando conda em vez de pip é o resultado do sistema de gerenciamento de pacotes do conda. Quando o TensorFlow é instalado usando conda, o conda também instala todas as dependências necessárias e compatíveis para os pacotes."

Este artigo orientará você no processo de instalação do TensorFlow e do Keras usando a versão GUI do Anaconda. Presumo que você já tenha baixado e instalado o Anaconda Navigator.

Vamos começar!

1. Inicie o Anaconda Navigator. Vá para a guia Ambientes (Environments) e clique em 'Create'.

2. Insira um novo nome de ambiente - (eu coloquei 'tensorflow_env'). Certifique-se de selecionar Python 3.6 aqui! Em seguida, clique em 'Create' – o processo pode levar alguns minutos.

Nota da tradução: o Python, atualmente, está na versão 3.12. O Anaconda também possui novas versões capazes de instalar algo nas versões mais recentes do Python. Caso você queira, pode testar a instalação com versões mais novas.

3. Em seu novo ambiente 'tensorflow_env', selecione 'Not installed' e digite 'tensorflow'. Em seguida, marque 'tensorflow' e clique em 'Apply'. A janela de pop-up aparecerá. Vá em frente e clique em 'Apply'. Esse processo pode levar vários minutos.

Faça o mesmo para o 'keras'.

Verifique sua instalação importando os pacotes. Se tudo estiver bem, o comando não retornará nada. Se a instalação não for bem-sucedida, você receberá um erro.

Está feito! Você pode seguir este artigo (em inglês) para testar seus pacotes recém-instalados. 🙂

Obrigado pela leitura. Faça os testes!

Considere seguir o autor no GitHub, no Medium e no Twitter para obter mais artigos e tutoriais em seu feed, se gostou do artigo. 🙂

Escrito por: Siddy Zen

Para usar o MongoDB como banco de dados de back-end em seu projeto em Django, basta adicionar esta única linha em seu arquivo settings.py:

DATABASES = {'default': {      'ENGINE': 'djongo',      'NAME': 'nome-do-banco',   }}

É muito simples!

A seguir, faça login no home admin (localhost:8000/admin/) e comece a adicionar "embedded documents" (documentos incorporados, em português) no MongoDB usando a interface gráfica de administrador:

Em outubro de 2017, o MongoDB concluiu a última fase para se tornar uma companhia de capital aberto, abrindo seu IPO com um preço inicial de $24 e conseguindo $192 milhões no processo. O capital da empresa vem crescendo desde então.

O MongoDB oferece um software de banco de dados de código aberto. Ele é muito útil para start-ups que estão buscando iniciar nos negócios apesar do pouco orçamento inicial disponível. Uma análise no Google Trends das pesquisas pelo termo MongoDB revelam um aumento constante na busca do termo.

O MongoDB tem se tornado um banco de dados cada vez mais popular. Bancos de dados e sistemas de gerenciamento de bancos de dados (SGBDs) existem há mais de cinco décadas. Surgiram no início dos anos 1960 e a opção mais popular foi o banco de dados relacional.

Porém, o MongoDB vem se intitulando como um sistema de banco de dados "não-relacional" e tem feito uma grande propaganda sobre essa abordagem de armazenamento de dados que utiliza. Então, o que exatamente é importante aqui?

MongoDB x SQL

Praticamente todos os sistemas de bancos de dados relacionais utilizam a Linguagem de Consulta Estruturada (SQL), ou uma versão otimizada dela, para se comunicar com o software de gerenciamento de dados. Muitos cursos universitários são dedicados exclusivamente à compreensão e domínio da sintaxe do SQL.

O SQL tornou-se a linguagem padrão para o trabalho com qualquer software de banco de dados, seja ele proprietário ou de código aberto. Então, surgiu o MongoDB e decidiu demonstrar um completo desrespeito a essa linguagem ancestral de poder, criando sua própria sintaxe de consulta.

A língua é a de Mordor, a qual não vou pronunciar aqui., mas isto em língua comum quer dizer, aproximadamente: "Um anel para todos governar, um anel para encontrá-los, um anel para todos trazer e na escuridão aprisioná-los." – Gandalf (de O Senhor dos Anéis)

MongoDB sem esquemas x esquemas do SQL: em um banco de dados em SQL, é impossível adicionar dados enquanto você não definir tabelas e tipos de campos no que é chamado de esquema (em inglês, schema). Em um banco de dados do MongoDB, os dados podem ser adicionados em qualquer lugar, a qualquer momento. Não há necessidade de especificar com antecedência um documento de design ou mesmo uma coleção de documentos.

Documentos do MongoDB  x tabelas do SQL: bancos de dados em SQL fornecem uma coleção de tabelas de dados relacionados. Cada linha é um registro diferente. O design é rígido: não podemos usar a mesma tabela para armazenar informações diferentes ou inserir uma string onde um número é esperado.

O banco de dados do MongoDB armazena apenas documentos de pares campo-valor, semelhantes ao formato JSON. Documentos similares podem ser armazenados em uma coleção de documentos, que é análoga a uma tabela do SQL. Entretanto, você pode armazenar qualquer tipo de dado em um documento — o MongoDB não vai reclamar. As tabelas em SQL implementam um modelo de dados rígido, o que torna mais difícil que erros sejam cometidos. O MongoDB é mais flexível e permissivo, mas a possibilidade de armazenar qualquer tipo de dado em qualquer lugar pode levar a erros de consistência.

Existe uma infinidade de conteúdo na internet argumentando que o MongoDB não é um superconjunto do SQL. Softwares que rodam em SQL não podem ser migrados para MongoDB. Vou me arriscar aqui afirmando que, no contexto do Django, MongoDB é um superconjunto do SQL.

Então, por que essa crença popular de que MongoDB não é um superconjunto do SQL existe, para começo de conversa?

O MongoDB requer desnormalização de dados: o MongoDb não oferece suporte a JOIN. Isso significa que vamos precisar desnormalizar nossos documentos. Documentos desnormalizados implicam maior velocidade nas consultas, mas atualizar informações nos campos do documento, em múltiplos documentos desnormalizados, é significativamente mais lento.

Não existem JOINs: consultas do SQL oferecem uma poderosa cláusula JOIN. Podemos obter dados relacionados em várias tabelas usando uma única instrução SQL. Em bancos de dados não relacionais como o MongoDB, não existem JOINs. Isso que dizer que você precisa executar muitas consultas e depois fazer a união dos dados manualmente em seu código.

Sem transações: em bancos de dados SQL, duas ou mais atualizações podem ser executadas em uma transação – um invólucro que segue o princípio do "tudo ou nada", que garante sucesso ou falha das operações. Se executarmos duas atualizações individualmente, uma pode ter sucesso e a outra pode falhar – deixando nossos dados fora de sincronia. Colocar as mesmas atualizações em uma transação garante que ambas tenham sucesso ou ambas falhem.

Sem restrições de chave estrangeira: a maioria dos bancos de dados de SQL permite que você assegure a integridade dos dados usando restrições de chave estrangeira. Isso garante que todas as linhas tenham uma chave estrangeira válida no código que corresponde a uma entrada na tabela de join, e garante que um registro da tabela de join não seja removido caso uma ou mais linhas ainda possuam referência a ele.

O esquema impõe essas regras ao banco de dados. É impossível que desenvolvedores e usuários adicionem, editem, ou removam registros, o que poderia resultar em dados inválidos ou registros órfãos. As mesmas opções para integridade de dados não estão disponíveis no MongoDB. Você pode armazenar o que quiser, independentemente de quaisquer outros documentos. Idealmente, um único documento serviria como a única fonte de informação sobre um item.

A necessidade de um modelo de banco de dados

Objetos são a abstração de dados que Python usa. Todos os dados em um programa em Python são representados por objetos ou pelas relações que eles têm entre si. Embora objetos sejam uma boa maneira de representar dados, um problema surge quando queremos tornar os dados persistentes. A quantidade de dados pode ser enorme, e precisa ser recuperada da memória persistente de maneira rápida e eficiente. Logo, será necessário usar um software de banco de dados para armazenar esses objetos. Um possível software de banco de dados é um que seja relacional, baseado em SQL.

Um mapeador objeto-relacional (ORM) é uma biblioteca de código que automatiza a transferência de dados armazenados em tabelas de banco de dados relacionais em objetos Python que são usados no código Python. ORMs fornecem uma abstração em alto nível de um banco de dados relacional, o que permite que um desenvolvedor digite código Python em vez de sintaxe SQL para criar, ler, atualizar e excluir dados e esquemas de seu banco de dados. Desenvolvedores podem usar linguagem de programação Python, com a qual estão familiarizados, ao invés de escrever declarações em SQL ou procedimentos armazenados.

Um exemplo de framework ORM para Python é o SQLAlchemy. Esse ORM possui um método de associar classes definidas pelo usuário em Python a tabelas de banco de dados, e instâncias dessas classes (objetos) a linhas em suas respectivas tabelas. Ele também possui um sistema que, de modo transparente, sincroniza todas as alterações de estado entre objetos e linhas que estão a eles relacionadas. Frameworks para a web, como o Flask, usam o SQLAlchemy para armazenar dados de maneira persistente.

Django ORM: o Django vem com seu próprio ORM, ou modelo, para ser mais específico . O modelo é a única fonte definitiva de informações sobre seus dados. Ele contém os campos e comportamentos essenciais dos dados que você está armazenando. Geralmente, cada modelo mapeia para uma única tabela de banco de dados. O modelo também torna possível alternar entre vários bancos de dados relacionais, como Oracle SQL, MySQL ou MSSQL.

Usando o ORM do Django para adicionar documentos ao MongoDB

Digamos que você deseja criar uma plataforma de blogs usando Django e MongoDB como back-end.

No arquivo app/models.py do blog, defina o modelo BlogContent:

from djongo import modelsfrom djongo.models import forms

class BlogContent(models.Model):    comment = models.CharField(max_length=100)    author = models.CharField(max_length=100)    class Meta:        abstract = True

Para acessar o modelo usando o Django Admin, você precisa de uma definição de formulário para o modelo acima. Defina desta maneira:

class BlogContentForm(forms.ModelForm):    class Meta:        model = BlogContent        fields = (            'comment', 'author'        )

Agora, incorpore seu BlogContent dentro de um BlogPost usando o EmbeddedModelField, assim:

class BlogPost(models.Model):    h1 = models.CharField(max_length=100)    content = models.EmbeddedModelField(        model_container=BlogContent,        model_form=BlogContentForm    )   

Pronto! Rode o Django Admin em localhost:8000/admin/ e essa tela vai aparecer:

Depois, assuma que você quer "estender" o campo author para conter mais informações além do nome. Suponhamos que você precise tanto do nome quanto do e-mail. Basta tornar o campo author em um campo "embedded" ao invés de  "char":

class Author(models.Model):    name = models.CharField(max_length=100)    email = models.CharField(max_length=100)    class Meta:        abstract = Trueclass AuthorForm(forms.ModelForm):    class Meta:        model = Author        fields = (            'name', 'email'        )

class BlogContent(models.Model):    comment = models.CharField(max_length=100)    author = models.EmbeddedModelField(        model_container=Author,        model_form=AuthorForm    )    class Meta:        abstract = True

Se um post de blog tiver conteúdo diverso de vários autores, defina um novo modelo:

class MultipleBlogPosts(models.Model):    h1 = models.CharField(max_length=100)    content = models.ArrayModelField(        model_container=BlogContent,        model_form=BlogContentForm    )

Rode o Django Admin com as atualizações. Agora você tem:

Formas de integrar Django ao MongoDB

O ORM do Django consiste em várias camadas de abstração empilhadas uma em cima da outra.

Como desenvolvedor para a web, você pode encarar o desafio de conectar o Django ao MongoDB de duas maneiras. Dê uma olhada na stack do framework Django acima para tentar adivinhar possíveis pontos de conexão.

Use um modelo compatível com o MongoDB

Você pode evitar completamente o uso de modelos Django "com tudo incluso" em seu projeto. Em vez disso, use um framework de terceiros como MongoEngine ou Ming em seus projetos do Django.

Tenha em mente, porém, que escolher um modelo diferente significa perder:

• Mais de 1500 desenvolvedores que contribuem no núcleo do projeto
• Correções a cada hora e resolução de chamados

Você então diminuiria a expertise nos modelos existentes do Django e aumentaria no novo framework de modelos. Talvez a maior desvantagem, no entanto, resida no fato de que seu projeto não vai poder usar nenhum dos pacotes do django.contrib! Esqueça o uso de Admin, Sessions, Users, Auth e outros módulos desse pacote em seu projeto.

Algumas dessas desvantagens são compensadas quando bifurcamos uma nova ramificação no próprio Django. O Django-nonrel, por exemplo, é uma ramificação independente que adiciona ao Django suporte a banco de dados NoSQL. Ele permite que aplicações do Django portáteis sejam escritas. Entretanto, a interface admin não funciona completamente. Além disso, não existe uma comunidade ativa de fato desenvolvendo o projeto.

Django MongoDB Engine é outro back-end com MongoDB para Django, que é uma bifurcação do MongoEngine ODM.

Djongo – transpilador de Django SQL para MongoDB

Outra abordagem é traduzir a sintaxe da consulta SQL gerada pelo ORM do Django em comandos do pymongo. O Djongo é um desses compiladores de consultas SQL para MongoDB. Ele traduz toda string de consulta SQL em um documento de consulta do mongoDB. O resultado é que todos os modelos do Django e modelos relacionados funcionam assim. Por conta disso, temos as seguintes vantagens:

• Reuso dos modelos Django: o Django é um framework estável em contínuo desenvolvimento e aprimoramento. O ORM do Django é um tanto quanto extenso e dotado de vários recursos . Definir um ORM de terceiros para trabalhar com o MongoDB significa reproduzir todo o ORM do Django novamente. O novo ORM precisa se alinhar constantemente com o ORM do Django. Diversas funcionalidades do Django nunca vão ser incluídas em um ORM de terceiros. A ideia com o Djongo é reutilizar recursos existentes do ORM do Django, traduzindo então consultas SQL para a sintaxe do MongoDB.
• A sintaxe do SQL nunca vai mudar: independentemente de futuras adições no Django, com o Djongo, seu projeto não vai ter problemas no futuro!

Fazendo o Django funcionar com o MongoDB

Emulando o esquema no MongoDB: embora não haja suporte a esquemas no MongoDB, isso pode ser emulado. O Djongo fornece o suporte a esquemas necessário no Django, usando e definindo uma combinação de regras de validação do MongoDB e criando uma coleção __schema__. A coleção __schema__ armazena informações para suportar recursos como a chave SQL AUTOINCREMENT.

Suporte a JOIN no MongoDB: na versão 3.2, o MongoDB introduziu o operador $lookup. Ele realiza um left outer join com uma coleção no mesmo banco de dados para filtrar documentos da coleção "unida" (em inglês, joined) para processamento. A etapa de $lookup faz uma correspondência de igualdade entre um campo dos documentos de entrada e um campo dos documentos da coleção "unida".

Para cada documento de entrada, a fase de $lookup adiciona um campo array cujos elementos são os documentos correspondentes da coleção "unida". A fase de $lookup passa, então,  esses documentos remodelados para a próxima etapa.

O Djongo usa o operador de agregação $lookup para realizar todas as consultas de JOIN relacionadas ao Django. É assim que ele faz o módulo admin e os outros módulos contrib funcionarem.

Suporte a transações no MongoDB: apesar do poder das operações atômicas de um único documento, existem casos onde transações multidocumento são necessárias. Ao se executar uma transação composta por operações sequenciais, certos problemas surgem, como nos casos em que, se operação falhar, a operação anterior dentro da transação precisa voltar a seu estado anterior — ou seja,  "tudo ou nada".

Para situações que exigem transações multidocumento, o Djongo implementa o padrão de confirmação de duas fases (documentação em inglês), fornecendo suporte para essas atualizações multidocumento. O uso de confirmação de duas fases garante a consistência dos dados e, em caso de erro , o estado que precedeu a transação pode ser recuperado.

O Djongo surgiu com seu próprio conjunto de preceitos, na verdade. Então, quais são as desvantagens de se optar pelo uso do Djongo em seu projeto Django?

Desempenho: o ORM do Django faz o trabalho pesado de converter manipulações complexas de objeto em strings de consulta no padrão SQL. Se o banco de dados do seu back-end fosse baseado em SQL, você poderia passar essa string de consulta diretamente para ele sem quase nenhum pós-processamento. Usando Djongo, entretanto, a string de consulta precisará ser convertida em um documento de consulta do MongoDB.

Isso vai exigir alguns ciclos de CPU. Porém, se ciclos adicionais de CPU são realmente um problema, você não deveria estar usando Python em primeiro lugar.

Conclusão

Apresentei diversas maneiras de se integrar Django ao MongoDB. Você encontrará uma infinidade de literatura on-line descrevendo a MongoEngine e outras variantes para fazer isso.

Concentrei-me no Djongo, que é um novo conector que torna isso possível de uma maneira diferente, é fácil de usar e simplifica o processo de migração de um back-end com SQL para o MongoDB, adicionando apenas uma linha de código.

Quando as pessoas que falam idiomas diferentes estão juntas e conversam, elas tentam usar uma linguagem que todos do grupo possam entender.

Para isso, todos precisam traduzir seus pensamentos, que normalmente estão na sua língua nativa, para todos do grupo. Essa "codificação e decodificação" do idioma, no entanto, leva a uma perda de eficiência, velocidade e precisão.

O mesmo conceito está presente nos sistemas do computador e em seus componentes. Por que deveríamos enviar dados em XML, JSON, ou em outra linguagem de humanos se não precisamos entender diretamente sobre o que eles estão falando? Basta que possamos traduzir para o formato da linguagem humana se precisarmos.

Os buffers de protocolo são uma forma de codificar dados antes do transporte, o que reduz de maneira eficiente os blocos de dados e, portanto, aumenta a velocidade de envio. Eles abstraem os dados em um formato neutro em termos de linguagem e plataforma.

Índice

• Por que precisamos dos buffers de protocolo?
• O que são os buffers de protocolo e como eles funcionam?
• Buffers de protocolo com o Python
• Considerações finais

Por que precisamos dos buffers de protocolo?

O objetivo inicial dos buffers de protocolos foi o de simplificar o trabalho com protocolos de solicitação/resposta. Antes do ProtoBuf, O Google usou um formato diferente para solicitação adicional de manipulação do marshaling para o envio de mensagens.

Além disso, as novas versões dos formatos anteriores exigiam que os desenvolvedores tivessem a certeza de que as novas versões fossem entendidas antes de substituir as antigas, tornando o trabalho com elas um problema.

Isso motivou a Google a projetar uma interface que resolvesse precisamente esses problemas.

Os buffers do protocolo permitem alterações no protocolo sem interferir na compatibilidade. Além disso, servidores podem transmitir os dados e executar operações de leitura nos dados sem modificar o conteúdo.

Como o formato se autodescreve, o ProtoBuf é usado como base para geração automática de código para serializadores e desserializadores.

Outro caso de uso interessante é como a Google o usa para chamadas de procedimento remoto (RPC – texto em inglês) de curta duração e para armazenar dados persistentemente na Bigtable. Devido ao seu caso de uso especifico, eles integraram interfaces de RPC aos buffers de protocolo. Isso permite a geração rápida e direta de códigos stub que podem ser usados como pontos de partidas para a implementação real (mais a respeito de ProtoBuf RPC aqui – texto em inglês).

Outros exemplos de onde o ProtoBuf pode ser usado são os dispositivos IoT conectados através de redes móveis, nas quais a quantidade de dados enviadas deve ser pequena ou para aplicações de países onde larguras de banda altas ainda são raras. O envio de cargas úteis, otimizada em formatos binários, pode levar a diferenças perceptíveis no custo e na velocidade de operação.

Usar a compactação gzip em sua comunicação por HTTPS pode melhorar ainda mais essas métricas.

O que são os buffers de protocolo e como eles funcionam?

De modo geral, os buffers de protocolo podem ser definidos como uma interface para serialização de dados estruturados. Isso define uma forma normalizada de comunicação, totalmente independente de linguagens e plataformas.

O Google anuncia o buffer de protocolo como:

Buffers de protocolo são os mecanismo extensível, neutro em termos de linguagem e de plataforma do Google para serializar dados estruturados – pense no XML, mas menor, mais rápido e mais simples. Você define como deseja que seus dados sejam estruturados uma vez…

A interface ProtoBuf descreve a estrutura de dados a serem enviados. As estruturas de cargas útil são definidas como "mensagens" no que é chamado de Proto-Arquivo. Esses arquivos sempre terminam com a extensão .proto

Por exemplo, a estrutura básica de um arquivo todolist.proto é semelhante a que vemos a seguir. Também veremos um exemplo completo na próxima seção.

syntax = "proto3";

// Não é necessário para Python, ainda deve ser declarado para evitar colisões de nomes
// no namespace Protocol Buffers e em linguagens além do Python

package protoblog;

message TodoList {
   // Os elementos da lista de tarefas serão definidos aqui
      ...
}

Esses arquivos são, então, usados para gerar classes de integração ou stubs para a linguagem de sua escolha usando geradores de código dentro do compilador protoc. A versão atual, Proto3, já suporta todas as principais linguagens de programação. A comunidade oferece suporte a muito mais implementações de código aberto de terceiros.

As classes geradas são os elementos principais dos buffers de protocolo. Eles permitem a criação de elementos instanciando novas mensagens, baseadas nos arquivos .proto, que são, então, utilizados para serialização. Veremos em detalhes como isso é feito com Python na próxima seção.

Independentemente da linguagem de serialização, as mensagens são serializadas em um formato binário, não auto descritivo, que é bastante inútil sem a definição inicial da estrutura.

Os dados binários podem, então, ser armazenados, enviados pela rede e usados de qualquer outra forma que os dados legíveis por humanos, como JSON ou XML, sejam. Após a transmissão ou armazenamento, o fluxo de bytes pode ser desserializado e restaurado usando qualquer classe protobuf compilada específica da linguagem que geramos a partir do arquivo .proto.

Usando Python como exemplo, o processo poderia ser mais ou menos assim:

Primeiro, criamos uma lista de tarefas e a preenchemos com algumas tarefas. Essa lista de tarefas é, então, serializada e enviada pela rede, salva em um arquivo ou armazenada persistentemente em um banco de dados.

O fluxo de bytes enviado é desserializado usando o método parse de nossa classe compilada específica da linguagem.

A maioria das arquiteturas e infraestruturas atuais, especialmente microsserviços, é baseada em comunicação REST, WebSockets ou GraphQL. No entanto, quando a velocidade e a eficiência são essenciais, os RPCs de baixo nível podem fazer uma enorme diferença.

Em vez de protocolos de alta sobrecarga, podemos usar uma forma rápida e compacta de mover dados entre as diferentes entidades para o nosso serviço sem desperdiçar muitos recursos.

Por que isso ainda não é usado em todos os lugares?

Os buffers de protocolo são um pouco mais complicados do que outros formatos legíveis por humanos. Isso os torna comparativamente mais difíceis de depurar e integrar em suas aplicações.

Os tempos de iteração na engenharia também tendem a aumentar, pois as atualizações nos dados exigem a atualização dos arquivos proto antes do uso.

Considerações cuidadosas devem ser feitas, uma vez que o ProtoBuf pode ser uma solução com excesso de engenharia em muitos casos.

Que alternativas eu tenho?

Vários projetos adotam uma abordagem semelhante aos buffers de protocolo do Google.

Os Flatbuffer do Google e uma implementação de terceiros, chamada Cap’n Proto, estão mais focados em remover a etapa de análise e descompactação, que é necessária para acessar os dados reais ao usar ProtoBufs. Eles foram projetados explicitamente para aplicações de desempenho crítico, tornando-os ainda mais rápidos e mais eficientes em termos de memória do que o ProtoBuf.

Ao focar nos recursos RPC do ProtoBuf (usado com gRPC), existem projetos de outras grandes empresas como Facebook (Apache Thrift) ou Microsoft (protocolos Bond) que podem oferecer alternativas.

Buffers de protocolo com o Python

O Python já fornece algumas formas de persistência de dados usando decapagem. A decapagem é útil em aplicações que tenham somente Python. Ela não é adequada para cenários mais complexos onde está envolvido o compartilhamento de dados com outras linguagens ou a alteração de esquemas.

Os buffers de protocolo, por outro lado, são desenvolvidos exatamente para esses cenários. O arquivo .proto, que abordamos rapidamente antes, permite ao usuário gerar código para muitas linguagens suportadas.

Para compilar o arquivo .proto para a classe de linguagem de nossa escolha, usamos protoc, o compilador proto.

Se você não possui o compilador protoc instalado, existem excelentes guias sobre como fazer isso:

• MacOS/Linux (em inglês)
• Windows (em inglês)

Depois de instalar o protoc em nosso sistema, podemos usar um exemplo estendido de nossa estrutura de lista de tarefas anterior e gerar a classe de integração Python a partir dele.

syntax = "proto3";

// Não necessário para o Python, mas ainda deve ser declarado para evitar colisões de nome 
// no namespace dos Buffers de Protocolo e em linguagens que não sejam o Python
package protoblog;

// O guia de estilo prefere a prefixação de valores de enum em vez de cercá-los
// com uma mensagem de fechamento
enum TaskState {
    TASK_OPEN = 0;
    TASK_IN_PROGRESS = 1;
    TASK_POST_PONED = 2;
    TASK_CLOSED = 3;
    TASK_DONE = 4;
}

message TodoList {
    int32 owner_id = 1;
    string owner_name = 2;

    message ListItems {
        TaskState state = 1;
        string task = 2;
        string due_date = 3;
    }

    repeated ListItems todos = 3;
}

Vamos dar uma olhada mais detalhada na estrutura do arquivo  .proto  para entendê-lo. Na primeira linha do arquivo proto, definimos se estamos usando Proto2 ou 3. Nesse caso, estamos usando Proto3.

Os elementos mais incomuns dos arquivos proto são os números atribuídos a cada entidade de uma mensagem. Esses números dedicados tornam cada atributo único e são usados para identificar os campos atribuídos na saída codificada em binário.

Um conceito importante de se entender é que apenas os valores de 1 a 15 são codificados com um byte a menos (Hex), o que é útil de entender para que possamos atribuir números mais altos às entidades usadas com menos frequência. Os números não definem a ordem de codificação nem a posição do atributo fornecido na mensagem codificada.

A definição do pacote ajuda a evitar conflitos de nomes. Em Python, os pacotes são definidos por seu diretório. Portanto, fornecer um atributo de pacote não tem nenhum efeito no código em Python gerado.

Observe que os pacotes ainda devem ser declarados para evitar colisões de nomes relacionadas ao buffer de protocolo e para outras linguagens como Java.

Enumerações são listagens simples de valores possíveis para uma determinada variável. Nesse caso, definimos um Enum para os possíveis estados de cada tarefa na lista de tarefas. Veremos como usá-los daqui a pouco, quando observarmos o uso em Python.

Como podemos ver no exemplo, também podemos aninhar mensagens dentro de mensagens. Se quisermos, por exemplo, ter uma lista de todos os dados associados a uma determinada lista de tarefas, podemos usar a palavra-chave repeated, que é comparável a arrays de tamanho dinâmico .

Para gerar código de integração utilizável, usamos o compilador proto, que compila um determinado arquivo .proto em classes de integração específicas da linguagem. No nosso caso, usamos o argumento --python-out para gerar código específico em Python.

protoc -I=. --python_out=. ./todolist.proto

No terminal, invocamos o compilador do protocolo com três parâmetros:

1. -I: define o diretório onde procuramos quaisquer dependências (usamos ., que é o diretório atual)
2. --python_out: define o local onde queremos gerar uma classe de integração do Python (novamente usamos ., que é o diretório atual)
3. O último parâmetro sem nome define o arquivo .proto que será compilado (usamos o arquivo todolist.proto, no diretório atual)

Isso cria um novo arquivo em Python chamado <nome_do_arquivo_proto>_pb2.py. No nosso caso, é todolist_pb2.py. Ao examinar esse arquivo mais de perto, não seremos capazes de entender muito sobre sua estrutura imediatamente.

Isso ocorre porque o gerador não produz elementos de acesso direto aos dados, mas abstrai ainda mais a complexidade usando metaclasses e descritores para cada atributo. Eles descrevem como uma classe se comporta em vez de cada instância dessa classe.

A parte mais interessante é como usar esse código gerado para criar, construir e serializar dados. Uma integração direta feita com nossa classe gerada recentemente é vista a seguir:

import todolist_pb2 as TodoList

my_list = TodoList.TodoList()
my_list.owner_id = 1234
my_list.owner_name = "Tim"

first_item = my_list.todos.add()
first_item.state = TodoList.TaskState.Value("TASK_DONE")
first_item.task = "Teste de ProtoBuf para o Python"
first_item.due_date = "31.10.2019"

print(my_list)

Ele apenas cria uma lista de tarefas e adiciona um item a ela. Em seguida, imprimimos o próprio elemento da lista de tarefas e podemos ver a versão não binária e não serializada dos dados que acabamos de definir em nosso script.

owner_id: 1234
owner_name: "Tim"
todos {
  state: TASK_DONE
  task: "Teste de ProtoBuf para o Python"
  due_date: "31.10.2019"
}

Cada classe Protocol Buffer possui métodos para ler e escrever mensagens usando uma  codificação específica do buffer de protocolo (texto em inglês), que codifica mensagens em formato binário. Esses dois métodos são SerializeToString() e ParseFromString().

import todolist_pb2 as TodoList

my_list = TodoList.TodoList()
my_list.owner_id = 1234

# ...

with open("./serializedFile", "wb") as fd:
    fd.write(my_list.SerializeToString())


my_list = TodoList.TodoList()
with open("./serializedFile", "rb") as fd:
    my_list.ParseFromString(fd.read())

print(my_list)

No exemplo de código acima, escrevemos a string serializada de bytes em um arquivo usando os sinalizadores wb.

Como já escrevemos o arquivo, podemos ler o conteúdo e analisá-lo usando ParseFromString. ParseFromString chama uma nova instância de nossa classe serializada usando os sinalizadores rb e a analisa.

Se serializarmos essa mensagem e se a imprimimos no console, obteremos a representação de bytes semelhante a esta.

b'\x08\xd2\t\x12\x03Tim\x1a(\x08\x04\x12\x18Teste de ProtoBuf para o Python\x1a\n31.10.2019'

Observe o b na frente das aspas. Isso indica que a string a seguir é composta de octetos de bytes em Python.

Se compararmos isso diretamente com, por exemplo, XML, podemos ver o impacto que a serialização do ProtoBuf tem no tamanho.

<todolist>
	<owner_id>1234</owner_id>
	<owner_name>Tim</owner_name>
	<todos>
		<todo>
			<state>TASK_DONE</state>
			<task>Teste de ProtoBuf para o Python</task>
			<due_date>31.10.2019</due_date>
		</todo>
	</todos>
</todolist>

A representação JSON, ajustada, ficaria assim.

{
	"todoList": {
		"ownerId": "1234",
		"ownerName": "Tim",
		"todos": [
			{
				"state": "TASK_DONE",
				"task": "Teste de ProtoBuf para o Python",
				"dueDate": "31.10.2019"
			}
		] 
	}
}

Julgando os diferentes formatos apenas pelo número total de bytes utilizados, ignorando a memória necessária para o overhead de formatação, podemos obviamente ver a diferença.

Além da memória utilizada para os dados, no entanto, também temos 12 bytes extras no ProtoBuf para formatação de dados serializados. Comparando isso com XML, temos 171 bytes extras em XML para formatar dados serializados.

Sem um esquema, precisamos de 136 bytes extras em JSON para formatar dados serializados.

Se estamos falando de milhares de mensagens enviadas pela rede ou armazenadas em disco, o ProtoBuf pode fazer a diferença.

Há uma questão importante, no entanto. A plataforma Auth0.com criou uma extensa comparação entre ProtoBuf e JSON. Ela mostra que, quando comprimido, a diferença de tamanho entre os dois pode ser mínima (apenas cerca de 9%).

Se você estiver interessado nos números exatos, consulte o artigo completo (em inglês), que fornece uma análise detalhada de vários fatores como tamanho e velocidade.

Uma observação interessante é que cada tipo de dados possui um valor padrão. Se os atributos não forem atribuídos ou alterados, eles manterão os valores padrão. No nosso caso, se não alterarmos o TaskState de um ListItem, ele terá o estado "TASK_OPEN" por padrão. A vantagem significativa disso é que os valores não definidos não são serializados, economizando espaço adicional.

Se, por exemplo, alterarmos o estado da nossa tarefa de TASK_DONE para TASK_OPEN, ela não será serializada.

owner_id: 1234
owner_name: "Tim"
todos {
  task: "Teste de ProtoBuf para o Python"
  due_date: "31.10.2019"
}

b'\x08\xd2\t\x12\x03Tim\x1a&\x12\x18Teste de ProtoBuf para o Python\x1a\n31.10.2019'

Considerações finais

Como vimos, os buffers de protocolo são bastante úteis quando se trata de velocidade e eficiência ao trabalhar com dados. Devido à sua natureza poderosa, pode levar algum tempo para se acostumar com o sistema ProtoBuf, embora a sintaxe para definir novas mensagens seja simples.

Como última observação, quero salientar que houve/há discussões em andamento sobre a "utilidade" dos buffers de protocolo para aplicações regulares. Eles foram desenvolvidos explicitamente para problemas que o Google tinha em mente.

Se você tiver alguma dúvida ou feedback, sinta-se à vontade para entrar em contato com o autor em qualquer mídia social, como o Twitter ou por e-mail.

Acredita-se que o Python seja uma das linguagens de programação mais fáceis de aprender. Saber disso fez com que eu me sentisse muito mal na primeira vez que tentei e não consegui aprender. Foi ainda pior na segunda vez em que eu tentei.

Acontece, no entanto — e eu só aprendi isso na terceira tentativa — que o Python pode ser bastante acessível, mesmo para um amante da área de humanidades e não programador como eu. Baste que você aborde a linguagem do modo certo.

Como eu não consegui aprender Python… na primeira tentativa

A primeira vez em que tentei aprender Python foi há quase uma década. Eu não tinha certeza do que eu queria fazer com ele – talvez automatizar parte do meu trabalho, talvez escrever uma aplicação pequena. Parecia apenas uma habilidade que seria bom saber.

Então, eu peguei uma cópia do livro Learn Python the Hard Way (Aprenda Python da maneira difícil, eu português) em PDF e comecei a tentar ler do início ao fim.

A primeira barreira que encontrei foi configurar o Python no meu próprio sistema. Especialmente naquela época, a maioria das instruções sobre como fazer isso estavam escritas para programadores experientes. Eu levei uma eternidade para passar por tudo.

Eu queria aprender a escrever código em Python. Meu primeiro passo foi passar cinco horas lutando com a linha de comando. Eu estava desmotivado antes mesmo de começar.

Quando, finalmente, consegui configurar tudo, pude escrever código junto com o livro. Eu fiz isso, por um tempo, criando lentamente um jogo de aventura de texto muito simples.

Porém, quando cheguei no meu primeiro desafio real – aqueles momentos que sempre vêm na programação em que algo não funciona e você simplesmente não consegue descobrir o porquê – eu desisti.

Eu tinha coisas mais importantes para fazer do que bater a cabeça contra o teclado e desvendar um quebra-cabeça de mensagens de erro inescrutáveis, especialmente quando meu objetivo final era fazer um jogo de aventura de texto com o qual eu não me importava e que ninguém jamais jogaria.

Como eu não consegui aprender Python… na segunda tentativa

Alguns anos depois, tentei novamente. Naquela época, eu estava trabalhando como jornalista e me interessei por jornalismo de dados e, em particular, por web scraping.

Eu sabia que ter habilidades de programação em Python seria necessário, então encontrei uma plataforma de educação on-line – não vou dizer qual – e comecei um curso de Python para iniciantes.

Como a maioria dos MOOCs (Massive Open Online Course, ou, em português, curso on-line aberto e para o grande público), este curso foi baseado em vídeo. Eu assistia a uma aula sobre um tópico relacionado ao Python, respondia a um questionário no site do curso para confirmar que havia aprendido o assunto e, em seguida, passava para o próximo módulo.

Programadores experientes provavelmente já podem adivinhar o que aconteceu a seguir: quando fui tentar escrever código em Python para mim, não consegui fazer nada.

Ver outra pessoa programar em vídeos e ouvir suas explicações me fez achar que estava aprendendo a fazer isso por mim mesmo. Os testes de múltipla escolha e preenchimento de espaços em branco que eu estava respondendo 100% corretamente pareciam confirmar que eu havia entendido o assunto.

Naturalmente, na hora de aplicar por conta própria, não consegui. Eu podia assistir os vídeos do início ao fim e copiar o que o professor fazia, mas tinha muita dificuldade em aplicar qualquer coisa que eu tinha aprendido aos meus próprios projetos.

Também foi difícil me manter motivado, porque eu estava trabalhando em coisas que não pareciam relevantes.

Eu queria aprender web scraping. Em vez disso, eu estava lutando para entender as videoaulas sobre o conceito de programação orientada a objetos (OOP). O que isso tem a ver com meus objetivos? Eu não tinha certeza, e isso facilitou a desistência mais uma vez.

Por que eu não consegui?

Olhando para trás, não é muito difícil descobrir o porquê. Na primeira vez, meus grandes erros foram:

1. Não ter um objetivo claro. Por que eu estava aprendendo Python? Eu realmente não sabia. Isso torna muito fácil desistir quando as coisas ficam difíceis – o que sempre acontecerá, mais cedo ou mais tarde.
2. Muitos desafios logo de início. Mais cedo ou mais tarde, eu teria de aprender a absorver o Python de algum jeito, mas configurar tudo tendo zero de experiência, mesmo antes de ter escrito um simples print("Olá, mundo!") Foi tudo o que eu precisava para não conseguir aprender e desistir.

Quando você está aprendendo algo desafiador, especialmente quando se está começando do zero, você precisa de sucesso cedo para ajudá-lo a acreditar que você pode realmente fazer isso.

Começar com um desafio frustrante que nem envolvia a programação em si garantiu que eu não conseguisse aquelas vitórias precoces motivadoras e afirmativas.

Na segunda vez, eu evitei esses erros, mas acabei cometendo erros novos:

1. Eu não estava aprendendo através da prática. Assistir a vídeos e passar em testes estava me fazendo sentir que poderia programar, mas, na verdade, eu não estava programando. Quando eu tentei (e não consegui) escrever código, foi ainda mais frustrante porque eu achava que já entendia. Além disso, eu tive que clicar diversas vezes em cada vídeo para reassistir a seções diferentes e reaprender as coisas.
2. Eu tinha um objetivo claro, mas não um caminho claro para chegar a ele. Eu sabia que queria fazer jornalismo de dados e web scraping, mas estava fazendo um curso genérico de Python. Isso significava que eu estava aprendendo lições que poderiam ter sido fundamentais para o desenvolvimento de software, mas não eram tão relevantes para o jornalismo de dados. Muitas vezes, tive dificuldade em conectar os fundamentos que estava aprendendo nas aulas com o que eu realmente queria estar fazendo com o código.

Ao longo de tudo isso, eu também estava cometendo outro grande erro mental. Eu estava pensando em aprender Python como se fosse oito ou oitenta. Eu tinha "aprendido Python" – tudo de Python – ou não tinha.

Isso tornou a perspectiva de aprendizado realmente intimidante. Sempre que eu chegava em um desafio, tudo ficava pior pelo fato de que eu estava pensando em alguma "linha de chegada" imaginária do Python que ainda estava muito, muito longe.

Isso é um erro, é claro. Assim como ocorre com um idioma, Python (e outras linguagens de programação) não são algo que você realmente termine de aprender. Da mesma maneira que os idiomas, você não precisa ser fluente em Python para fazer coisas com ele.

Como qualquer intercambista do primeiro ano pode confirmar, a simples capacidade de perguntar "Quanto isso custa?" e "Onde fica o banheiro?" no idioma local pode realmente afetar sua qualidade de vida.

A mesma coisa vale para o Python. Você não precisa saber tudo – nem mesmo tanto, necessariamente – para que isso faça uma diferença real em sua própria vida.

Essa, porém, é uma lição que só aprendi por acaso.

Como eu aprendi, de fato, (alguma coisa de) Python

Em 2018, eu já havia desistido de aprender Python. Eu tinha tentado duas vezes e não conseguido duas vezes! Fui, então, contratado pela Dataquest, uma empresa que ensina habilidades em ciência de dados – incluindo programação em Python – on-line.

Meu novo emprego não exigia nenhuma habilidade em programação, mas achei que ainda precisava dar uma chance à plataforma de aprendizagem. Eu precisava entender nosso produto e o que nossos alunos sentiam que estavam experimentando. Talvez, pensei, eu pudesse até aprender o suficiente para fazer algum web scraping, como eu tinha planejado antes.

Então, com alguma apreensão, criei uma conta e iniciei meu caminho de curso de Python para Ciência de Dados.

Para minha surpresa, parecia divertido e fácil. Para minha maior surpresa, não demorou muito para que eu sentisse que podia criar alguns projetos por conta própria.

Eu escrevi um script pequeno para classificar e-mails. Eu usei Python para analisar rapidamente alguns dados de pesquisa. Aos trancos e barrancos, construí o grande projeto de web scraping e análise com o qual sonhava quando era jornalista.

Eu estava – e ainda estou – usando Python para facilitar meu trabalho e melhorar minha vida. Alguns anos depois, ainda sou um programador novato, mas posso criar scripts pequenos para facilitar as coisas e resolver problemas de análise de dados que tenho no trabalho usando Python.

Isso aconteceu porque, mais por acaso do que por planejamento de fato, eu havia me deparado com uma maneira de aprender Python que evitava quase todos os erros que eu havia cometido com meus esforços anteriores:

• Eu comecei com um objetivo claro – aprender Python o suficiente para ser capaz de trabalhar um pouco com dados para que eu pudesse entender melhor nossos clientes.
• Eu evitei o desafio inicial de instalar o Python completamente, porque a Dataquest permite que você aprenda e escreva código diretamente em uma janela do navegador.
• Eu estava aprendendo a programar escrevendo código em vez de ver outra pessoa fazendo isso.
• Eu estava aprendendo em uma trilha projetada para o trabalho com dados em Python, especificamente. Então, tudo o que eu estava aprendendo e cada exercício que eu fazia parecia relevante.
• Eu estava simplesmente tentando aprender o que eu precisava, em vez de tentar aprender tudo em Python.

Como tornar o aprendizado de Python mais fácil

Olhando para os meus erros e, depois, para o meu sucesso acidental, acho que tudo se resume a algumas conclusões simples:

Primeiro, começar tendo um objetivo. Por que você quer aprender Python? O que, especificamente, você quer criar com ele? Se você não tiver uma boa resposta para essa pergunta, será muito difícil se manter motivado.

Em segundo lugar, encontre uma maneira de aprender fazendo o que você realmente quer fazer. Se você puder encontrar um recurso de aprendizado direcionado, como uma plataforma que ensina Python especificamente para desenvolvimento de jogos, isso é ótimo. Os recursos gerais de aprendizagem, no entanto, também podem funcionar, desde que você esteja aplicando o que aprendeu com alguns projetos para iniciantes em Python (link em inglês) enquanto estuda.

Aprender a programar tem que incluir realmente escrever código – e tem que ser realmente código que faz algo em que você está interessado.

Em terceiro lugar, evite o desafio inicial de configurar o Python e suas várias bibliotecas em seu sistema local.

Existem muitas plataformas on-line agora que permitem que você escreva e execute código em um navegador, ou você pode escrever e executar código em um notebook no Google Colab ou em uma plataforma semelhante. Apenas tente tornar o início o mais fácil possível. Você pode se preocupar com sua configuração local mais tarde.

Em quarto lugar, não tente "aprender Python". Esse é um objetivo enorme, de longo prazo, que é indiscutivelmente meio inatingível – mesmo os melhores desenvolvedores de Python não sabem literalmente tudo sobre ele.

Em vez disso, tente aprender a usar Python para criar uma versão simples do projeto que é o seu objetivo, ou uma parte desse projeto. Em seguida, aprenda a usar Python para aumentar esse projeto ou como passar para a próxima etapa.

Divida grandes tarefas em partes menores e concentre seus objetivos em construir algo para que dê a você a recompensa psicológica de ter construído algo atingir um objetivo.

Siga estas dicas independentemente do seu motivo pessoal para aprender Python e não tenho dúvidas de que você será capaz de alcançar seus objetivos sem ter que falhar e desistir duas vezes ao longo do seu caminho!

Traduzido em português europeu.

O Python é uma linguagem de programação de utilização geral, que é escrita e interpretada dinamicamente, conhecida pela sua fácil legibilidade com ótimos princípios de design.

O freeCodeCamp tem um dos cursos mais populares sobre Python. É completamente gratuito (e também não tem quaisquer anúncios, basta estar conectado à plataforma). Podes, também, assistir ao curso no YouTube.

Queres aprender mais?

A internet é um sítio vasto, existe muito mais para explorar (links em inglês):

• Livro prático de Python: http://anandology.com/python-practice-book/index.html
• Pensa em Python: http://greenteapress.com/thinkpython/html/index.html
• Python prático para negócios: http://pbpython.com/
• Outro curso: https://realpython.com/?utmsource=fsp&utmmedium=promo&utm_campaign=bestresources
• Generalidade: https://www.fullstackpython.com/
• Aprenda os fundamentos: https://www.codecademy.com/learn/learn-python
• Ciência computacional utilizando Python: https://www.edx.org/course/introduction-computer-science-mitx-6-00-1x-11?ref=hackernoon#!
• Lista de mais recursos para aprender Python: https://github.com/vinta/awesome-python
• Python interativo: http://interactivepython.org/runestone/static/thinkcspy/index.html
• Manual do programador para Python: https://devguide.python.org/

Para que é utilizado o Python?

O Python pode ser facilmente utilizado para projetos pequenos, grandes, on-line e off-line. As melhores opções para utilizar Python são a programação para a web, criação simples de scripts e análise de dados. Abaixo estão alguns exemplos do que o Python permitirá fazer:

Programação para a web:

Podes utilizar o Python para criar aplicações para a web de vários níveis de complexidade. Existem muitas frameworks de Python para a web, incluindo Pyramid, Django e Flask, para mencionar algumas.

Análise de dados:

O Python é a principal escolha em termos de linguagem para muitos cientistas de dados. O Python cresceu em popularidade neste ramo devido à disponibilidade de várias bibliotecas excelentes focadas em ciências de dados (das quais, NumPy e Pandas são duas das mais conhecidas) e visualização de dados (como Matplotlib e Seaborn). O Python tornou o processamento de dados interessante com todas as suas inúmeras bibliotecas disponíveis. Ipython com JupyterLab é outra forma de Python que melhora a utilização de Python no ramo da ciência de dados.

Automatização:

Python é uma linguagem muito flexível que pode ser utilizada para automatizar tarefas aborrecidas e repetitivas. Administradores de sistemas utilizam-na geralmente ao escrever scripts que podem ser facilmente executados no terminal. O Python também pode ser utilizado para criar bots que automatizam algumas das nossas tarefas diárias.

Inteligência artificial:

O Python também é utilizado extensivamente no ramo emergente da Inteligência Artificial (IA). A Google selecionou o Python como uma das primeiras linguagens de programação bem suportadas para treinar e interagir com modelos, utilizando o Tensorflow.

Desenvolvimento de aplicações para dispositivos móveis

Podem ser criadas aplicações para dispositivos móveis e jogos com Python através da utilização de Kivy, Pygame e PyQt.

Segurança e rede:

O Python é utilizado para criar ferramentas de rede e segurança que são utilizadas amplamente. A automatização remota do Python é a mais segura, rápida e eficaz para testes de frameworks na cloud. É por isso que programadores profissionais utilizam Python para criar as frameworks mais seguras e para programação de sockets.

Machine Learning, Deep Learning

Python é uma das melhores linguagens adequadas para machine learning, deep learning e análises de dados, com uma forte eficácia em todos eles.

Existem linguagens especializadas mais adequadas para vários papéis, como R e MATLAB, mas, no que diz respeito a combinar vários ramos de aplicações, o Python vence facilmente devido à sua flexibilidade, rápida criação de protótipos e disponibilidade de bibliotecas.

Desenvolvimento de bots para o Telegram

Podes utilizar Python e algumas bibliotecas do Python para desenvolver os teus próprios Bots do Telegram (link em inglês).

Obtenção de dados através de gathering e scraping

O Python também pode ser utilizado para analisar o código-fonte das páginas e obter a sua informação. Utilizar alguns módulos do Python, tais como o Scrapy e também (para algumas páginas que utilizam JavaScript) o Selenium deve resolver o problema!

O Python é geralmente utilizado para:

• Desenvolvimento para a web e Internet
• Progresso educacional
• Estudos/computações científicos
• Desenvolvimento para desktop
• Computação numérica
• Desenvolvimento de software
• Desenvolvimento de aplicações empresariais
• Machine Learning
• IOT (Internet Of Things)
• Desenvolvimento de jogos
• Prototipagem rápida
• Automatização de browser
• Análise de dados
• Obter dados de websites
• Processamento de imagens

Alguns artigos que abordam a utilidade do python

• 10 Major Uses of Python (10 principais utilizações do Python, link em inglês)
• Applications for Python (Aplicações para Python, link em inglês)
• Where is the Python Language Used? (Onde é utilizada a linguagem Python?, link em inglês)
• What is Python used for? (Para que é utilizado o Python?, link em inglês)

O índice oficial de pacotes para o Python está aqui (link em inglês).

Deves utilizar Python 2 ou Python 3?

As duas versões são semelhantes. Se conheceres uma delas, trocar para escrever código na outra é fácil.

• Python 2.x não recebe mais manutenção desde 2020 (link em inglês).
• 3.x está em desenvolvimento ativo. Isto quer dizer que todas as melhorias recentes de bibliotecas predefinidas, por exemplo, estão apenas disponíveis por defeito na versão Python 3.x.
• O ecossistema do Python acumulou uma quantidade significativa de software de qualidade ao longo dos anos. A desvantagem de quebrar a compatibilidade com versões anteriores ao 3.x é que alguns desses softwares (especialmente software interno em empresas) ainda não funcionam na versão 3.x.

Instalação

A maior parte dos sistemas operativos com base *nix já trazem o Python instalado (geralmente o Python 2, ou Python 3 nos mais recentes). Substituir a instalação predefinida do Python no teu sistema não é recomendado e pode causar problemas. No entanto, podem ser instaladas diferentes versões do Python em segurança, juntamente com a versão predefinida do teu sistema. Ver Configuração do Python e utilização (link em inglês).

O Windows não vem com o Python instalado, mas o instalador e as instruções de instalação podem ser encontradas aqui (link em inglês).

Intérprete de Python

O intérprete de Python é o que é utilizado para executar scripts de Python.

Se este estiver disponível e no caminho de pesquisa da linha da shell do Unix, é possível iniciá-lo ao escrever o comando python, seguido pelo nome do script. Isto invocará o intérprete e executar o script.

hello_campers.py

print('Hello campers!')

A partir do terminal:

$ python hello_campers.py
Hello campers!

Quando estão instaladas várias versões do Python, é possível chamar o intérprete por versão, dependendo da configuração da instalação. No ambiente personalizado do IDE Cloud9, podem ser invocados da seguinte forma:

$ python --version
Python 2.7.6
$ python3 --version
Python 3.4.3
$ python3.5 --version
Python 3.5.1
$ python3.6 --version
Python 3.6.2 
$ python3.7 --version
Python 3.7.1

Modo interativo do intérprete de Python

O modo interativo pode ser iniciado ao invocar o intérprete de Python com a flag -i ou sem qualquer argumento.

O modo interativo tem uma prompt onde podem ser inseridos e executados comandos de Python:

$ python3.5
Python 3.5.1 (default, Dec 18 2015, 00:00:00)
GCC 4.8.4 on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello campers!")
Hello campers!
>>> 1 + 2
3
>>> exit()
$

O Zen do Python

Alguns dos princípios que influenciaram o design do Python estão incluídos como extra e podem ser lidos ao utilizar o comando dentro do modo interativo do intérprete de Python:

>>> import this
O Zen do Python, escrito por Tim Peters

Bonito é melhor que feio.
Explícito é melhor que implícito.
Simples é melhor que complexo.
Complexo é melhor que complicado.
Linear é melhor do que aninhado.
Esparso é melhor que denso.
Legibilidade conta.
Casos especiais não são especiais o bastante para quebrar as regras.
Ainda que praticidade vença a pureza.
Erros nunca devem passar silenciosamente.
A menos que sejam explicitamente silenciados.
Diante da ambiguidade, recuse a tentação de adivinhar.
Deveria haver um — e preferencialmente só um — modo óbvio para fazer algo.
Embora esse modo possa não ser óbvio a princípio a menos que você seja holandês.
Agora é melhor que nunca.
Embora nunca frequentemente seja melhor que já.
Se a implementação é difícil de explicar, é uma má ideia.
Se a implementação é fácil de explicar, pode ser uma boa ideia.
Namespaces são uma grande ideia — vamos ter mais dessas!

Prós e contras do Python

Prós

1. Linguagem interativa com suporte de módulo para quase todas as funcionalidades.
2. Código aberto: portanto, podes contribuir para a comunidade com as funções que desenvolveres para utilização futura e para ajudar outros.
3. Muitos bons intérpretes e notebooks disponíveis para uma melhor experiência, como o Jupyter Notebook.

Contras

1. Sendo de código aberto, foram desenvolvidas muitas formas diferentes das mesmas funções ao longo dos anos. Isso, por vezes, cria caos quando outras pessoas leem o código de outra pessoa.
2. É uma linguagem lenta. Por isso, é uma linguagem muito má para desenvolver algoritmos comuns.

Documentação

O Python está bem documentado (link em inglês). Esses documentos incluem tutoriais, guias, referências e informações chave da linguagem.

Outra referência importante são as Python Enhancement Proposals (PEPs –Propostas de Melhoria do Python, em português). Incluído nas PEPs está um guia de estilos para escrever código Python, o PEP 8 (link em inglês).

Depuração

Podem ser utilizadas instruções print em linha para depurações simples:

… por vezes, a forma mais rápida de depurar um programa é adicionar algumas instruções print ao código: o ciclo rápido de edição-teste-depuração torna esta abordagem muito eficaz.

Sumário executivo (link em inglês)

O Python também inclui ferramentas mais potentes para depuração, tais como:

• módulo de registo, logging (link em inglês)
• módulo de depuração, pdb (link em inglês)

Por enquanto, tem apenas em mente que elas existem.

Olá, mundo!

Voltando à documentação, podemos ler sobre a função print, uma função integrada (link em inglês) da Biblioteca Predefinida do Python (link em inglês).

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

As funções integradas estão listadas por ordem alfabética. O nome é seguido por uma lista entre parênteses de parâmetros formais com valores predefinidos opcionais. Por baixo disso, é fornecida uma breve descrição da função e dos seus parâmetros e existe, ocasionalmente, um exemplo.

A função print do Python 3 substitui a instrução print do Python 2.

>>> print("Olá, mundo!")
Olá, mundo!

Uma função é chamada quando o nome da função é seguido por (). Para o exemplo Olá, mundo!, a função print é chamada com uma string como argumento para o primeiro parâmetro. Para os restantes parâmetros, são utilizados os valores predefinidos.

O argumento com que chamamos a função print é um objeto str, ou string, um dos tipos integrados do Python. Além disso, a coisa mais importante sobre Python é que não precisas de especificar o tipo de dados quando declaras uma variável. O compilador do Python, ele próprio, fará isso com base no tipo do valor atribuído.

O parâmetro objects tem um * como prefixo, que indica que a função receberá um número arbitrário de argumentos para esse parâmetro.

Em um tutorial anterior do freeCodeCamp, expliquei como criar visualizações de dados com atualizações automáticas em Python (texto em inglês).

Alguns leitores perguntaram se havia algum modo de tornar as visualizações interativas. Felizmente, uma solução fácil já está disponível!

Neste tutorial, vou ensinar como você pode criar visualizações interativas de dados em Python. Essas visualizações são excelentes candidatas para incorporação em seu blog ou site.

A visualização de dados específica com a qual trabalharemos

Em vez de construir uma visualização de dados inteira do zero neste artigo, trabalharemos com a visualização que criamos em meu último tutorial.

A visualização usa pandas, matplotlib e Python para apresentar vários pontos de dados dos 5 maiores bancos de capital aberto dos Estados Unidos.

Aqui está uma imagem estática da visualização que criamos:

O código real para a visualização está incluído abaixo. Abordamos isso no último tutorial, mas observe que você precisará gerar sua própria chave de API IEX Cloud e incluí-la na variável IEX_API_Key para que o script funcione.

############################
#Importação das dependências
############################

import pandas as pd
import matplotlib.pyplot as plt

###############################
#Importação e limpeza dos dados
###############################

IEX_API_Key = ''

tickers = [
            'JPM',
            'BAC',
            'C',
            'WFC',
            'GS',
            ]

#Crie uma string vazia chamada `ticker_string`, a qual adicionaremos tickers e vírgulas
ticker_string = ''

#Percorra cada elemento de `tickers` e adicione-os com uma vírgula a ticker_string
for ticker in tickers:
    ticker_string += ticker
    ticker_string += ','
    
#Remova a última vírgula de `ticker_string`
ticker_string = ticker_string[:-1]

#Crie as strings endpoint e years
endpoints = 'chart'
years = '5'

#Faça a interpolação das strings endpoint em HTTP_request string
HTTP_request = f'https://cloud.iexapis.com/stable/stock/market/batch?symbols={ticker_string}&types={endpoints}&range={years}y&cache=true&token={IEX_API_Key}'

#Envie a solicitação HTTP à API IEX Cloud e armazene a resposta em um DataFrame do pandas
bank_data = pd.read_json(HTTP_request)

#Crie uma lista vazia, onde adicionaremos uma série do pandas de dados de preços de ações
series_list = []

#Percorra cada um dos tickers e mostre uma série do pandas com seus preços ao encerramento da bolsa nos últimos 5 anos
for ticker in tickers:
    series_list.append(pd.DataFrame(bank_data[ticker]['chart'])['close'])

#Adicione a coluna dates (datas)
series_list.append(pd.DataFrame(bank_data['JPM']['chart'])['date'])

#Copie a lista 'tickers' que aparece anteriormente no script e adicione um novo elemento chamado 'Date'. 
#Esses elementos serão os nomes das colunas de nosso DataFrame do pandas posteriormente.
column_names = tickers.copy()
column_names.append('Date')

#Concatene as séries do pandas Series em um único DataFrame
bank_data = pd.concat(series_list, axis=1)

#Nomeie as colunas do DataFrame e defina a coluna 'Date' como o índice
bank_data.columns = column_names
bank_data.set_index('Date', inplace = True)

########################
#Crie a imagem do Python
########################

#Defina o tamanho do canvas do matplotlib
fig = plt.figure(figsize = (18,8))

################################################
################################################
#Crie subgráficos no Python
################################################
################################################

########################
#Subgráfico 1
########################
plt.subplot(2,2,1)

#Gere o diagrama de caixas (boxplot)
plt.boxplot(bank_data.transpose())

#Adicione títulos ao gráfico e aos eixos
plt.title('Boxplot of Bank Stock Prices (5Y Lookback)')
plt.xlabel('Bank')
plt.ylabel('Stock Prices')

#Adicione os rótulos a cada diagrama de caixas individual no canvas
ticks = range(1, len(bank_data.columns)+1)
labels = list(bank_data.columns)
plt.xticks(ticks,labels)

########################
#Subgráfico 2
########################
plt.subplot(2,2,2)

#Crie os dados do eixo x
dates = bank_data.index.to_series()
dates = [pd.to_datetime(d) for d in dates]

#Crie os dados do eixo y
WFC_stock_prices =  bank_data['WFC']

#Gere o gráfico de dispersão (scatterplot)
plt.scatter(dates, WFC_stock_prices)

#Adicione títulos ao gráfico e aos eixos
plt.title("Wells Fargo Stock Price (5Y Lookback)")
plt.ylabel("Stock Price")
plt.xlabel("Date")

########################
#Subgráfico 3
########################
plt.subplot(2,2,3)

#Crie os dados do eixo x
dates = bank_data.index.to_series()
dates = [pd.to_datetime(d) for d in dates]

#Crie os dados do eixo y
BAC_stock_prices =  bank_data['BAC']

#Gere o gráfico de dispersão (scatterplot)
plt.scatter(dates, BAC_stock_prices)

#Adicione títulos ao gráfico e aos eixos
plt.title("Bank of America Stock Price (5Y Lookback)")
plt.ylabel("Stock Price")
plt.xlabel("Date")

########################
#Subgráfico 4
########################
plt.subplot(2,2,4)

#Gere o histograma
plt.hist(bank_data.transpose(), bins = 50)

#Adicione uma legenda ao histograma
plt.legend(bank_data.columns,fontsize=10)

#Adicione títulos ao gráfico e aos eixos
plt.title("A Histogram of Daily Closing Stock Prices for the 5 Largest Banks in the US (5Y Lookback)")
plt.ylabel("Observations")
plt.xlabel("Stock Prices")

plt.tight_layout()

################################################
#Salve a imagem em sua máquina local
################################################

plt.savefig('bank_data.png')

Agora que entendemos a visualização específica com a qual trabalharemos, vamos falar sobre o que significa uma visualização ser interativa.

O que significa uma visualização ser interativa?

Existem dois tipos de visualizações de dados que são úteis para embutir em seu site.

O primeiro tipo é uma visualização estática. Esta é basicamente uma imagem - pense em arquivos .png ou .jpg.

O segundo tipo é uma visualização dinâmica. Essas visualizações mudam em resposta ao comportamento do usuário, geralmente via panorâmica ou zoom. As visualizações dinâmicas não são armazenadas em arquivos .png ou .jpg, mas geralmente em tags svg ou iframe.

Este tutorial é sobre criação de visualizações dinâmicas de dados. Especificamente, a visualização que queremos criar terá as seguintes características:

1. Você clicará em um botão no canto inferior esquerdo para ativar o modo dinâmico.
2. Depois que o modo dinâmico estiver ativado, você poderá ampliar e deslocar a visualização com o mouse.
3. Você também pode cortar e dar zoom em uma seção específica da visualização.

Na próxima seção deste tutorial, você aprenderá como instalar e importar a biblioteca mpld3, que é a dependência do Python que usaremos para criar nossos gráficos interativos.

Como importar a biblioteca mpld3

Para usar a biblioteca mpld3 em nossa aplicação do Python, há duas etapas que precisamos concluir primeiro:

1. Instalar a biblioteca mpld3 na máquina em que estamos trabalhando.
2. Importar a biblioteca mpld3 em nosso script do Python.

Primeiro, vamos instalar o mpld3 em nossa máquina local.

A maneira mais fácil de fazer isso é usando o gerenciador de pacotes pip para Python3. Se você já tem o pip instalado em sua máquina, você pode fazer isso executando a seguinte declaração na sua linha de comando:

pip3 install mpld3

Agora que o mpld3 está instalado em sua máquina, podemos importá-lo para nosso script do Python com a seguinte declaração:

import mpld3

Para facilitar a leitura, é considerada uma prática recomendada incluir essa importação junto com o restante das importações na parte superior de seu script. Isso significa que agora sua seção de importação ficará assim:

############################
#Importação das dependências
############################

import pandas as pd
import matplotlib.pyplot as plt
import mpld3

Como transformar uma visualização estática do matplotlib em uma visualização interativa de dados

A principal funcionalidade da biblioteca mpld3 é pegar uma visualização matplotlib existente e transformá-la em algum código HTML que você pode embutir em seu site.

A ferramenta que usamos para isso é o arquivo fig_to_html do mpld3, que aceita um objeto figure do matplotlib como seu único argumento e retorna HTML.

Para usar o método fig_to_html para nosso propósito, basta adicionar o seguinte código ao final do nosso script do Python:

html_str = mpld3.fig_to_html(fig)
Html_file= open("index.html","w")
Html_file.write(html_str)
Html_file.close()

Este código gera o HTML e o salva com o nome de arquivo index.html em seu diretório de trabalho atual. Esta é a aparência disso quando renderizado em uma página da web:

Ao passar o mouse sobre esta visualização, três ícones aparecerão no canto inferior esquerdo. O ícone esquerdo retorna a visualização à sua aparência padrão. O ícone do meio ativa o modo dinâmico. O ícone direito permite cortar e aplicar zoom em um ponto específico da visualização.

Um erro comum ao trabalhar com pandas e mpld3

Ao criar a visualização interativa neste tutorial, você pode encontrar o seguinte erro gerado pelo mpld3:

TypeError: array([ 1.]) is not JSON serializable

Felizmente, existe uma solução bem documentada para esse erro no GitHub.

Você precisa editar o arquivo _display.py encontrado em Lib\site-packages\mpld3 e substituir a classe NumpyEncoder por esta:

class NumpyEncoder(json.JSONEncoder):
    """ Special json encoder for numpy types """

    def default(self, obj):
        if isinstance(obj, (numpy.int_, numpy.intc, numpy.intp, numpy.int8,
            numpy.int16, numpy.int32, numpy.int64, numpy.uint8,
            numpy.uint16,numpy.uint32, numpy.uint64)):
            return int(obj)
        elif isinstance(obj, (numpy.float_, numpy.float16, numpy.float32, 
            numpy.float64)):
            return float(obj)
        try: # Added by ceprio 2018-04-25
            iterable = iter(obj)
        except TypeError:
            pass
        else:
            return list(iterable)
         # Let the base class default method raise the TypeError
        return json.JSONEncoder.default(self, obj)

Depois que essa substituição for feita, seu código deverá funcionar corretamente e seu arquivo index.html deverá ser gerado com êxito.

Reflexões finais

Neste tutorial, você aprendeu como criar visualizações interativas de dados em Python usando as bibliotecas matplotlib e mpld3. Aqui está um resumo específico do que abordamos:

1. A definição de uma visualização dinâmica de dados
2. Como instalar e importar a biblioteca mpld3 em Python
3. Como usar a biblioteca mpld3 para transformar uma visualização do matplotlib em uma visualização dinâmica que você pode embutir em seu site
4. Como corrigir um erro comum que os usuários da biblioteca mpld3 enfrentam

Este tutorial foi escrito por Nick McCullum, que ensina desenvolvimento em Python e JavaScript em seu site.

A especificação de APIs com JSON é uma maneira poderosa de habilitar a comunicação entre client e servidor. Ela especifica a estrutura das solicitações e respostas enviadas entre os dois, usando o formato JSON.

Como formato de dados, o JSON tem as vantagens de ser leve e legível. Isso torna muito fácil trabalhar com rapidez e produtividade. A especificação foi projetada para minimizar o número de solicitações e a quantidade de dados que precisam ser enviados entre o client e o servidor.

Aqui, você pode aprender a criar uma API em JSON básica usando Python e Flask. Em seguida, o resto do artigo mostrará como experimentar alguns dos recursos que a especificação da API em JSON tem a oferecer.

O Flask é uma biblioteca do Python que fornece um "microframework" para o desenvolvimento para a web. É ótimo para desenvolvimento rápido, pois vem com uma funcionalidade básica simples, mas extensível.

Um exemplo bastante simples de como enviar uma resposta em JSON usando Flask é vista abaixo:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def example():
   return '{"name":"Bob"}'

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

Este artigo usará dois add-ons para o Flask:

• Flask-REST-JSONAPI ajudará a desenvolver uma API que siga de perto a especificação de APIs em JSON.
• Flask-SQLAlchemy usará SQLAlchemy para tornar a criação e a interação com um banco de dados simples bastante rápida.

O cenário geral

O objetivo final é criar uma API que permita a interação do lado do client com um banco de dados subjacente. Haverá algumas camadas entre o banco de dados e o client – uma camada de abstração de dados e uma camada de gerenciador de recursos.

Aqui temos uma visão geral das etapas envolvidas:

1. Defina um banco de dados usando o Flask-SQLAlchemy
2. Crie uma abstração dos dados com Marshmallow-JSONAPI
3. Crie os gerentes de recurso com a Flask-REST-JSONAPI
4. Crie os endpoints de URL e inicie o servidor com o Flask

Este exemplo usará um esquema simples descrevendo artistas modernos e suas relações com diferentes obras de arte.

Instale tudo

Antes de começar, você precisará configurar o projeto. Isso envolve a criação de um espaço de trabalho e ambiente virtual, a instalação dos módulos necessários e a criação dos principais arquivos do Python e do banco de dados para o projeto.

Na linha de comando, crie um diretório e navegue para ele.

$ mkdir flask-jsonapi-demo
$ cd flask-jsonapi-demo/

É bom praticar a criação de ambientes virtuais (texto em inglês) para cada um de seus projetos em Python. Você pode ignorar essa etapa, mas ela é bastante recomendada.

$ python -m venv .venv
$ source .venv/bin/activate

Uma vez que seu ambiente virtual tenha sido criado e ativado, você pode instalar os módulos necessários para este projeto.

$ pip install flask-rest-jsonapi flask-sqlalchemy

Tudo o que você precisará será instalado conforme os requisitos para essas duas extensões. Isso inclui o próprio Flask e o SQLAlchemy.

A próxima etapa é criar um arquivo Python e um banco de dados para o projeto.

$ touch application.py artists.db

Crie o esquema do banco de dados

Aqui, você começa a modificar a application.py para definir e criar o esquema do banco de dados para o projeto.

Abra application.py no seu editor de texto favorito. Comece a importar os módulos. Para ser claro, os módulos serão importados conforme avançamos.

Em seguida, crie um objeto chamado app como instância da classe Flask.

Depois, use o SQLAlchemy para conectar com o arquivo de banco de dados que você criou. A etapa final é definir e criar uma tabela chamada artists.

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

# Criar a aplicação em Flask
app = Flask(__name__)

# Configurar o SQLAlchemy
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////artists.db'
db = SQLAlchemy(app)

# Definir uma classe para a tabela Artist
class Artist(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String)
    birth_year = db.Column(db.Integer)
    genre = db.Column(db.String)

# Criar a tabela
db.create_all()

Criação da camada de abstração

A próxima etapa usa o módulo Marshmallow-JSONAPI para criar uma abstração de dados lógica sobre as tabelas que acabamos de definir.

A razão para criar essa camada de abstração é simples. Ela oferece mais controle sobre como seus dados subjacentes são expostos por meio da API. Pense nessa camada como uma lente através da qual o consumidor da API pode visualizar os dados subjacentes claramente e apenas as partes que eles precisam ver.

No código abaixo, a camada de abstração de dados é definida como uma classe que herda da classe Schema de Marshmallow-JSONAPI. Ela dará acesso por meio da API a registros únicos ou múltiplos da tabela artists.

Neste bloco, a classe Meta define alguns metadados. Especificamente, o nome do endpoint de URL para a interação com registros simples será artist_one, onde cada artista será identificado com um parâmetro <id> de URL. O nome do endpoint para a interação com diversos registros será artist_many.

Os demais atributos definidos referem-se às colunas na tabela artists. Aqui, você pode controlar ainda mais como cada um é exposto por meio da API.

Por exemplo, ao fazer solicitações de POST para adicionar novos artistas ao banco de dados, você pode garantir que o campo name seja obrigatório definindo required=True.

Se, por alguma razão, você não quiser que o campo birth_year seja retornado ao fazer solicitações de GET, é possível especificar isso com load_only=True.

from marshmallow_jsonapi.flask import Schema
from marshmallow_jsonapi import fields

# Criar a camada de abstração de dados
class ArtistSchema(Schema):
    class Meta:
        type_ = 'artist'
        self_view = 'artist_one'
        self_view_kwargs = {'id': '<id>'}
        self_view_many = 'artist_many'

    id = fields.Integer()
    name = fields.Str(required=True)
    birth_year = fields.Integer(load_only=True)
    genre = fields.Str()

Criar os gerentes de recursos e os endpoints de URL

A peça final do quebra-cabeça é criar um gerente de recursos e o endpoint correspondente para cada uma das rotas, /artists e /artists/id.

Cada gerente de recursos é definido como uma classe que herda das classes ResourceList e ResourceDetail da Flask-REST-JSONAPI.

Eles recebem dois atributos. schema é usado para indicar a camada de abstração de dados que o gerente de recursos utiliza, enquanto data_layer indica a sessão e o modelo de dados que será usado para a camada de dados.

Em seguida, definimos api como uma instância da classe Api de Flask-REST-JSONAPI e criamos as rotas para a API com api.route(). Esse método recebe três argumentos – a classe da camada de abstração de dados, o nome do endpoint e o caminho do URL.

A última etapa é escrever um loop principal para iniciar a aplicação no modo de depuração quando o script é executado diretamente. O modo de depuração é ótimo para desenvolvimento, mas não é adequado para execução em produção.

# Criar gerentes de recursos e endpoints

from flask_rest_jsonapi import Api, ResourceDetail, ResourceList

class ArtistMany(ResourceList):
    schema = ArtistSchema
    data_layer = {'session': db.session,
                  'model': Artist}

class ArtistOne(ResourceDetail):
    schema = ArtistSchema
    data_layer = {'session': db.session,
                  'model': Artist}

api = Api(app)
api.route(ArtistMany, 'artist_many', '/artists')
api.route(ArtistOne, 'artist_one', '/artists/<int:id>')

# loop principal para executar a aplicação em modo de depuração
if __name__ == '__main__':
    app.run(debug=True)

Fazer solicitações de GET e de POST

Agora, você pode começar a usar a API para fazer solicitações em HTTP (texto em inglês). Isso pode ocorrer por meio de um navegador da web, com uma ferramenta de linha de comando, como o curl, ou a partir de outro programa (por exemplo, um script do Python usando a biblioteca Requests).

Para iniciar o servidor, execute o script application.py:

$ python application.py

No seu navegador, vá para http://localhost:5000/artists.  Você verá um resultado em JSON de todos os registros no banco de dados até o momento. Porém, agora, o banco está vazio.

Para começar a adicionar registros ao banco de dados, você pode fazer uma solicitação de POST. Uma maneira de se fazer isso é a partir da linha de comando usando a ferramenta curl. Como alternativa, você pode usar a ferramenta Insomnia ou criar uma interface de usuário simples em HTML que publique os dados usando um formulário.

Com o curl, na linha de comando, você pode inserir o seguinte:

curl -i -X POST -H 'Content-Type: application/json' -d '{"data":{"type":"artist", "attributes":{"name":"Salvador Dali", "birth_year":1904, "genre":"Surrealism"}}}' http://localhost:5000/artists

Se você navegar até http://localhost:5000/artists, verá o registro que acaba de adicionar. Se for adicionar mais registros, eles também aparecerão aqui, pois o caminho do URL chama o endpoint artists_many.

Para ver apenas um único artista pelo id, navegue até o URL relevante. Por exemplo, para ver o primeiro artista, experimente http://localhost:5000/artists/1.

Filtragem e ordenação

Um dos recursos interessantes da especificação de APIs em JSON é a capacidade de retornar a resposta de maneiras mais úteis, definindo alguns parâmetros no URL. Por exemplo, você pode classificar os resultados de acordo com um campo escolhido ou filtrar com base em alguns critérios.

O Flask-REST-JSONAPI vem com isso incorporado.

Para ordenar os artistas por ano de nascimento, navegue para http://localhost:5000/artists?sort=birth_year. Em uma aplicação da web, isso evitaria que você precisasse ordenar os resultados do lado do client, o que demandaria bastante em termos de desempenho e causaria um impacto na experiência do usuário.

A filtragem também é fácil. Anexe ao URL os critérios pelos quais você deseja filtrar, contidos por colchetes. Há três informações para incluir:

• "name" – o campo pelo qual você está filtrando (por exemplo, birth_year)
• "op" - a operação de filtro ("maior que", "menor que", "igual a" etc.)
• "val" - o valor com relação à operação de filtro (por exemplo, 1900)

O URL abaixo filtra artistas cuja data de nascimento é após 1900:

http://localhost:5000/artists?filter=[{"name":"birth_year","op":"gt","val":1900}]

Essa funcionalidade torna muito mais fácil recuperar apenas informações relevantes ao chamar a API. Isso é valioso para melhorar o desempenho, especialmente ao recuperar volumes potencialmente grandes de dados em uma conexão lenta.

Paginação

Outro recurso da especificação da API em JSON que auxilia o desempenho é a paginação. É quando grandes respostas são enviadas em várias "páginas", em vez de todas de uma só vez. Você pode controlar o tamanho da página e o número da página solicitada no URL.

Assim, por exemplo, você pode receber 100 resultados em 10 páginas em vez de carregar todos os 100 de uma só vez. A primeira página conteria resultados de 1 a 10, a segunda página conteria resultados de 11 a 20 e assim por diante.

Para especificar o número de resultados que você deseja receber por página, você pode adicionar o parâmetro ?page[size]=X para o URL, onde X é o número de resultados por página. O Flask-REST-JSONAPI usa 30 como o tamanho de página padrão.

Para solicitar um determinado número de página, você pode adicionar o parâmetro ?page[number]=X, onde X é o número da página. Você pode combinar os dois parâmetros, como vemos aqui:

http://localhost:5000/artists?page[size]=2&page[number]=2

Esse URL define o tamanho da página como sendo de dois resultados por página, pedindo pela segunda página de resultados. Isso retornará o terceiro e o quarto resultados da resposta completa.

Relacionamentos

Quase sempre, os dados em uma tabela estarão relacionados aos dados armazenados em outra. Por exemplo, se você tem uma tabela de artistas, é provável que você também queira uma tabela de obras de arte. Cada obra está relacionada ao artista que a criou.

A especificação da API em JSON permite que você trabalhe com dados relacionais facilmente. O Flask-REST-JSONAPI permite que você aproveite isso. Aqui, isso será demonstrado adicionando uma tabela de obras de arte (artworks) ao banco de dados e incluindo relacionamentos entre artista e obra de arte.

Para implementar o exemplo de obras de arte, será necessário fazer algumas alterações no código em application.py.

Primeiro, fazemos algumas importações adicionais, e criamos uma tabela que relacione cada obra de arte a um artista:

from marshmallow_jsonapi.flask import Relationship
from flask_rest_jsonapi import ResourceRelationship


# Definir a tabela Artwork
class Artwork(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String)
    artist_id = db.Column(db.Integer, 
        db.ForeignKey('artist.id'))
    artist = db.relationship('Artist',
        backref=db.backref('artworks'))

Em seguida, refazemos a camada de abstração:

# Criar a abstração de dados
class ArtistSchema(Schema):
    class Meta:
        type_ = 'artist'
        self_view = 'artist_one'
        self_view_kwargs = {'id': '<id>'}
        self_view_many = 'artist_many'

    id = fields.Integer()
    name = fields.Str(required=True)
    birth_year = fields.Integer(load_only=True)
    genre = fields.Str()
    artworks = Relationship(self_view = 'artist_artworks',
        self_view_kwargs = {'id': '<id>'},
        related_view = 'artwork_many',
        many = True,
        schema = 'ArtworkSchema',
        type_ = 'artwork')

class ArtworkSchema(Schema):
    class Meta:
        type_ = 'artwork'
        self_view = 'artwork_one'
        self_view_kwargs = {'id': '<id>'}
        self_view_many = 'artwork_many'

    id = fields.Integer()
    title = fields.Str(required=True)
    artist_id = fields.Integer(required=True)

Isso define uma camada de abstração para a tabela artwork e adiciona uma relação entre artista e obra de arte à classe ArtistSchema.

Em seguida, defina novos gerentes de recursos para acessar várias obras de arte de uma vez e uma por vez, bem como para acessar os relacionamentos entre artista e obra de arte.

class ArtworkMany(ResourceList):
    schema = ArtworkSchema
    data_layer = {'session': db.session,
                  'model': Artwork}

class ArtworkOne(ResourceDetail):
    schema = ArtworkSchema
    data_layer = {'session': db.session,
                  'model': Artwork}

class ArtistArtwork(ResourceRelationship):
    schema = ArtistSchema
    data_layer = {'session': db.session,
                  'model': Artist}

Por fim, adicionamos alguns endpoints novos:

api.route(ArtworkOne, 'artwork_one', '/artworks/<int:id>')
api.route(ArtworkMany, 'artwork_many', '/artworks')
api.route(ArtistArtwork, 'artist_artworks',
    '/artists/<int:id>/relationships/artworks')

Executamos application.py e, ao tentar publicar alguns dados a partir da linha de comando usando a ferramenta curl, temos:

curl -i -X POST -H 'Content-Type: application/json' -d '{"data":{"type":"artwork", "attributes":{"title":"The Persistance of Memory", "artist_id":1}}}' http://localhost:5000/artworks

Isso criará uma obra de arte relacionada ao artista com o id=1.

No navegador, vá para http://localhost:5000/artists/1/relationships/artworks. Isso deve mostrar as obras relacionadas ao artista com id=1. Isso evita que você escreva um URL mais complexo com parâmetros para filtrar trabalhos artísticos por seu campo artist_id. Você pode listar rapidamente todas as relações entre um determinado artista e suas obras de arte.

Outro recurso é a capacidade de incluir resultados relacionados na resposta à chamada do endpoint artists_one:

http://localhost:5000/artists/1?include=artworks

Isso retornará a resposta comum para o endpoint artists, além dos resultados para cada uma das obras desse artista.

Campos esparsos

Um último recurso que vale a pena mencionar – campos esparsos. Ao trabalhar com grandes recursos de dados com muitos relacionamentos complexos, os tamanhos de resposta podem crescer muito rapidamente. É útil recuperar apenas os campos em que você está interessado.

A especificação da API em JSON permite que você faça isso adicionando um parâmetro fields ao URL. Por exemplo, o URL abaixo obtém a resposta para um determinado artista e suas obras de arte relacionadas. No entanto, em vez de retornar todos os campos para a obra de arte fornecida, ele retorna apenas o título.

http://localhost:5000/artists/1?include=artworks&fields[artwork]=title

Isso é muito útil para melhorar o desempenho, especialmente em conexões lentas. Como regra geral, você só deve fazer solicitações de e para o servidor com a quantidade mínima de dados necessária.

Comentários finais

A especificação de APIs em JSON é um framework bastante útil para o envio de dados entre servidor e client em um formato limpo e flexível. Este artigo forneceu uma visão geral do que você pode fazer com ele, com um exemplo trabalhado em Python usando a biblioteca Flask-REST-JSONAPI.

Então, o que você vai fazer a seguir? As possibilidades são muitas. O exemplo neste artigo foi simples, com apenas duas tabelas e uma única relação entre elas. Você pode desenvolver uma aplicação tão sofisticada quanto quiser e criar uma API poderosa para interagir com a aplicação usando todas as ferramentas fornecidas aqui.

Obrigado pela leitura e uma ótima programação em Python para você!

A maioria dos trabalhos tem tarefas repetitivas que você pode automatizar, o que libera parte do seu tempo precioso. Isso torna a automação uma habilidade fundamental a ser adquirida.

Um pequeno grupo de engenheiros de automação qualificados e especialistas em domínio pode ser capaz de automatizar muitas das tarefas mais tediosas de equipes inteiras.

Neste artigo, exploraremos os conceitos básicos da automação de fluxo de trabalho usando o Python – uma linguagem de programação poderosa e fácil de aprender. Usaremos o Python para escrever um script de automação fácil e útil que limpará uma pasta específica e colocará cada arquivo em sua pasta correspondente.

Nosso objetivo não será escrever código perfeito ou criar arquiteturas ideais no início. Também não vamos criar nada "ilegal". Em vez disso, veremos como criar um script que limpa automaticamente uma determinada pasta e todos os seus arquivos.

Sumário

1. Áreas de automação e por onde começar

1.1 Automação simples

1.2 Automação com API pública

1.3 Engenharia reversa de API

2. Considerações éticas sobre a automação

3. Criação de um script de limpeza de um diretório

4. Um guia completo sobre a criação de bots e como automatizar seu trabalho diário

Áreas de automação e por onde começar

Vamos começar definindo que tipo de automações existem.

A arte da automação se aplica à maioria dos setores. Para começar, ela ajuda com tarefas como extrair endereços de e-mail de diversos documentos para que você possa fazer um envio em massa de e-mails. Abordagens mais complexas, como a otimização de fluxos de trabalho e processos dentro de grandes corporações, também podem ter a automação como auxílio.

É claro que passar de pequenos scripts pessoais para grandes infraestruturas de automação que substituem pessoas reais envolve um processo de aprendizado e melhoria. Então, vamos ver onde você pode começar sua jornada.

Automação simples

Automações simples permitem um ponto de entrada rápido e direto. Isso pode abranger pequenos processos independentes, como limpezas de projetos e reestruturação de arquivos dentro de diretórios, ou partes de um fluxo de trabalho, como redimensionar automaticamente arquivos já salvos.

Automação de API pública

As automações de API pública são o modo mais comum de automação, uma vez que podemos acessar a maioria das funcionalidades usando solicitações HTTP para APIs hoje em dia. Por exemplo, se você quiser automatizar a maneira como regar seu jardim inteligente em casa.

Para fazer isso, você quer verificar o tempo do dia atual para ver se você precisa regar ou se há chuva chegando.

Engenharia reversa de API

A automação baseada em engenharia reversa de API é mais comum em bots reais e na seção "Bot Imposter" (impostor de bot, em inglês) do gráfico na seção "Considerações éticas" abaixo.

Através da engenharia reversa de uma API, entendemos o fluxo de usuários das aplicações. Um exemplo pode ser o login em um jogo de navegador on-line.

Ao entender o processo de login e autenticação, podemos duplicar esse comportamento com nosso próprio script. Em seguida, podemos criar nossa própria interface para trabalhar com a aplicação, mesmo que os próprios criadores não a forneçam.

Seja qual for a abordagem que você está buscando, sempre considere se ela é legal ou não.

Você não quer se meter em problemas, não é?

Considerações éticas sobre a automação

Alguém no GitHub, um dia, entrou em contato comigo e me disse:

"Curtidas e engajamento são a moeda digital e você está desvalorizando essa moeda."

Isso ficou comigo e me fez questionar a ferramenta que construí exatamente para esse propósito.

O fato de que essas interações e o engajamento podem ser automatizados e "falsificados" cada vez mais leva a um sistema de redes social distorcido e quebrado.

Pessoas que produzem conteúdo valioso e bom são invisíveis para outros usuários e empresas de publicidade se não usarem bots e outros sistemas de engajamento. Um amigo meu criou a seguinte associação com os "Nove Círculos do Inferno", de Dante, onde, a cada passo, mais perto de se tornar um influenciador social você fica e cada vez menos consciente de como todo esse sistema realmente está quebrado.

Quero compartilhar isso com vocês aqui, pois acho que é uma representação extremamente precisa do que testemunhei enquanto trabalhava ativamente com influenciadores com o InstaPy.

Nível 1: Limbo – quando você não usa bots

Nível 2: Flerte – quando você dá as curtidas e segue manualmente quantas pessoas puder para que elas sigam você de volta/curtam suas publicações

Nível 3: Conspiração – quando você se junta a um grupo no Telegram para dar curtidas e comentar em 10 fotos para que outras 10 pessoas curtam e comentem em sua foto

Nível 4: Infidelidade – quando você usa um assistente virtual de baixo custo para dar curtidas e seguir em seu nome

Nível 5: Lascívia – quando você usa um bot para dar curtidas, sem receber curtidas de volta (mas sem pagar por isso – como, por exemplo, com uma extensão do Chrome)

Nível 6: Promiscuidade – quando você usa um bot para dar 50 ou mais curtidas para receber 50 ou mais curtidas, mas sem pagar por isso – como, por exemplo, com uma extensão do Chrome

Nível 7: Avareza ou ganância em excesso – quando você usa um bot para dar curtidas/seguir/comentar em torno de 200 a 700 fotos, ignorando a chance de ser banido

Nível 8: Prostituição – quando você paga por um serviço de terceiros desconhecidos para dar reciprocidade às curtidas/seguidas automatizadas por você, mas esse serviço usa sua conta para dar curtidas/seguir de volta

Nível 9: Fraude/Heresia – quando você compra seguidores e curtidas e tenta se vender para as marcas como um influencer

O nível de uso de bots nas redes sociais é tanto que, se você não usar bots, estará preso no nível 1, o Limbo, sem crescimento no número de seguidores e com baixo engajamento com relação aos seus pares.

Na teoria econômica, isso é conhecido como o dilema do prisioneiro e como jogo da soma zero. Se você não usar bots e eu usar, eu ganho. Se ninguém usar, todos ganham. Como, porém, não há incentivo para que todos não usem bots, todos usam bots. Assim, ninguém ganha.

Cuidado com isso e nunca se esqueça das implicações que todo esse ferramental tem nas redes sociais.

Queremos evitar lidar com implicações éticas e ainda trabalhar em um projeto de automação aqui. É por isso que criaremos um script de limpeza de diretório simples, que ajuda você a organizar suas pastas bagunçadas.

Criação de um script de limpeza de um diretório

Agora, queremos examinar um script bastante simples. Ele limpa automaticamente um determinado diretório, movendo esses arquivos para pastas de acordo com a extensão do arquivo.

Então, tudo o que queremos fazer é o seguinte:

Configurando o analisador de argumentos

Como estamos trabalhando com uma funcionalidade do sistema operacional, como mover arquivos, precisamos importar a biblioteca os. Além disso, queremos dar ao usuário algum controle sobre qual pasta é limpa. Usaremos a biblioteca argparse para isso.

import os
import argparse

Depois de importar as duas bibliotecas, vamos primeiro configurar o analisador de argumentos. Certifique-se de fornecer uma descrição e um texto de ajuda para cada argumento adicionado para auxiliar o usuário quando ele digitar --help.

Nosso argumento será chamado de --path. Os traços duplos na frente do nome informam à biblioteca que esse é um argumento opcional. Por padrão, queremos usar o diretório atual, então defina o valor padrão como ".".

parser = argparse.ArgumentParser(
    description="Limpa o diretório e coloca os arquivos nas respectivas pastas."
)

parser.add_argument(
    "--path",
    type=str,
    default=".",
    help="Caminho do diretório a ser limpo",
)

# analisa os argumentos dados pelo usuário e extrai o caminho
args = parser.parse_args()
path = args.path

print(f"Limpando o diretório {path}")

Isso já termina a seção de análise de argumentos – é bem simples e legível, certo?

Vamos executar o nosso script e ver se tem erros.

python directory_clean.py --path ./test 

=> Limpando o diretório ./test

Uma vez executado, podemos ver o nome do diretório sendo impresso no console. Ótimo!
Vamos usar a biblioteca os para obter os arquivos no caminho fornecido.

Obtendo uma lista de arquivos da pasta

Ao usar o método os.listdir(path) e fornecer a ele um caminho válido, obtemos uma lista de todos os arquivos e pastas dentro desse diretório.

Depois de listar todos os elementos na pasta, queremos diferenciar entre arquivos e pastas, pois não queremos limpar as pastas, apenas os arquivos.

Nesse caso, usamos uma compreensão de lista do Python para iterar todos os elementos e colocá-los nas novas listas se eles atenderem ao requisito dado de ser um arquivo ou pasta.

# obter todos os arquivos de um diretório
dir_content = os.listdir(path)

# criar um caminho relativo a partir do caminho do arquivo e o nome do documento
path_dir_content = [os.path.join(path, doc) for doc in dir_content]

# filtrar o conteúdo do nosso diretório em uma lista de documentos e pastas
docs = [doc for doc in path_dir_content if os.path.isfile(doc)]
folders = [folder for folder in path_dir_content if os.path.isdir(folder)]

# contador para registrar a quantidade de arquivos movidos 
# e a lista das pastas já criadas para evitar a criação de diversas pastas iguais
moved = 0
created_folders = []

print(f"Limpando {len(docs)} de {len(dir_content)} elementos.")

Como sempre, vamos garantir que nossos usuários recebam feedback. Portanto, adicionamos uma instrução de impressão que dê ao usuário uma indicação sobre quantos arquivos serão movidos.

python directory_clean.py --path ./test 

=> Limpando o diretório ./test
=> Limpando 60 de 60 elementos.

Depois de executar novamente o script do Python, agora, podemos ver que a pasta /test que criei contém 60 arquivos que serão movidos.

Criação de uma pasta para cada extensão de arquivo

O próximo – e mais importante – passo é criar a pasta para cada uma das extensões de arquivo. Queremos fazer isso passando por todos os nossos arquivos filtrados e, se eles tiverem uma extensão para a qual ainda não há uma pasta, criamos uma.

A biblioteca os nos ajuda com funcionalidades mais interessantes, como a divisão do tipo de arquivo e caminho de um determinado documento, extraindo o próprio caminho e o nome do documento.

# percorre todos os arquivos e os move para as pastas certas
for doc in docs:
    # separar o nome da extensão do arquivo
    full_doc_path, filetype = os.path.splitext(doc)
    doc_path = os.path.dirname(full_doc_path)
    doc_name = os.path.basename(full_doc_path)

	print(filetype)
    print(full_doc_path)
    print(doc_path)
    print(doc_name)
    
    break

A instrução break ao final do código acima garante que nosso terminal não fique travado se nosso diretório tiver centenas de arquivos.

Depois de definirmos isso, vamos executar nosso script e ver um resultado semelhante a este:

python directory_clean.py --path ./test 

=> ...
=> .pdf
=> ./test/test17
=> ./test
=> test17

Podemos ver que a implementação acima divide o tipo de arquivo e, em seguida, extrai as partes do caminho completo.

Como temos o tipo de arquivo, agora podemos verificar se já existe uma pasta com o nome desse tipo.

Antes de fazermos isso, queremos ter certeza de pular alguns arquivos. Se usarmos o diretório atual "." como caminho, precisamos evitar mover o próprio script do Python. Uma condição simples cuida disso.

Além disso, não queremos mover arquivos ocultos (texto em inglês). Vamos, então, incluir todos os arquivos que comecem com um ponto. O arquivo .DS_Store no macOS é um exemplo de arquivo oculto.

	# ignore este arquivo quando ele estiver no diretório
    if doc_name == "directory_clean" or doc_name.startswith('.'):
        continue

    # obtenha o nome da subpasta e crie a pasta se ela não existir
    subfolder_path = os.path.join(path, filetype[1:].lower())

    if subfolder_path not in folders:
    	# cria a pasta

Depois de cuidarmos do script do Python e dos arquivos ocultos, podemos passar para a criação das pastas no sistema.

Além da nossa verificação, se a pasta já estava lá quando lemos o conteúdo do diretório, no início, precisamos de uma maneira de rastrear as pastas que já criamos. Essa foi a razão pela qual declaramos a lista created_folders = []. Ela servirá como a memória para acompanhar os nomes das pastas.

Para criar outra pasta, a biblioteca os fornece um método chamado os.mkdir(caminho_da_pasta), que recebe um caminho e cria a pasta com o nome dado ali.

Esse método pode lançar uma exceção, nos dizendo que a pasta já existe. Assim, vamos garantir que capturamos esse erro.

if subfolder_path not in folders and subfolder_path not in created_folders:
        try:
            os.mkdir(subfolder_path)
            created_folders.append(subfolder_path)
            print(f"Pasta {subfolder_path} criada.")
        except FileExistsError as err:
            print(f"Pasta já existe em {subfolder_path}... {err}")

Depois de definir a criação da pasta, vamos executar novamente nosso script.

python directory_clean.py --path ./test 

=> ...
=> Pasta ./test/pdf criada.

Na primeira passagem da execução, podemos ver uma lista de logs nos informando que as pastas com tipos determinados de extensões de arquivo foram criadas.

Movendo cada arquivo para a subpasta correta

A última etapa agora é realmente mover os arquivos para suas novas pastas pai.

Uma coisa importante a entender ao trabalhar com operações de os é que, às vezes, as operações não podem ser desfeitas. É o caso, por exemplo, da exclusão. Portanto, faz sentido primeiro apenas registrar o comportamento que nosso script alcançaria se o executássemos.

É por isso que o método os.rename(...) foi comentado aqui.

# Obtém o caminho da nova pasta e move o arquivo
    new_doc_path = os.path.join(subfolder_path, doc_name) + filetype
    # os.rename(doc, new_doc_path)
    moved += 1
    
    print(f"Arquivo {doc} movido para {new_doc_path}")

Depois de executar nosso script e ver o registro correto, agora podemos remover a hashtag de comentário antes do nosso método os.rename() e dar a ele a sua vez.

# Obtém o caminho da nova pasta e move o arquivo
    new_doc_path = os.path.join(subfolder_path, doc_name) + filetype
    os.rename(doc, new_doc_path)
    moved += 1

    print(f"Arquivo {doc} movido para {new_doc_path}")

print(f"Renomeados {moved} de {len(docs)} arquivos.")

python directory_clean.py --path ./test 

=> ...
=> Arquivo ./test/test17.pdf movido para ./test/pdf/test17.pdf
=> ...
=> Renomeados 60 de 60 arquivos.

Essa execução final, agora, moverá todos os arquivos para suas pastas apropriadas e nosso diretório estará limpo, sem a necessidade de ações manuais.

Na próxima etapa, poderíamos usar o script que criamos acima e, por exemplo, programá-lo para ser executado todas as segundas-feiras para limpar nossa pasta de Downloads para obter uma estrutura melhor.

É exatamente por isso que estamos criando uma continuação dentro de nosso curso da Udemy, chamado Bot Creation and Workflow Automation (em português, criação de bots e automação de fluxos de trabalho).

Um guia completo para a criação de bots e a automação do seu trabalho diário

Felix e eu criamos um curso em vídeo on-line para ensinar para você a criação de bots, com base no que você aprendeu criando o InstaPy e o Travian-Bot. De fato, ele foi, inclusive, forçado a derrubar o bot por ser eficaz até demais.

Junte-se a nós e comece a aprender (curso da Udemy em inglês, pago).

Se tiver perguntas ou feedback, fique à vontade para entrar em contato conosco pelo Twitter ou diretamente pela seção de discussão do curso.

O Python é uma linguagem linda de se programar. Com um ecossistema de pacotes maravilhoso, nela, há bem menos ruído que em outras linguagens, além de ser muito fácil de usar.  

O Python pode ser usado para várias coisas – desde a análise de dados até a programação em back-end. Dentre todas as opções, uma das maneiras mais empolgantes de se usar o Python é o scraping (em português, algo como "raspagem" ou extração) de dados na web.

Neste artigo, abordaremos como utilizar a linguagem Python para fazer scraping na web. Também trabalharemos com uma aula prática e interativa, guiando você à medida que avançamos neste artigo.

Observação: faremos scraping em um site da web hospedado por mim. Assim, poderemos aprender a fazê-lo em segurança. Muitas empresas não permitem o scraping de dados em seus sites. Então, essa será uma boa maneira de aprender. Certifique-se de checar isso antes de começar um scraping de dados na web.

Introdução à aula de scraping de dados na web

Se você quiser programar em paralelo no decorrer deste artigo, pode usar esta aula no codedamn, que consiste em diversos laboratórios que ajudam você a fazer o scraping de dados. Será um exercício prático e interativo no codedamn, muito similar à maneira que você aprende no freeCodeCamp.

Nesta aula, você utilizará essa página para testar o scraping de dados:

https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/  (em inglês)

A aula é composta por sete laboratórios. Você resolverá o que há em cada um ao longo deste artigo. Usaremos o Python 3.8 e o BeautifulSoup 4 para o scraping de dados.

Parte 1: carregando páginas da web com 'request'

Este é o link deste laboratório.

O módulo requests permite que você envie solicitações de HTTP usando o Python.

A solicitação de HTTP retorna um objeto response com todos os dados de resposta (conteúdo, código, status e assim por diante). Aqui vai um exemplo ao pegar HTML de uma página:

import requests

res = requests.get('https://codedamn.com')

print(res.text)
print(res.status_code)

Requerimentos necessários:  

• Pegar o conteúdo do URL a seguir usando o módulo requests: https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/
• Armazenar a resposta recebida (como demonstrado logo abaixo) em uma variável chamada txt    
• Armazenar o código do status (como demonstrado abaixo) em uma variável chamada status
• Imprimir txt e status usando a função print  

Uma vez que você esteja entendendo o que está acontecendo no código abaixo, será bastante simples para você completar este laboratório. Aqui está a solução para ele:  

import requests
# Faça uma solicitação para https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/
# Armazene o resultado na variável 'res'
res = requests.get(
    'https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/')
txt = res.text
status = res.status_code
# Imprima o resultado
print(txt, status)

Vamos prosseguir para a parte 2 agora. Nela, você poderá programar mais, aproveitando o código que já fez até o momento.

Parte 2: extraindo o título com BeautifulSoup  

Este é o link para o laboratório.

Em toda esta lição, você usará uma biblioteca chamada BeautifulSoup no Python para fazer o scraping de dados na web. Algumas funcionalidades que fazem o BeautifulSoup ser uma solução poderosa são:

1. Fornecer muitos métodos simples e expressões "Pythônicas" para a navegação, pesquisa e modificação da árvore do DOM. Não é necessário programar muito para escrever uma aplicação.
2. O BeautifulSoup fica no topo dos analisadores (do inglês, parsers) mais populares de Python, como lxml e html5lib, permitindo que você teste diferentes estratégias de análise ou que faça uma troca entre velocidade e flexibilidade.

Basicamente, o BeautifulSoup pode analisar qualquer coisa que tenha na página da web fornecida.

Aqui está um exemplo simples do BeautifulSoup:

from bs4 import BeautifulSoup

page = requests.get("https://codedamn.com")
soup = BeautifulSoup(page.content, 'html.parser')
title = soup.title.text # Obtém o texto que está entre as tags <title>(...)</title>

Requerimentos necessários:

• Utilizar o pacote requests para pegar o título do URL: https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/
• Utilizar o BeautifulSoup para armazenar o título dessa página dentro de uma variável chamada page_title

Vendo o exemplo abaixo, você pode notar que, uma vez inserido o page.content dentro do BeautifulSoup, você poderá começar a trabalhar com a análise da árvore do DOM de uma maneira bem típica do Python. A solução para o laboratório seria:

import requests
from bs4 import BeautifulSoup

# Fazer uma solicitação para https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/
page = requests.get(
    "https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/")
soup = BeautifulSoup(page.content, 'html.parser')

# Extrair o título da página
page_title = soup.title.text

# Imprimir o resultado
print(page_title)

Esse foi um laboratório simples, onde tivemos que mudar o URL e imprimir o título da página. O código acima passaria nesse laboratório.

Parte 3:  extraindo body e head

Aqui está o link para este laboratório.  

No último laboratório, você viu como extrair o title da página. Da mesma maneira, seria fácil extrair seções mais específicas.

Você também viu que deve usar .text nelas para obter a string, mas você também pode imprimi-las sem utilizar o .text. Isso dará a você a marcação completa. Tente rodar o exemplo abaixo:

import requests
from bs4 import BeautifulSoup

# Fazer uma solicitação
page = requests.get(
    "https://codedamn.com")
soup = BeautifulSoup(page.content, 'html.parser')

# Extrair o título da página
page_title = soup.title.text

# Extrair o body da página
page_body = soup.body

# Extrair a head da página
page_head = soup.head

# Imprimir o resultado
print(page_body, page_head)

Vamos ver como você pode extrair as seções body e head de suas páginas.

Requerimentos necessários:

• Repetir o experimento com o URL: https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/
• Armazenar o título da página (sem usar o .text) do URL em page_title
• Armazenar o conteúdo do body (sem usar o .text) do URL em page_body
• Armazenar o conteúdo da head (sem usar o .text) do URL em page_head

Quando você tentar imprimir page_body ou page_head, verá que eles estarão impressos como strings. Na verdade, porém, quando você colocar print(type page_body), verá que não é exatamente uma string. Mesmo assim, isso funcionará bem.

A solução desse exemplo seria simples, baseada no código abaixo:

import requests
from bs4 import BeautifulSoup

# Fazer uma solicitação
page = requests.get(
    "https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/")
soup = BeautifulSoup(page.content, 'html.parser')

# Extrair o título da página
page_title = soup.title

# Extrair o body da página
page_body = soup.body

# Extrair a head da página
page_head = soup.head

# Imprimir o resultado
print(page_title, page_head)

Parte 4: selecionando com o BeautifulSoup

Aqui está o link para este laboratório.

Agora que você já explorou algumas partes do BeautifulSoup, veremos como você pode selecionar elementos do DOM com métodos do BeautifulSoup.

Uma vez que você tenha a variável soup (como nos laboratórios anteriores), você pode trabalhar com .select nela, um seletor de CSS dentro do BeautifulSoup. Ou seja, você pode ter acesso à arvore do DOM do mesmo modo como você selecionaria elementos com CSS. Vejamos um exemplo:

import requests
from bs4 import BeautifulSoup

# Fazer uma solicitação
page = requests.get(
    "https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/")
soup = BeautifulSoup(page.content, 'html.parser')

# Extrair o texto do primeiro <h1>(...)</h1>
first_h1 = soup.select('h1')[0].text

O .select retorna uma lista em Python de todos os elementos. Essa é a razão pela qual você selecionou apenas o primeiro elemento aqui com o índice [0].  

Requerimentos necessários:

• Criar uma variável all_h1_tags. Colocá-la em uma lista vazia.
• Usar .select para selecionar todas as tags <h1> e armazenar seus textos dentro da lista all_h1_tags.
• Criar uma variável seventh_p_text e armazenar o texto do 7º elemento  p  (índice 6) dentro dela.

A solução do laboratório é:

import requests
from bs4 import BeautifulSoup
# Fazer uma solicitação
page = requests.get(
    "https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/")
soup = BeautifulSoup(page.content, 'html.parser')

# Criar all_h1_tags como uma lista vazia
all_h1_tags = []

# Definir all_h1_tags como todas as tags h1 de soup
for element in soup.select('h1'):
    all_h1_tags.append(element.text)

# Criar seventh_p_text e defini-lo como o texto do 7º elemento p da página
seventh_p_text = soup.select('p')[6].text

print(all_h1_tags, seventh_p_text)

Vamos continuar.

Parte 5: fazendo o scraping dos itens que estão no topo

Aqui está o link deste laboratório.

Agora, extrairemos os itens do topo retirados por scraping do URL https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/

Se você abrir essa página da web em uma nova guia, verá alguns itens no topo dela. Nesse laboratório, sua tarefa é pegar (ou fazer o scraping de) seus nomes e armazená-los em uma lista chamada top_items. Você também extrairá as suas avaliações.

Para concluir esse desafio, preste atenção nos seguintes pontos:

• Use o .select para obter os títulos. (Dica: um seletor para os títulos dos produtos poderia ser a.title)
• Use .select para obter o rótulo de contagem de comentários para esses títulos de produtos.
• Use .select para extrair o contador de avaliações dos títulos desses produtos. (Dica: um seletor para as avaliações poderia ser div.ratings ) Observação: esse é um rótulo completo (ou seja, 2 avaliações), não só um número.
• Crie um dicionário nesse formato:

info = {
   "title": 'Asus AsusPro Adv...   '.strip(),
   "review": '2 reviews\n\n\n'.strip()
}

• Note que você está usando o método strip para remover quaisquer linhas extras ou espaços em branco que possam aparecer no resultado. Isso é algo importante para avançar nesse laboratório.
• Use .append para adicionar esse dicionário em uma lista chamada top_items.
• Imprima essa lista no final usando print.

Há algumas tarefas a serem completadas nesse desafio. Vamos, primeiramente, dar uma olhada na solução para entendermos o que está acontecendo aqui:

import requests
from bs4 import BeautifulSoup
# Fazer uma solicitação
page = requests.get(
    "https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/")
soup = BeautifulSoup(page.content, 'html.parser')

# Criar top_items como uma lista vazia
top_items = []

# Extrair e armazenar em top_items de acordo com as instruções
products = soup.select('div.thumbnail')
for elem in products:
    title = elem.select('h4 > a.title')[0].text
    review_label = elem.select('div.ratings')[0].text
    info = {
        "title": title.strip(),
        "review": review_label.strip()
    }
    top_items.append(info)

print(top_items)

Note que essa é apenas uma das soluções. Fique à vontade para tentar de outras maneiras. Nessa solução:

1. Primeiro, você selecionará todos os elementos em div.thumbnail, obtendo uma lista de produtos individuais
2. Depois, você realiza uma iteração neles.
3. Você pode usar select outra vez para obter o título, já que ele permite iterar sobre ele mesmo.
4. Note que, agora que você já está rodando um laço para div.thumbnail, o seletor h4 > a.title daria somente um resultado dentro de uma lista. O que você deve fazer é selecionar o elemento de número 0 dessa lista e, então, extrair o seu texto.
5. Agora, você já pode usar strip para remover quaisquer espaços extras contidos no texto e adicionar o texto à sua lista utilizando append.

Simples, não é mesmo?

Parte 6: extraindo links

Aqui está o link deste laboratório  

Até agora, você viu como é possível extrair o texto, ou innerText, dos elementos. Veremos em seguida como é possível extrair os atributos por meio da extração dos links da página.

Aqui está um exemplo de como extrair toda a informação de imagem da página:

import requests
from bs4 import BeautifulSoup
# Fazer uma solicitação
page = requests.get(
    "https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/")
soup = BeautifulSoup(page.content, 'html.parser')

# Criar top_items como uma lista vazia
image_data = []

# Extrair e armazenar em top_items de acordo com as instruções
images = soup.select('img')
for image in images:
    src = image.get('src')
    alt = image.get('alt')
    image_data.append({"src": src, "alt": alt})

print(image_data)

Nesse laboratório, sua tarefa é extrair o atributo href dos links e seus respectivos textos text. Certifique-se das seguintes coisas:

• Você terá que criar uma lista chamada all_links
• Nessa lista, armazene toda a informação do link. Isso deverá ficar no seguinte formato:

info = {
   "href": "<link here>",
   "text": "<link text here>"
}

• Certifique-se que o seu text esteja sem nenhum espaço em branco.
• Certifique-se de checar se o seu .text é None antes de usar o .strip() nele.
• Armazene todos esses dicionários em all_links
• Use print para imprimir essa lista no final.

Você extrairá os valores dos atributos da mesma maneira que você extrai os valores de um dicionário, usando a função get. Veremos agora a solução para esse laboratório:

import requests
from bs4 import BeautifulSoup
# Fazer uma solicitação
page = requests.get(
    "https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/")
soup = BeautifulSoup(page.content, 'html.parser')

# Criar top_items como uma lista vazia
all_links = []

# Extrair e armazenar em top_items de acordo com as instruções
links = soup.select('a')
for ahref in links:
    text = ahref.text
    text = text.strip() if text is not None else ''

    href = ahref.get('href')
    href = href.strip() if href is not None else ''
    all_links.append({"href": href, "text": text})

print(all_links)

Aqui, você extrairá o atributo href do mesmo modo que você fez no caso da imagem. A única coisa que você fará de diferente é conferir se ele é None, tal qual fizemos anteriormente. Queremos defini-lo como uma string vazia. Caso contrário, tiraremos o espaço em branco.

Parte 7: gerando CSV a partir de dados

Aqui está o link deste laboratório

Por fim, vamos entender como gerar CSV a partir de um conjunto de dados. Você criará um CSV com os seguintes tópicos:

1. Nome do produto
2. Preço
3. Descrição
4. Avaliações
5. Imagem do produto

Esses produtos estão localizados em div.thumbnail. O padrão do CSV está logo abaixo:

import requests
from bs4 import BeautifulSoup
import csv
# Fazer uma solicitação
page = requests.get(
    "https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/")
soup = BeautifulSoup(page.content, 'html.parser')

all_products = []

products = soup.select('div.thumbnail')
for product in products:
    # TODO: Trabalho
    print("Trabalho com o produto aqui")


keys = all_products[0].keys()

with open('products.csv', 'w', newline='') as output_file:
    dict_writer = csv.DictWriter(output_file, keys)
    dict_writer.writeheader()
    dict_writer.writerows(all_products)

Você deverá extrair os dados do site da web e gerar o CSV para três produtos.

Requerimentos necessários:

• O nome do produto é a versão com o espaço em branco cortado do nome do item (exemplo - Asus AsusPro Adv.)
• Preço é o espaço em branco cortado mas com o rótulo do preço inteiro (exemplo - $1101.83)
• A descrição é a versão com o espaço em branco cortado da descrição do produto (exemplo - Asus AsusPro Advanced BU401LA-FA271G Dark Grey, 14", Core i5-4210U, 4GB, 128GB SSD, Win7 Pro)
• Avaliações são as versões com o espaço em branco cortado do produto (exemplo - 7 avaliações)
• Imagem do produto é o URL (atributo src) da imagem do produto (exemplo - /webscraper-python-codedamn-classroom-website/cart2.png)
• O nome do arquivo CSV deve ser products.csv e deve ser armazenado na mesma pasta que o seu arquivo script.py.

Aqui está a solução para esse laboratório:

import requests
from bs4 import BeautifulSoup
import csv
# Fazer uma solicitação
page = requests.get(
    "https://codedamn-classrooms.github.io/webscraper-python-codedamn-classroom-website/")
soup = BeautifulSoup(page.content, 'html.parser')

# Criar top_items como uma lista vazia
all_products = []

# Extrair e armazenar em top_items de acordo com as instruções
products = soup.select('div.thumbnail')
for product in products:
    name = product.select('h4 > a')[0].text.strip()
    description = product.select('p.description')[0].text.strip()
    price = product.select('h4.price')[0].text.strip()
    reviews = product.select('div.ratings')[0].text.strip()
    image = product.select('img')[0].get('src')

    all_products.append({
        "name": name,
        "description": description,
        "price": price,
        "reviews": reviews,
        "image": image
    })


keys = all_products[0].keys()

with open('products.csv', 'w', newline='') as output_file:
    dict_writer = csv.DictWriter(output_file, keys)
    dict_writer.writeheader()
    dict_writer.writerows(all_products)

O bloco for é o mais interessante aqui. Você extrai todos os elementos e atributos de tudo o que já foi aprendido até agora em todos os laboratórios.

Quando você rodar esse código, terá um bom arquivo CSV. Isso é praticamente todo o básico de scraping de dados com o BeautifulSoup!

Conclusão

Eu espero que essa aula interativa do codedamn tenha ajudado você a entender o básico de scraping de dados com o Python.

Se você gostou desta aula e deste artigo, o autor pede que compartilhe com ele sya opinião no Twitter e no Instagram do autor. Ele adoraria ter o seu feedback!

Escrito por: Maxim Mamaev

Vamos pegar um problema computacional como exemplo, escrever o código e ver como podemos melhorar o tempo de execução. Aqui vamos nós.

Montando a cena: o problema da mochila

Este é o problema computacional que usaremos como exemplo:

O problema da mochila é um problema bem conhecido em otimização combinatória. Nesta seção, revisaremos seu tipo mais comum, o problema da mochila 0–1, e sua solução por meio de programação dinâmica. Se você estiver familiarizado com o assunto, pode pular essa parte.

Você recebe uma mochila de capacidade C e uma coleção de N itens. Cada item tem peso w[i] e valor v[i]. Sua tarefa é arrumar a mochila com os itens mais valiosos. Em outras palavras, você deve maximizar o valor total dos itens que coloca na mochila, com uma restrição: o peso total dos itens levados não pode exceder a capacidade da mochila.

Depois de obter uma solução, o peso total dos itens na mochila é chamado de "peso da solução" e seu valor total é o "valor da solução".

O problema tem muitas aplicações práticas. Por exemplo, você decidiu investir R$ 1.600 em uma famosa ação da FAANG (nome coletivo das ações do Facebook, Amazon, Apple, Netflix e Google, também conhecida como Alphabet). Cada ação tem um preço de mercado atual e a estimativa de preço de um ano. A partir de um dia em 2018, eles são os seguintes:

========= ======= ======= ==========
Empresa   Ticker   Preço  Estimativa
========= ======= ======= ==========
Alphabet  GOOG    1030    1330
Amazon    AMZN    1573    1675
Apple     AAPL    162     193 
Facebook  FB      174     216 
Netflix   NFLX    312     327
========= ======= ======= ==========

Para simplificar o exemplo, vamos supor que você nunca colocaria todos os seus ovos na mesma cesta. Você está disposto(a) a comprar não mais do que uma ação de cada. Quais ações você compra para maximizar seu lucro?

Esse é um problema da mochila. Seu orçamento (R$ 1.600) é a capacidade (C) de armazenamento. As ações são os itens a serem embalados. Os preços atuais são os pesos (w). As estimativas de preços são os valores. O problema parece trivial. No entanto, a solução não é evidente à primeira vista – se você deve comprar uma ação da Amazon, ou uma ação do Google mais uma de alguma combinação de Apple, Facebook, ou Netflix.

Claro que, nesse caso, você pode fazer cálculos rápidos à mão e chegar na solução: você deve comprar Google, Netflix, e Facebook. Desse modo, você gasta R$ 1.516 e espera ganhar R$ 1.873.

Agora, você acredita que descobriu uma mina de outro. Você destrói seu cofrinho e recebe R$ 10.000. Apesar de sua empolgação, você permanece inflexível com a regra "uma ação – uma compra". Portanto, com esse orçamento maior, você tem que ampliar suas opções. Você decide considerar todas as 100 ações da lista da NASDAQ como candidatas para compra.

O futuro nunca foi tão brilhante, mas, de repente, você percebe que, para identificar sua carteira de investimentos ideal, você terá que verificar cerca de 2¹⁰⁰ combinações. Mesmo que você seja superotimista com a iminência e a onipresença da economia digital, qualquer economia requer — no mínimo — um universo onde funcione. Infelizmente, em alguns trilhões de anos, quando sua computação terminar, nosso universo provavelmente não existirá.

Algoritmo de programação dinâmica

Temos que abandonar a abordagem de força bruta e programar alguma solução inteligente. Pequenos problemas de mochila (e o nosso é pequeno, acredite ou não) são resolvidos por programação dinâmica. A ideia básica é partir de um problema trivial cuja solução conhecemos e depois adicionaremos complexidade passo a passo.

Se você achar as explicações a seguir muito abstratas, aqui está uma ilustração comentada da solução para um problema de mochila bem pequeno. Isso ajudará você a visualizar o que está acontecendo.

Suponha que, dados os primeiros itens i da coleção, nós saibamos os valores de solução s(i, k) para todas as capacidades de mochila k no intervalo de 0 a C.

Em outras palavras, costuramos mochilas "auxiliares" C+1 de todos os tamanhos de 0 a C. Em seguida, organizamos nossa coleção, pegamos o primeiro item i e temporariamente separamos todo o resto. E agora assumimos que, por alguma mágica, nós sabemos como embalar de maneira ideal cada um dos pacotes desse conjunto funcional de i itens. Os itens que escolhemos do conjunto funcional podem ser diferentes para pacotes diferentes, mas no momento não estamos interessados em quais itens pegamos ou pulamos. É apenas o valor da solução s(i, k) que registramos para cada um de nosso pacotes recém costurados.

Agora, buscamos o próximo item (i+1)º da coleção e adicionamos ao conjunto funcional. Vamos encontrar valores de solução para todas as mochilas auxiliares com esse novo conjunto funcional. Em outras palavras, nós encontramos s(i+1, k) para todo k=0..C dado s(i, k).

Se k for menor que o peso do novo item w[i+1], não podemos pegar esse item. De fato, mesmo que pegássemos apenas esse item, ele sozinho não caberia na mochila. Portanto, s(i+1, k) = s(i, k) para todo k < w[i+1].

Para os valores k >= w[i+1] temos que fazer uma escolha: ou colocamos o novo item na mochila de capacidade k ou o pulamos. Temos que avaliar essas duas opções para determinar qual delas nos dá mais valor embalado no pacote.

Se pegarmos o (i+1)º item, adquirimos o valor v[i+1] e consumimos a parte da capacidade da mochila para acomodar o peso w[i+1]. Isso nos deixa com a capacidade k–w[i+1] que devemos preencher de modo otimizado usando (alguns dos) primeiros i itens. Esse preenchimento otimizado tem o valor de solução s(i, k–w[i+1]). Esse número já é conhecido por nós porque, por suposição, conhecemos todos os valores de solução para o conjunto funcional de i itens. Portanto, o valor da solução candidata para a mochila k com o item i+1 levado seria
s(i+1, k | i+1 levado) = v[i+1] + s(i, k–w[i+1]).

A outra opção seria pular o item i+1. Nesse caso, nada muda em nossa mochila, e o valor da solução candidata seria o mesmo que s(i, k).

Para decidir sobre a melhor opção, comparamos os dois candidatos para os valores da solução:

s(i+1, k | i+1 levado) = v[i+1] + s(i, k–w[i+1])
s(i+1, k | i+1 ignorado) = s(i, k)

O máximo destes torna-se a solução s(i+1, k).

Resumindo:

if k < w[i+1]:
	s(i+1, k) = s(i, k)
else:
	s(i+1, k) = max( v[i+1] + s(i, k-w[i+1]), s(i, k) )

Agora, podemos resolver o problema da mochila passo a passo. Começamos com o conjunto de trabalho vazio (i=0). Obviamente, s(0, k) = 0 para qualquer k. Em seguida, avançamos adicionando itens ao conjunto de trabalho e encontrando os valores de solução s(i, k) até chegarmos a s(i+1=N, k=C), que é o valor de solução do problema original.

Observe que, ao fazer isso, construímos a grade de valores da solução NxC.

No entanto, apesar de ter aprendido o valor da solução, não sabemos exatamente quais itens foram colocados na mochila. Para descobrir isso, retrocedemos a grade. Partindo de s(i=N, k=C), comparamos s(i, k) com s(i–1, k).

Se s(i, k) = s(i–1, k), o i-ésimo item não foi considerado. Nós reiteramos com i=i–1 mantendo o valor de k inalterado. Caso contrário, o i-ésimo item foi retirado e, para a próxima etapa de exame, encolhemos a mochila em w[i] — definimos i=i–1, k=k–w[i].

Desse modo, examinamos todos os itens do N-ésimo ao primeiros e determinamos quais deles foram colocados na mochila. Isso nos dá a solução para o problema da mochila.

Código e análise

Como temos o algoritmo, vamos comparar várias implementações, começando por uma simples. O código está disponível no GitHub.

Os dados são a lista Nasdaq 100, contendo preços atuais e estimativas de preços para cem ações (até um dia em 2018). Nosso orçamento de investimento é de R$ 10.000.

Lembre-se que preços de ações não são números redondos em reais, mas vêm com centavos. Portanto, para obter a solução exata, temos que contar tudo em centavos — definitivamente queremos evitar números float. Portanto, a capacidade de nossa mochila é ($)10.000 x 100 centavos = ($)1.000.000, e o tamanho total de nosso problema N x C = 1.000.000.

Com um inteiro ocupando 4 bytes de memória, esperamos que o algoritmo vá consumir aproximadamente 400 MB de RAM. Portanto, a memória não será uma limitação. É com o tempo de execução que devemos no preocupar.

Claro, todas as nossas implementações produzirão a mesma solução. Para referência, o investimento (o peso da solução) é 999930 (R$ 9.999,30) e o retorno esperado (o valor da solução) é 1219475 (R$ 12.194,75). A lista de ações a comprar é bem longa (80 de 100 itens). Você pode obtê-la rodando o código.

Lembre-se de que este é um exercício de programação, não um conselho de investimento. Quando você for ler esse artigo, os preços e as estimativas terão mudado em relação ao que é usado aqui como exemplo.

Os bons e velhos loops do tipo "for"

A implementação direta do algoritmo é dada abaixo.

def solve_naive(capacity, items, weights, values):

    grid = [[0] * (capacity+1)]
    for item in range(items):
        grid.append(grid[item].copy())
        for k in range(weights[item], capacity+1):
            grid[item + 1][k] = max(grid[item][k], grid[item][k-weights[item]] + values[item])

    solution_value = grid[items][capacity]
    solution_weight = 0
    taken = []
    k = capacity
    for item in range(items, 0, -1):
        if grid[item][k] != grid[item-1][k]:
            taken.append(item - 1)
            k -= weights[item - 1]
            solution_weight += weights[item-1]

    return solution_value, solution_weight, taken

Existem duas partes.

Na primeira parte (linhas 3-7 acima), dois loops for aninhados são usados para construir a grade da solução.

O loop externo adiciona itens ao conjunto de trabalho até atingirmos N (o valor de N é passado no parâmetro items). A linha de valores de solução para cada novo conjunto de trabalho é inicializada com os valores calculados para o conjunto de trabalho anterior.

O loop interno para cada conjunto de trabalho itera os valores de k do peso do item recém adicionado a C (o valor de C é passado no parâmetro capacity).

Note que não precisamos iniciar o loop de k=0. Quando k é menor do que o peso do item, os valores da solução são sempre os mesmos calculados para o conjunto de trabalho anterior. Esses números já foram copiados para a linha atual pela inicialização.

Quando os loops são concluídos, temos a grade e o valor da solução.

A segunda parte (linhas 9-17) é um único loop for de N iterações. Ele retrocede a grade para descobrir quais itens foram levados pela mochila.

Mais adiante, nos concentraremos exclusivamente na primeira parte do algoritmo, já que este possui complexidade de tempo e espaço O(N*C). A parte de retrocesso requer apenas tempo O(N) e não gasta nenhuma memória adicional – seu consumo de recursos é relativamente insignificante.

A implementação direta leva 180 segundos para resolver o problema da mochila Nasdaq 100 no meu computador.

Isso é muito ruim? Por um lado, com as velocidades da era moderna, não estamos acostumados a passar três minutos esperando que um computador faça as coisas. Por outro lado, o tamanho do problema - cem milhões - parece realmente intimidador, então, talvez, três minutos seja ok?

Para obter algum benchmark, vamos programar o mesmo algoritmo em outra linguagem. Precisamos de uma linguagem compilada estaticamente tipada para garantir a velocidade de computação. Não, não C. Não é chique. Vamos seguir a moda e escrever em Go:

func solver(capacity, items int, weights, values []int) (int, int, []int) {
    
    grid :=  make([][]int, items+1, items+1)
    grid[0] = make([]int, capacity+1, capacity+1) 

    for item := 0; item < items; item++ {

        grid[item+1] = make([]int, capacity+1, capacity+1)
        for k:=0; k<weights[item]; k++ {
            grid[item + 1][k] = grid[item][k]
        }
        for k:=weights[item]; k <= capacity; k++ {
            grid[item + 1][k] = max(grid[item][k], grid[item][k-weights[item]] + values[item])
        }
    } 

    solution_value := grid[items][capacity]
    solution_weight := 0
    var taken []int
    k := capacity
    for item := items; item > 0; item-- {
        if grid[item][k] != grid[item-1][k] {
            taken = append(taken, item-1)
            k -= weights[item - 1]
            solution_weight += weights[item-1]
        }
    }

    return solution_value, solution_weight, taken
}

Como você pode ver, o código Go é bem similar ao do Python. Até copiei e colei uma linha, a mais longa, como está.

Qual é o tempo de execução? 400 milissegundos! Em outras palavras, o Python foi 500 vezes mais lento do que o Go. A lacuna provavelmente será ainda maior se tentarmos em C. Isso é definitivamente um desastre para o Python.

Para descobrir o que torna o código Python mais lento, vamos executá-lo com o line profiler. Você pode encontrar a saída do profiler para esta implementação e as subsequentes do algoritmo no GitHub.

No solucionador direto, 99,7% do tempo de execução é gasto em duas linhas. Essas duas linhas compõem o loop interno, que é executado 98 milhões de vezes:

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    ...
    42       101        170.0      1.7      0.0  for item in range(items):
    43       100    1457275.0  14572.8      0.3      grid.append(grid[item].copy())
    44  98387558  121134401.0      1.2     26.4      for k in range(weights[item], capacity+1):
    45  98387458  336078747.0      3.4     73.3          grid[item + 1][k] = max(grid[item][k], grid[item][k-weights[item]] + values[item])
    ...

Peço desculpas pelas linhas excessivamente longas, mas o line profiler não pode lidar adequadamente com quebras de linha na mesma instrução.

Ouvi dizer que o operador for do Python é lento, mas, curiosamente, a maior parte do tempo não é gasta na linha for mas no corpo do loop.

Podemos dividir o corpo do loop em operações individuais para ver se alguma operação específica é muito lenta:

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    ...
    67       101        196.0      1.9      0.0      for item in range(items):
    68       100    1454886.0  14548.9      0.2          grid.append(grid[item].copy())
    69       100       1463.0     14.6      0.0          wi = weights[item]
    70       100        323.0      3.2      0.0          vi = values[item]
    71  98387558  133663554.0      1.4     16.7          for k in range(wi, capacity+1):
    72  98387458  156110242.0      1.6     19.4              a = grid[item][k]
    73  98387458  194935490.0      2.0     24.3              b = grid[item][k-wi] + vi
    74  98387458  138902753.0      1.4     17.3              if b > a:
    75  60782758  109728042.0      1.8     13.7                  grid[item + 1][k] = b
    76                                                       else:
    77  37604700   67944391.0      1.8      8.5                  grid[item + 1][k] = a
    ...

Parece que nenhuma operação em particular se destaca. Os tempos de execução das operações individuais dentro do loop interno são praticamente os mesmos que os tempos de execução de operações análogas em outras partes do código.

Observe como quebrar o código aumentou o tempo total de execução. O loop interno agora leva 99,9% do tempo de execução. Quanto mais burro seu código Python, mais lento ele fica. Interessante, não é?

Função map integrada

Vamos tornar o código mais otimizado e substituir o loop for interno por uma função map() integrada:

def solve_map(capacity, items, weights, values):
  
    grid = [[0] * (capacity+1)]
    for item in range(items):
        grid.append(grid[item].copy())
        this_weight = weights[item]
        this_value = values[item]
        
        grid[item+1][this_weight:] = 
            list(map(lambda k: max(grid[item][k], 
                                   grid[item][k - this_weight] + this_value), 
                     range(this_weight, capacity+1)))
        
    solution_value = grid[items][capacity]
    solution_weight = 0
    taken = []
    k = capacity
    for item in range(items, 0, -1):
        if grid[item][k] != grid[item-1][k]:
            taken.append(item - 1)
            k -= weights[item - 1]
            solution_weight += weights[item-1]

    return solution_value, solution_weight, taken

O tempo de execução desse código é de 102 segundos, estando 78 segundos abaixo da pontuação da implementação direta. De fato, map() é executado visivelmente, mas não excessivamente, mais rápido.

List comprehension

Você deve ter notado que cada execução do loop interno produz uma lista (que é adicionada à grade de solução como uma nova linha). O jeito do Python de criar listas é, claro, list comprehension. Vamos tentar isso, em vez de map().

def solve_list_comp(capacity, items, weights, values):

    grid = [[0] * (capacity+1)]
    for item in range(items):
        grid.append(grid[item].copy())
        this_weight = weights[item]
        this_value = values[item]
        
        grid[item+1][this_weight:] = 
            [max(grid[item][k], grid[item][k - this_weight] + this_value) 
             for k in range(this_weight, capacity+1)]
        
    solution_value = grid[items][capacity]
    solution_weight = 0
    taken = []
    k = capacity
    for item in range(items, 0, -1):
        if grid[item][k] != grid[item-1][k]:
            taken.append(item - 1)
            k -= weights[item - 1]
            solution_weight += weights[item-1]

    return solution_value, solution_weight, taken

O programa terminou em 81 segundos. Conseguimos outra melhoria e reduzimos o tempo de execução pela metade em comparação à implementação direta (180 s). Fora de contexto, isso seria elogiado como um progresso significativo. Infelizmente, ainda estamos a anos-luz do nosso benchmark de 0,4 s.

Arrays do NumPy

Por fim, esgotamos as ferramentas integradas do Python. Sim, posso ouvir o rugido do público cantando "NumPy! NumPy!" Mas, para apreciar a eficiência do NumPy, devemos colocá-lo em contexto, tentando for, map() e list comprehension de antemão.

Ok, agora é a hora do NumPy. Então, abandonamos as listas e colocamos nossos dados em arrays do NumPy:

def solve_list_comp_numpy(capacity, items, weights, values):

    grid = np.empty((items + 1, capacity + 1), dtype=int)
    grid[0] = 0
    for item in range(items):
        grid[item+1] = grid[item]
        this_weight = weights[item]
        this_value = values[item]
        
        grid[item+1, this_weight:] = 
            [max(grid[item, k], grid[item, k - this_weight] + this_value) 
             for k in range(this_weight, capacity+1)]

    solution_value = grid[items, capacity]
    solution_weight = 0
    taken = []
    k = capacity
    for item in range(items, 0, -1):
        if grid[item, k] != grid[item-1, k]:
            taken.append(item - 1)
            k -= weights[item - 1]
            solution_weight += weights[item-1]

    return solution_value, solution_weight, taken

De repente, o resultado é desencorajador. Este código é executado 1,5 vezes mais devagar do que a solução sem graça por list comprehension (123 s em comparação com os 81 s). Como isso?

Vamos examinar os perfis de linha para ambos solucionadores.

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
Vanilla list comprehension

   245         1       8212.0   8212.0      0.0  grid = [[0] * (capacity+1)]
   246
   247       101       1654.0     16.4      0.0  for item in range(items):
   248       100    1452204.0  14522.0      0.7      grid.append(grid[item].copy())
   249       100       1603.0     16.0      0.0      this_weight = weights[item]
   250       100        272.0      2.7      0.0      this_value = values[item]
   251
   252       100  202696910.0 2026969.1     99.3     grid[item+1][this_weight:] = [max(grid[item][k], grid[item][k - this_weight] + this_value) for k in range(this_weight, capacity+1)]

Using numpy arrays

   273         1         42.0     42.0      0.0  grid = np.empty((items + 1, capacity + 1), dtype=int)
   274         1       2527.0   2527.0      0.0  grid[0] = 0
   275       101       1427.0     14.1      0.0  for item in range(items):
   276       100     322952.0   3229.5      0.1      grid[item+1] = grid[item]
   277       100       1341.0     13.4      0.0      this_weight = weights[item]
   278       100        266.0      2.7      0.0      this_value = values[item]
   279       100  311244493.0 3112444.9     99.9     grid[item+1, this_weight:] = [max(grid[item, k], grid[item, k - this_weight] + this_value) for k in range(this_weight, capacity+1)]

A inicialização do grid[0] como um array do NumPy (linha 274) é três vezes mais rápida do que quando é feita com uma lista do Python (linha 245). Dentro do loop externo, a inicialização do grid[item+1] é 4,5 vezes mais rápida para um array do NumPy (linha 276) do que para uma lista (linha 248). Até agora, tudo bem.

No entanto, a execução da linha 279 é 1,5 vezes mais lenta do que seu análogo sem o NumPy na linha 252. O problema é que list comprehension cria uma lista de valores, mas armazenamos esses valores em um array do NumPy que é encontrado no lado esquerdo da expressão. Portanto, essa linha adiciona implicitamente uma sobrecarga de conversão de uma lista em um array do NumPy. Com a linha 279 respondendo por 99,9% do tempo de execução, todas as vantagens do NumPy observadas anteriormente tornam-se insignificantes.

Ainda precisamos, porém, de uma maneira de iterar por meio de arrays para fazer cálculos. Já aprendemos que list comprehension é a ferramenta de iteração mais rápida. A propósito, se você tentar construir um array do NumPy dentro de um bom e velho loop for, evitando a conversão de lista para array do NumPy, obterá o impressionante tempo de execução de 295 segundos. Então, estamos travados e o NumPy é inútil? Claro que não.

Uso adequado do NumPy

Apenas armazenar dados em arrays do NumPy não adianta. O verdadeiro poder do NumPy vem com as funções que executam cálculos em arrays do NumPy. Elas pegam arrays como parâmetros e retornam arrays como resultados.

Por exemplo, existe a função where(), que recebe três arrays como parâmetros: condition, x, e y, e retorna um array construído pela seleção de elementos de x ou de y. O primeiro parâmetro, condition, é um array de booleanos. Ele diz de onde escolher: se um elemento de condition for avaliado como True, o elemento correspondente de x é enviado para a saída, caso contrário, o elemento de y é selecionado.

Observe que a função do NumPy faz tudo isso em uma única chamada. Percorrer os arrays passa a ser um processo integrado.

É assim que usamos where() como um substituto do loop for interno no primeiro solucionador ou, respectivamente, o list comprehension do último:

def solve_numpy_func(capacity, items, weights, values):

    grid = np.empty((items + 1, capacity + 1), dtype=int)
    grid[0] = 0
    for item in range(items):
        this_weight = weights[item]
        this_value = values[item]
        grid[item+1, :this_weight] = grid[item, :this_weight]
        temp = grid[item, :-this_weight] + this_value
        grid[item + 1, this_weight:] = 
            np.where(temp > grid[item, this_weight:], 
                     temp, 
                     grid[item, this_weight:])

    solution_value = grid[items, capacity]
    solution_weight = 0
    taken = []
    k = capacity
    for item in range(items, 0, -1):
        if grid[item][k] != grid[item - 1][k]:
            taken.append(item - 1)
            k -= weights[item - 1]
            solution_weight += weights[item-1]

    return solution_value, solution_weight, taken

Existem três trechos de códigos interessantes: linha 8, linha 9 e linhas 11-13, conforme numeradas acima. Juntas, elas substituem o loop interno que percorreria todos os tamanhos possíveis de mochilas para encontrar os valores da solução.

Até que a capacidade da mochila atinja o peso do item recém adicionado ao conjunto de trabalho (this_weight), devemos ignorar esse item e definir os valores da solução para os do conjunto de trabalho anterior. Isso é bastante direto (linha 8):

grid[item+1, :this_weight] = grid[item, :this_weight]

Em seguida, construímos um array auxiliar temp (linha 9):

temp = grid[item, :-this_weight] + this_value

Esse código é análogo, mas muito mais rápido do que:

[grid[item, k — this_weight] + this_value
for k in range(this_weight, capacity+1)]

Ele calcula possíveis valores de solução se o novo item for levado para cada uma das mochilas que podem acomodar esse item.

Observe como o array temp é construído adicionando um escalar a um array. Esse é outro recurso poderoso do NumPy chamado "broadcasting". Quando o NumPy vê operandos com dimensões diferentes, ele tenta expandir (ou seja, "transmitir" – em inglês, broadcast) o operando de baixa dimensão para corresponder às dimensões do outro. Em nosso caso, o escalar é expandido para um array do mesmo tamanho que grid[item, :-this_weight] e esses dois arrays são somados. Como resultado, o valor de this_value é adicionado a cada elemento de grid[item, :-this_weight] — nenhum loop é necessário.

Na próxima parte (linhas 10–13), usamos a função where(), que faz exatamente o que é exigido pelo algoritmo: compara dois possíveis valores de solução para cada tamanho de mochila e seleciona aquele que é maior.

grid[item + 1, this_weight:] =             
    np.where(temp > grid[item, this_weight:],
             temp,
             grid[item, this_weight:])

A comparação é feita pelo parâmetro condition, que é calculado como temp > grid[item, this_weight:]. Essa é uma operação elementar que produz um array de valores booleanos, um para cada tamanho de uma mochila auxiliar. Um valor True significa que o item correspondente deve ser colocado na mochila. Portanto, o valor da solução obtido do array é o segundo argumento da função temp. Caso contrário, o item deve ser ignorado, e o valor da solução é copiado da linha anterior da grade - o terceiro argumento da função where().

Por fim, o motor de dobra foi ativado! Esse solucionador é executado em 0,55 s. Isso é 145 vezes mais rápido que o solucionador baseado em list comprehension e 329 vezes mais rápido que o código utilizando o loop for. Embora não tenhamos ultrapassado o solucionador escrito em Go (0,4 s), chegamos bem perto disso.

Alguns loops são pra ficar

Espere, mas e o loop for externo?

Em nosso exemplo, o código do loop externo, que não faz parte do loop interno, é executado apenas 100 vezes, para que possamos escapar sem mexer nele. No entanto, outras vezes, o loop externo pode ser tão longo quanto o interno.

Podemos reescrever o loop externo usando uma função do NumPy de maneira semelhante ao que fizemos para o loop interno? A resposta é não.

Apesar de ambos serem loops for, os loops externo e interno são bem diferentes no que fazem.

O loop interno produz um array 1D baseado em outro array 1D cujos elementos são todos conhecidos quando o loop começa. É essa disponibilidade prévia dos dados de entrada que nos permitiu substituir o loop interno por map(), list comprehension ou uma função do NumPy.

O loop externo produz um array 2D a partir de um array 1D, cujos elementos não são conhecidos quando o loop começa. Além disso, esses componentes de arrays são calculados por um algoritmo recursivo: podemos encontrar os elementos (i+1)º do array somente depois de encontrarmos o iº.

Suponha que o loop externo possa ser apresentado como uma função:
grid = g(row0, row1, … rowN)
Todos os parâmetros da função devem ser avaliados antes que a função seja chamada, mas somente row0 é conhecida de antemão. Como o cálculo da (i+1)ª linha depende da disponibilidade da i-ésima, precisamos de um loop indo de 1 a N para calcular todos os parâmetros da linha. Portanto, para substituir o loop externo com uma função, precisamos de outro loop que avalie os parâmetros dessa função. Esse outro loop é exatamente o loop que estamos tentando substituir.

A outra maneira de evitar o loop for externo é usar recursão. Pode-se facilmente escrever a função recursiva calculate(i) que produz a i-ésima linha da grade. Para fazer o trabalho, a função precisa conhecer a (i-1)ª linha, portanto, chama a si mesma como calculate(i-1) e, em seguida, calcula a i-ésima linha usando as funções do NumPy como fizemos anteriormente. Todo o loop externo pode então ser substituído por calculate(N). Para tornar a imagem completa, um solucionador de mochila recursivo pode ser encontrado no código-fonte que acompanha este artigo no GitHub.

No entanto, a abordagem recursiva claramente não é escalável. O Python não é otimizado para a recursão de cauda. A profundidade da pilha de recursão é, por padrão, limitada pela ordem de mil. Esse limite é certamente conservador, mas, quando exigimos uma profundidade de milhões, o estouro da pilha é altamente provável. Além disso, o experimento mostra que a recursão nem mesmo fornece uma vantagem de desempenho sobre um solucionador baseado em NumPy com o loop for externo.

É aqui que esgotamos as ferramentas fornecidas pelo Python e suas bibliotecas (pelo que sei). Se for absolutamente necessário acelerar o loop que implementa um algoritmo recursivo, será preciso recorrer ao Cython, ou a uma versão do Python compilada em JIT, ou a outra linguagem.

Aprendizados

• Faça cálculos numéricos com as funções do Numpy. Elas são duas ordens de magnitude mais rápidas do que as ferramentas integradas do Python.
• Das ferramentas integradas do Python, list comprehension é mais rápida que map(), que é significativamente mais rápido que for.
• Para algoritmos profundamente recursivos, os loops são mais eficientes do que as chamadas recursivas de funções.
• Você não pode substituir loops recursivos por map(), list comprehension ou uma função do NumPy.
• O código "burro" (dividido em operações elementares) é o mais lento. Use funções e ferramentas integradas.

Você está aqui porque:

1. Está usando o Windows 10, 11 ou superior
2. Gostaria de usar diversas versões do Python no mesmo computador
3. Está cansado de ver a internet dizer "basta usar o Virtualenv, ora"

Versão resumida

1. Abra o prompt de comando e digite pip install virtualenv
2. Faça o download da versão que quer do python (NÃO a adicione ao PATH!), e lembre-se do caminho\para\o\novo\executavel\do\python.exe para a versão recém-instalada
3. Para criar um virtualenv (ambiente virtual), abra o prompt de comando e digite
   virtualenv \caminho\para\o\novo\executavel\do\python.exe
4. Se estiver usando o PyCharm, atualize o interpretador de projetos e a inspeção de compatibilidade de código.
5. Para instalar os pacotes:
   (I) Ative o virtualenv: abra o prompt de comando e digite caminho\para\o\env\Scripts\activate.bat
   (II)  Instale os pacotes desejados
   (III)  Desative com deactivate.

Versão estendida

Prólogo

Se estiver usando a aplicação Anaconda,  este processo pode ser mais fácil usando a GUI de lá. Eu não tentei. Se alguém tentar, ficaria feliz de saber o resultado. 🙂

1. Instale o virtualenv

Se já estiver usando ambientes virtuais ou se estiver usando o Anaconda, certifique-se de que as próximas etapas estejam sendo realizadas fora de todos esses ambientes.

2. Instale o Python

Você pode baixar o Python do site oficial. Se quiser a versão python3.7.3, por exemplo, você pode baixá-la aqui.

Nota da tradução: a versão 3.7.3 acima é apenas um exemplo e era, possivelmente, a versão mais recente do Python quando a autora lançou este artigo. A versão mais recente (no momento da tradução) é a 3.11.4 e você pode baixá-la para o Windows aqui.

O arquivo que você baixará será um instalador executável do Windows versão x86–64 ou instalador executável do Windows x86 se, por algum motivo, você estiver usando uma versão do Windows de 32 bits.

Depois de concluir o download, abra o arquivo executável e um prompt de instalação se abrirá.

• Você NÃO deseja adicionar o novo Python ao seu PATH, pois vamos ter diversas versões do Python no mesmo computador. Queremos que cada aplicação conheça apenas uma versão do Python.
• Use o local padrão sugerido para o novo Python ou forneça um local que quiser. Seja como for, guarde bem esse local, o qual passaremos a chamar daqui para diante de C:\<um_caminho_qualquer>\Python37 .

3. Crie um virtualenv

Abra o prompt de commando ou, se estiver usando o Anaconda, abra o prompt do Anaconda.

Decida onde você quer que seu virtualenv esteja, por exemplo,
C:\Users\<seu_nome_de_usuário>\Anaconda3\envs\<nome_do_ambiente> .

Digite:

virtualenv C:\Users\<seu_nome_de_usuário>\Anaconda3\envs\<nome_do_ambiente> -p C:\<um_caminho_qualquer>\Python37\python.exe

4. Atualize o interpretador do PyCharm

Se estiver usando o PyCharm, abra o projeto no qual você gostaria de trabalhar (quer dizer, aquele que será escrito nessa nova versão do Python) e vá em File -> Settings -> Project -> Project Interpreter. Pressione o ícone da engrenagem e, a seguir, em Add....

Isso abrirá uma janela do prompt que permitirá a você definir um novo interpretador:

Assumindo que você está usando as inspeções de código (em inglês, Code Inspections), pode ser que você precise dizer ao PyCharm qual versão do Python ele deve inspecionar. Acesse File -> Settings-> Editor -> Inspections -> Python -> Code compatibility Inspection, garanta que a caixa na parte superior indica o projeto específico no qual você está trabalhando e marque a caixa de sua versão do Python.

5. Instale os pacotes

No momento, seu virtualenv contém apenas os pacotes cruciais, pip e setuptools. Para instalar mais pacotes:

1. Abra o prompt de comando ou o prompt do Anaconda e ative seu virtualenv digitando
   C:\Users\<seu_nome_de_usuário>\Anaconda3\envs\<nome_do_ambiente>\activate.bat
2. Use o pip para instalar os pacotes, como você faz normalmente.
3. Desative seu virtualenv digitando deactivate .

Epílogo

Hoje de manhã, quando decidi abrir um novo projeto com uma versão diferente do Python, pensei, "É isso! Basta usar o virtualenv", porque a internet disse que eu podia "simplesmente fazer isso".

Bem, está funcionando agora. Então, nada de rancor, querida internet, mas, vamos combinar, o "simplesmente" não foi um pouco demais, não? Em que parte reinstalar-o-PyCharm-somente-porque-eu-quero-ter-inspeção-de-código-decente se ajusta à categoria do "simplesmente"? Simples para quem?

Seja como for, durante o percurso, eu encontrei diversos guias úteis, mas cada um me conduziu "simplesmente" por uma etapa. Foi aí que decidi colocar tudo em um único lugar.

Espero que minha jornada tenha ajudado você com a sua e que possamos nos divertir com a programação, com o mínimo de atrito relacionado à instalação e configuração de coisas quanto possível. 😀

É necessário construir projetos para dominar o desenvolvimento de software.

Não um.

Nem dois.

Muitos projetos!

No entanto, você deve começar da maneira correta. Se você começar qualquer projeto aleatório como desenvolvedor iniciante ou júnior, não apenas se sentirá perdido como também começará a questionar se programação é para você. Portanto, trabalhe de maneira inteligente.

Comece do mais simples.

Primeiro, melhore sua confiança a partir de um projeto pequeno. Depois, de outro projeto pequeno. Depois de vários desses projetos pequenos, passe para algo maior e vá tão longe quanto sua imaginação permitir.

Antes de construir qualquer projeto, aprenda o básico

Se você não aprender o básico, você estará construindo sobre uma base frágil.

Independentemente do nível de domínio que você espera alcançar em Python, você precisará desses fundamentos antes de começar qualquer projeto.

Você precisa saber como:

• declarar variáveis
• receber dados inseridos pelo usuário
• armazenar informações
• repetir uma ação através de laços de repetição
• escrever funções para reaproveitar blocos de código

É basicamente isso.

Naturalmente, há mais a ser aprendido em Python, mas esse é o básico que você precisa saber. Será suficiente para você começar projetos para iniciantes.

Há aquela sensação tentadora de que você precisa terminar diversos tutoriais em Python antes de trabalhar em qualquer projeto.

Não siga por esse caminho.

Muitos caem na armadilha de seguir um tutorial atrás do outro até se sentirem ultrapreparados. Em vez disso, aprenda o básico primeiro. Em seguida, construa alguns projetos pequenos. Feito isso, volte a aprender com mais tutoriais.

Vá por mim, você pode terminar 100 tutoriais e ainda sentir que não está pronto para construir projeto algum.

Estudar por conta própria não é suficiente.

Você precisa aplicar o que aprendeu.

Como fazer uso desses projetos

• Primeiro, leia as instruções e certifique-se de que as entendeu. Tente expressar com suas próprias palavras o que tiver entendido delas.
• Tente solucionar o problema por conta própria sem buscar um tutorial no YouTube ou um código semelhante no GitHub. Provavelmente, vai ser difícil. Tudo bem. Dê o seu melhor. Essa é a ideia de prática deliberada (texto em inglês) da Psicologia Comportamental.
• Se você não conseguiu progredir por conta própria, assista ao tutorial do YouTube e veja o código de exemplo. Você também pode pesquisar na internet por mais tutoriais de exemplo e outros códigos em Python que visam resolver o mesmo problema.
• Depois disso, tente dar um passo atrás e escrever o código sozinho sem olhar o tutorial. De novo: dê o seu melhor. Esse é o chamado grit (às vezes traduzido como garra), também da Psicologia Comportamental (vídeo com legenda em português disponível). Você precisa disso.
• Em hipótese alguma você deve copiar cegamente o código do tutorial e se dar por satisfeito. Você até pode terminar o projeto rapidamente, mas a realidade é que você não aprendeu nada.
• Se você por acaso sentir que está travado após várias tentativas, faça uma pausa. Sabemos pelas pesquisas neurocientíficas (texto em inglês) que o nosso subconsciente continua aprendendo mesmo quando paramos. Isso acontece porque nossa mente muda do modo focado para o modo difuso.
• Quando conseguir resolver um problema, comemore! É importante ter esse reforço positivo para construir referências do seu sucesso. No futuro, quando sua mente disser "Você não vai conseguir" e fizer você duvidar do seu potencial, você pode responder a ela: "não é verdade; e eis a prova de que consegui no passado e vou conseguir agora também".
• Repita, repita, repita.

Você também poderá usar essas dicas para outros projetos além dos que serão listados abaixo. Agora, vamos aos projetos em Python.

Projetos para desenvolvedores juniores de Python

Aqui estão alguns projetos amigáveis para iniciantes que você pode desenvolver:

1. Par ou ímpar
2. Jogo Mad Libs
3. Contador de palavras
4. Informações biográficas
5. Qual é a sigla?
6. Pedra, papel, tesoura
7. Adivinhar o número
8. Verificador de palíndromo
9. Calculadora de gorjeta
10. Divisor de e-mail
11. Gerador de letras de música

Par ou ímpar

Dê boas-vindas ao usuário e peça-o para inserir um número de 1 a 1000.

Depois de o usuário informar o número, verifique se ele é par ou ímpar e diga ao usuário.

Exemplo:

• Mensagem: Em qual número você pensou?
• Entrada: 25
• Saída: Esse é um número ímpar! Gostaria de verificar outro?

Jogo Mad Libs

Peça ao usuário para informar alguns valores.

Eles podem ser qualquer coisa como um nome, um adjetivo, um pronome ou mesmo uma ação. Uma vez recebidos esses valores, reorganize-os e crie uma história.

• Aqui temos um tutorial no YouTube de como criar um jogo Mab Libs usando o Python (vídeo em inglês).
• Aqui, você verá  um código de exemplo no Github.

Contador de palavras

Peça ao usuário que informe em uma frase algo em que ele pensou. Depois, conte o número de palavras na sentença informada e mostre esse valor na tela.

Examplo:

• Mensagem: Informe em uma frase algo em que você pensou hoje .
• Entrada: Bem, é só mais um dia para eu ser um profissional em programação .
• Saída: Legal! Você acabou de me dizer no que pensou usando 13 palavras!

Para dar um passo mais adiante: abra um arquivo com conteúdo textual nele, conte o número de palavras no texto e mostre esse valor na tela.

Eis aqui um código de exemplo no Github.

Informações biográficas

Faça algumas perguntas pedindo informações sobre o usuário. Em seguida, verifique se as informações inseridas são válidas. Por fim, mostre um resumo de todas as informações que foram introduzidas.

Exemplo: Qual é o seu nome? Se o usuário informar *, a aplicação deve informar que esse é um nome inválido e pedir que o usuário informe um nome válido.

Ao final, deve ser exibido na tela um resumo como este:

- Nome: João da Silva
- Data de nascimento: 1 de Janeiro de 1954
- Endereço: Avenida das flores, 1500, São Paulo
- Objetivos: Ser o melhor programador que já existiu.

Qual é a sigla?

Peça ao usuário para informar um conceito ou o nome de alguma organização. A aplicação deve retornar uma sigla adequada. Por exemplo:

• Entrada -> O Mais Rápido Possível. Saída -> OMRP.
• Entrada -> Organização Mundial da Saúde. Saída -> OMS.
• Entrada -> Ausência Sem Justificativa. Saída -> ASJ.

Pedra, papel, tesoura

Esta é uma brincadeira popular entre duas pessoas. Cada jogador usa uma das mãos para formar uma das seguintes opções:

• pedra (mão fechada)
• papel (mão aberta)
• tesoura (estender apenas os dedos indicador e médio da mão em formato de V)

Veja aqui um tutorial no YouTube sobre como programar um jogo de pedra-papel-tesoura em Python (vídeo em inglês).

Adivinhar o número

A aplicação deve pedir ao usuário para adivinhar um número entre 1 e 50.

Se o usuário informar um número fora desse intervalo, deve ser exibida uma mensagem de erro lembrando-o dos valores aceitos.

Sempre que o usuário errar o número, a aplicação deve perguntar se ele gostaria de tentar novamente ou de desistir.

Se o jogador conseguir acertar o número, parabenize-o e exiba o número de tentativas que ele fez até acertar.

Você pode conferir aqui um tutorial no YouTube para programar um jogo de adivinhar o número em Python (vídeo em inglês).

Verificador de palíndromo

Peça ao usuário que informe cinco palavras. Em seguida, verifique se alguma das cinco palavras é um palíndromo.

Um palíndromo é uma palavra que permanece a mesma, caso seja lida da esquerda para a direita ou no sentido inverso.

Exemplo:

• radar é um palíndromo.
• salas também é.
• geeks não é.

Aqui temos um código de exemplo no Github para esse projeto.

Calculadora de gorjeta

O objetivo dessa aplicação é calcular o quanto de gorjeta deve-se pagar pelo serviço. Nesse cenário, é preciso pedir pelo valor total da conta. Depois, é preciso exibir na tela as opções de gorjeta: 18%, 20% ou 25% do valor total da conta.

Exemplo:

• Mensagem: Qual o valor total da conta?
• Entrada: R$ 55,87
• Saída: 18% de gorjeta equivale a R$ 10,06; o que aumenta o total a ser pago para R$65,93

Lembre-se de arredondar os valores para cima para ter números mais amigáveis. Se quiser ir mais além, pode perguntar o número de pessoas envolvidas para dividir igualmente o valor da conta e da gorjeta entre eles.

Se quiser ir mais longe ainda, faça essa divisão de valores de maneira proporcional. Por exemplo: uma pessoa paga 70% do valor e outra paga 30%.

Divisor de e-mail

Receba o endereço de e-mail do usuário e verifique se ele tem um domínio próprio ou popular. Por exemplo:

• Entrada: mary.jane@gmail.com
• Saída: Olá, Mary. Vejo que seu e-mail está registrado no Google. Que bacana!.
• Entrada: peter.pan@myfantasy.com
• Saída: Oi, Peter. Parece que você tem sua própria configuração personalizada no MyFantasy. Impressionante!.

Esse é um projeto em Python bem útil e que pode ser bastante usado futuramente. O programa ajuda a obter o nome de usuário e o nome do domínio de um endereço de e-mail.

Se quiser ir mais adiante, você pode personalizar a aplicação para enviar uma mensagem para o host com essa informação.

Você pode conferir este tutorial no YouTube (vídeo em inglês) e este exemplo de código no Github sobre o projeto.

Gerador de letras de música

Peça ao usuário para escolher uma música de uma lista de 10 músicas exibidas. Depois de o usuário fazer isso, exiba a letra da música selecionada.

Exemplo:

Seja bem-vindo. Por favor, selecione uma dentre as 10 músicas a seguir:

1. Baby, de Justin Bieber
2. Hotline Bling, de Drake
3. Flawless, de Beyonce
4. Fall, de Eminem

Você escolheu Flawless, de Beyonce. Aqui está a letra da música:

---------- Flawless, de Beyonce ------------
I'm out that H, town coming coming down
I'm coming down, drippin' candy on the ground
H, Town, Town, I'm coming down, coming down
Drippin' candy on the ground...

Pressione * para escolher outra música.

Para desenvolver mais o projeto, tenha pelo menos 3 músicas para cada artista.

Assim, peça para o usuário escolher pelo nome do artista e depois selecionar uma música daquele mesmo artista. Assim, o usuário pode escolher uma música específica da lista exibida.

Finalizando

Trabalhando nesses projetos, você pode se deparar com alguns obstáculos e ficar completamente desanimado. Mantenha a calma. Você consegue.

Lembre-se: faça uma pausa e tente de novo mais tarde. Você também pode ler estas histórias de diversos programadores (texto em inglês) que conseguiram manter a motivação e seguir adiante.

Desenvolvimento de software é uma área difícil, mas tem muitas recompensas.

Se tantos outros conseguiram, você também consegue.

Obrigado pela leitura

Se gostou deste texto, pode conferir outros como ele.

• Junte-se à comunidade do autor via e-mail: lá, ele compartilha técnicas para que novos programadores e desenvolvedores juniores cresçam mais rapidamente e melhorem sua confiança. Se tiver interesse, faça parte da comunidade.
• Siga o autor no Twitter: Quer mais dicas rápidas? Ou, por acaso, tem alguma pergunta? O autor é bastante ativo no Twitter, então fique à vontade para entrar em contato com ele. Ele deixa a  DM aberta para conversas.

Atenção — o autor é apaixonado por pesquisa. Por isso, ele adverte que tem uma tendência a usar abordagens e conceitos da Psicologia Comportamental e da Neurociência.

Em Python, uma string é uma sequência de caracteres que podem ser especiais ou alfanuméricos.

Um exemplo de string é: "nos vemos na sexta-feira" (em inglês, we meet on Friday). Você pode acessar subpartes específicas da string, que são popularmente conhecidas como substrings.

Podemos definir uma substring como sendo uma sequência de caracteres dentro de uma string. Usemos a frase anterior como exemplo. No Python, poderíamos considerar como substrings as partes "sexta-feira", "na" e "vemos".

Como criar uma substring em Python

O Python nos fornece diferentes maneiras e métodos para criarmos uma substring, para verificarmos se uma substring está presente, para obtermos o índice de uma substring, entre outras funcionalidades.

Você pode extrair uma substring de uma string recortando-a com índices que obtêm sua substring da seguinte maneira:

string[começo:fim:passo]

• começo — O índice inicial da substring. O caractere deste índice estará incluso no recorte.
• parada — O índice final da substring. O caractere deste índice serve apenas como ponto de parada e não estará incluso no recorte.
• passo — O número que determina o intervalo do recorte. O valor padrão é 1.

Os valores dos índices podem ser positivos ou negativos. Índices positivos começam do início e vão até o final da string, enquanto que índices negativos começam do final e vão até o início da string.

Neste artigo, você aprenderá como executar várias operações relacionadas às substrings em Python.

Como obter os primeiros n caracteres de uma string em Python

Este exemplo nos mostra como recortar os primeiros 5 caracteres da string:

string = "hello world"
print(string[:5])

Aqui definimos o índice de parada como 5. O índice de começo é 0 por padrão.

A saída é: 'hello'.

Como obter os caracteres do meio de uma string usando substrings em Python

Este exemplo nos mostra como recortar os caracteres a partir do índice 3 até o índice 5 de uma string:

string = "hello world"
print(string[3:5])

A saída é: 'lo'.

Como obter o último caractere de uma string em Python

Para obter o último caractere, basta usar o índice -1 (índice negativo). Vejamos o seguinte exemplo:

string = "freecodecamp"
print(string[-1])

A saída será: 'p'.

Como obter os últimos n caracteres de uma string em Python

Neste exemplo, recortaremos os últimos 4 caracteres da string. Aqui, usamos o índice negativo para começarmos o recorte a partir do final da string.

string = "freecodecamp"
print(string[-4:])

A saída será: 'camp'.

Como recortar a string com passos usando substrings em Python

Podemos indicar o passo no recorte da string após indicarmos os índices de começo e de parada. Por padrão, o passo tem valor 1. No exemplo a seguir, porém, usaremos o passo com valor 2.

string = "welcome to freecodecamp"
print(string[::2])

A saída será: 'wloet fecdcm'. Isso porque, com passo 2, recortamos de 2 em 2 caracteres.

Como verificar se uma substring está presente em uma string em Python

Às vezes, gostaríamos de verificar se uma substring está presente em uma string. O exemplo a seguir verificará se a substring 'code' faz parte da string:

substring = "code"
string = "welcome to freecodecamp"
print(substring in string)

Se a substring definida estiver presente na string, o retorno será True. Do contrário, será False.

Nesse caso, a saída será: True. Isso acontece porque 'code' faz parte de 'freecodecamp'.

Outra maneira de verificar se uma substring está presente em uma string em Python

Podemos usar o método find() para verificar se encontramos a substring desejada na string.

Vejamos o seguinte exemplo:

substring = "zz"
string = "hello world"
print(string.find(substring))

Se a substring for encontrada na string, o retorno será o índice em que a substring começa. Se não for encontrada, o método retorna -1.

Neste caso, a saída é: -1. Isso significa que "zz" não está faz parte de "hello world".

Como obter o caractere de um determinado índice em uma string em Python

Podemos passar o índice de um caractere específico para recortá-lo.

string ="hello world"
print(string[4])

A saída será: 'O', que é o caractere presente na posição 4.

Como criar uma lista de substrings a partir de uma string em Python

Podemos usar o método split() para criarmos uma lista de substrings. Vejamos sua aplicação no seguinte exemplo:

string = "welcome to freecodecamp platform"
print(string.split())

A saída será: ['welcome', 'to', 'freecodecamp', 'platform'].

Como inverter uma string em Python usando passo negativo

Para inverter a string, o passo deve ter um valor negativo, por exemplo: -1.

string = "welcome to freecodecamp"
print(string[::-1])

A saída será: 'pmacedoceerf ot emoclew'.

Como contar quantas vezes uma substring está presente em uma string em Python

Podemos usar o método count() para sabermos quantas vezes uma determinada substring aparece em uma string.

string = "we will have a quick coding lesson this afternoon"
print(string.count('noon'))

A saída será: 1.

Considerações finais sobre substrings em Python

Parabéns por chegar ao final deste artigo. 👏👏 Espero que você tenha aprendido algo novo sobre substrings em Python.

Se você, de fato, aprendeu algo novo ou se gostou de ler este artigo, compartilhe-o para que outras pessoas também possam lê-lo. Até lá, nos vemos no próximo artigo!

Você também pode encontrar o autor no Twitter e ler mais artigos como este aqui (textos em inglês).