Introdução

Python, com sua simplicidade e versatilidade, tornou-se uma potência no campo da ciência de dados por vários motivos. Entre eles está a grande quantidade de pacotes disponíveis e a facilidade de leitura e compreensão de código, em comparação com outras linguagens mais complexas como C# e JavaScript. Como cientistas de dados, escrever código limpo, conciso e legível é fundamental, e o Python oferece um conjunto de construções para alcançar exatamente isso. Neste artigo, exploraremos três atalhos essenciais do Python: Ternary operators (operadores ternários, List Comprehension (compreensões de lista) e Dict Comprehension (ou dictionary comprehension, compreensões de dicionário). Vamos nos aprofundar em sua sintaxe, casos de uso, vantagens e considerações ao usá-los.

Ternary Operator

Antes de falar de list e dict comprehension, precisamos falar de ternary operators. Esta sintaxe pythônica é a base para o que vem a seguir em list e dict comprehensions, é onde a sintaxe se origina.

O ternary operator fornece uma maneira concisa de escrever expressões condicionais em uma única linha:

resultado = expressão_se_verdadeiro if condição else expressão_se_falso

Considere o seguinte exemplo:

x = 5
paridade = "par" if x % 2 == 0 else "ímpar"
# O valor de paridade será "ímpar" pois 5 é um número ímpar

Neste exemplo, a variável paridade recebe o valor "par" se x for par e "ímpar" caso contrário. O operador % representa o módulo, assim o código realiza a divisão e o output desta operação é o resto da divisão. Se o resto for 0, quer dizer que é par, se for 1 (neste caso, no código não é preciso especificar porque é a única opção possível), o número é ímpar.

Vantagens

1. Conciso e Legível: Expressa lógica condicional em uma única linha, melhorando a legibilidade do código.
2. Simplicidade: Simplifica a sintaxe para atribuições condicionais simples.
3. Código Expressivo: Demonstra ações de maneira clara e concisa.

Quando Exercer Cautela

Embora essas construções ofereçam vantagens, há situações em que a cautela é necessária:

1. Preocupações com a Legibilidade: O uso excessivo de comprehensions em expressões complexas pode reduzir a legibilidade.
2. Lógica Complexa: Se a lógica se tornar muito intrincada e longa, considere o uso de construções tradicionais para clareza.
3. Implicações de Desempenho: Comprehensions extremamente grandes podem impactar o desempenho; use loops tradicionais para eficiência.
4. Compreensões Aninhadas: Aninhar compreensões muito profundamente pode resultar em código de difícil compreensão.
5. Operador Ternário em Condições Complexas: Para condições complexas, prefira instruções if-else tradicionais para clareza.
6. Manutenibilidade: Priorize a manutenção do código; se as construções prejudicarem a compreensão, escolha alternativas explícitas.

List Comprehensions

List comprehensions oferecem uma maneira concisa de criar listas em Python. A sintaxe é direta:

[expressão for item in iterável if condição]

• expressão: O valor a ser incluído na lista.
• item: A variável que representa cada elemento no iterável (por exemplo, uma lista, tupla ou intervalo).
• iterável: A fonte dos elementos.
• condição (opcional): Filtra elementos com base na condição especificada.

Vamos ilustrar com um exemplo:

# Quadrados dos números de 0 a 9
quadrados = [x**2 for x in range(10)]
# Saída: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Casos de Uso

1. Filtragem e Transformação: Compreensões de lista são úteis para filtrar elementos ou transformá-los de alguma forma.
2. Inicialização: Use compreensões ao inicializar listas ou dicionários com uma sintaxe concisa e legível.
3. Operações Matemáticas: Quando você precisa realizar operações matemáticas nos elementos de um iterável e criar uma nova lista ou dicionário.
4. Lógica Condicional: Aplique compreensões ao criar uma nova coleção com base em determinadas condições.

Um exemplo demonstrando lógica condicional:

# Obtenha os quadrados pares de 0 a 9
quadrados_pares = [x**2 for x in range(10) if x % 2 == 0]
# Saída: [0, 4, 16, 36, 64]

List comprehensions podem melhorar a legibilidade do código, reduzindo o número de linhas necessárias para várias operações.

Dict Comprehension

Dict comprehensions oferecem uma maneira concisa de criar dicionários em Python. A sintaxe é semelhante às list comprehensions. A grande diferença é que o resultado não é uma lista, mais sim um dicionário com a estrutura chave: valor.

{expressão_chave: expressão_valor for item in iterável if condição}

• expressão_chave: A expressão para a chave do dicionário.
• expressão_valor: A expressão para o valor correspondente.
• item, iterável e condição têm os mesmos significados que em list comprehensions.

Vamos usar um exemplo simples e criar um dicionário de quadrados de 0 a 9:

# Quadrados dos números de 0 a 9 como pares chave-valor
quadrados_dict = {x: x**2 for x in range(10)}
# Saída: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

Casos de Uso

• Filtragem e Transformação: Assim como as compreensões de lista, as compreensões de dicionário se destacam na filtragem e transformação de dados.
• Inicialização: Inicialize eficientemente dicionários, especificando relações chave-valor de forma concisa.
• Transformação de Dados: Transforme dados de um dicionário em outro com facilidade.

Dict comprehensions oferecem um conjunto poderoso de ferramentas para trabalhar com pares chave-valor.

Conclusão

Ternary operators, list comprehensions e dict comprehensions são ferramentas poderosas no arsenal de um cientista de dados. Quando usados com discernimento, eles podem significativamente melhorar a legibilidade e concisão do código. No entanto, é crucial encontrar um equilíbrio e considerar fatores como complexidade, manutenibilidade e legibilidade. Ao dominar esses atalhos do Python, estudantes de ciência de dados podem elevar suas habilidades de codificação, tornando seu código mais expressivo e eficiente no cenário da ciência de dados.

Nos ajude a te ajudar!

Se você gostou deste artigo e quer apoiar o Let’s Data, dê uns claps! E você pode fazer isso mais de uma vez, que tal uns 15?

Deixe um comentário dizendo o que acha deste assunto!

Ternary operator, List Comprehension e Dict Comprehension para Data Science was originally published in Let’s Data on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introdução

As window functions (funções de janela) em SQL são uma ferramenta poderosa e versátil para analisar e processar dados em conjuntos de dados complexos. Se você é um estudante de ciência de dados, entender como utilizar essas funções pode elevar suas habilidades de manipulação e análise de dados a um novo patamar. Neste artigo, exploramos o que são as window functions, por que são importantes e como aplicá-las em situações do mundo real.

O que são Window Functions em SQL?

Em termos simples, as window functions em SQL permitem que você realize cálculos ou agregações em um conjunto específico de linhas relacionadas a uma linha de dados específica. Essas funções operam sobre uma "janela" de dados que é definida com base em condições específicas, como uma partição ou ordenação.

Existem várias funções de janela essenciais, incluindo ROW_NUMBER(), RANK(), DENSE_RANK(), SUM(), AVG(), LEAD() e LAG().

ROW_NUMBER():

• Descrição: A função ROW_NUMBER() atribui um número sequencial único para cada linha em um conjunto de resultados, baseado na ordem especificada.
• Uso Prático: Útil quando você precisa de uma identificação única para cada linha.

RANK():

• Descrição: A função RANK() atribui uma classificação única para cada linha com base no valor especificado. Valores iguais recebem a mesma classificação, e o próximo valor recebe a classificação subsequente.
• Uso Prático: Útil para identificar a posição relativa de valores em uma ordem específica.

DENSE_RANK():

• Descrição: Similar ao RANK(), a função DENSE_RANK() também atribui classificações únicas, mas sem pular classificações para valores iguais.
• Uso Prático: Útil quando você deseja evitar lacunas nas classificações para valores iguais.

SUM():

• Descrição: A função SUM() calcula a soma cumulativa de uma expressão em um conjunto de resultados, considerando a ordem especificada pelas cláusulas OVER.
• Uso Prático: Permite calcular somas acumulativas, como a soma acumulativa de receitas ao longo do tempo.

AVG():

• Descrição: A função AVG() calcula a média cumulativa de uma expressão em um conjunto de resultados, com base na ordem especificada pelas cláusulas OVER.
• Uso Prático: Útil para calcular médias móveis e tendências ao longo do tempo.

LEAD():

• Descrição: A função LEAD() fornece o valor da próxima linha em relação à linha atual, com base na ordem especificada pelas cláusulas OVER.
• Uso Prático: Útil para comparar valores consecutivos em séries temporais.

LAG():

• Descrição: A função LAG() fornece o valor da linha anterior em relação à linha atual, com base na ordem especificada pelas cláusulas OVER.
• Uso Prático: Similar ao LEAD(), útil para análise de séries temporais e comparação de valores consecutivos.

Vamos abordar cada uma delas com exemplos práticos.

ROW_NUMBER(), RANK() e DENSE_RANK()

Essas funções são comumente usadas para atribuir um número de linha a cada registro em um conjunto de dados, permitindo ordenação e classificação eficientes.

-- Exemplo de ROW_NUMBER(), RANK() e DENSE_RANK()
SELECT
  Product,
  Price,
  ROW_NUMBER() OVER (ORDER BY Price) AS RowNum,
  RANK() OVER (ORDER BY Price) AS Rank,
  DENSE_RANK() OVER (ORDER BY Price) AS DenseRank
FROM Products;

Output:

Essa consulta atribui um número de linha (RowNum), um rank (Rank) e um rank denso (DenseRank) para cada produto com base no preço.

SUM() e AVG()

As funções SUM() e AVG() podem ser usadas com a cláusula OVER para calcular somas e médias em uma janela específica.

-- Exemplo de SUM() e AVG()
SELECT
  Date,
  Revenue,
  SUM(Revenue) OVER (ORDER BY Date) AS RunningTotal,
  AVG(Revenue) OVER (ORDER BY Date) AS MovingAverage
FROM SalesData;

Output:

Neste exemplo, calculamos o total acumulado e a média móvel da receita ao longo do tempo.

LEAD() e LAG()

LEAD() e LAG() permitem acessar valores de linhas subsequentes ou anteriores em uma janela, respectivamente.

-- Exemplo de LEAD() e LAG()
SELECT
  Date,
  Revenue,
  LEAD(Revenue, 1) OVER (ORDER BY Date) AS NextDayRevenue,
  LAG(Revenue, 1) OVER (ORDER BY Date) AS PreviousDayRevenue
FROM DailySales;

Output:

Nesta consulta, obtemos a receita do próximo dia (NextDayRevenue) e do dia anterior (PreviousDayRevenue) para cada dia.

Aplicação Prática em Ciência de Dados

Agora que entendemos as funções de janela, vamos considerar uma situação prática com um conjunto de dados fictício de vendas diárias.

Suponha que temos uma tabela chamada DailySales com colunas Date e Revenue. Queremos calcular a média móvel de 7 dias da receita para suavizar variações diárias.

-- Aplicação Prática em Ciência de Dados: Média Móvel de 7 Dias
SELECT
  Date,
  Revenue,
  AVG(Revenue) OVER (ORDER BY Date ROWS BETWEEN 6 PRECEDING AND CURRENT ROW) AS SevenDayMovingAvg
FROM DailySales;

Output:

Nesta consulta, a cláusula ROWS BETWEEN 6 PRECEDING AND CURRENT ROW especifica que a janela de cálculo incluirá os 6 dias anteriores e o dia atual, calculando assim a média móvel de 7 dias.

Conclusão

As window functions em SQL são uma ferramenta essencial para manipular e analisar dados de forma eficaz. Ao entender essas funções e aplicá-las em situações do mundo real, os estudantes de ciência de dados podem melhorar suas habilidades de manipulação de dados e extrair insights valiosos. Esperamos que este artigo tenha fornecido uma compreensão sólida das funções de janela e como aplicá-las em seu próprio trabalho.

Nos ajude a te ajudar!

Se você gostou deste artigo e quer apoiar o Let’s Data, dê uns claps! E você pode fazer isso mais de uma vez, que tal uns 15?

Deixe um comentário dizendo o que acha deste assunto!

Desvendando o Poder das Window Functions em SQL para Estudantes de Ciência de Dados was originally published in Let’s Data on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introdução

Se você é um estudante de Data Science que trabalha com Python, provavelmente já ouviu falar sobre Git e GitHub. Essas ferramentas são essenciais para o controle de versão e colaboração em projetos de programação. Neste artigo, vamos explorar passo a passo como começar a usar o Git e o GitHub, desde a instalação até o trabalho colaborativo.

Verificando sua Instalação do Git

Antes de começarmos, é importante verificar se o Git está instalado no seu computador. Para isso, abra o terminal (no caso do MacOS ou do Windows) e digite o seguinte comando:

git --version

Se você não tiver o Git instalado, siga as instruções oficiais de instalação para o seu sistema operacional no site do Git.

Criando uma Conta no GitHub

Se você ainda não possui uma conta no GitHub, acesse github.com e clique em “Sign up” para criar uma. Siga as instruções para configurar sua conta. Lembre-se de escolher um nome de usuário relevante para sua área de estudo.

Criando um Novo Repositório

Agora que você tem o Git instalado e uma conta no GitHub, vamos aprender como criar um novo repositório.

No GitHub

1. Faça login na sua conta do GitHub.
2. Clique no ícone “+” no canto superior direito e escolha “New repository”.
3. Preencha o nome do repositório, uma descrição opcional e escolha se ele será público ou privado.
4. Clique em “Create repository”.

Na sua Máquina

1. Abra o terminal e navegue até a pasta onde deseja criar o repositório.
2. Use o comando git init para iniciar um novo repositório local.

Conectando o Repositório Local ao GitHub

Depois de criar o repositório local e no GitHub, é hora de conectá-los.

No GitHub

1. No repositório recém-criado, clique no botão “Code” e copie o URL do repositório.

No Terminal

1. Use o comando git remote add origin [URL] para adicionar o repositório remoto. Substitua [URL] pelo URL que você copiou anteriormente.

Adicionando Arquivos, Commit, Pull e Push

Agora que seu repositório está configurado, você pode adicionar seus primeiros arquivos.

1. Crie ou mova os arquivos que deseja para a pasta do repositório local.
2. Use git add . para adicionar todos os arquivos ao controle de versão.
3. Em seguida, execute git commit -m "Primeiro commit" para criar um commit.
4. Para manter seu repositório atualizado com as mudanças feitas por outros colaboradores no GitHub, use git pull origin master para fazer o pull das alterações.
5. Por fim, faça o push dos arquivos para o GitHub com git push origin master.

Commit

Um commit é uma espécie de “instantâneo” do estado atual dos arquivos em seu repositório. É uma forma de registrar as mudanças que você fez. Cada commit possui uma mensagem descritiva que explica as alterações realizadas. É uma boa prática manter essas mensagens concisas, mas informativas. Por exemplo, ao usar o comando git commit -m "Adicionei funcionalidade de gráficos", você está registrando um commit com a mensagem "Adicionei funcionalidade de gráficos" que reflete as mudanças que você fez em seus arquivos.

Pull

O comando git pull é usado para atualizar seu repositório local com as alterações feitas no repositório remoto do GitHub. Imagine que você está trabalhando em um projeto em equipe, e um colega de equipe fez algumas mudanças no código e as enviou para o GitHub. Para manter seu repositório local atualizado e sincronizado com as mudanças deles, você utiliza o git pull. Isso garante que você esteja sempre trabalhando com a versão mais recente do código.

Push

O comando git push é usado para enviar seus commits locais para o repositório remoto no GitHub. Quando você faz alterações em seus arquivos e cria commits locais, essas alterações estão apenas no seu computador. Para compartilhá-las com outros colaboradores ou fazer backup seguro no GitHub, você utiliza o git push. Isso envia seus commits para o repositório remoto, tornando suas mudanças disponíveis para outras pessoas que trabalham no mesmo projeto.

Em resumo, o fluxo de trabalho geralmente envolve fazer alterações nos arquivos, adicionar essas alterações aos commits, registrar as mudanças com mensagens descritivas (commit), manter seu repositório local atualizado com git pull para sincronizar com o repositório remoto e, em seguida, enviar suas alterações para o GitHub com git push. Dessa forma, você mantém uma colaboração eficiente e acompanha as alterações em seu projeto de Data Science.

Trabalhando com Arquivos Desatualizados

Se você editou arquivos localmente antes de fazer um pull e percebeu que eles não estão atualizados em relação ao repositório do GitHub, existem maneiras de contornar essa situação.

1. Use git stash para salvar suas alterações locais.
2. Faça um git pull para atualizar seu repositório local.
3. Use git stash apply para reaplicar suas alterações salvas.

Entendendo o Funcionamento das Branches

Branches são uma parte fundamental do Git e do GitHub. Eles permitem que você trabalhe em diferentes versões de um projeto ao mesmo tempo.

• Para criar uma nova branch, use git checkout -b [nome-da-branch].
• Para alternar entre branches, use git checkout [nome-da-branch].
• Para mesclar alterações de uma branch para outra, use git merge [nome-da-branch].

Trabalhando com Colaboradores

Colaborar em projetos no GitHub envolve o uso de pull requests (PRs) para propor e revisar alterações. Aqui está um resumo rápido:

1. Um colaborador faz fork do repositório principal.
2. Eles criam uma nova branch para suas alterações.
3. Após concluir as alterações, eles enviam um PR para o repositório principal.
4. Os revisores podem comentar, aprovar ou solicitar alterações no PR.
5. Quando o PR é aprovado, as alterações são mescladas no repositório principal.

É importante destacar que, em projetos de código aberto, geralmente são os mantenedores do projeto que têm o poder de aprovar PRs. Em projetos privados ou em equipes, o processo de aprovação pode variar, mas geralmente envolve revisores designados.

Mantenha seu Código Atualizado

Lembre-se de começar o seu trabalho no código com um pull para garantir que você está usando a versão mais recente do projeto e termine com um pull para garantir que todos estejam com o código atualizado. Isso ajuda a evitar conflitos e manter a colaboração eficaz.

Agora que você tem uma compreensão básica do Git e do GitHub, você está pronto para começar a colaborar em projetos de Data Science de forma mais eficaz. Lembre-se de praticar e explorar mais recursos à medida que avança em sua jornada de programação. Boa sorte!

Nos ajude a te ajudar!

Se você gostou deste artigo e quer apoiar o Let’s Data, dê uns claps! E você pode fazer isso mais de uma vez, que tal uns 15?

Deixe um comentário dizendo o que acha deste assunto!

Desvendando o Git e o GitHub para Estudantes de Data Science was originally published in Let’s Data on Medium, where people are continuing the conversation by highlighting and responding to this story.

No campo da ciência de dados e programação, as expressões regulares (Regex) se destacam como uma ferramenta poderosa para extrair padrões, manipular texto e validar dados. Essas construções versáteis ganharam imensa popularidade devido à sua capacidade de lidar com tarefas complexas de busca e correspondência com precisão e flexibilidade. Embora as Regex possam parecer assustadoras à primeira vista, é essencial para qualquer aspirante a cientista de dados compreender seus fundamentos e utilizar efetivamente suas capacidades.

Introdução às Expressões Regulares (Regex)

As expressões regulares, frequentemente abreviadas como Regex, é uma ferramenta poderosa de correspondência de padrões usada para buscar, localizar e manipular strings. Elas oferecem uma maneira concisa e expressiva de descrever padrões dentro de texto, permitindo que programadores extraiam informações específicas, validem dados e realizem várias operações relacionadas a texto.

A Anatomia de uma Expressão Regular

Um padrão de Regex é composto por vários componentes que trabalham juntos para definir o padrão desejado. Estes incluem:

Metacaracteres: Esses caracteres especiais têm significados específicos dentro do Regex. Por exemplo, o asterisco (*) representa zero ou mais ocorrências do caractere precedente.

Classes de Caracteres: Elas permitem que você especifique um intervalo de caracteres, como [a-z] para todas as letras minúsculas ou [0–9] para dígitos.

Espaçamento: Espaços em branco podem ser usados para delimitar diferentes componentes do padrão Regex.

Correspondência de Padrões com Expressões Regulares

As expressões regulares empregam correspondência de padrões para buscar strings específicas dentro de um texto fornecido. Isso é alcançado usando o módulo re embutido do Python, que fornece funções para executar várias operações de Regex.

1. re.search(): Esta função verifica se o padrão existe dentro da string e retorna um objeto de correspondência se encontrado.
2. re.findall(): Esta função extrai todas as ocorrências do padrão da string e retorna uma lista de objetos de correspondência.
3. re.sub(): Esta função substitui todas as ocorrências do padrão pela string de substituição especificada.

Exemplos de Expressões Regulares

Para ilustrar o uso de Regex, vamos explorar alguns exemplos práticos:

Extraindo Endereços de E-mail: Utilize o padrão r"[\w\.-]+@[\w\.-]+\.[\w]{2,3}" para extrair endereços de e-mail do texto.

Metacaracteres

A expressão utiliza vários metacaracteres, que são símbolos especiais com significados específicos dentro do Regex. Estes incluem:

• \w: Corresponde a um caractere alfanumérico (a-z, A-Z, 0-9, _).
• \.: Corresponde a um ponto (.) literal.
• -: Corresponde a um hífen (-) literal.
• +: Corresponde a uma ou mais ocorrências do caractere precedente.
• {2,3}: Corresponde exatamente a duas ou três ocorrências do caractere precedente.

Classes de Caracteres

Regex também utiliza classes de caracteres, que permitem especificar um intervalo de caracteres. As seguintes classes de caracteres são usadas neste exemplo:

• [\w\.-]: Corresponde a um ou mais caracteres alfanuméricos, pontos ou hifens.
• [\w\.-]+: Corresponde a uma ou mais ocorrências da classe de caracteres precedente.
• [\w\.-]+@: Corresponde a um nome de usuário seguido por um símbolo '@' literal.
• [\w\.-]+\.[\w]{2,3}: Corresponde a um nome de domínio seguido por um ponto (.) literal e dois a três caracteres, o que representa um domínio como .com, .org, .net, ou .br.

Espaçamento

Espaçamento é usado para delimitar diferentes componentes do padrão Regex. A sequência de escape ‘\r\n’ representa um carriage return (quebra de linha) (\r) seguido de uma quebra de linha (\n), que é frequentemente usada para representar o final de uma linha em texto.

Combinando Componentes

A expressão combina esses componentes para formar um padrão que corresponde a um endereço de e-mail válido. O nome de usuário pode conter caracteres alfanuméricos, pontos ou hifens, e o nome do domínio também pode conter esses caracteres junto com pontos. O domínio deve ter dois ou três caracteres e pode incluir caracteres alfanuméricos.

Exemplo de Uso: Para usar essa expressão para extrair endereços de e-mail do texto, você pode usar o seguinte código Python:

import re

texto = "Este é um exemplo de um endereço de e-mail: johndoe@example.com. Outro exemplo é example@example.org."

correspondencias = re.findall(r"[\w\.-]+@[\w\.-]+\.[\w]{2,3}", texto)

for correspondencia in correspondencias:
    print(correspondencia)

Este código imprimirá a seguinte saída:

johndoe@example.com
example@example.org

O pacote Python para expressões regulares é o regex, que é importado pelo comando import re.

Metacaracteres Especiais: \s e \d

Além dos metacaracteres que discutimos anteriormente, o Regex oferece alguns metacaracteres especiais que podem ser incrivelmente úteis na correspondência de padrões. Dois desses metacaracteres especiais são \s e \d.

• \s: O metacaractere \s representa caracteres de espaço em branco. Isso inclui espaços, tabulações, quebras de linha e outros caracteres semelhantes usados para formatação e espaçamento em texto. Por exemplo, se você deseja corresponder a qualquer sequência de caracteres de espaço em branco, pode usar \s+ em seu padrão Regex, onde + corresponde a uma ou mais ocorrências. Aqui está um exemplo de como usá-lo:

import re

texto = "Este é algum texto    com     múltiplos espaços."
correspondencias = re.findall(r"\s+", texto)

for correspondencia in correspondencias:
    print(f"Espaço em branco encontrado: '{correspondencia}'")

Este código identificará e imprimirá todas as sequências de um ou mais caracteres de espaço em branco no texto.

• \d: O metacaractere `\d` corresponde a qualquer dígito de 0 a 9. É uma maneira útil de encontrar valores numéricos dentro do texto. Por exemplo, se você deseja extrair todos os números de telefone de um documento, pode usar `\d{2}-\d{5}-\d{4}` em seu padrão para corresponder ao formato comum de números de telefone no Brasil:

import re

texto = "Aqui estão alguns números de telefone: 11-92345-67890 e 11-99876-5432."
correspondencias = re.findall(r"\d{2}-\d{5}-\d{4}", texto)

for correspondencia in correspondencias:
    print(f"Número de telefone encontrado: {correspondencia}")

Este código identificará e imprimirá todos os números de telefone no formato `xx-xxxx-xxxx`.

Esses metacaracteres especiais, \s e \d, podem ser combinados com outros componentes Regex para criar padrões poderosos para corresponder e extrair tipos específicos de informações de texto. Quer você esteja trabalhando com dados de texto em ciência de dados ou precise validar e processar entradas, entender e usar esses metacaracteres de forma eficaz pode ser um ativo valioso em sua caixa de ferramentas.

Conclusão

Dominar expressões regulares (Regex) é uma habilidade inestimável para profissionais de ciência de dados. Com suas poderosas capacidades de correspondência de padrões e diversas aplicações, o Regex capacita cientistas de dados a lidar eficazmente com dados textuais, extrair informações valiosas e garantir a qualidade dos dados. Ao compreender os fundamentos do Regex e praticar seu uso com conjuntos de dados do mundo real, os cientistas de dados podem aumentar sua produtividade e contribuir para análises mais esclarecedoras.

Nos ajude a te ajudar!

Se você gostou deste artigo e quer apoiar o Let’s Data, dê uns claps! E você pode fazer isso mais de uma vez, que tal uns 15?

Deixe um comentário dizendo o que acha deste assunto!

Desmistificando Expressões Regulares (Regex) em Python was originally published in Let’s Data on Medium, where people are continuing the conversation by highlighting and responding to this story.

Inferência Causal

Neste episódio, batemos um papo com o Matheus Facure, destaque mundial em inferência causal, com livro publicado na editora O’Reilly.

Neste episódio, batemos um papo com o Matheus Facure, destaque mundial em inferência causal, com livro publicado na editora O’Reilly: Causal Inference in Python: Applying Causal Inference in the Tech Industry. Também disponibiliza um livro gratuitamente, que se chama Causal Inference for the Brave and True, e não menos importante é Cientista de Dados na Nubank desde 2017.

Falamos sobre a sua especialidade em inferência causal, sua migração de carreira de economista para cientista de dados e aprendemos como a inferência causal pode ser aplicada para a tomada de decisões nas empresas, após os modelos de machine learning serem aplicados. Foi um papo muito bacana com quem é referência no assunto!

Referências de assuntos neste episódio
☑️ Observação: os timestamps se referem ao tempo do episódio no YouTube.

[00:02:40] Seu caminho para se tornar Cientista de Dados

[00:06:45] Laboratório de Aprendizado de Máquina em Finanças e Organizações (LAMFO) e Let’s Data #001 — Pedro Albuquerque

[00:11:20] O que é Inferência Causal?

[00:14:45] Quais tipos de problema Machine Learning resolvem? E quais Inferência Causal resolvem?

[00:22:45] Teste A/B é inferência causal?

[00:24:40] Erros ao utilizar o teste A/B nas empresas

[00:29:40] Visão sobre modelos de Uplift Modeling

[00:33:00] Por que inferência causal ainda é pouco explorado pelas empresas?

[00:38:00] Seu caminho dentro da Nubank

[00:43:00] Inferência causal na Nubank

[00:45:30] Como é trabalhar na Nubank? Como é o perfil do seu funcionário?

[00:51:30] Como foi publicar um livro na editora O’Reilly?

[00:56:20] Python ou R?

[00:56:50] Cientista de Dados: Susan Athey

[00:57:30] O que a IA ainda não consegue?

[00:58:10] Livro: Mostly Harmless Econometrics

[00:58:35] Série: Only Murders in the Building

[00:59:00] Banda: Pink Floyd

[00:59:10] Hobby: Cozinhar

[00:59:30] Viagem: Japão

[01:00:20] Sonho: Fazer um podcast sobre finanças pessoais

[01:01:10] Pergunta de 1 milhão de euros

As referências deste espisódio foram curadas pelo João Rocha Vianna.

Obrigado João!

Let’s Data Podcast #042 — Matheus Facure was originally published in Let’s Data on Medium, where people are continuing the conversation by highlighting and responding to this story.

Análise de Dados e MVP Microsoft

Neste episódio, batemos um papo com o Leonardo Karpinski, destaque no mundo da Análise de Dados e PowerBI no Brasil.

Falamos sobre a carreira de analista de dados, como ele saiu de uma graduação em engenharia e passou até por vender marmitas, e hoje é um dos maiores nomes em formação em análise de dados e Power BI do Brasil. Falamos também sobre a nova parceria entre a Xperiun e o Let’s Data!

☑️ Observação: os timestamps se referem ao tempo do episódio no YouTube.

[00:03:25] Seu caminho para se tornar Analista de Dados

[00:06:50] C++

[00:10:40] Transição de Excel para Power BI

[00:15:12] ChatGPT para análise de dados

[00:19:55] Análise de dados para empresas de diferentes setores

[00:24:00] Análise de dados x Criação de dashboards

[00:27:00] Dicas para quem está começando em Análise de Dados

[00:29:00] Sobre ser empreendedor

[00:34:40] Sobre a Xperiun

[00:38:26] Sobre ser MVP Microsoft

[00:40:25] Sobre trabalho remoto, híbrido ou presencial

[00:44:00] Power BI ou Tableau? Python ou R?

[00:44:45] Analista de Dados: Fernando Garcia

[00:45:25] O que a IA ainda não consegue?

[00:45:43] Livro: O mensageiro milionário

[00:46:15] Série: Depois da cabana e Breaking Bad

[00:46:40] Banda: Iron Maiden

[00:47:25] Hobby

[00:47:34] Viagem: Suíça

[00:47:49] Sonho

[00:48:35] Pergunta de 1 milhão de euros

As referências deste espisódio foram curadas pelo João Rocha Vianna.

Obrigado João!

Let’s Data Podcast #040 — Leonardo Karpinski was originally published in Let’s Data on Medium, where people are continuing the conversation by highlighting and responding to this story.

Neste artigo, exploraremos um conceito crucial neste campo: a “Feature Importance”. Este artigo é para iniciantes e em Data Science que já dão os seus primeiros passos em modelagem e querem aprofundar nos resultados dos modelos.

O Que é Feature Importance?

Imagine um cenário onde você tem inúmeras variáveis, mas nem todas são igualmente importantes para o resultado de seu modelo. Aqui entra a “Feature Importance”. É a técnica de avaliar e classificar as variáveis de um conjunto de dados com base na influência que exercem na variável alvo de um modelo preditivo. Compreender a “Feature Importance” ajuda a simplificar modelos, melhorar a eficiência e, o mais importante, aumentar a compreensão dos dados.

Técnicas Comuns de Feature Importance

Análise de Coeficientes em Modelos Lineares

Em modelos lineares, como a regressão linear, os coeficientes atribuídos às variáveis podem ser interpretados como medidas de importância. Um coeficiente alto implica uma forte influência na variável dependente. Por exemplo:

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
import pandas as pd

# Loading the Iris dataset
iris = load_iris()
X = pd.DataFrame(iris.data, columns=iris.feature_names)
y = iris.target

# Adjusting the logistic regression model
model = LogisticRegression(max_iter=200)
model.fit(X, y)

# Visualizing the importance of features
coefficients = pd.Series(model.coef_[0], index=X.columns)
coefficients.plot(kind='barh')
plt.title('Feature Importance in Logistic Regression Model')
plt.xlabel('Coefficient')
plt.ylabel('Feature')
plt.show()

No exemplo de regressão logística que usamos com o conjunto de dados Iris, observamos a importância de cada feature através dos coeficientes do modelo. A regressão logística, sendo um modelo linear, atribui um peso ou coeficiente a cada feature, que pode ser interpretado como sua importância relativa.

No gráfico gerado, podemos ver claramente quais features têm maior peso. Por exemplo, se a “largura da pétala” (petal width) tem o coeficiente mais alto, isso indica que ela tem a maior influência na determinação da classe da íris. Isso faz sentido, pois na biologia da íris, a largura e o comprimento da pétala são características distintivas entre as espécies.

É importante notar que coeficientes altos podem representar tanto uma influência positiva quanto negativa, dependendo do sinal do coeficiente. Um coeficiente positivo indica que quanto maior o valor da feature, maior será o impacto na variável dependente, enquanto um coeficiente negativo sugere o contrário.

Esta análise nos ajuda a entender não apenas quais features são importantes, mas também como elas influenciam a previsão do modelo.

Importância das Features em Árvores de Decisão

Árvores de decisão e modelos baseados em árvores, como random forest, oferecem um insight direto sobre a importância das features. Estes modelos fornecem uma pontuação para cada feature, indicando sua utilidade na construção das árvores. Por exemplo:

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
import pandas as pd
import matplotlib.pyplot as plt

# Carregando o conjunto de dados Iris
iris = load_iris()
X = pd.DataFrame(iris.data, columns=iris.feature_names)
y = iris.target

# Criando e treinando o modelo de floresta aleatória
modelo = RandomForestClassifier(n_estimators=100)
modelo.fit(X, y)

# Visualizando a importância das features
importancias = pd.Series(modelo.feature_importances_, index=X.columns)
importancias.nlargest(4).plot(kind='barh')
plt.title('Importância das Features no Random Forest')
plt.show()

No exemplo usando o modelo Random Forest, a importância das features é determinada com base em quão úteis elas são para a construção das árvores de decisão. Diferente da regressão logística, esta técnica não se baseia em coeficientes lineares, mas sim na eficácia de cada feature em reduzir a impureza das árvores.

O gráfico mostra que certas features, como “comprimento da pétala” (petal length) e “largura da pétala” (petal width), são mais significativas para o modelo. Estas features provavelmente fornecem as divisões mais informativas e ajudam o modelo a diferenciar eficazmente entre as classes.

Essa análise é crucial para entender como o modelo está tomando suas decisões e quais características dos dados estão mais fortemente associadas às diferentes categorias de íris. Isso também pode guiar futuras coletas de dados e a preparação de features, priorizando aquelas que são mais informativas para o modelo.

Aplicações Importantes

Feature importance pode ser aplicado para feature selection, que é a seleção de features que vão ser utilizadas para um modelo. Assim é possível determinar as variáveis mais importantes e otimizar o modelo, ou até mesmo experimentar novas opções de features.

Outra é a interpretação do modelo, ajudando o cientista de dados a explicar melhor as variáveis mais importantes e mais relevantes ao modelo, ou até mesmo ao produto ou negócio que na empresa que ele trabalha. Dessa forma é possível até em eventuais casos, ajudar outras equipes a entender melhor que tipo de informação é crucial para o desenvolvimento do negócio.

Considerações Finais

“Feature Importance” é uma ferramenta valiosa no arsenal de qualquer cientista de dados. Não só melhora a performance dos modelos, como também proporciona insights mais profundos sobre os dados. Recomendamos aos leitores que apliquem essas técnicas em seus próprios projetos para uma compreensão mais prática e aprofundada.

Nos ajude a te ajudar!

Se você gostou deste artigo e quer apoiar o Let’s Data, dê uns claps! E você pode fazer isso mais de uma vez, que tal uns 15?

Deixe um comentário dizendo o que acha deste assunto!

Desvendando a Importância das Features em Data Science was originally published in Let’s Data on Medium, where people are continuing the conversation by highlighting and responding to this story.

Trabalho em unicórnio de IA da gringa

Conversamos com o Luiz Santos, Solutions Engineering Manager na H2O.ai.

Sabia que eles tem mais mais Kaggle Grandmasters que a própria NVIDIA!? Falamos sobre trabalho na gringa, carreira de gestor na área de dados, perfil de profissional que a H2O procura e muito mais! Aproveite o episódio e prepare o currículo porque eles estão contratado 😂

Referências de assuntos neste episódio
☑️ Observação: os timestamps se referem ao tempo do episódio no YouTube.

[00:02:50] Seu caminho para se tornar um Cientista de Dados

[00:05:55] O que faz a H2O.ai

[00:10:13] Trabalho na H2O.ai

[00:12:25] O que os Kaggle Masters fazem na H2O.ai

[00:17:00] Projetos desenvolvidos na H2O.ai

[00:20:10] Trabalhar em outro idioma

[00:23:00] Perfil que a H2O.ai procura em novos profissionais

[00:26:07] Mudança para uma carreira de gerência

[00:28:15] Trabalhar para o exterior

[00:31:05] Modelo de trabalho remoto, híbrido ou presencial

[00:34:03] Conselhos para trabalhar pro exterior e/ou na H2O.ai

[00:39:10] Mestrado na Georgia Tech

[00:45:53] Python ou R?

[00:46:55] Referência em TI: Joel Spolsky (Cofundador do Stack

[00:49:54] O que a IA ainda não consegue?

[00:52:47] Livro: Saga brasileira — Miriam Leitão

[00:55:05] Filme: Moneyball

[00:56:04] Banda: Pink Floyd

[00:56:55] Hobby: Marcenaria e LEGO

[00:58:36] Viagem: EUA

[00:59:58] Sonho?

[01:00:53] Pergunta de 1 milhão de euros

As referências deste espisódio foram curadas pelo João Rocha Vianna.

Obrigado João!

Let’s Data Podcast #039 — Luiz Santos was originally published in Let’s Data on Medium, where people are continuing the conversation by highlighting and responding to this story.

Neste episódio, batemos um papo com o Rodrigo Teoria, destaque no mundo da Engenharia de Dados e na Comunidade de Dados no Brasil.

Conversamos sobre as principais diferenças entre as carreiras de cientista e engenheiro de dados. Teoria compartilhou conosco os segredos por trás de um pipeline de dados eficaz e por que o data mesh está ganhando tanto destaque no mundo corporativo. Se você está buscando insights valiosos sobre a vanguarda da engenharia de dados, este é o episódio para você.

Referências de assuntos neste episódio
☑️ Observação: os timestamps se referem ao tempo do episódio no YouTube.

[00:03:03] Seu caminho para se tornar um Engenheiro de Dados

[00:12:03] Diferença entre Engenheiro de Dados, Cientista de Dados e MLOps

[00:17:34] Segredos por trás de um pipeline de dados eficaz

[00:29:08] Por que o Data Mesh está ganhando tanto destaque no mundo corporativo

[00:38:25] História da origem do apelido ‘Teoria’

[00:41:34] Trabalho na Serasa Experian

[00:45:37] Trabalho na Universidade de Pernambuco (UPE)

[00:50:58] ‘Supletivos’ (projeto criado com a comunidade Data Hackers

[00:57:46] Python ou R?

[00:59:36] Cientistas de Dados: Andrew Ng e Téo Calvo

[01:00:30] O que a IA ainda não consegue?

[01:01:07] Livro: Como as pessoas aprendem?

[01:01:43] Série: Breaking Bad

[01:02:23] Banda: Metallica

[01:02:46] Hobby: Jiu Jitsu e Corrida

[01:05:14] Pergunta de 1 milhão de euros

As referências deste espisódio foram curadas pelo João Rocha Vianna.

Obrigado João!

Let’s Data Podcast #038— Rodrigo Teoria was originally published in Let’s Data on Medium, where people are continuing the conversation by highlighting and responding to this story.

O que as empresas buscam em profissionais de dados

Neste episódio conversamos com João Paulo Nogueira, Cientista de Dados na Datarisk.

Conversamos sobre os desafios da migração da carreira acadêmica para o mercado de trabalho. Como são as consultorias de dados para empresas. Falamos também sobre os requisitos que facilitam a contratação de um profissional de dados, seja Júnior, Pleno ou Sênior.

Referências de assuntos neste episódio
☑️ Observação: os timestamps se referem ao tempo do episódio no YouTube.

[00:03:54] Universidade Federal do Ceará

[00:04:32] Linguagens: Ruby, Java

[00:08:06] Livro: RESEARCH SOFTWARE ENGINEERING

[00:12:50] Curso: Machine Learning Specialization — Andrew Ng

[00:13:14] Comunidade: Data Hackers

[00:18:10] Sobre as oportunidades e desafios da trajetória acadêmica

[00:25:48] Sobre seu cargo atual na empresa Datarisk

[00:31:13] O que é MLOps?

[00:35:12] Erros mais comuns que empresas cometem ao tentar implementar soluções de Machine Learning

[00:37:40] Habilidades fundamentais num profissional de dados Júnior, Pleno e Sênior

[00:42:10] Experiência como professor de Machine Learning na FIA Business School

[00:46:40] Python ou R: Python! — Antes e depois do Tidyverse no R

[00:53:30] Biblioteca do R recomendada: recipes

[00:54:35] Cientista de Dados: Téo Calvo

[00:57:20] Livro: Estatística nua e crua — Charles Wheelan (livro em inglês)

[00:58:30] Série: From (Origem) — dos mesmos produtores de Lost / disponível no Globoplay

[01:00:30] Artista: Taylor Swift

[01:07:30] Resposta à pergunta de 1 Milhão de Euros

As referências deste espisódio foram curadas pelo João Rocha Vianna.

Obrigado João!

Let’s Data Podcast #037 — João Paulo Nogueira was originally published in Let’s Data on Medium, where people are continuing the conversation by highlighting and responding to this story.