Loop “For” em Python: Uma Jornada para a Eficiência e Produtividade

Olá seja muito bem-vindo (a),

No mundo da programação, a capacidade de executar tarefas repetitivas de maneira eficiente é essencial. Uma das ferramentas mais poderosas no arsenal de um programador Python é o loop “for”. O loop “for” permite que você itere sobre uma sequência de elementos, executando um bloco de código repetidamente para cada elemento da sequência. Veremos como utilizar este recurso aplicado em tarefas de um Cientista de Dados.

No Python, o loop “for” é uma estrutura de controle versátil e flexível que pode ser aplicada a uma ampla variedade de situações. Ele fornece uma maneira concisa e legível de percorrer elementos em uma lista, tupla, conjunto, dicionário ou até mesmo uma string. Além disso, o loop “for” também pode ser usado com objetos iteráveis personalizados, abrindo um mundo de possibilidades para desenvolvedores criativos.

Neste artigo, exploraremos em detalhes como aproveitar ao máximo o loop “for” em Python aplicado em um dataset para análise de dados. Discutiremos a sintaxe básica do loop “for”, mostrando como criar iterações simples e complexas.

Ao final deste artigo, você terá uma compreensão sólida do loop “for” em Python e estará pronto para aplicar esse conhecimento em seus próprios projetos. Os exemplos dos códigos fornecidos ao longo do texto irão ajudá-lo a se familiarizar com as melhores práticas e a desenvolver um estilo de programação elegante.

O fio lógico de condução deste artigo está baseado na análise de um dataset retirado do Kaggle, os códigos podem ser vistos ao final do artigo ou pelo GitHub (link no final da descrição); a ideia fundamental deste post é mostrar a utilidade do Loop For para alavancar as diversas etapas de um profissional de dados, este presente artigo tem a intenção de abordar os seguintes tópicos com o uso do Loop For no Python:

1. Verificação de colunas numéricas no Dataset
2. Conversão do tipo de dados
3. Verificação da porcentagem de valores nulos
4. Divisão de palavras numa mesma linha separada por um delimitador
5. Geração de gráficos eficientes

Vamos nessa?

Primeiramente vamos importar o objeto is_numeric_dtype do módulo do Pandas, este recurso faz a verificação se o array ou dtype da coluna fornecida pertence a um tipo de dados numérico, neste caso, aplicamos a condicional False, portanto o código nos retornará as colunas que não são do tipo numérico:

from pandas.api.types import is_numeric_dtype

numeric_cols = ['total_layoffs', 'impacted_workforce_percentage']
cols = df.columns

for x in cols:
    if is_numeric_dtype( df[x]) == False:
        print(x)

Vejamos, foi criado uma variável numeric_cols para armanezar em uma lista as colunas que são numéricas, mas que por padrão vieram como o tipo object, podendo dificultar nossas análises; seguindo foi criado uma outra variável nomeada de cols que usa o método .columns para retornar uma lista das colunas presentes no dataset, e por fim, foi adicionado a iteração for para percorrer todas as colunas e fazer a verificação se elas estão como tipo de dados diferente de numérico, por isso a condicional ‘False’, com o resultado deste código as colunas ‘total_layoffs’ e ‘impacted_workforce_percentage’ são retornadas, e com isso acusando de que não estão com tipo numérico, é um ponto de atenção para que nós Cientistas de Dados façamos a conversão dessas colunas antes de começar a trabalhar com elas.

Após descobrir que as colunas que deveriam ser numéricas na verdade não são, precisamos fazer a conversão desse tipo de dados, e isto pode ser feito através do Loop, para fins de exemplo vamos fazer a conversão na coluna ‘total_layoffs’, para a coluna ‘impacted_workforce_percentage’ pode ser conferida no notebook, vejamos o seguinte código abaixo:

# 1
df['total_layoffs'] = df['total_layoffs'].astype(str)

# 2
total_layoffs_converted = []

# 3
for x in df['total_layoffs']:
    if not x.isnumeric():
        total_layoffs_converted.append(0)
    
    else:
        total_layoffs_converted.append( int(x))
# 4
df['total_layoffs'] = total_layoffs_converted

2.1 Convertemos a coluna para o tipo string, porque a funcão isnumeric() funciona apenas em strings, se você não realizar a conversão para strings, a função isnumeric() lançará um erro quando for aplicada a valores que não sejam do tipo string;

2.2 Inicialização de uma lista vazia;

2.3 Faz a iteração para verificar se os dados da coluna ‘total_layoffs’ não são do tipo numérico, por este motivo, a condição if not é inserida no código, no caso desse dataset a coluna havia um dado textual com nome de ‘Unclear’ misturado no meio dos números, esta palavra será substituída por 0, caso contrário, os dados da coluna forem compostos por dígitos numéricos, a linha converte o valor para um número inteiro usando a função int() e adiciona o valor convertido à lista ‘total_layoffs_converted’ anteriormente criada;

2.4 Neste passo há uma substituição dos valores armazenados na lista para a coluna original do dataset, retornando os valores convertidos;

Este código é bem legal para você conhecer a representatividade de dados nulos presentes em seu conjunto de dados:

for x in df.columns:
    if df[x].isnull:
        print(x, df[x].isnull().sum()*100 / df.shape[0])

O código vai percorrer todas as colunas do dataset e verificar se há dados nulos em cada uma delas e retornar em porcentagem.

Este código é útil quando você precisa separar palavras de uma coluna através de um delimitador, por exemplo, na coluna ‘industry’ há o dado Fintech, payments há um espaço em branco após a vírgula que servirá como delimitador. E com isso, conseguimos capturar a última palavra que é realmente o que precisamos neste caso.

#1
list_industry = []

#2
for x in df['industry'].to_list():
    list_industry.append(x.split(' ')[-1])
    
# 3
list_industry = [x.lower() for x in list_industry]

# 4
list_industry = [x.replace('-', '') for x in list_industry]

#5
df['industry'] = list_industry

4.1 Inicializa uma lista vazia;

4.2 Realizando a iteração na coluna do dataframe e convertendo-o em uma lista com o comando to_list() e com a ação de pegar esse dado e cortar ele pelo delimitador ‘espaço em branco’ e pegando o último valor dessa lista com o comando [-1] , por exemplo, se na lista houvesse um dado da seguinte forma [São Paulo, Brasil] supondo que queremos capturar apenas a palavra Brasil para isso utilizamos [-1] no código;

4.3 Esta linha de código transforma todos os valores em letras minúsculas;

4.4 Esta linha de código remove os valores com hífen;

4.5 Por fim, os valores obtidos com as transformações na lista são substituídos aos valores originais;

Nesta seção, iremos utilizar o Loop para verificar a distribuição das colunas numéricas:

#1
numerics = ['int64', 'int32', 'int64', 'float16', 'float32', 'float64']

#2
df_numeric = df.select_dtypes( include = numerics)

#3
fig, axs = plt.subplots(ncols=2, nrows=1, figsize=(20, 10))

#4
index = 0

#5
axs = axs.flatten()

#6
for k,v in df_numeric.items():
		#7
    sns.kdeplot( v, ax=axs[index], fill=True)
		#8
    index += 1

5.1 Define uma lista na qual contém apenas os tipos de dados numéricos;

5.2 Método para selecionar apenas as colunas numéricas do dataframe, passando o parâmetro include com a lista criada que indica os dados numéricos;

5.3 Criando um conjunto de eixos com a função subplots do Matplotlib, definimos 2 colunas e 1 linha para apresentar os gráficos;

5.4 Inicializa a variável index como o valor 0;

5.5 Na quinta linha, os eixos são “achatados” em uma única dimensão utilizando o método “flatten”. Isso é feito para que os eixos possam ser acessados sequencialmente em um loop posterior;

5.6 O código entra em um loop “for” que itera sobre os itens do objeto "df_numeric.items()". Isso permite percorrer cada coluna numérica do dataframe e associar um nome (chave) à respectiva série de valores (valor);

5.7 Dentro do loop, a função “kdeplot” do pacote seaborn (importado como sns) é chamada para traçar um gráfico de densidade de kernel para a série de valores atual. O parâmetro “v” é usado para fornecer a série de valores, e o parâmetro “ax” é usado para fornecer o eixo correspondente para plotagem;

5.8 Após cada iteração do loop, a variável “index” é incrementada em 1 para acessar o próximo eixo na próxima iteração;

Basicamente, o código seleciona as colunas numéricas de um dataframe, cria uma figura com subplots e, em seguida, itera sobre as colunas numéricas, plotando um gráfico de densidade em cada eixo correspondente na figura. Isso pode ser útil para visualizar a distribuição dos dados numéricos em um dataframe.

Galerinha, neste artigo foi apresentado 5 maneiras de utilizar o Loop no Python para os projetos de Ciência de Dados, peguem esses códigos e tentem replicar nos seus projetos, vimos que com o domínio dessas estruturas, os profissionais podem escrever códigos mais eficientes e realizar tarefas complexas com facilidade. Dominar o conceito de loop é essencial para qualquer profissional de Dados em busca de soluções eficientes e elegantes.

Obrigado, até mais!

Links Úteis

GitHub: Clique Aqui

Dataset Retirado do Kaggle: Clique Aqui

Documentação Seaborn: Clique Aqui