Analisando os dados do Airbnb do Rio de Janeiro com Python
“Viagens inesquecíveis começam com o Airbnb. Encontre aventuras próximas ou distantes de você e acesse acomodações, experiências e lugares únicos em todo o mundo.”
Criado em 2008, o maior site de hospedagens que não possui nenhum imóvel, busca unir anfitriões e viajantes para que possam anunciar suas acomodações ou reservá-las em qualquer parte do mundo.
O Airbnb torna esse compartilhamento fácil e seguro, permitindo um sistema de avaliações para que o viajante encontre o local perfeito para a sua viagem de turismo ou negócios. Além de poder reservar um apartamento, casa ou apenas um quarto.
Toda a comunicação e pagamento é feito diretamente pela plataforma, além de possuir um suporte 24h em 11 idiomas. A plataforma é extremamente intuitiva, mesmo para quem a usa pela primeira vez. Em uma ocasião, precisei cancelar uma reserva que tinha feito para passar o final de semana na cidade de Porto Belo/SC, e rapidamente consegui esse cancelamento, sem muita burocracia, e no mesmo mês o valor cobrado do cartão de crédito foi estornado.
“Como o Airbnb está realmente sendo usado e afetando os bairros da sua cidade?”
Para conseguirmos os dados para estudo, iremos extraí-los do portal Inside Airbnb, que disponibiliza informações sobre diversas cidades ao redor do mundo, como Paris, Roma, Washington, Rio de Janeiro entre outras.
Antes de iniciarmos o tratamento de dados, precisaremos importar as bibliotecas necessárias. Um dos grandes pontos positivos de usar o Google Colab, um jupyter notebook disponibilizado pelo Google em nuvem, é que não precisamos fazer o download de nenhuma ferramenta e a importação das bibliotecas é feita com comandos bem simples.
A princípio, usaremos três bibliotecas:
Pandas, uma biblioteca de software criada para a linguagem Python para manipulação e análise de dados. Em particular, oferece estruturas e operações para manipular tabelas numéricas e séries temporais. Ao utilizarmos essa biblioteca, a manipulação de dados é equivalente a manipular uma planilha pelo Excel, disposta em linhas e colunas.
Matplotlib, utilizado para fazer gráficos básicos. Os conjuntos de dados são visualizados com a ajuda de gráficos de barras, histogramas, gráficos de partes, gráficos de dispersão, linhas e assim por diante.
Seaborn, que contém uma série de padrões e gráficos para visualização de dados. Ele usa temas fascinantes. Ele ajuda a compilar dados inteiros em um único gráfico. Ele também fornece distribuição de dados.
import pandas as pdimport matplotlib.pyplot as pltimport seaborn as sns
Uma das facilidades de trabalharmos com o Google Colab, é que caso os dados analisados estejam disponíveis na internet, podemos acessá-los diretamente com a biblioteca Pandas, que está com o atalho “pd” definido.
Os dados das cidades encontram-se nesse link, e os dados da cidade do Rio de Janeiro aqui.
Com o caminho dos dados definido, iremos carregá-lo em um DataFrame, batizado de “df”, que possui a mesma estrutura de uma planilha de Excel, bidimensional contendo linhas e colunas, com o comando “pd.read_csv(“url”)”.
Além disso, com o comando “.head()”, iremos exibir as 5 primeiras linhas do DataFrame. A estrutura do comando é primeiro o nome do DataFrame, seguido por “.head()”.
df = pd.read_csv('http://data.insideairbnb.com/brazil/rj/rio-de-janeiro/2021-02-22/visualisations/listings.csv')df.head()
Ao exibir os dados, notamos que a ferramenta Pandas já definiu a primeira linha como cabeçalho, além de fazer a separação das colunas pela vírgula, pois o é o separador de um arquivo CSV.
Um dos primeiros itens a serem feitos antes de começarmos, é a criação do dicionário de variáveis, mas antes disso iremos verificar a porcentagem de linhas vazias por coluna.
Para isso faremos uma soma da quantidades de colunas com valor nulo, com o comando “.isnull().sum()” e iremos dividir pela quantidade total de linhas, com o comando “.shape[0]”. Além disso o resultado será multiplicado por 100, para ficar em porcentagem:
df.isnull().sum() / df.shape[0] * 100
Com essa análise, podemos verificar que a coluna “neighbourhood_group” não possui nenhum valor diferente de nulo, por isso a desconsideraremos no estudo.
Outras duas colunas que possuem uma grande quantidade de valores nulos, são as “last_review” e “reviews_per_month”, ambas possuindo mais de 37% de valores nulos. Provavelmente isso se deve a imóveis que ainda não possuem nenhuma avaliação.
Criando o dicionário de variáveis
Agora que carregamos os dados e verificamos a representatividade de valores nulos, precisamos entender o que cada coluna possui:
- id — id do imóvel, código único para identificação do imóvel dentro do Airbnb.
- name — nome da propriedade.
- host_id — id do proprietário, código único para identificação do proprietário dentro do Airbnb.
- host_name — nome do proprietário.
- neighbourhood_group — grupo do bairro, não iremos adentrar no mérito dessa coluna pois a mesma possui apenas valores nulos.
- neighbourhood — bairro onde o imóvel está localizado.
- latitude — latitude do imóvel.
- longitude — longitude do imóvel.
- room_type — tipo do quarto: casa, apartamento ou algum outro tipo.
- price — preço por noite.
- minimum_nights — número mínimo de noites para reserva.
- number_of_reviews — número de avaliações.
- last_review — dia, mês e ano da última avaliação.
- reviews_per_month — número médio de avaliações por mês.
- calculated_host_listings_count — quantidade de imóveis do mesmo proprietário.
- availability_365 — número de dias disponíveis nos próximos 365 dias.
Analisando os dados
Agora, iremos plotar um histograma para analisar a distribuição dos dados de cada coluna, com o comando “.hist();”:
df.hist()
Acima nota-se que os gráficos ficaram muito pequenos, o que está inviabilizando a análise. Vamos novamente criar os histogramas, mas dessa vez iremos definir o número de barras, altura e largura dos gráficos. Para saber os valores dessas informações, teremos que testar até encontrarmos a melhor visualização. Além disso após o código será colocado um “;”, para aparecerem apenas os gráficos.
df.hist(bins=15, figsize=(30,25));
Com os histogramas plotados, podemos verificar que provavelmente existem outliers presentes no conjunto de dados. Notem, por exemplo, como os gráficos de “price” e “minimum_nights” estão distorcidos, com uma grande quantidade no início do eixo e praticamente nada no final.
Para confirmar a presença de outliers, usaremos dois métodos:
- Uso da função “.describe()”, que trará um resumo das estatísticas de cada coluna, como a média, separação dos quartis e máximos.
- Plotagem de boxplots para verificarmos a dispersão dos dados de maneira mais detalhada.
df.describe()
Com os dados acima, podemos tirar alguns insights, como:
- 3/4 das hospedagens possuem o valor diário abaixo de R$ 500,00, enquanto a mais cara possui o valor de R$ 625.216,00.
- A média de noites mínimas por hospedagem é de 5 noites, aproximadamente, enquanto uma das hospedagens possui uma quantidade mínima de 1000 noites, quase 3 anos.
Boxplots e outliers
Agora vamos criar os boxplots das colunas que identificamos a possibilidade da existência de outliers, que são pontos que fogem da normalidade e podem estar incorretos. Além do boxplot, vamos verificar a quantidade de hospedagens com o mínimo de noites acima de 15 dias, que já é uma quantidade de noites considerável.
df.minimum_nights.plot(kind='box', vert=False, figsize=(15,3))print("Quantidade de hospedagens com número de noites mínimas acima de 30 dias")print(len(df[df.minimum_nights > 30]))
Agora vamos ver o quanto essas 204 hospedagens representam sobre a quantidade total:
len(df[df.minimum_nights > 30])/df.shape[0]*1000.7664850648130753
Ou seja, esses outliers representam menos de 1%. Podemos visualizar essa dispersão no gráfico acima.
Agora vamos fazer a mesma análise sobre o coluna “price”, que contém o valor por noite hospedada. Para isso vamos plotar o boxplot e verificar a representatividade das hospedagens com valores acima de R$ 5.000,00:
df.price.plot(kind='box', vert=False, figsize=(15,3))print("Quantidade de hospedagens com valor diário acima de R$1.500,00")print(len(df[df.price > 2000]))len(df[df.price > 2000])/df.shape[0]*100
Com isso podemos verificar que menos de 5% das hospedagens possuem o valor acima de R$ 2.000,00, o que está gerando uma grande distorção no gráfico.
Dados sem outliers
Agora, apenas para efeitos visuais, vamos recriar os histogramas dessas duas colunas removendo os outliers. Para isso iremos criar uma cópia do DataFrame “df”, manter apenas as colunas “price” e “minimum_nights”, remover os outliers e plotá-los.
Primeiro vamos remover os outliers e coluna “neighbourhood_group” no novo DataFrame:
df_new = df.copy()df_new.drop(df_new[df_new.price > 1500].index, axis = 0, inplace = True)df_new.drop(df_new[df_new.minimum_nights > 30].index, axis = 0, inplace = True)df_new.drop('neighbourhood_group', axis = 1, inplace = True)
Agora vamos plotar os novos histogramas sem os outliers:
df_new.hist(bins=15, figsize=(30,25));Enquanto a maioria dos histogramas ficaram igual na primeira análise, os únicos que alteraram foram os de “price” e “minimum_nights”:
Nota-se que a distribuição não ficou tão uniforme quanto anteriormente, sem valores extremos.
Correlação entre os dados
Agora vamos verificar se existem correlações entre as colunas, seja com relação à quantidade mínima de noites, valor por noite ou latitude, por exemplo.
Para isso vamos criar um mapa de correlação, ou heatmap. Para inserirmos os dados dentro desse mapa, precisaremos primeiro gerar uma matriz de correlação, com o comando “.corr()”:
correlation = df_new[['price', 'minimum_nights', 'number_of_reviews', 'availability_365' ]].corr();display(correlation);
Agora vamos plotar o heatmap com essas informações, utilizando a biblioteca seaborn:
sns.heatmap(correlation, fmt='.2f', annot=True);
Podemos identificar que não existem grandes correlações entre as variáveis.
Tipo de hospedagem mais procurada
Para verificarmos o tipo de hospedagem mais procurado, iremos considerar a quantidade de avaliações, considerando que cada vez que uma pessoa se hospeda, é feita uma avaliação.
Usaremos o comando “.groupby()”, para agrupar os tipos de hospedagem, junto do comando “.sum()”, para somar o número de avaliações. Além disso, usaremos o comando “.sort_values(ascending=False)” para ordenar do maior para o menor, sendo que caso não defina a ordenação o padrão é do menor para o maior.
df.groupby(["room_type"]).number_of_reviews.sum().sort_values(ascending=False)
Com isso podemos identificar que o tipo de hospedagem mais procurada são casas e apartamentos inteiros, e não apenas um quarto.
Mapa com a localização das hospedagens
Agora vamos plotar um mapa usando a latitude e longitude, com uma escala de cores considerando o preço por noite.
df_new.plot(kind='scatter', x='longitude', y='latitude',alpha=0.4, c=df_new['price'], s=8, cmap=plt.get_cmap('jet'),figsize=(12,8));
Os pontos foram plotados juntamente da escala de cores, porém concorda que para a maioria das pessoas esse mapa não ajuda em nada? Fica muito difícil de identificar até onde fica o mar, a não ser que seja uma pessoa que conhece muito bem a capital carioca e seu mapa.
Para resolvermos isso, plotaremos esses pontos sobre o mapa do Rio, usando como base esse esse artigo do Chris I.
Primeiro vamos importar a biblioteca “matplotlib.image” para carregarmos a imagem do mapa do Rio de Janeiro retirada direto do Google Maps.
import matplotlib.image as mpimgAgora iremos plotar os pontos sobre a imagem que retiramos do Google Maps.
Para identificar as coordenadas dos extremos da imagem, basta apenas clicar com o botão direito do mouse sobre o ponto pré-definido:
As coordenadas devem ser retiradas de dois pontos da imagem: canto inferior esquerdo e canto superior direito.
Agora iremos seguir o passo a passo para criação do mapa:
# importando a imagemrj_img = mpimg.imread('RJ.png')# plotando os dados do nosso DataFrame df_new, o qual removemos os outliers, e definir as cores de acordo com o preçoax = df_new.plot(kind="scatter",x="longitude",y="latitude",figsize=(20,14),c="price",cmap=plt.get_cmap("jet"),colorbar=True,alpha=0.5,)# definindo as coordenadas dos extremos da imagem retirada do Google Maps# a ordem é: Longitude do canto inferior esquerdo, longitude do superior direito, latitude do inferior esquerdo e latitude do superior direitoplt.imshow(rj_img, extent=[-43.83001,-43.13512,-23.11770,-22.77330], alpha=0.5)# adicionando os rótulos dos eixosplt.ylabel("Latitude", fontsize=20)plt.xlabel("Longitude", fontsize=20)# definindo os valores mínimos e máximos dos eixos, devem ser os mesmo que definimos acimaplt.ylim(-23.11770,-22.77330)plt.xlim(-43.83001,-43.13512)plt.legend(fontsize=20)plt.show();
Que resultará no seguinte gráfico:
Conclusão
Com o mapa da cidade do Rio de Janeiro e os pontos plotados, podemos identificar as seguintes situações:
- A maior parte das hospedagens disponibilizadas estão próximos das praias, principalmente na região do Cristo Redentor e Maracanã, na região leste da cidade.
- Na Ilha do Governador, próximo ao Aeroporto Internacional Tom Jobim, também conhecido como RIOGaleão, possui uma das maiores densidades de hospedagens da cidade.
- Apesar de existirem muitas hospedagens com um preço elevado de diária, existem muitas opções em torno de 200,00 reais, que são os pontos que possuem coloração próxima do azul escuro.
- Caso precise de uma hospedagem na região de Campo Grande ou Bangu, mais a Oeste/Norte, a quantidade de opções é muito menor, mas com uma grande variedade de valores de diária.
O jupyter notebook utilizado para esse projeto está nesse link, e caso queiram discutir algo sobre esse projeto, podem me chamar direto no Linkedin.
