Tag

análise de dados Archives - Análise Macro

Lidando com datas no Python: as bibliotecas time e datetime

By | Python

Trabalhar com datas em uma computador pode ser algumas vezes complicado, visto a vasta quantidade detalhes que essa área oferece. Apesar disso, é possível descomplicar totalmente essa questão através de duas bibliotecas do Python: time e datetime. No post de hoje, iremos ensinar alguns pontos importantes sobre tempo e data no Python, bem como realizaremos exemplo com as duas bibliotecas.

Tipos de datas

No Python, podemos definir os tipos de dados para datas para os seguintes:

  • data: armazena uma data de calendário
  • time: armazena a hora do dia na forma de horas, minutos, segundos e microssegundos
  • datetime: armazena data e hora
  • timedelta: diferença entre dois valores de datas
  • tzinfo: fuso horário (time zone)

Para especificação de formatos de datas, é comum usar o padrão %Y para ano com quatro dígitos, %m para mês com dois dígitos e %d para dia com dois dígitos, formando o padrão %Y-%m-%d, comum para a importação de diversos dados em séries temporais ao redor do mundo. Ainda é possível que seja adicionado %H, que representa as horas em formato de 24h.

Existem diversos outros formatos para anos, meses, dias e horas, seguindo a lista abaixo:

ano

  • %y: ano de dois dígitos (22)
  • %Y: ano de quatro dígitos (2022)

mês

  • %b: Mês abreviado (Mar)
  • %B: Nomes completos de meses (March)
  • %m: Mês como número (03 ou 3)

dia

  • %d: Dia do mês (30)

dia da semana

  • %a: Nome abreviado (Wed)
  • %A: Nome completo
  • %w: número (3 - Sunday sempre como 0 até Saturday como 6)

horas

  • %H: 24 horas (00 até 23)
  • %I: 12 horas (01 até 12)
  • %M: minutos (01 até 59)

segundos

  • %S: segundos de 00 até 59

AM/PM

  • %p: utilizado junto com horas em formatos de 12 horas

Feito a introdução, podemos prosseguir com as bibliotecas e suas respectivas funções.

Time

A biblioteca time oferece ao usuário mecanismos de obter os valores do tempo no Python. O chamado tipo de dado timestamp, que são instantes específicos no tempo. Além também de calcular o tempo de processamento de um iteração ou função, útil para que aqueles que necessitam comparar tempos de resposta de modelos, de forma que se possa otimizar o trabalho e reduzir custos.

Construímos um vetor de tempo através do módulo locatime(), com o formato de struct_time, contendo todas as informações do momentos atual em formato de horas, dias, semanas, mês, anos, etc. É possível transformar esse tipo de dado com o módulo asctime, tornando-o mais interessante.

Através do código abaixo, podemos calcular o tempo de processamento do for construído. Vejam que realizamos através da diferença de contagem de dois objetos de data, resultando em um dado do tipo timedelta.

Datetime

A biblioteca datetime oferece uma gama de ferramentas para a criação e manipulação de séries no tempo para data frame. O seu uso em conjunto com o pandas os torna poderosos, de forma que aqueles que lidam com séries temporais podem se beneficiar.

Construímos um objeto do tipo datetime com a data de interesse através de datetime(). Veja que criamos um objeto com o dia atual, mas também podemos realizar com outras datas.

Para construir um objeto do tipo datetime com o momento atual, utilizamos os módulo now(), que retorna esse dado.

Se quisermos realizar transformações de datas, utilizamos strptime que passando o objeto de strings, e o formato que queremos, geramos um objeto datetime.

Também é possível construir essa transformação com objeto date time de formato numérico, utilizando strftime, porém com outro formato.

Por fim, podemos realizar comparações lógicas com as datas, além também de realizar operações númericas, sendo o mais comum o timedelta, que nos retorna a diferença entre duas datas.

Apesar de simples o contexto do datetime, a biblioteca é extremamente útil com o pandas, oferecendo um grande ferramental para manipulação de séries no tempo, como mudanças do índice, frequências e intervalos de datas, operações, entre outros.

Migrando do Excel para R e Python

By | Hackeando o R, Python

Todos sabemos que boa parte do armazenamento e do uso dados viveu (ou ainda vive) dentro de planilhas eletrônicas, principalmente pelo Excel. Não podemos deixar de negar todos os pontos benéficos do uso dessas planilhas, seja pela simplicidade ou pela facilidade de aprender a utilizar uma. Por outro lado, sabemos das dificuldades que o  uso do Excel podem impor, comparado com as linguagens de programação R e Python, principalmente para a área de limpeza de dados, análise exploratória de grandes bases de dados e modelagem. Neste post, iremos mostrar aos usuários do Excel pontos em comuns com R e Python e também o que se pode alcançar a mais com essas linguagens.

Excel e Análise de dados

O Excel, por historicamente estar relacionado com o uso de dados, consequentemente leva aos seus usuários como intuitivamente a utilizar e compreender como trabalhar com dados: é possível ordenar, filtrar, agrupar, juntar dados, calcular suas medidas estatísticas e criar gráficos. Este é um conhecimento útil para análise de dados, porém, haverá momentos em que o usuário ficará preso em pouca variedade de técnicas, além de que se for realizar um passo adiante nessas técnicas irá encontrar dificuldades (no qual será o ponto que R e Python irão preencher).

Para começar nossas comparações e estudos, iremos pegar como exemplo um dataset (um conjunto de dados) com suas colunas (variáveis) e observações (linhas). Cada observação de uma coluna é indexada a outra observação de outra coluna. Importante dizer que uma coluna deve ser homogênea, isto é, possuir o mesmo tipo de dado. A grosso modo, existem dois tipos: categórico e quantitativo (que se dividem em mais tipos).

Veja um exemplo de dataset no Excel:

A partir das variáveis que encontram no dataset, o usuários do Excel poderiam ter uma variedade de recursos e funções para analisá-lo: medidas de tendência central (média, moda, mediana), medidas de dispersão (variância e desvio padrão), ordenamento e agrupamento de categoria, entre outras diversas possibilidades.

R para Análise de dados e Tidyverse

No R, começamos na forma em que podemos manipular os dados, por mais que estejamos lidando aqui com um dataset que está estruturado, é útil para que possamos realizar cálculos e tirar variáveis/observações que não é de nosso interesse. Para isso, iremos apresentar o mundo do Tidyverse, que envolve uma família de pacotes do R, utilizado para manipular dados. As funções mais comuns do Tidyverse são:

  • select() - seleciona as colunas de interesse;
  • mutate() - cria novas colunas baseado nas colunas já existentes;
  • rename() - renomeia as colunas de interesse;
  • arrange() - ordena as colunas de formas crescente ou decrescente;
  • filter() - seleciona as linhas com base em uma condição;
  • group_by() - agrupa as linhas (normalmente dados categóricos) das colunas de interesse;
  • summarize() - agrega os valores de cada grupo (útil para realizar cálculos agrupados);
  • left_join() - junta dois datasets que possuem uma mesma coluna correspondente.

Com o dataset (que no R e Python chamaremos de DataFrame) iris (que vem em conjunto do pacote Tidyverse no R), podemos fazer alguns exemplos, utilizando o Tidyverse para manipulação de dados. O primeiro passo será carregar o pacote (caso não tenha, instale com install.packages('tidyverse')). A função head() permite que possamos dar uma olhada nos dados antes de começar. Entendido os dados, podemos selecionar as colunas de interesse, com a função select(), veja que no primeiro argumento deve ser inserido o DataFrame que queremos utilizar e no segundo argumento a coluna deste DataFrameAlém de selecionar pelo nome, podemos selecionar pelo número da ordem da coluna no DataFrame. No exemplo, selecionamos as colunas de 1 até 3, utilizando 1:3.

Para  realizar o caminho contrário, isto é, retirar colunas de um DataFrame, utilizamos a mesma função, porém, com o símbolo de negação ! do R, que a grosso modo, significa realizar o contrário.

 

 

Para realizar mudanças nas colunas, utilizamos a função mutate(), seguindo o mesmo processo da função anterior, utilizando como primeiro argumento o DataFrame que queremos, por outro lado, como queremos criar uma nova coluna, devemos mudar um pouco a sintaxe, criando um nome para a nova coluna e mudando os valores que queremos com uma função ou cálculo. No exemplo, utilizamos toupper() para que todos as letras da colunas Species sejam maiúsculas.

Para renomear a coluna, utilizamos rename(), orientando o novo nome ao nome atual da coluna. Mudado de Sepal.Length para sepal_length.

A função arrange() irá permitir que a coluna Species fique em ordem crescente. Essa função também reconhece variáveis quantitativas, ordenando números por ordem crescente ou descrecente.

O filter(), como dito, permite filtrar as linhas de acordo com critérios escolhidos. No primeiro uso, colocamos como condição que apenas as observações do DataFrame que possuem Sepal.Width maior que 3.6 apareçam. No segundo uso, colocamos como condição que apenas as Species de nome setosa estivessem no DataFrame. E por último, mostramos como podemos colocar mais de uma condição misturando as duas condições anteriores utilizando o &.

Para agrupar os dados, utilizamos a função group_by, porém, não é tão útil utiliza-la sozinha, visto que precisamos realizar uma chamada de um cálculo ou mudanças nas observações para que tenha efeito. Para isso, o summarize() é uma ótima combinação, permitindo que seja feito operações nas colunas de acordo com o grupo selecionado pelo group_by(). No exemplo, calculamos a média de Sepal.Width para cada Species. Veja também que utilizamos o símbolo %>%, uma função do Tidyverse que nos ajuda a utilizar mais de uma função em sequencia.

Por fim, podemos juntar DataFrames diferentes (ou iguais no caso) para que possamos manipula-los em conjunto. O segredo é que ambos os DataFrames devem possuem pelo menos uma coluna em comum, de forma que elas tenham uma relação entre si. No exemplo, utilizamos a função left_join  para juntar o DataFrame iris da esquerda com o da direito, de acordo com a coluna Species.

Python para Análise de dados e pandas

O Python, assim como o R como Tidyverse, também possui uma biblioteca extremamente importante para facilitar a análise de dados, que é o pandas,  uma biblioteca que oferece um ferramental gigantesco não só para criar e utilizar DataFrames, como também para manipula-los. Nos exemplos, também iremos mostrar os mesmos resultados que obtivemos com o R e o Tidyverse, porém utilizando o pandas do Python.

O primeiro passo será carregar a biblioteca pandas no Python e também o DataFrame iris, que neste caso, utilizamos um arquivo .csv em conjunto com a função do pandas read_csv().

Utilizando a função head(), verificamos o nosso Dataframe para que possamos trabalhar. O primeiro passo será como selecionar colunas no Python, que segue apenas chamando o nosso DataFrame iris e através de dois colchete, selecionarmos os nomes das colunas queremos. Caso utilizarmos apenas um colchete, será retornado um objeto do tipo Series, e não DataFrame, o que não nos é útil no momento.

Para o caminho contrário, usamos drop() para que a coluna de interesse seja excluída do DataFrame. Veja que utilizamos o argumentos axis, isso porque queremos dropar colunas e não linhas.

Para criar novas colunas, seguimos o mesmo raciocínio de colchetes para selecionar colunas, porém utilizamos operadores matemáticos para realizar o procedimento. Veja que no exemplo somamos duas colunas selecionando-as com apenas um colchete (o suficiente para selecionar os valores).

Para ordenar as colunas, utilizamos a função sort_values(), especificando a coluna de interesse com o argumento by. O raciocinio desta função é o mesmo que o do Tidyverse.

Para realizar filtros, o raciocínio segue o mesmo para selecionar colunas, a diferença é que utilizamos o operador lógico para realizar o filtro. O porém aqui é que o que é retornado é na realidade um vetor de True e False dos valores que preencheram a condição exigida. A solução é utilizar o objeto do filtro dentro de um colchete do DataFrame para selecionar as observações do DataFrame.

Em relação ao agrupamento, utilizamos a função groupby() para selecionar a coluna de interesse. Logo em seguinda, utilizamos a função mean() para obter a média de todas as colunas agrupadas por Species.

E por fim, para juntarmos DataFrames, utilizamos a função merge(), que permite juntar DataFrames que possuem colunas em comum. Na função, o argumento on nos permite especificar qual coluna será essa. O argumento how especificar qual coluna será a base.

Vimos neste post as principais funções do R e Python que se assemelham com aquelas utilizadas no Excel para análise de dados. Existe ainda um enorme mundo a ser percorrer em ambas as linguagens, tanto na parte Estatística, de Visualização e também por Modelagem. Aqui na Análise Macro realizamos post diários sobre ambas as linguagens, ensinando desde o básico até o avançado. Para compreender ainda mais ambas as linguagens, nossos Cursos de R e Python aplicados a Ciências de Dados, Economia e Finanças pode lhe ajudar mais ainda.

Quer aprender mais sobre R e Python? 

Abrimos hoje, 22/3, as inscrições com 30% de desconto para as Turmas de Outono dos nossos Cursos Aplicados de R e Python. As vagas com esse desconto são limitadas aos primeiros inscritos. Haverá vagas para 25 Cursos Livres e 3 Formações. As turmas de Outono terão início no dia 04/04 e contarão com Cursos de Introdução à Programação em R ou Python, de modo que não é necessário nenhum conhecimento prévio nas linguagens. Para todos os detalhes sobre as Turmas de Outono, entre neste link e garanta sua vaga!

Introdução ao pandas

By | Python

A biblioteca pandas pode ser considerada a mais importante dentro do mundo da análise de dados para o Python. É a ferramenta principal para construção de estrutura, manipulação e limpeza de dados, sendo também utilizada com bibliotecas de processamento numérico e construção de gráficos. No post de hoje, iremos realizar uma breve introdução a esta biblioteca.

O ponto chave do pandas está na estrutura de dados no qual a biblioteca permite criar e manipular, são elas: Series e DataFrame.

Series é um objeto array unidimensional (tal qual o array criado com o Numpy) possuindo um índice (rótulos das observações). O DataFrame é considerado como um conjunto de dados retangulares ou dados tabulares, no qual cada coluna tem um tipo de dado, representados por um índice de colunas e um índice para cada observação (linha).

Para importar a biblioteca, iremos utilizar a seguinte convenção:

import pandas as pd

Series

Como dito, o objeto Series é um array unidimensional associado a um rótulo de dados chamado índice (ou index). Podemos criar uma Series a partir do seguinte código.

series_obj = pd.Series([4, 5, 6, 3])
series_obj

Veja que para cada valor há um número representando a ordem das observações. É possível criar os valores dos índice.

series_obj2= pd.Series([4, 7, 8, -2], index = ['a', 'b', 'c', 'd'])
series_obj2

Assim como um array do Numpy, é possível realizar cálculos com o objeto séries, seja através de funções, multiplicação escalar ou mesmo filtragens. A ordem do índice não se altera. Veja também que pela filtragem é possível escolher através do rótulo da observação.

# Calcula a média da Series
series_obj2.mean()
# Multiplica a array por 2
series_obj2 * 2
# Seleciona o valor no qual o índice é representado por 'a'
series_obj2['a']

DataFrame

Como dissemos, o DataFrame representa uma tabela de dados retangulares contendo uma coleção de colunas, preenchidas de uma série de observações, sejam elas numéricas, strings, booleans, etc. Possui também dois índices, sendo uma para as observações e outra para as colunas. Podemos dizer que é uma coleção de lista, dicionários ou arrays unidimensionais.

Vamos construir um DataFrame a partir de um conjunto de dicionários.

data_raw = {'cursos' : ['machine learning', 'econometria', 'séries', 'visualização'],
        'carga_horaria' : [90, 60, 90, 40],
        'desconto' : [True, False, True, False]}

data = pd.DataFrame(data_raw)
data

É possível também, a partir do pandas, importar dados de outros lugares. O mais comum é importar arquivos .csv. Vemos um exemplo abaixo, importando um dataset de treino de um conjunto de dados sobre preços de casas na Califórnia contidos no Google Colab.

california_houses = pd.read_csv('/content/sample_data/california_housing_train.csv')

Quando recebemos esse conjunto de dados, o interessante é explorá-lo para obter uma noção de seu conteúdo. Podemos utilizar diversos métodos para isso.

# Retorna as primeiras linhas do DataFrame
california_houses.head()

# Exibe as informações sobre o DataFrame
california_houses.info()
# Sumariza as estatísticas
california_houses.describe()
Também é possível retirar os números dos índices e os nomes das colunas
# Retira as colunas
california_houses.columns

# Números dos índices
california_houses.index

Nesse post realizamos uma breve introdução aos pandas, há ainda uma série de outras possibilidades de manipulação e cálculos que podemos realizar, tais como filtragens mais avançadas dos DataFrames, agregação e junção com condições, além de aprender métodos para preparar um Dataframe para visualização e modelagem.

Como analogia, podemos dizer que a biblioteca pandas pode ser considerada como um canivete suíço, com uma variedade de ferramentas, ficando a cargo do usuário qual utilizar, podendo em muitas vezes ser vasto o tempo necessário de aprendizagem. Apesar disso, os cursos da Análise Macro facilitam este problema, com uma série de aulas teóricas e práticas com o Python, facilitando a vida de quem quer aprender mais sobre Análise de Dados.

Hackeando o R: o pacote {data.table}

By | Hackeando o R

O {data.table} é um pacote do R e também uma classe de objetos que pode ser considerado uma extensão do data.frame comum: possuem uma estrutura de colunas que dispõe do mesmo comprimento, e para cada coluna, uma classe única, e também diferentes tipos de observações em diferentes colunas. O objetivo do pacote é ter uma sintaxe simples para a análise de dados, e ser extremamente rápido em relação ao tempo de resposta do uso. Por isso, o ponto alto do pacote é que ele é extremamente útil para análise de grandes conjuntos de dados, principalmente microdados. No post de hoje, iremos introduzir o pacote {data.table} e mostrar como ele pode ser útil.

O {data.table} além de um pacote, é um tipo de classe que funciona no que pode se chamar de "3d": linhas, colunas e grupos.

DT[i, j, by ] + argumentos adicionais

O primeiro argumento "i", serve com controle das linhas do data.table, filtrando expressões ou números de acordo com as colunas selecionadas.

O argumento, "j" é utilzado para controlar colunas, sendo possivel selecionar, calcular e realizar diversas outras mudanças.

"by" realiza as operações de colunas por grupos, para comparação, tem o efeito parecido com a função group_by do pacote {dplyr}, porém com mais possbilidade de transformações e sinergia com os argumentos anteriores.

Na prática, a forma de escrita dos argumentos do {data.table} lê-se como: Pegue os dados, filtre as linhas por "i", e então calcule "j" por "by'. Iremos demonstrar alguns exemplos com pontos introdutórios importantes do pacote.

library(data.table)

Criar um objeto data.table funciona da mesma forma que criar um objeto data.frame comum. Utilizamos a função data.table para criar as linhas conforme os nomes das colunas. No exemplo abaixo, criamos um data.table com três colunas: uma do tipo numérico, a segunda do tipo caracter, e a terceira do tipo lógico.

 

data.table::data.table(a = 1:5,
name = c("a", "b", "c", "d", "e"),
logical = c(TRUE, FALSE, TRUE, FALSE, FALSE))

Para transformar um objeto data.frame (ou outra classe) para data.table, utiliza-se a função as.data.table. No exemplo abaixo vemos qual o efeito sobre o data.frame "iris".

as.data.table(iris)

 

Repare na forma que é apresentado um conjunto de dados da classe data.table no console. É criado um índice numerando a quantidade de linhas, a partir da primeira observação, e que se separa visualmente das colunas por dois pontos. Outro ponto é que mostrado as primeiras e últimas 5 linhas do data.table.

A importação de dados pelo data.table é feita a partir da função fread. Além de ser extremamente rápida na leitura de dados, se comparada com outras funções, fread realiza a leitura de forma inteligente, não necessitando na maioria das vezes criar argumentos ou utilizar de outras funções para ler corretamente os dados.

iris_table <- fread("https://forge.scilab.org/index.php/p/rdataset/source/file/master/csv/datasets/iris.csv")

 

O objeto importado pela função fread é automaticamente criado em classe data.table.

class(iris_table)

 

Com o básico em mãos, podemos adentrar nos conceitos básicos dos argumentos do pacote.

Filtrar

O filtro de observações deve ser sempre utilizado como primeiro argumento no data.table. Veja que para utilizar a função deve-se escrever o nome do objeto e em seguida abrir colchetes.

</pre>
# Filtra valores de Sepal.Length maiores que 7

iris_table[Sepal.Length > 7]

# Filtra valores de Sepal.Length maiores que 7 e Sepal.Width maiores que 3

iris_table[Sepal.Length > 7 & Sepal.Width > 3]

# Filtra valores de Species para apenas virginica

iris_table[Species == "virginica"]
<pre>

Colunas

O argumento de manipulação de colunas deve sempre ser o segundo argumento dentro dos colchetes, é separado por uma virgula do primeiro argumento, mesmo que este não seja utilizado.

</pre>
# Retirar a primeira coluna do data.table

iris_table <- iris_table[, -"V1"]
<pre>

Um ponto importante a comentar é que a seleção de colunas pode ser feita de diferentes formas. É possível selecionar pelo número da ordem da coluna ou pelo nome. Pelo nome da coluna, caso não esteja entre aspas, é retornado um vetor, ao invés de objeto data.table. Outro forma de selecionar é através de um parênteses em conjunto de um ponto, essa forma torna mais simples os cálculos da colunas.

</pre>
# Seleciona a primeira coluna

iris_table[, 1]

# Seleciona apenas a colunas Sepal.Lenth

iris_table[, Sepal.Length] # Retorna vetor

iris_table[, "Sepal.Length"]

iris_table[, .(Sepal.Length)]
<pre>

Vemos também a utilização dos argumentos "i" e "j" juntos. Também realizamos calculos das colunas utilizando funções base do R.

</pre>
# Filtra valores de Sepal.Length maiores que 7 e seleciona apenas a coluna Sepal.Length

iris_table[Sepal.Length > 7, "Sepal.Length"]

# Calcula a média da coluna Sepal.Length

iris_table[, mean(Sepal.Length)] # retorna um vetor

iris_table[, .(mean(Sepal.Length))] # retorna um data.table

# Filtra valores de Sepal.width maiores que 3,2 e calcula os desvio padrão da coluna

iris_table[Sepal.Width > 3.2, sd(Petal.Width)]
<pre>

Grupos

Os grupos surgem como o último argumento dos colchetes, sendo necessário a utilização dos outros dois argumentos. O propósito do "by" é junta as categorias de uma coluna e possibilitar o cálculo por grupos.

</pre>
# Calcula a média de Sepal.Length por espécie

iris_table[, mean(Sepal.Length), by = "Species"]

# Calcula a média de Sepal.Length por espécie nomeando a nova coluna de "mean"

iris_table[, .(mean = mean(Sepal.Length)), by = (Species)]
<pre>

O data.table permite que seja feito um encadeamento de colchetes, possibilitando que seja feito manipulações por etapas.


iris_table[, .(Sepal.Length, Species, Petal.Length)][Sepal.Length > 6.5][, .(mean_sepal = mean(Sepal.Length),
mean_petal = mean(Petal.Length)), by = "Species"]

 

Por fim, é possível exportar um objeto data.table para outros tipos de arquivos através da função fwrite

</pre>
iris_table_ <- iris_table[Sepal.Length > 6.5, .(Species, Sepal.Length)]

fwrite(iris_table_, "iris_table_.csv")
<pre>

___________________

Quer aprender mais sobre o pacote {data.table} e aprender a realizar análise de dados em grandes conjuntos de dados? Veja nossos Cursos de Microdados Aplicados.

___________________

Hackeando o R: acessando os dados do datasus com o R

By | Hackeando o R

Dentro do universo do R, cada vez mais tem sido facilitado o acesso a diversos tipos de dados. Para tanto, O pacote {microdatasus} tem como principal propósito a importação dos microdados do DATASUS, este sendo um sistema do estado brasileiro de apoio a conexão e suporte de informações sobre a saúde com os entes federativos. No Hackeando o R de hoje, iremos dar uma olhada sobre o pacote.

Antes de tudo é necessário realizar o download do pacote, que se encontra no repositório do autor no github.


# remotes::install_github("rfsaldanha/microdatasus")

library(microdatasus)
library(tidyverse)

O pacote se separa em dois tipos de funções, a primeira  sendo fetch_datasus(), que consiste na função que realiza o download dos dados. E o segundo tipo, que se refere ao pré-processamento dos dados, sendo eles: process_sim(), process_sinac() e process_sih().

Para importar os dados mostraremos exemplos da função fetch_datasus().

(obs: antes de replicar o código, certifique que sua máquina pode lidar com grandes quantidades de dados. O processo pode demorar um pouco).

# Sistema de Informação sobre Mortalidade de Minas Gerais de 2019

data_sim_mg <- fetch_datasus(year_start = 2019,
year_end = 2019,
uf = "MG",
information_system = "SIM-DO")

# Sistema de informação Hospital Descentralizada de Minas Gerais de 2019
data_sih_mg <- fetch_datasus(year_start = 2019,
year_end = 2019,
month_start = 1,
month_end = 12,
uf = "MG",
information_system = "SIH-RD")

# Sistema de informações sobre Nascidos Vivos de Minas Gerais de 2019

data_sinasc_mg <- fetch_datasus(year_start = 2019,
year_end = 2019,
uf = "MG",
information_system = "SINASC")

Trataremos de pegar somente dados de um único ano, já que são grandes quantidade de dados. Dependendo da máquina, pode demorar um pouco o tempo de download.

Ao seguir a etapa, agora é preciso tratar os dados com as respectivas funções de cada sistema.


# Trata os dados do SIM

sim_mg <- process_sim(data_sim_mg)

# Trata os dados do SIH

sih_mg <- process_sih(data_sih_mg)

# Trata os dados do SIA

sinasc_mg <- process_sinasc(data_sinasc_mg)

As variáveis dos dados de cada sistema possuem uma forma especial de lidar, além de seus nomes serem processados em abreviações. Para obter a informações de todas as variáveis e suas convenções, é recomendável checar o repositório do github do pacote.


# Seleciona os dados de interesse: Estado civil da mãe e Sexo do bebê

sinasc <- sinasc_mg %>%
select(ESTCIVMAE, SEXO) %>%
na.omit()

# Visualiza os número de Mães por Estado Civil

sinasc %>%
count(ESTCIVMAE) %>%
ggplot(aes(x = ESTCIVMAE, y = n,
fill = ESTCIVMAE,
color = ESTCIVMAE,
label = n))+
geom_bar(stat = "identity")+
geom_label(color = "black")+
labs(title = "Estado Civil das Mães de Nascidos em Minas Gerais",
subtitle = "ano de 2019",
x = "",
y = "",
caption = "Elaborado por analisemacro.com.br com dados do DATASUS")+
theme_minimal()+
theme(legend.position = "none")


# Visualiza o número de bebês por sexo

sinasc %>%
count(SEXO) %>%
ggplot(aes(x = SEXO, y = n,
fill = SEXO,
color = "SEXO",
label = n))+
geom_bar(stat = "identity")+
geom_label(color = "black")+
labs(title = "Sexo dos bebês nascidos em Minas Gerais",
subtitle = "ano de 2019",
x = "",
y = "",
caption = "Elaborado por analisemacro.com.br com dados do DATASUS")+
theme_minimal()+
theme(legend.position = "none")

 

 

________________________________

Na Análise macro oferecemos cursos que ensinam você a como lidar com o micro dados e análise de dados. Veja nossa trilha de Micro dados e nosso curso de R para análise de dados.

________________________________

Receba diretamente em seu e-mail gratuitamente nossas promoções especiais
e conteúdos exclusivos sobre Análise de Dados!

Assinar Gratuitamente