joseferson da silva barreto
07/11/2021
Objetivo
Realizar uma análise exploratória afim de responder algumas questões , para estem fim usaremos os dados públicos disponíveis no IMDB sobre as avaliações dos filmes .
As principais pergutas que buscaremos respostas:
1- Quais São as Categorias de Filmes Mais Comuns no IMDB?
2- Qual o Número de Títulos Por Gênero?
3- Qual o Número de Filmes Produzidos Por País?
4- Quais São os Top 10 Melhores Filmes?
5- Quais São os Top 10 Piores Filmes?
Escolhendo o diretório e chamando a liguagem python
Para podermos utilizar a liguagem pyhon no Rmarkdown vamos chamar o pacote “reticulate”
Carregando pacotes
Agora vamos carregar os pacotes python necessários para a nossa análise
# Imports
import re
import time
import sqlite3
import pycountry
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib import cm
from IPython.display import display
from sklearn.feature_extraction.text import CountVectorizer
import warnings
warnings.filterwarnings("ignore")
sns.set_theme(style = "whitegrid")fazendo download do banco de dados publico do IMDB
As seguintes linhas de comando abaixo faz o download do banco de dados do IMDB , para utilizar remova as “#” depois de baixado,coloque a “#” novamente. É possível utilizar os comandos abaixo pelo o próprio CMD,caso queira .
#!imdb-sqliteConectando o banco dedos SQlite
Para conectar ao artquivo “db” vamos utilizar o comando “sqlite3.connect()”da do pacote sqlite3 , além disso , para podermos utilizar o arquivo SQl temos que indicar o caminho onde o arquivo “db” está localizado
# Conecta no banco de dados
conn = sqlite3.connect("C:/Users/josef/Documents/PythonFundamentos-master/Cap06/Notebooks/imdb.db")Gerando o data frame
O comando “pd.read_sql_query” do pacote “pandas” gera o nosso data frame onde os argumentos “SElECT AS” ,“FROM” ,“WHERE” são argumentos da linguagem SQL para seleção e “conn” é a variavél criada anteriomente que está conectada ao servidor Sql .
import pandas as pd
import sqlite3
# Extrai a lista de tabelas
tabelas = pd.read_sql_query("SELECT NAME AS 'Table_Name' FROM sqlite_master WHERE type = 'table'", conn)visualiza o tipo do objeto
visualiza o tipo de objeto que nosso caso é um DataFrame
# Tipo do objeto
#type(tabelas)Visualiza o resultado
# Visualiza o resultado
tabelas.head()## Table_Name
## 0 people
## 1 titles
## 2 akas
## 3 crew
## 4 episodesConvertendo o nosso DataFrame em lista
O comando “values.tolist()” é responsável pela conversão de DataFrame para lista.
# Vamos converter o dataframe em uma lista
tabelas = tabelas["Table_Name"].values.tolist()criando um loop
O loop vai funcionar da seguinte forma , para cada tabela na lista de tabelas ,vamos buscar os detalhes da tabela,logo,fazemos uma “consulta” ,na sequência buscaremos os “resultados” , o próximo passo imprime(print) o nome da tabela e o resultado display(resultado) além disso , imprimimos uma quebra de linha para que sejá visivél todas as tabelas .
# Vamos percorrer a lista de tabelas no banco de dados e extrair o esquema de cada uma
for tabela in tabelas:
consulta = "PRAGMA TABLE_INFO({})".format(tabela)
resultado = pd.read_sql_query(consulta, conn)
print("Esquema da tabela:", tabela)
display(resultado)
print("-"*100)
print("\n")
## Esquema da tabela: people
## cid name type notnull dflt_value pk
## 0 0 person_id VARCHAR 0 None 1
## 1 1 name VARCHAR 0 None 0
## 2 2 born INTEGER 0 None 0
## 3 3 died INTEGER 0 None 0
## ----------------------------------------------------------------------------------------------------
##
##
## Esquema da tabela: titles
## cid name type notnull dflt_value pk
## 0 0 title_id VARCHAR 0 None 1
## 1 1 type VARCHAR 0 None 0
## 2 2 primary_title VARCHAR 0 None 0
## 3 3 original_title VARCHAR 0 None 0
## 4 4 is_adult INTEGER 0 None 0
## 5 5 premiered INTEGER 0 None 0
## 6 6 ended INTEGER 0 None 0
## 7 7 runtime_minutes INTEGER 0 None 0
## 8 8 genres VARCHAR 0 None 0
## ----------------------------------------------------------------------------------------------------
##
##
## Esquema da tabela: akas
## cid name type notnull dflt_value pk
## 0 0 title_id VARCHAR 0 None 0
## 1 1 title VARCHAR 0 None 0
## 2 2 region VARCHAR 0 None 0
## 3 3 language VARCHAR 0 None 0
## 4 4 types VARCHAR 0 None 0
## 5 5 attributes VARCHAR 0 None 0
## 6 6 is_original_title INTEGER 0 None 0
## ----------------------------------------------------------------------------------------------------
##
##
## Esquema da tabela: crew
## cid name type notnull dflt_value pk
## 0 0 title_id VARCHAR 0 None 0
## 1 1 person_id VARCHAR 0 None 0
## 2 2 category VARCHAR 0 None 0
## 3 3 job VARCHAR 0 None 0
## 4 4 characters VARCHAR 0 None 0
## ----------------------------------------------------------------------------------------------------
##
##
## Esquema da tabela: episodes
## cid name type notnull dflt_value pk
## 0 0 episode_title_id INTEGER 0 None 0
## 1 1 show_title_id INTEGER 0 None 0
## 2 2 season_number INTEGER 0 None 0
## 3 3 eposide_number INTEGER 0 None 0
## ----------------------------------------------------------------------------------------------------
##
##
## Esquema da tabela: ratings
## cid name type notnull dflt_value pk
## 0 0 title_id VARCHAR 0 None 1
## 1 1 rating INTEGER 0 None 0
## 2 2 votes INTEGER 0 None 0
## ----------------------------------------------------------------------------------------------------Logo , teremos o esquema com os valores de cada tabela: pessoas(people), ou seja ,os atores que participaram dos filmes a tabela titulos(titles) que são os nomes dos filmes , a tabela “akas” que contem a região e o idioma dos filmes , a tabela “crew” que é as equipes que participaram na criação dos filmes , a tabela “episodes” que contem informações sobre séries ,documentários ,sagas e por último temos a tabela de avaliações(ratings)
Agora começamos a Análise Exploratória dos Dados.
1- Quais São as Categorias de Filmes Mais Comuns no IMDB?
Quais são os principais tipos (categorias) dos títulos (filmes)?
Primeiramente vamos realizar uma consulta a nossa fonte de dados , para isso vamos utilizar uma instrução Sql SELECT type onde “type” é a categoria ,“COUNT(*)” numero de registros , FROM titles ,ou seja, para a tabela “titles” agrupando por tipo GROUP BY type.
# Cria a consulta SQL
consulta1 = '''SELECT type, COUNT(*) AS COUNT FROM titles GROUP BY type''' Extraindo os resultados
vamos retornar o conjunto de resultados da string de consulta pelo comando pd.read_sql_query(),nesse caso, vamos executar a consulta(consulta1) da nossa conexão(conn).
# Extrai o resultado
resultado1 = pd.read_sql_query(consulta1, conn)Visualizando os resultados
para visualizar os resultados vamos utilizar o comando display() , caso dê erro , execute a seguinte linha de comandos no carregamento de pacotes python from IPython.display import display.
# Visualiza o resultado
display(resultado1)| type | COUNT |
|---|---|
| movie | 593301 |
| short | 840231 |
| tvEpisode | 6170725 |
| tvMiniSeries | 40522 |
| tvMovie | 133578 |
| tvPilot | 2 |
| tvSeries | 215826 |
| tvShort | 10362 |
| tvSpecial | 34752 |
| video | 327493 |
| videoGame | 29650 |
calculando o percentual para cada tipo
resultado1 irá receber uma nova variável(percentual) que nada mais é que cada total de registros dividido pela soma de registros multiplicado por 100
# Vamos calcular o percentual para cada tipo
resultado1['percentual'] = (resultado1['COUNT'] / resultado1['COUNT'].sum()) * 100Exibindo o resultado
# Visualiza o resultado
display(resultado1)| type | COUNT | percentual |
|---|---|---|
| movie | 593301 | 7.06610014099 |
| short | 840231 | 10.00698867449 |
| tvEpisode | 6170725 | 73.49214107595 |
| tvMiniSeries | 40522 | 0.48260918137 |
| tvMovie | 133578 | 1.59088814048 |
| tvPilot | 2 | 0.00002381961 |
| tvSeries | 215826 | 2.57044591030 |
| tvShort | 10362 | 0.12340941556 |
| tvSpecial | 34752 | 0.41388959752 |
| video | 327493 | 3.90037827928 |
| videoGame | 29650 | 0.35312576446 |
Vamos criar um gráfico com apenas 4 categorias:
Vamos criar um gráfico com 4 categorias , sendo 3 delas referente as categorias com mais títulos e 1 categoria com todo o restante (others). Antes vamos criar um dicionario vazio onde irá fica armazenado os valores das categorias restantes , depois vamos filtrar o percentual do (resultado1) que foram menor do que 5% depois vamos gravar o resultado em others[“percentual”].
# Vamos criar um gráfico com apenas 4 categorias:
# As 3 categorias com mais títulos e 1 categoria com todo o restante
# Cria um dicionário vazio
others = {}
# Filtra o percentual em 5% e soma o total
others['COUNT'] = resultado1[resultado1['percentual'] < 5]['COUNT'].sum()
# Grava o percentual
others['percentual'] = resultado1[resultado1['percentual'] < 5]['percentual'].sum()
# Ajusta o nome
others['type'] = 'others'visualisando
# Visualiza
others## {'COUNT': 792185, 'percentual': 9.434770108576943, 'type': 'others'}Próximo passo
Vamos filtrar os resuldos maiores que 5%, em seguida vamos adicionar “others” ao resultado1 e por último vamos ordenar (resultado1) por “COUNT”
# Filtra o dataframe de resultado
resultado1 = resultado1[resultado1['percentual'] > 5]
# Append com o dataframe de outras categorias
resultado1 = resultado1.append(others, ignore_index = True)
# Ordena o resultado
resultado1 = resultado1.sort_values(by = 'COUNT', ascending = False)
#renomeando
resultado1 = resultado1.rename(columns={'type': 'tipo','COUNT':'contagem'})# Visualiza
resultado1.head()| tipo | contagem | percentual |
|---|---|---|
| tvEpisode | 6170725 | 73.49214 |
| short | 840231 | 10.00699 |
| others | 792185 | 9.43477 |
| movie | 593301 | 7.06610 |
Logo , a categoria mais comum no IMDB é tvEpisode com 73% , na segunda posição aparece a categria short
com 10%.
Ajustandos os labels
Para ajustar os Labels vamos utilizar list comprehension onde que para cada índice do DataFrame do resultado1 retorno a categoria(tipo) e o percentual .
# Ajusta os labels
labels = [str(resultado1['tipo'][i])+' '+'['+str(round(resultado1['percentual'][i],2)) +'%'+']' for i in resultado1.index]Executando o gráfico de rosca
Para o mapeamento das cores vamos utilizar o “set3”, depois criamos a figura , em seuida criamos o gráfico atráves do comando plt.pie()
pequena descrição sobre alguns argumentos :
figsize= determina o tamanho da figura
radius= raio dá circunferência
wedgeprops = dict() = determina o tamanho da torta na circunferência
loc= local
# Plot
# Mapa de cores
# https://matplotlib.org/stable/tutorials/colors/colormaps.html
cs = cm.Set3(np.arange(100))
# Cria a figura
f = plt.figure(figsize = (8,8))
#f.set_size_inches(4,4)
#f.set_size_inches(6, 6, forward=True)
# Pie Plot
plt.pie(resultado1['contagem'], labeldistance = 0.5, radius = 1.2, colors = cs, wedgeprops = dict(width = 0.4))plt.legend(labels = labels, loc = 'center', prop = {'size':14})
plt.title("Distribuição de Títulos", loc = 'center', fontdict ={'fontsize':16,'fontweight':10})
plt.show()
Como foi dito anteriormente a categoria mais comum foi a de TvEpisode
2- Qual o Número de Títulos Por Gênero?
Vamos montar uma nova consulta ao nosso banco de dados como citado na questão 1 , dessa vez , bvamos utilizar a coluna “genres”, lembre-se que as palavras em letras maiúsculas são sintaxe Sql e as palavras em letras minúsculas é aquilo que está presente em nosso banco de dados .
# Cria a consulta SQL
consulta2 = '''SELECT genres, COUNT(*) FROM titles WHERE type = 'movie' GROUP BY genres''' vamos retornar o conjunto de resultados da string de consulta pelo comando pd.read_sql_query(),nesse caso, vamos executar a consulta(consulta2) da nossa conexão(conn).
# Resultado
resultado2 = pd.read_sql_query(consulta2, conn)
# Visualiza o resultado
display(resultado2)# Visualiza o resultado
display(resultado2)| N | genero | COUNT(*) |
|---|---|---|
| 1 | Action | 13589 |
| 2 | Action,Adult | 11 |
| 3 | Action,Adult,Adventure | 1 |
| 4 | Action,Adult,Comedy | 5 |
| 5 | Action,Adult,Crime | 10 |
| 6 | Action,Adult,Documentary | 1 |
Como podemos ver , alguns filmes estão com mais de um gênero, logo, vamos ter que ajustar essas informações , além disso,*** indica que temos filque que não foi indicado o seu gênero,ou seja , tbm temos que resolver essa questão.
Para facilitar nosso trabalho
Vamos converter as strings
# Converte as strings para minúsculo
resultado2['genres'] = resultado2['genres'].str.lower().valuesremove os valores
.dropna() remove os valores ausentes
# Remove valores NA (ausentes)
temp = resultado2['genres'].dropna()Usamos o Countvectorizer para converter a coluna de gêneros em um vetor one-hot encoded para contar o número de filmes em cada gênero.
Para este fim vamos utlizar também a expressão regular para filtrar as strings e vamos criar ma matriz esparsa
# Vamos criar um vetor usando expressão regular para filtrar as strings
# https://docs.python.org/3.8/library/re.html
padrao = '(?u)\\b[\\w-]+\\b'
# https://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.CountVectorizer.html
vetor = CountVectorizer(token_pattern = padrao, analyzer = 'word').fit(temp)#type(vetor)criando a matriz
# Aplica a vetorização ao dataset sem valores NA
bag_generos = vetor.transform(temp)type(bag_generos)## <class 'scipy.sparse.csr.csr_matrix'>Obetendo nome dos atributos através do comando get_feature_names() e guardando em generos_unicos
# Retorna gêneros únicos
generos_unicos = vetor.get_feature_names()Criando um DataFrame
Através dos comando pd.DataFrame() vamos criar um data frame
# Cria o dataframe de gêneros
generos = pd.DataFrame(bag_generos.todense(), columns = generos_unicos, index = temp.index)# Visualiza
generos.info()## <class 'pandas.core.frame.DataFrame'>
## Int64Index: 1451 entries, 0 to 1450
## Data columns (total 29 columns):
## # Column Non-Null Count Dtype
## --- ------ -------------- -----
## 0 action 1451 non-null int64
## 1 adult 1451 non-null int64
## 2 adventure 1451 non-null int64
## 3 animation 1451 non-null int64
## 4 biography 1451 non-null int64
## 5 comedy 1451 non-null int64
## 6 crime 1451 non-null int64
## 7 documentary 1451 non-null int64
## 8 drama 1451 non-null int64
## 9 family 1451 non-null int64
## 10 fantasy 1451 non-null int64
## 11 film-noir 1451 non-null int64
## 12 game-show 1451 non-null int64
## 13 history 1451 non-null int64
## 14 horror 1451 non-null int64
## 15 music 1451 non-null int64
## 16 musical 1451 non-null int64
## 17 mystery 1451 non-null int64
## 18 n 1451 non-null int64
## 19 news 1451 non-null int64
## 20 reality-tv 1451 non-null int64
## 21 romance 1451 non-null int64
## 22 sci-fi 1451 non-null int64
## 23 short 1451 non-null int64
## 24 sport 1451 non-null int64
## 25 talk-show 1451 non-null int64
## 26 thriller 1451 non-null int64
## 27 war 1451 non-null int64
## 28 western 1451 non-null int64
## dtypes: int64(29)
## memory usage: 340.1 KBObservação
Agora temos cada um dos gêneros de maneira individual , mas ainda temos um problema , perceba que temos uma coluna n que foi gerada por acaso no processo de conversão ,então vamos removê-la.
Removendo a coluna “n”
Para a remoção vamos utilizar o comando drop().
# Drop da coluna n
generos = generos.drop(columns = 'n', axis = 0)calculando o percentual
calculando o percentual e retornando os 10 principais
# Calcula o percentual
generos_percentual = 100 * pd.Series(generos.sum()).sort_values(ascending = False) / generos.shape[0]
generos_percentual.head(10)| N | genero | percentual |
|---|---|---|
| 1 | drama | 18.33218 |
| 2 | comedy | 16.95382 |
| 3 | documentary | 15.92006 |
| 4 | adventure | 14.81737 |
| 5 | action | 14.54170 |
| 6 | romance | 13.37009 |
| 7 | crime | 13.09442 |
| 8 | mystery | 12.47416 |
| 9 | thriller | 12.33632 |
| 10 | fantasy | 12.26740 |
Plotando o gráfico
Vamos tornar as coisas mais visuais plotando um gráfico
# Plot
plt.figure(figsize = (16,10))
sns.barplot(x = generos_percentual.values, y = generos_percentual.index, orient = "h", palette = "terrain")
plt.ylabel('Gênero')
plt.xlabel("\nPercentual de Filmes (%)")
plt.title('\nNúmero (Percentual) de Títulos Por Gênero\n')
plt.show()
Podemos perceber que o gênero “drama” é o qual detem maior percentual de filmes mais de 18%, em segundo lugar temos o gênero “comedy” com 16,95% e em terceiro aparece o gênero “documentary” com 15,92% .
3- Qual o Número de Filmes Produzidos Por País?
A região onde cada fime foi produzido está na tabela “akas”,logo ,vamos fazer uma consulta ao nosso banco de dados usando os conceitos vistos na questão 1 e 2 :
vamos contar numero de flmes ,buscando os dados na tabela “akas” junto com a tabela”titles”
as.title_id = titles.title_id é a junção das tabelas
# Consulta SQL
consulta3 = '''
SELECT region, COUNT(*) Number_of_movies FROM
akas JOIN titles ON
akas.title_id = titles.title_id
WHERE region != 'None'
AND type = \'movie\'
GROUP BY region
''' dataframe
montando o nosso DataFrame como nas questões anteriores
# Resultado
resultado3 = pd.read_sql_query(consulta3, conn)
display(resultado3)| region | Number_of_movies |
|---|---|
| AD | 22 |
| AE | 2601 |
| AF | 109 |
| AG | 12 |
| AL | 1242 |
| AM | 280 |
criando duas listas auxiliares
# Listas auxiliares
nomes_paises = []
contagem = []criando um loop
o loop Para cada elemento,resultado3.shape[0] garante o total de linhas mesmo que o banco de dados seja atualizado , depois vamos utilizar o tratamento de erros “try”, “except” para que em caso de erro , apenas continue : vamos retirnar o nosso conjunto de dados a coluna region depois vamos preencher as listas auxiliares nomes_paises e contagem
# Loop para obter o país de acordo com a região
for i in range(resultado3.shape[0]):
try:
coun = resultado3['region'].values[i]
nomes_paises.append(pycountry.countries.get(alpha_2 = coun).name)
contagem.append(resultado3['Number_of_movies'].values[i])
except:
continuePreparando o DataFrame
# Prepara o dataframe
df_filmes_paises = pd.DataFrame()
df_filmes_paises['country'] = nomes_paises
df_filmes_paises['Movie_Count'] = contagemOrdenando os resultados
o argumento ascending ordena os resultados , caso use “true” ele vai do menor para o maior , logo temos que usar “false”
# Ordena o resultado
df_filmes_paises = df_filmes_paises.sort_values(by = 'Movie_Count', ascending = False)
# Visualizando
df_filmes_paises.head(10)| country | Movie_Count |
|---|---|
| United States | 301122 |
| United Kingdom | 154562 |
| Japan | 89646 |
| France | 82552 |
| India | 76215 |
| Canada | 72649 |
| Germany | 67975 |
| Italy | 64137 |
| Brazil | 63550 |
| Spain | 63485 |
Plotando o gráfico
Para melhor visualização vamos plotar o gráfico
# Plot
# Figura
plt.figure(figsize = (20,12))
# Barplot
sns.barplot(y = df_filmes_paises[:20].country, x = df_filmes_paises[:20].Movie_Count, orient = "h")
# Loop
for i in range(0,20):
plt.text(df_filmes_paises.Movie_Count[df_filmes_paises.index[i]]-1,
i + 0.30,
round(df_filmes_paises["Movie_Count"][df_filmes_paises.index[i]],2))
plt.ylabel('País')
plt.xlabel('\nNúmero de Filmes')
plt.title('\nNúmero de Filmes Produzidos Por País\n')
plt.show()
Como podemos perceber , os Estados Unidos(United States) é o pais que mais produz filmes com 301.122 filmes produzidos , em segundo lugar temos o Reino Unido(United Kingdom ) com mais de 154 mil filmes produzidos e em terceiro lugar temos o japão(Japan) com 89.646 produções.Além disso , o Brasil aparece na lista dos 10 países que mais produções, atualmente na nona colocação , o país possui 63.550 produções.
4- Quais São os Top 10 Melhores Filmes?
Top 10 filmes com melhor avaliação com 25 mil votos ou mais .
vamos retortnar o título do filme como o nome do filme , também vamos retornar o gênero e a avaliação a partir da tabela titulo(titles) juntando com a tabela avaliação(rating) com o número de votos maior ou igual a 25 mil votos ordenando em ordem decrescente ,ou seja , do maior para o menor ,pegando os 10 primeiros
# Consulta SQL
consulta4 = '''
SELECT primary_title AS Movie_Name,genres, rating
FROM
titles JOIN ratings
ON titles.title_id = ratings.title_id
WHERE titles.type = 'movie' AND ratings.votes >= 25000
ORDER BY rating DESC
LIMIT 10
''' # Resultado
top10_melhores_filmes = pd.read_sql_query(consulta4, conn)
#visualizando
display(top10_melhores_filmes)| N | Movie_Name | genres | rating |
|---|---|---|---|
| 1 | Jai Bhim | Crime,Drama | 9.7 |
| 2 | The Shawshank Redemption | Drama | 9.3 |
| 3 | The Chaos Class | Comedy,Drama | 9.3 |
| 4 | The Godfather | Crime,Drama | 9.2 |
| 5 | Soorarai Pottru | Drama | 9.1 |
| 6 | CM101MMXI Fundamentals | Comedy,Documentary | 9.1 |
| 7 | Mirror Game | Crime,Mystery,Thriller | 9.1 |
| 8 | 12 Angry Men | Crime,Drama | 9.0 |
| 9 | The Godfather: Part II | Crime,Drama | 9.0 |
| 10 | The Dark Knight | Action,Crime,Drama | 9.0 |
Caso queira plotar um gráfico
plt.figure(figsize = (20,10))
sns.barplot(top10_melhores_filmes['rating'],top10_melhores_filmes['Movie_Name'], palette = "terrain",orient = "h")
plt.title('\n top 10 melhores filmes \n')
plt.xlabel('notas')
#
plt.show()
os melhores filmes segundo as avaliações feitas no IBMI são :
1-Jai Bhim,com nota 9.7 nas avaliações
2-The Shawshank Redemption, com nota 9.3 nas avaliações
3-The Chaos Class,com nota geral 9.3 nas avaliações
4-The Godfather,com nota geral 9.2 nas avalições
5-Soorarai Pottru , com nota geral de 9.1 nas avaliações
6-CM101MMXI Fundamentals, com nota geral de 9.1 nas avaliações
7-Mirror Game, com nota geral de 9.1 nas avaliações
8- Angry Men, com nota geral de 9.0 nas avaliações
9-The Godfather: Part II, com nota geral 9.0 nas avaliações
10- The Dark Knight, com nota geral 9.0 nas avaliações
5- Quais São os Top 10 Piores Filmes?
Top 10 filmes com pior avaliação com 25 mil votos ou mais.
# Consulta SQL
consulta5 = '''
SELECT primary_title AS Movie_Name, genres, rating
FROM
titles JOIN ratings
ON titles.title_id = ratings.title_id
WHERE titles.type = 'movie' AND ratings.votes >= 25000
ORDER BY rating ASC
LIMIT 10
''' # Resultado
top10_piores_filmes = pd.read_sql_query(consulta5, conn)
visualizando
display(top10_piores_filmes)| N | Movie_Name | genres | rating |
|---|---|---|---|
| 1 | Cumali Ceber | Comedy | 1.0 |
| 2 | Sadak 2 | Action,Drama | 1.1 |
| 3 | Smolensk | Drama,Thriller | 1.2 |
| 4 | The Cost of Deception | Crime,Drama,History | 1.4 |
| 5 | Reis | Biography,Drama | 1.4 |
| 6 | Justin Bieber: Never Say Never | Documentary,Music | 1.6 |
| 7 | Manos: The Hands of Fate | Drama,Horror | 1.8 |
| 8 | Radhe | Action,Crime,Thriller | 1.8 |
| 9 | Superbabies: Baby Geniuses 2 | Comedy,Family,Sci-Fi | 1.9 |
| 10 | The Hottie & the Nottie | Comedy,Romance | 1.9 |
Caso queira plotar um gráfico
plt.figure(figsize = (20,10))
sns.barplot(top10_piores_filmes['rating'],top10_piores_filmes['Movie_Name'], palette = "terrain",orient = "h")
plt.title('\n top 10 piores filmes \n')
plt.xlabel('notas')
#
plt.show()
Os piores filmes segundo as avaliações feitas no IBMI são :
1-Cumali Ceber com nota geral 1.0 nas avaliações
2-Sadak 2 com nota geral 1.1 nas avaliações
3-Smolenskcom nota geral de 1.2 nas avaliações
4-The Cost of Deception com nota geral de 1.4 nas avaliações
5-Reis com nota geral de 1.4 nas avaliações
6-Justin Bieber: Never Say Never com nota geral 1.6 nas avaliações
7-Manos: The Hands of Fate com nota geral 1.8 nas avaliações
8-Radhe com nota geral 1.8 nas avaliações
9-Superbabies: Baby Geniuses 2 com nota geral 1.9 nas avaliações
10-The Hottie & the Nottie com nota geral 1.9 nas avaliações
Conclusão
Como podemos perceber , podemos utilizar a liguagem python para vários fins, inclusive para executar uma análise exploratória dos dados e obter o resultado com poucas linhas de comando .
Link para download
Acesse o repositório no GitHub : https://github.com/JosefersonBarreto/exploratoriaPY.git.