A análise de dados moderna exige ferramentas que equilibrem automação, flexibilidade e poder computacional. Um cientista de dados que precisa processar grandes volumes de informações pode optar por uma abordagem visual e automatizada no KNIME, simplificando a construção de workflows sem a necessidade de codificação manual. Por outro lado, se for necessário desenvolver um modelo preditivo altamente customizado, Python oferece bibliotecas poderosas como Scikit-learn e TensorFlow. Enquanto o KNIME se destaca pela interface intuitiva e facilidade de automação, Python brilha na flexibilidade e capacidade de personalização, permitindo controle total sobre algoritmos e análises complexas.

Por essas características tão distintas, o cientista de dados precisa escolher entre uma plataforma ou outra? Por que não aproveitar o melhor de ambas? KNIME e Python são duas das plataformas mais utilizadas por cientistas de dados, cada uma com suas vantagens e particularidades. Mas, em vez de escolher entre elas, que tal combiná-las para potencializar suas análises? Neste artigo, exploramos como integrar KNIME e Python para criar workflows mais eficientes, customizáveis e poderosos, combinando a automação visual do KNIME com a flexibilidade e o vasto ecossistema de bibliotecas do Python.

 Vantagens de Usar KNIME e Python Juntos

Integrar KNIME e Python em um mesmo fluxo de trabalho permite que cientistas de dados aproveitem o melhor dos dois mundos: a praticidade da abordagem visual do KNIME e a flexibilidade do código em Python. Essa combinação oferece mais eficiência, personalização e escalabilidade para diferentes tipos de projetos.

• Automatização e flexibilidade: A combinação de KNIME e Python equilibra automatização e flexibilidade, proporcionando uma abordagem poderosa para análise de dados. Com KNIME, é possível construir workflows de forma visual e intuitiva, eliminando a necessidade de codificação manual para muitas tarefas, como limpeza e transformação de dados. No entanto, quando são necessárias personalizações mais avançadas, Python entra em cena, permitindo a criação de algoritmos específicos, manipulação detalhada de dados e uso de bibliotecas especializadas. Dessa forma, o cientista de dados pode automatizar processos repetitivos no KNIME e, ao mesmo tempo, manter a liberdade para desenvolver soluções complexas com Python.

• Redução do tempo de desenvolvimento: A utilização combinada de KNIME e Python reduz significativamente o tempo de desenvolvimento de soluções analíticas. Os workflows padronizados do KNIME facilitam a modelagem e execução de processos repetitivos, eliminando a necessidade de escrever código do zero para cada nova tarefa. Além disso, sua interface visual permite rápida prototipagem e ajustes, tornando o desenvolvimento mais ágil e colaborativo. Ao mesmo tempo, a integração com Python amplia as possibilidades de customização, permitindo que refinamentos específicos sejam implementados sem comprometer a estrutura automatizada do fluxo de trabalho. Dessa forma, equipes podem equilibrar eficiência e flexibilidade, acelerando o ciclo de desenvolvimento e garantindo que modelos e análises atendam às necessidades do negócio de maneira otimizada.

• Aproveitamento de bibliotecas poderosas: A integração entre KNIME e Python permite o uso de bibliotecas populares e altamente eficientes para análise de dados, aprendizado de máquina e visualização. Com essa sinergia, é possível incorporar ferramentas como pandas, para manipulação avançada de dados; scikit-learn, para a criação e avaliação de modelos de machine learning; e seaborn, para gerar visualizações estatísticas sofisticadas. Essa flexibilidade garante que workflows no KNIME possam usufruir do melhor dos dois mundos: a praticidade da modelagem visual e a robustez dos pacotes Python. Dessa forma, analistas e cientistas de dados podem realizar desde operações simples de limpeza e transformação até implementações avançadas de algoritmos personalizados, tudo dentro do ambiente estruturado e automatizado do KNIME.

• Melhor colaboração entre equipes: A integração entre KNIME e Python promove um ambiente de trabalho colaborativo, onde tanto profissionais técnicos quanto não técnicos podem contribuir de forma eficiente para os projetos de análise de dados. A interface intuitiva e visual do KNIME permite que usuários sem experiência em programação construam e executem workflows complexos sem a necessidade de escrever código. Isso facilita a participação de especialistas de diferentes áreas, como negócios, marketing e operações, na criação e interpretação de análises. Ao mesmo tempo, desenvolvedores e cientistas de dados podem expandir as capacidades do KNIME ao incorporar scripts Python personalizados, adicionando funcionalidades avançadas e otimizando o desempenho das soluções. Esse equilíbrio entre acessibilidade e flexibilidade melhora a comunicação entre as equipes, acelera a implementação de projetos e garante que as soluções sejam compreendidas e utilizadas por todos os envolvidos.

3. Casos de Uso Combinados

A integração entre KNIME e Python possibilita uma ampla gama de aplicações em diferentes áreas, combinando a automação dos workflows visuais com o poder analítico do código Python. Essa sinergia permite desde tarefas simples, como pré-processamento de dados, até projetos avançados envolvendo aprendizado de máquina, otimização e visualização interativa. Ao explorar casos de uso combinados, é possível entender como essa abordagem pode melhorar a eficiência, a precisão e a escalabilidade das soluções desenvolvidas.

• Processamento Avançado de Dados: Ao trabalhar com grandes volumes de dados, muitas vezes é necessário realizar limpezas e transformações personalizadas antes da análise. No KNIME, podemos estruturar um fluxo de trabalho visual para carregamento e manipulação inicial dos dados e, quando for necessário um tratamento mais detalhado, integrar scripts Python utilizando a biblioteca pandas. Por exemplo, considere um conjunto de dados de vendas que apresenta problemas comuns, como valores ausentes e formatação inconsistente:

• Valores ausentes na coluna Valor_Transacao
• Datas no formato incorreto
• Categorias de produtos inconsistentes (nomes com variações)

Para garantir que os dados estejam limpos e padronizados antes da análise de desempenho de vendas, podemos estruturar um fluxo no KNIME da seguinte forma:

1. Leitura dos Dados – Utilizamos o nó File Reader ou Excel Reader para importar os dados brutos.
2. Pré-processamento Visual – Aplicamos nós como Missing Value para tratar valores ausentes de maneira básica.
3. Execução de Script Python – Inserimos um nó Python Script para realizar transformações mais complexas com pandas.
4. Saída e Continuidade – Após o processamento, os dados transformados podem ser utilizados em outros nós do KNIME para análise ou visualização.

Essa abordagem permite unir a praticidade do KNIME com a flexibilidade do Python, garantindo um processamento de dados mais eficiente e automatizado.

• Modelos de Machine Learning Customizados: A integração entre KNIME e Python permite a criação de modelos de machine learning personalizados, combinando a facilidade dos workflows visuais com a flexibilidade do scikit-learn. No KNIME, podemos estruturar um fluxo para preparar os dados, enquanto o Python Script permite a implementação de algoritmos específicos de aprendizado de máquina. Por exemplo, ao prever a rotatividade de clientes (churn), um modelo pode ser treinado utilizando scikit-learn, aplicando técnicas como Random Forest ou Regressão Logística. Podemos estruturar um fluxo no KNIME assim:

1. Pré-processamento de Dados – Importamos os dados e utilizamos nós como Normalization e Missing Value para limpeza e padronização.
2. Treinamento do Modelo – Inserimos um nó Python Script para treinar um modelo personalizado com scikit-learn.
3. Avaliação – Calculamos métricas como Acurácia e Matriz de Confusão para validar o desempenho.
4. Implantação – Utilizamos o modelo treinado dentro do workflow para prever novos dados.

Essa abordagem combina a automação do KNIME com o poder do scikit-learn, permitindo modelos mais precisos e customizados dentro de um ambiente estruturado e intuitivo.

4. Como Integrar Python no KNIME

A integração do Python no KNIME amplia as possibilidades de análise e modelagem de dados, combinando a automação dos workflows visuais com a flexibilidade da programação. Com o nó “Python Script”, é possível executar códigos Python diretamente dentro do fluxo de trabalho, permitindo desde manipulações avançadas de dados até a implementação de modelos de machine learning personalizados.

Para garantir uma configuração eficiente e compatível com as principais bibliotecas utilizadas em ciência de dados, a melhor opção é instalar o Anaconda Python. Ele oferece um ambiente gerenciado que já inclui pacotes essenciais, como pandas, scikit-learn, seborn, matplotlib e muitos outros, além de facilitar a criação de ambientes virtuais específicos para o KNIME. Nesta seção, veremos o passo a passo para configurar essa integração e aproveitar todo o potencial do Python dentro do KNIME.

• Configuração do Ambiente: Para integrar Python ao KNIME, é essencial configurar um ambiente compatível com as principais bibliotecas utilizadas em ciência de dados. A melhor opção para isso é instalar o Anaconda Python, que facilita o gerenciamento de pacotes e ambientes virtuais.

As etapas básicas para essa configuração incluem:

1. Instalar o Anaconda Python – Disponível para Windows, Linux e macOS, garantindo compatibilidade com as bibliotecas necessárias (https://anaconda.org/).
2. Criar um ambiente dedicado ao KNIME – Utilizar o conda para configurar um ambiente específico com pandas, scikit-learn, matplotlib, entre outras bibliotecas.
3. Configurar o KNIME para utilizar o ambiente Python – Ajustar as preferências no KNIME para que ele reconheça o interpretador Python correto.
4. Garantir compatibilidade e atualização – Manter o ambiente atualizado para evitar problemas de dependências.

Com essa configuração, o KNIME pode executar scripts Python diretamente dentro dos workflows, combinando automação visual com a flexibilidade do código. Para um guia detalhado sobre a instalação e configuração, este tema será abordado no curso específico sobre KNIME e Python.

• O uso do Nó Python Script: O KNIME oferece dois tipos de nós para executar códigos Python: o Python Script, que processa e transforma dados, e o Python View, que permite gerar visualizações personalizadas dentro do workflow. Um caso prático desse uso é a construção de uma matriz de correlação utilizando o nó Python View, que possibilita gerar gráficos customizados dentro do KNIME com matplotlib e seaborn. Suponha que estamos analisando um conjunto de dados que contém informações sobre investimentos em anúncios nos canais TV, rádio e jornal, além do volume de vendas associadas a essas campanhas. Nosso objetivo é identificar quais canais de publicidade têm maior impacto sobre as vendas, analisando a matriz de correlação entre essas variáveis. Para isso, podemos estruturar um workflow no KNIME com os seguintes passos:
• Importação dos Dados – Utilizamos o nó File Reader ou CSV Reader para carregar os dados de investimento e vendas.
• Pré-processamento – Aplicamos transformações iniciais, como tratamento de valores nulos e normalização, se necessário.

• Execução do Python View – Usamos o nó Python View para calcular a correlação e gerar um heatmap interativo.

Saída e Análise – O KNIME exibe o heatmap gerado diretamente no workflow, facilitando a interpretação das correlações.

Com essa abordagem, podemos identificar se o investimento em TV, rádio ou jornal tem maior impacto nas vendas, ajudando na otimização de campanhas publicitárias. Essa integração entre KNIME e Python torna a análise mais dinâmica e visual, sem a necessidade de ferramentas externas.

A integração entre KNIME e Python combina o melhor dos dois mundos: a praticidade dos workflows visuais do KNIME com a flexibilidade e o poder computacional do Python. Com os nós Python Script e Python View, é possível realizar desde manipulações avançadas de dados até a criação de modelos de machine learning e visualizações personalizadas. Essa sinergia permite automatizar processos, personalizar análises e aumentar a eficiência na tomada de decisões, tornando o KNIME uma plataforma ainda mais robusta para ciência de dados.

5. Melhores Práticas para uma Integração Eficiente

Para garantir que a integração entre KNIME e Python seja fluida, eficiente e escalável, é fundamental adotar algumas boas práticas. A organização do código, a escolha adequada dos nós Python, o gerenciamento de dependências e a otimização do desempenho são aspectos essenciais para evitar erros e garantir um fluxo de trabalho robusto. Nesta seção, exploramos dicas e estratégias para maximizar o potencial da integração, tornando workflows estruturados, reutilizáveis e fáceis de manter.

• Quando usar apenas KNIME e quando recorrer ao Python: Uma das chaves para uma integração eficiente entre KNIME e Python é saber quando utilizar cada ferramenta. O KNIME é ideal para tarefas que podem ser resolvidas de forma visual e automatizada, como pré-processamento de dados, junção de tabelas e modelagem básica, sem a necessidade de escrever código. Um bom exemplo disso é o uso do nó Missing Value para preencher automaticamente valores ausentes em um conjunto de dados. Já o Python deve ser utilizado quando há necessidade de maior flexibilidade, como o desenvolvimento de modelos de machine learning personalizados, manipulações avançadas de dados com pandas ou a criação de visualizações complexas com matplotlib e seaborn. Por exemplo, combinar estratégias de modelagem que os nós específicos do KNIME não realizam, como o ajuste fino de hiperparâmetros com GridSearchCV do scikit-learn. Por fim, o equilíbrio entre ambos garante workflows mais organizados e eficientes, aproveitando ao máximo cada ferramenta.

• Como organizar código e workflows para melhor manutenção: Uma boa organização de código e workflows no KNIME é essencial para garantir a manutenção, reutilização e escalabilidade dos projetos. No KNIME, uma prática recomendada é estruturar o workflow de forma modular, separando etapas como ingestão de dados, pré-processamento, modelagem e visualização em seções distintas, utilizando Meta Nodes ou Componentes para facilitar a organização. Um exemplo disso é agrupar todas as transformações de dados dentro de um Meta Node, tornando o fluxo mais limpo e compreensível. Já no Python, é importante seguir boas práticas de codificação, como a organização do código em funções reutilizáveis, o uso de docstrings para documentação e a separação de scripts conforme sua função. Por fim, documentar cada etapa do workflow no KNIME, utilizando anotações e descrições nos nós, facilita a colaboração e evita retrabalho. Ao combinar essas práticas, garantimos workflows bem estruturados, fáceis de entender e manter ao longo do tempo

• Dicas para otimizar a performance e evitar gargalos: Para garantir que workflows no KNIME e scripts em Python rodem de forma eficiente, é fundamental adotar algumas estratégias de otimização. No KNIME, uma das melhores práticas é minimizar o uso de nós desnecessários e processar apenas os dados essenciais, filtrando colunas e registros logo no início do fluxo. Um exemplo disso é utilizar o nó “Row Filter” para remover dados irrelevantes antes de operações mais pesadas, reduzindo o volume de processamento. Além disso, sempre que possível, utilizar nós nativos do KNIME, pois eles são otimizados para melhor desempenho em comparação com execuções externas. No Python, a performance pode ser aprimorada ao evitar loops desnecessários e priorizar operações vetorizadas com pandas e numpy. Um exemplo prático disso é substituir um loop for por uma operação eficiente com a função apply(). Outra dica essencial é gerenciar corretamente o uso de memória, limitando a quantidade de dados carregados em cada etapa e utilizando formatos compactados, como Parquet, para armazenar arquivos temporários. Por fim, monitorar a execução do workflow e identificar gargalos através do KNIME Timer Info ou logs do Python ajuda a detectar pontos de lentidão e aprimorar a eficiência do processamento. Aplicando essas práticas, conseguimos fluxos de trabalho mais rápidos, leves e escaláveis.

5. Conclusão

A integração entre KNIME e Python oferece uma abordagem poderosa para análise de dados, combinando a automação visual do KNIME com a flexibilidade e o vasto ecossistema de bibliotecas do Python. Ao longo deste artigo, exploramos como essa combinação permite maior eficiência no processamento e modelagem de dados, reduzindo o tempo de desenvolvimento e ampliando as possibilidades analíticas. Vimos como configurar e otimizar a integração entre as ferramentas, vimos também casos de uso práticos, como a limpeza avançada de dados com pandas e a construção de modelos personalizados com scikit-learn. Discutimos ainda, boas práticas para organizar workflows e código, garantindo escalabilidade e manutenção facilitada, além de estratégias para otimizar a performance e evitar gargalos. Ao aplicar essas técnicas, cientistas de dados e analistas podem construir soluções mais ágeis, poderosas e colaborativas, aproveitando o melhor de cada tecnologia.

A integração entre KNIME e Python une o melhor dos dois mundos: a praticidade dos workflows visuais e a flexibilidade da programação. Com boas práticas de estruturação, manutenção e otimização, é possível criar soluções escaláveis, eficientes e acessíveis a diferentes perfis de profissionais. Essa combinação torna a análise de dados mais produtiva e inovadora, proporcionando insights mais rápidos e precisos para a tomada de decisão.

É fácil perceber então que, KNIME e Python não são ferramentas concorrentes, mas complementares. Utilizando o melhor de cada uma, cientistas de dados podem otimizar suas análises, acelerar processos e obter insights mais refinados. Integrar ambas as tecnologias é um diferencial para profissionais que desejam combinar eficiência e personalização em seus projetos. 

Se você deseja experimentar o KNIME e entender como ele pode transformar seu fluxo de trabalho, fique atento! Em breve, realizaremos uma live para demonstrar suas funcionalidades e apresentar um treinamento exclusivo para quem deseja aprofundar seus conhecimentos na ferramenta.

Webinar

Quer ver isso na prática? No próximo dia 11/03, vamos ter uma Live demosntrando como implementar um modelo de Chrun utilizando o Knime.

Evento Online e 100% Gratuito, basta acessar o link  abaixo e se inscrever na nossa live.

Link Live

Muito Obrigado.

Rodrigo Viera.

Quando falamos em API, as pessoas pensam muito em ferramentas, porém se esquecem que o mais importante é entender a API, saber qual é o método, se tem algum token, qual o seu Header, e por ai vai.

E a minha dica é sempre começar pelo Postman ou Insominia para tentar retornar os dados primeiramente.

Neste exemplo iremos demonstrar como extrair dados de uma api via Python, se você está procurando fazer essa tarefa sem utilizar uma linha de código recomendo ver o nosso artigo sobre como fazer isso utilizando o Pentaho.

Para o nosso exemplo, iremos utilizar a API de Cotação de moedas.

Link:https://docs.awesomeapi.com.br/api-de-moedas

O link baixo está retornando os seguintes dados:

https://economia.awesomeapi.com.br/json/last/EUR-BRL

Percebam que o link retorna os dados num formato json, como é uma API simples na própria url já temos o retorno dos dados mas o normal é termos que usar o Postman por exemplo para entender como a API funciona:

Percebam que retornou os mesmos dados, porém se tivesse token, header ou até mesmo parametros só conseguiriamos obter o retorno dos dados no Postman, então sempre começar por essa etapa.

Uma vez que já conseguimos retornar os dados, vamos para o Python.

No meu ex estou utilizando o Pycharm, mas poderia ser o Vs Code, ou qualquer outra IDE ou notebook.

Para o nosso ex: iremos utilizar duas bibliotecas do Python, requests para API e pandas para trabalhar com os dados.

Segue o Script abaixo:

# Importanto as bibliotecas que serão utilizadas
import requests
import pandas as pd

## add a url em uma varaivel
url = "https://economia.awesomeapi.com.br/last/EUR-BRL"
print(url)
## Aqui iremos fazer o mesmo processo que fizemos no Postman só que no Python para obter dados a partir de uma URL
results = requests.get(url)
data = results.json()
## Aqui estamos criando um DataFrame com base nos dados que retonaram da apip
df = pd.DataFrame(data['EURBRL'],index=[0])
print(df)





















Essas são só algumas possibilidades de se trabalhar com Python.
Muito Obrigado e até o próximo artigo!!

Tudo bem contigo?

Nesse sábado, 20/05/2023, tivemos o 1º dia do nosso mais novo treinamento, Python para Engenheiro de dados, aplicado pelo instrutor Leandro Silva.

Neste sábado foram abordados os seguintes temas:

• Criação da conta na Google Cloud.
• Utilizamos o IAM para criar as permissões e acessos.
• Criação de um banco de dados na nuvem, no caso o PostgreSQL.
• Conectamos no Bando de dados via Dbeaver
• Instalação do Python e também Vscode
• Conectamos no Postgres utilizando o Python.
• Criação da camada raw(bronze) do nosso data lake na Google Cloud utilizando o Python para ingestão dos dados.

Tudo isso no formato 100% Hand-ons, muito prático, sem contar que quando um aluno tinha algum erro, compartilhava a tela e o nosso instrutor e os alunos resolviam o problema, erros que os alunos só iriam ver em seus projetos conseguiram não só ver esses erros mas como resolver também.

Temos a certeza que após esse treinamento nossos alunos estarão muito mais preparados para as oportunidades de Engenheiro de dados.

Sábado que vem temos mais 8 horas de imersão de Python com Google Cloud.

Muito Obrigado a todos os nossos alunos que confiaram mais uma vez no nosso trabalho!!

Até o próximo artigo!!

Pandasql é uma biblioteca Python que permite que os usuários escrevam consultas SQL em pandas. Ele usa SQLite como backend, o que significa que as consultas são executadas em memória. Isso é especialmente útil para usuários que estão acostumados a trabalhar com SQL e querem estender suas habilidades para o mundo do pandas.

Instalando pandasql

Antes de começar a usar o pandasql, você precisa instalá-lo. Você pode instalar o pandasql usando pip:

pip install pandasql
pip install sqlalchemy==1.4.46

Exemplos de uso

Para ilustrar como usar o pandasql, vamos usar um conjunto de dados simples. Imagine que temos um conjunto de dados com informações sobre filmes, incluindo o título do filme, a duração e a classificação. Vamos usar pandas para criar um DataFrame com essas informações:

import pandas as pd

data = { 'title': ['The Shawshank Redemption', 'The Godfather', 'The Dark Knight', 'Schindler\'s List', 'Forrest Gump']
, 'duration': [142, 175, 152, 195, 142]
, 'rating': ['9.3', '9.2', '9.0', '8.9', '8.8'] }

movies = pd.DataFrame(data)

Exemplo 1: Selecionando dados com pandasql (select)

Agora que temos um DataFrame, podemos usar pandasql para selecionar dados com base em uma consulta SQL. Vamos começar selecionando todos os filmes com duração superior a 150 minutos:

from pandasql import sqldf
query = ''' SELECT title, duration FROM movies WHERE duration > 150 '''

result = sqldf(query, locals())
print(result)

                title  duration
0        The Godfather       175
1     The Dark Knight       152
2    Schindler's List       195

Exemplo 2: Ordenando dados com pandasql (order by)

Podemos usar pandasql para classificar dados também. Vamos classificar os filmes por duração em ordem decrescente:

query = ''' SELECT title, duration FROM movies ORDER BY duration DESC '''
result = sqldf(query, locals())
print(result)

Este código retornará um DataFrame com os títulos e as durações dos filmes ordenados por duração em ordem decrescente:

                      title   duration
0           Schindler's List  195
1             The Godfather   175
2            The Dark Knight  152
3  The Shawshank Redemption   142
4              Forrest Gump   142

Exemplo 3: Agrupando dados com pandasql (group by)

Podemos usar pandasql para agrupar dados também. Vamos agrupar os filmes por classificação e calcular a média das durações:

query = ''' SELECT rating, AVG(duration) as avg_duration FROM movies GROUP BY rating ''' 
result = sqldf(query, locals()) 
print(result)

Este código retornará um DataFrame com as classificações dos filmes e as médias das durações dos filmes para cada classificação:

  rating  avg_duration
0    8.8         142.0
1    8.9         195.0
2    9.0         152.0
3    9.2         175.0
4    9.3         142.0

Exemplo 4: Unindo dados com pandasql (joins)

Podemos usar pandasql para unir dados de diferentes fontes. Vamos criar outro DataFrame com informações sobre diretores e usar pandasql para unir as informações de diretores com as informações de filmes:

data = { 'title': ['The Shawshank Redemption', 'The Godfather', 'The Dark Knight', 'Schindler\'s List', 'Forrest Gump'], 'director': ['Frank Darabont', 'Francis Ford Coppola', 'Christopher Nolan', 'Steven Spielberg', 'Robert Zemeckis'] }

directors = pd.DataFrame(data)

query = ''' SELECT title, director, duration, rating 
FROM movies 
JOIN directors ON movies.title = directors.title '''

result = sqldf(query, locals())
print(result)

Este código retornará um DataFrame com os títulos dos filmes, diretores, durações e classificações dos filmes, unindo informações de duas fontes:

                title              director  duration rating
0        The Godfather  Francis Ford Coppola       175    9.2
1     The Dark Knight     Christopher Nolan       152    9.0
2    Schindler's List     Steven Spielberg       195    8.9
3  The Shawshank Redemption       Frank Darabont       142    9.3
4          Forrest Gump     Robert Zemeckis       142    8.8

Conclusão

Pandasql é uma ferramenta poderosa para usuários do pandas que querem usar SQL para manipular seus dados. Ele oferece muitas funções para selecionar, classificar, agrupar e unir dados de forma eficiente. Esperamos que esses exemplos tenham sido úteis para você começar a usar o pandasql em seus próprios projetos de análise de dados.

Quer aprender mais…
Então participe da nossa live que será no dia 09/05/2023, para se inscrever só clicar no link abaixo:

Live – Python + GCP

Muito Obrigado e nos vemos na live!!

A função zip() é usada para juntar duas ou mais listas em uma única lista de tuplas, onde cada tupla contém um elemento de cada uma das listas fornecidas. A função zip() é muito útil quando precisamos percorrer duas ou mais listas simultaneamente, pois elimina a necessidade de usar loops aninhados.

Sintaxe:

zip(*iterables)

O parâmetro iteráveis é uma sequência de objetos iteráveis (por exemplo, listas, tuplas ou strings) que serão agrupados. O operador * antes do parâmetro iteráveis é usado para descompactar a sequência de objetos iteráveis.

Exemplo de uso:

lista1 = [1, 2, 3]
lista2 = ['a', 'b', 'c']

zipped = zip(lista1, lista2)

for i in zipped:
   print(i)

Resultado:

(1, 'a')
(2, 'b')
(3, 'c')

No exemplo acima, a função zip() é usada para combinar as listas lista1 e lista2 em uma única lista de tuplas. O loop for é então usado para imprimir cada tupla.

Um exemplo prático de uso do zip() seria o cálculo da média de notas de alunos em diferentes disciplinas. Suponha que tenhamos as seguintes listas:

notas_aluno1 = [8, 9, 7]
notas_aluno2 = [6, 7, 5]
notas_aluno3 = [10, 9, 9]
disciplinas = ['Matemática', 'Português', 'Ciências']

Para calcular a média de notas de cada aluno em cada disciplina, podemos usar o zip() da seguinte maneira:

for notas in zip(notas_aluno1, notas_aluno2, notas_aluno3):
    media = sum(notas) / len(notas)
    print(f"A média das notas do aluno é {media}")

O resultado seria:

A média das notas do aluno é 8.0
A média das notas do aluno é 6.0
A média das notas do aluno é 9.33

Neste exemplo, o zip() é usado para combinar as notas de cada aluno em uma única lista de tuplas. Em seguida, é calculada a média de notas de cada aluno usando a função sum() e o número de notas usando a função len().

Em resumo, a função zip() é uma ferramenta útil para simplificar a manipulação de listas em Python, especialmente quando precisamos percorrer várias listas simultaneamente. Combinar várias listas em uma única lista de tuplas usando o zip() pode ajudar a tornar o código mais legível e fácil de entender.

Quer aprender mais…
Então participe da nossa live que será no dia 09/05/2023, para se inscrever só clicar no link abaixo:

Live – Python + GCP

Muito Obrigado e nos vemos na live!!

Um dos principais desafios da engenharia de dados é lidar com grandes volumes de dados e garantir que eles sejam processados de forma eficiente e escalável. Para isso, é essencial criar um pipeline de dados que permita ler, transformar e carregar dados de forma automatizada e eficiente. Neste artigo, vamos explorar como criar um pipeline de dados escalável e eficiente usando Python.

O que é um pipeline de dados?

Um pipeline de dados é um conjunto de processos que permitem transformar dados brutos em informações úteis e acionáveis. Isso envolve a leitura de dados de diferentes fontes, como bancos de dados, arquivos ou APIs, transformando os dados para adequá-los ao objetivo final e carregando os dados em um sistema de armazenamento, como um banco de dados relacional ou não-relacional. O pipeline de dados pode ser automatizado para que os processos sejam executados automaticamente, garantindo a eficiência e escalabilidade do processo.

Criando um pipeline de dados com Python

Para criar um pipeline de dados eficiente e escalável, podemos utilizar diversas bibliotecas Python que são voltadas para a engenharia de dados, tais como:

• Pandas: para manipulação e transformação de dados em formato de DataFrame
• Dask: para processamento paralelo e distribuído de grandes volumes de dados
• Airflow: para criação de workflows automatizados e gerenciamento de tarefas
• SQLAlchemy: para interagir com diferentes tipos de banco de dados

O primeiro passo para criar um pipeline de dados é a leitura dos dados. Dependendo da fonte dos dados, podemos utilizar diferentes bibliotecas e métodos para ler os dados em um formato adequado para processamento. Por exemplo, se estamos lendo dados de um arquivo CSV, podemos usar a biblioteca Pandas para ler o arquivo e carregar os dados em um DataFrame.

[code language="python"]
import pandas as pd
df = pd.read_csv('dados.csv')
[/code ]

Em seguida, podemos realizar transformações nos dados para adequá-los ao objetivo final do pipeline. Isso pode incluir a remoção de colunas desnecessárias, a correção de valores ausentes ou a agregação de dados. Para isso, podemos utilizar as funções da biblioteca Pandas para manipular o DataFrame.

# Remove coluna desnecessária
df = df.drop('coluna_desnecessaria', axis=1)

# Preenche valores ausentes com a média da coluna
df = df.fillna(df.mean())

# Agrupa os dados por categoria
df_agrupado = df.groupby('categoria').sum()

Depois de transformar os dados, podemos carregá-los em um sistema de armazenamento. Isso pode incluir o carregamento dos dados em um banco de dados relacional ou não-relacional, como o MySQL ou MongoDB, ou em um sistema de armazenamento em nuvem, como o Amazon S3 ou Google Cloud Storage. Para isso, podemos utilizar as bibliotecas e ferramentas disponíveis para interagir com esses sistemas.

from sqlalchemy import create_engine

# Cria conexão com banco de dados MySQL
engine = create_engine('mysql://user:password@localhost/db_name')

# Carrega dados em tabela MySQL
df_agrupado.to_sql('tabela', engine)

Com isso, temos um exemplo do pipeline de dados que faz a leitura das informações, transforma o dado e popula um destino;
Quer aprender mais…

Então participa da nossa live que será no dia 09/05/2023, para se inscrever só clicar no link abaixo:

Live – Python + GCP

Muito Obrigado e nos vemos na live!!