R: utilizando e manipulando estruturas para análises de dados

Importando e explorando os dados - Apresentação

Saber utilizar e manipular estruturas de dados é essencial para a análise de dados. A linguagem R é uma ferramenta poderosa para essa finalidade, permitindo manipular essas estruturas e, principalmente, apoiar o time de negócios a tomar decisões baseadas em dados.

Boas-vindas ao curso de R, focado na utilização e manipulação de estruturas de dados. O instrutor da Escola de Dados, Igor Nascimento Alves, irá nos acompanhar nesse conteúdo.

Audiodescrição: Igor Nascimento é um homem de pele clara, olhos castanhos e cabelos escuros e curtos. Usa uma camiseta cinza e está sentado em uma cadeira preta. Ao fundo, parede lisa iluminada por um gradiente do verde ao azul. À esquerda, um vaso de planta.

O que vamos aprender?

Este conteúdo é destinado a quem deseja aprender os conceitos iniciais de análise de dados utilizando a linguagem R.

Durante o curso, vamos acompanhar o projeto da empresa Meteora, uma loja de roupas online. O objetivo é auxiliar a Meteora a tomar decisões baseadas em dados, consumindo os dados de vendas e de estoque para extrair insights e responder às dúvidas da área de negócios.

No decorrer do projeto, vamos aprender a utilizar estruturas de dados, como listas e dataframes, além de funções como sum, aggregate, min e apply. Também serão utilizadas funções personalizadas para realizar análises diferenciadas.

Para acompanhar este conteúdo, é importante já ter tido algum contato com a linguagem R.

Importando e explorando os dados - Organizando dados com listas

O projeto para a empresa Meteora envolve realizar uma análise de dados com o objetivo de ajudar a empresa a responder dúvidas da área de negócios.

Essas questões podem variar desde perguntas simples, como a quantidade de vendas realizadas em um mês, até questões mais complexas, como identificar o mês com maior número de vendas no ano ou o momento ideal para renovar estoques.

Vamos analisar os dados de venda e estoque da empresa Meteora para ajudar a solucionar esses questionamentos do time de negócios.

Criando notebook em linguagem R

Para iniciar o processo, é necessário entender como carregar os dados utilizando a linguagem R.

O mais comum é utilizar o RStudio e o arquivo Quarto, mas neste curso será adotada uma abordagem diferente: o uso do Jupyter Notebook no ambiente do Google Colab. A ideia é proporcionar mais possibilidades de ferramentas, permitindo que cada pessoa escolha a que mais lhe agrada ou a que seja mais vantajosa ao projeto.

Para acessar o Colab, basta pesquisar pelo termo "Colab" no Google e clicar no primeiro link da página de boas-vindas ao Colab. Na janela de "Abrir Notebook", vamos clicar no botão "Novo notebook" localizado no canto inferior esquerdo.

Por padrão, o notebook (caderno) do Colab utiliza a linguagem Python, mas é necessário alterá-la para R antes de começar nosso projeto. Isso pode ser feito clicando em "Editar" no menu superior e, em seguida, em "Configurações de Notebook", onde devemos selecionar "R" em "Tipo de ambiente de execução" e clicar no botão "Salvar" no canto inferior direito para guardar as alterações.

Desse modo, esse ambiente de execução vai executar a linguagem R.

Carregando dados

Para começar o projeto, vamos trabalhar com uma amostra dos dados em Markdown. Vamos conferir os dez dados amostrais da empresa Meteora, colando-os em uma nova célula de texto.

No Jupyter Notebook, existem dois tipos de células: código e texto. Para inserir uma célula de texto, basta clicar em "+ Texto" e colar o conteúdo desejado.

Inicialmente, trabalharemos com dez produtos para entender como carregar dados e quais estruturas utilizar. Atualmente, já conhecemos as estrututas de vetores e matrizes, portanto, tentaremos utilizá-las para o carregamento.

como vetor

Primeiramente, vamos digitar cada uma das linhas amostrais e colá-las dentro de um vetor:

sales_data_vetor <- c(
     "2023-01-01", 1001, "Camisa Social Azul", 5, 50, "Camisas",
     "2023-01-01", 1002, "Calça Jeans", 8, 30, "Calças",
     "2023-01-02", 1003, "Jaqueta de Couro", 2, 20, "Jaquetas",
     "2023-01-03", 1004, "Camisa Social Branca", 3, 45, "Camisas",
     "2023-01-03", 1005, "Saia Longa", 4, 25, "Saias",
     "2023-01-04", 1006, "Blusa de Algodão", 7, 60, "Blusas",
     "2023-01-05", 1007, "Calça de Moletom", 10, 40, "Calças",
     "2023-01-06", 1008, "Vestido Floral", 6, 35, "Vestidos",
     "2023-01-07", 1009, "Terno Completo", 1, 15, "Ternos",
     "2023-01-08", 1010, "Camiseta Básica", 15, 100, "Camisetas"
)
sales_data_vetor

Esse código contém um vetor chamado sales_data_vetor com as informações das seis colunas da amostra sobre data, ID do produto, nome do produto, quantidade vendida, estoque disponível e categoria de dez registros diferentes.

Para executar a célula, podemos usar o atalho "Shift + Enter". A primeira execução pode demorar um pouco, pois estamos solicitando uma máquina ao Google para utilizar nesse projeto.

'2023-01-01''1001''Camisa Social Azul''5''50''Camisas''2023-01-01''1002''Calça Jeans''8''30''Calças''2023-01-02''1003''Jaqueta de Couro''2''20''Jaquetas''2023-01-03''1004''Camisa Social Branca''3''45''Camisas''2023-01-03''1005''Saia Longa''4''25''Saias''2023-01-04''1006''Blusa de Algodão''7''60''Blusas''2023-01-05''1007''Calça de Moletom''10''40''Calças''2023-01-06''1008''Vestido Floral''6''35''Vestidos''2023-01-07''1009''Terno Completo''1''15''Ternos''2023-01-08''1010''Camiseta Básica''15''100''Camisetas'

Após preencher o vetor, é possível perceber que ele não é ideal para leitura e acesso aos dados, o que indica que essa estrutura não é a mais adequada para armazenar os nossos dados.

como matriz

Portanto, vamos testar agora transformar o vetor em uma matriz e conferir o resultado.

Preparamos um código para criar uma matrix() que recebe como parâmetro: o vetor sales_data_vetor, o número de registros e o preenchimento por linha. Salvamos essa matriz na variável sales_data_matrix.

# Criar a matriz a partir do vetor
sales_data_matrix <- matrix(sales_data_vetor, nrow = 10, byrow = TRUE)
sales_data_matrix

A matrix: 10 × 6 of type chr

Apesar da matriz representar melhor os dados e facilitar a leitura dos campos, ainda falta o nome das colunas.

Isso pode ser corrigido utilizando a função colnames() na sales_data_matrix, passando o nome de cada uma das colunas através de um vetor.

# Definir os nomes das colunas
colnames(sales_data_matrix) <- c("Data", "ID_Produto", "Nome_Produto", "Quantidade_Vendida", "Estoque_Disponível", "Categoria")

# Exibir a matriz
sales_data_matrix

A matrix: 10 × 6 of type chr

Assim, conseguimos identificar o que cada uma das colunas contém. Entretanto, a matriz é idealmente utilizada para estruturas com o mesmo tipo de dado.

No nosso caso, temos dados do tipo data, inteiro e string. Sendo assim, por mais que a apresentação seja interessante visualmente, a matriz não é a estrutura adequada para esse tipo de situação.

como tabela

Essa estrutura com a qual estamos trabalhando se assemelha a uma tabela, como as que usamos no Google Planilhas ou Excel, por exemplo. Pesquisando na documentação do R, encontramos a estrutura table, que parece fazer sentido devido a seu nome.

Como vamos criar uma estrutura nova, vamos começar a digitar o código do zero. Para transformar uma matriz em uma tabela, vamos criar a sales_data_table e atribuir (<-) o resultado da função as.table(), passando a matriz armazenada em sales_data_matrix.

Antes de executar, vamos exibir a tabela sales_data_table depois de sua declaração.

sales_data_table <- as.table(sales_data_matrix)
sales_data_table

Retorno

  Data       ID_Produto Nome_Produto         Quantidade_Vendida
A 2023-01-01 1001       Camisa Social Azul   5                 
B 2023-01-01 1002       Calça Jeans          8                 
C 2023-01-02 1003       Jaqueta de Couro     2                 
D 2023-01-03 1004       Camisa Social Branca 3                 
E 2023-01-03 1005       Saia Longa           4                 
F 2023-01-04 1006       Blusa de Algodão     7                 
G 2023-01-05 1007       Calça de Moletom     10                
H 2023-01-06 1008       Vestido Floral       6                 
I 2023-01-07 1009       Terno Completo       1                 
J 2023-01-08 1010       Camiseta Básica      15                
  Estoque_Disponível Categoria
A 50                 Camisas  
B 30                 Calças   
C 20                 Jaquetas 
D 45                 Camisas  
E 25                 Saias    
F 60                 Blusas   
G 40                 Calças   
H 35                 Vestidos 
I 15                 Ternos   
J 100                Camisetas

Embora a tabela tenha conseguido carregar as estruturas e manter o nome das colunas, as linhas e colunas não estão separadas como queríamos. A transformação para table não trouxe o resultado esperado, pois não facilita a análise de dados.

Segundo a documentação, a table é uma estrutura de dados semelhante a matriz, pois espera dados do mesmo tipo. Porém, ela é útil para calcular dados categóricos.

Na nossa amostra, temos uma coluna chamada Categoria que se encaixa nesse perfil de dados categóricos. Ela contém dados de calça, camisa, blusa, entre outras vestimentas.

Então, vamos aplicar a table em dados categóricos para entender qual seu propósito adequado.

Para começar, devemos extrair esses dados categóricos. Em uma nova célula, criamos a variável categorias e atribuimos o valor sales_data_matrix, extraindo apenas os dados da sexta coluna de "Categoria". Entre colchetes, omitimos o primeiro parâmetro para pegar todas as linhas e definimos o 6 como segundo parâmetro.

categorias <- sales_data_matrix[,6]
categorias

'Camisas' 'Calças' 'Jaquetas' 'Camisas' 'Saias' 'Blusas' 'Calças' 'Vestidos' 'Ternos' 'Camisetas'

Ao exibir o resultado, são listadas todas as dez categorias extraídas de cada registro.

Para conferir se a table trabalha melhor com esses dados, vamos criar uma variável frequencias para transformá-la por meio da table(), enviando as categorias extraídas como parâmetro.

Como sempre, vamos exibir o resultado logo abaixo e apertar "Shift + Enter".

frequencias <- table(categorias)
frequencias

Categorias

Com isso, a table consegue computar a quantidade de cada categoria a partir de um vetor, o que é útil em grandes conjuntos de dados.

O resultado obtido nos ajuda a responder algumas dúvidas de negócio, como qual categoria tem o maior número de produtos.

Próximos passos

Apesar disso, ainda é necessário encontrar uma estrutura de dados que represente adequadamente todo o conjunto de dados da empresa Meteora. Vamos continuar essa busca daqui a pouco.

Importando e explorando os dados - Explorando a estrutura dos dados

Já conseguimos pegar os dados da empresa Meteora e realizar uma análise inicial utilizando a estrutura de dados table, que é capaz de lidar com dados categóricos.

No entanto, nosso conjunto de dados era apenas uma amostra e queremos utilizar a análise de dados com R no conjunto total dos dados. Para isso, ainda precisamos encontrar a estrutura ideal. Relembramos algumas estruturas já conhecidas, como vetores e matrizes, mas elas parecem não serem adequadas, pois queremos lidar com dados de diversos tipos diferentes.

Carregando dados como dataframe

Voltando ao Jupyter Notebook, no menu lateral esquerdo, há quatro ícones. Vamos clicar no quarto ícone de uma pasta chamada "Arquivos", onde podemos subir arquivos.

Queremos subir nossos dados completos para o Jupyter Notebook. Para isso, clicamos no primeiro ícone chamado "Fazer Upload para Armazenamento da Sessão". Depois, selecionamos o arquivo dados_vendas_inventario_meteora_grande.csv, o qual está disponível na atividade de "Preparando ambiente".

Um aviso aparece informando que esses dados precisam ser salvos em outro lugar, pois os arquivos salvos nesse ambiente de execução serão apagados quando ele for encerrado. Isso ocorre porque utilizamos uma máquina da Google para executar o código R, e ao fechar a sessão, a máquina é devolvida e todos os dados são apagados.

O código do notebook, sim, pode ser salvo, mas o arquivo carregado não fica salvo. Portanto, é importante lembrar de carregar os dados antes de executar o Jupyter Notebook pela primeira vez na sessão.

Após clicar no botão "OK" para fechar o aviso, aparece o arquivo CSV no painel lateral. Nele, vamos clicar no ícone de três pontos e escolher a opção "Copiar Caminho". Para ter mais espaço na tela, clicamos em "Arquivos" novamente para fechar a aba.

Para trazer o arquivo carregado na sessão para o R, a técnica utilizada anteriormente de digitar cada dado não é viável, pois temos muitos registros.

Precisamos de uma ferramenta do R capaz de ler um arquivo e carregá-lo. Para isso, em uma nova célula de código, criamos uma variável chamada path e atribuímos uma string com o caminho do arquivo que copiamos.

path <- "/content/dados_vendas_inventario_meteora_grande.csv"

Apertamos "Shift + Enter" para criar essa variável que indica onde está o arquivo.

No R básico, sem nenhum pacote extra, contamos com uma ferramenta chamada read para fazer a leitura de dados.

Em uma nova célula, utilizamos a função read.csv(), que é capaz de ler um arquivo CSV. Entre parênteses, passamos o path como argumento, que é o caminho dos dados de vendas da Meteora.

Vamos atribuir essa estrutura de dados à variável sales_data e exibi-la em seguida.

sales_data <- read.csv(path)
sales_data

A data.frame: 310 × 6

A estrutura retornada é um DataFrame, que na apresentação se assemelha a uma matriz. Contudo, as colunas são exibidas com nomes e tipos, como chr e int.

Ele possui as mesmas seis colunas de data, ID do produto, nome do produto, quantidade vendida, estoque disponível e categoria. Só que agora são 310 registros, ou seja, 300 registros a mais do que a amostra de dados utilizada anteriormente.

Diferente de uma matriz, que requer um tipo único de dados, o DataFrame suporta diversos tipos de dados.

Para confirmar a estrutura, utilizamos a função class(), passando sales_data como argumento:

class(sales_data)

'data.frame'

Ela retorna o tipo data.frame. Podemos comparar com a estrutura do sales_data_matrix, que era uma matriz de array.

class(sales_data_matrix)

'matrix' 'array'

O DataFrame vem como estrutura padrão da função read.csv(), o que nos sugere que essa é a estrutura correta para nosso propósito.

Explorando a estrutura de dados

Para explorar os dados de um DataFrame, podemos utilizar a função head() para exibir apenas os seis primeiros registros do sales_data.

head(sales_data)

A vantagem é que conseguimos ter uma noção da estrutura e do tipo de dados, sem precisar exibir todo o objeto.

Assim como fazemos com matriz e vetor, podemos usar colchetes para acessar dados específicos, passando primeiro a linha e depois a coluna.

Por exemplo, para conferir apenas a primeira linha, podemos digitar sales_data, abrir colchetes e selecionar o primeiro registro e todas as colunas, ou seja, [1, ].

sales_data[1,]

É retornado apenas o primeiro registro do DataFrame, como esperado.

Para saber o nome do produto do primeiro registro, podemos especificar tanto a linha 1 quanto a coluna 3 entre os colchetes.

sales_data[1, 3]

'Camisa Social Azul'

Além do número da coluna, também podemos usar o nome das colunas do DataFrame para acessar os dados. Tanto que se substituímos a coluna 3 por Nome_Produto, entre aspas, obteremos o mesmo resultado.

sales_data[1,"Nome_Produto"]

'Camisa Social Azul'

Uma última maneira de acessar esses dados é utilizar o cifrão ($) seguido do nome da coluna. Para exemplificar, em uma nova célula, digitaremos sales_data seguido de $Nome_Produto e especificando, entre colchetes, a linha 1.

sales_data$Nome_Produto[1]

'Camisa Social Azul'

Esses são algumas formas de acessar dados individuais para explorar os dados e adquirir insights sobre o conjunto.

Para responder a dúvidas de negócio, a função summary() fornece dados estatísticos sobre os dados passados como argumento. Nesse caso, passaremos o nome do DataFrame, sales_data.

summary(sales_data)

Data

• Length: 310
• Class: character
• Mode: character

ID_Produto

• Min.: 1001
• 1st Qu.: 1003
• Median: 1006
• Mean: 1006
• 3rd Qu.: 1008
• Max.: 1010

Nome_Produto

• Length: 310
• Class: character
• Mode: character

Quantidade_Vendida

• Min.: 1.00
• 1st Qu.: 6.00
• Median: 11.00
• Mean: 10.64
• 3rd Qu.: 15.75
• Max.: 19.00

Estoque_Disponível

• Min.: 10.00
• 1st Qu.: 33.00
• Median: 54.00
• Mean: 54.39
• 3rd Qu.: 76.00
• Max.: 99.00

Categoria

• Length: 310
• Class: character
• Mode: character

Para os dados do tipo chr, são devolvidas a quantidade de registros, a classe e o tipo. Já para dados do tipo int, ou seja, numéricos, foram retornadas algumas estatísticas, como mínimo, máximo, média e mediana.

É importante interpretar esses resultados, pois nem todos fazem sentido, como a mediana de um ID que é apenas um identificador do produto. Por outro lado, a mediana da quantidade de vendas pode ser útil para análises futuras.

Próximos passos

A estrutura DataFrame oferece diversos recursos e parece ideal para nossa análise de dados. Já conseguimos algumas respostas que podem ajudar o time de negócios.

Agora, precisamos entender quais problemas a Meteora quer resolver e como nossa análise de dados pode ajudar.

Sobre o curso R: utilizando e manipulando estruturas para análises de dados

O curso R: utilizando e manipulando estruturas para análises de dados possui 91 minutos de vídeos, em um total de 44 atividades. Gostou? Conheça nossos outros cursos de Data Science em Data Science, ou leia nossos artigos de Data Science.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Importando e explorando os dados
• Alterando e indexando os dados
• Agregando dados e criando funções
• Ordenando e filtrando os dados
• Salvando e exibindo os dados