<jupyter_start><jupyter_text>1. Definição do Problema:Esse notebook analisa as equipes finalistas das copas do mundo de futebol da FIFA, entre 1930 e 2018. Os dados foram obtidos no Keaglle (https://www.kaggle.com/abecklas/fifa-world-cup ), compreendendo o período de 1930 até 2014. Esses dados foram compilados no ano de 2018, mesmo ano em que aconteceu a Copa do Mundo Fifa na Rússia. A ideia do desafio do Keaglle é que algum competidor seja capaz de criar um modelo de machine learning que forneça uma estimativa do vencedor da copa de 2018, usando esse data set e outros dois que também estão disponíveis site do desafio.Como estamos em 2021, sabemos bem que a campeã naquele ano foi a França, que fez a final com a Croácia. A equipe que ficou com o terceiro lugar foi a Bélgica (eliminou o Brasil nas quartas de final) e ganhou a disputa com a Inglaterra.Dessa forma, vou adicionar essas informações ao data set, fazendo com que o tamanho da amostra seja de 21 observações. Obviamente não é um "Big Data", mas a finalidade aqui é exercitar o Python e a análise de dados com o Pandas.  2. Importação e limpeza dos Dados :No site do Keaglle temos 3 arquivos CSV. O primeiro é o "WorldCupMatches.csv", que contém as informações sobre todos os jogos disputados em todas as partidas das copas do mundo, desde 1930. O segundo arquivo é o "WorldCupPlayers.csv" que contém informações sobre as equipes que participaram dos torneios. E o terceiro arquivo é "WorldCups.csv", que tem informações consolidadas sobre as copas do mundo e seus quatro finalistas. É com esse terceiro arquivo que vou trabalhar aqui.<jupyter_code># Vou listar os arquivos e sua localização na minha máquina, considerando a subpasta onde eu os salvei.
import os
for dirname, _, filenames in os.walk('input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))
# Vou trabalhar com quatro pacotes. Dois para manipulação de dados, Pandas e Numpy, 
# mas a ideia aqui é exercitar o Pandas. Utilizo os outros dois pacotes para análise gráfica.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
# Criando o data frame. Lembrando que este data frame não tem as informações 
# da última copa do mundo, que serão adicionadas posteriormente.
dfCups = pd.read_csv('input/WorldCups.csv')<jupyter_output><empty_output><jupyter_text>Descrição das variáveis que compõe o data frame dfCups* Year = Ano em que aconteceu a copa do mundo* Country = País sede da copa* Winner = Campeão* Runners-Up = Vice campeão* Third = Terceiro colocado* Fourth = Quarto colocado* GoalsScored = Gols marcados durante a copa* QualifiedTeams = Total de equipes participantes* MatchesPlayed = Total de partidas disputadas na copa* Attendance = Público total da copa<jupyter_code>dfCups
dfCups.columns<jupyter_output><empty_output><jupyter_text>Manipulando os dadosPrimeiramente preciso incluir os dados da copa de 2018. Depois eu corrijo algumas informações que aparecem truncadas no data set. Alemanha por exemplo, até 1988 aparecia como Germany e Germany FR, porque tínhamos Alemanha Ocidental e Alemanha Oriental.Feito isso posso partir para a análise dos dados.<jupyter_code># Vou copiar o data set para mantar os dados originais armazenados. 
# Assim posso fazer toda a manipulação diretamente na cópia.
dfCups1 = dfCups.copy()
# Adicionando a linha com os dados da Copa de 2018.
dfCups1 = dfCups1.append({'Year':'2018', 'Country':'Russia', 'Winner':'France', 'Runners-Up':'Croatia', 'Third':'Belgium', 'Fourth':'England', 'GoalsScored':'157', 'QualifiedTeams': '32', 'MatchesPlayed': '64', 'Attendance': '3.031.768'}, ignore_index=True)
dfCups1<jupyter_output><empty_output><jupyter_text>Vamos corrigir o nome da Alemanha, apagando a expressão FR. Não vamos fazer isso para a variável 'Country' porque não há necessidade. Devemos fazer isso para 'Winner', 'Runners-Up', 'Third' e 'Fourth'. Começo criando um objeto chamado 'namesCups' e salvando a informação sempre que aparecer 'FR' nas variáveis.<jupyter_code>namesCupsW = dfCups1[dfCups1['Winner'].str.contains('Germany FR')]['Winner'].value_counts(); namesCupsW
namesCupsR = dfCups1[dfCups1['Runners-Up'].str.contains('Germany FR')]['Runners-Up'].value_counts(); namesCupsR
namesCupsT = dfCups1[dfCups1['Third'].str.contains('Germany FR')]['Third'].value_counts(); namesCupsT
namesCupsF = dfCups1[dfCups1['Fourth'].str.contains('Germany FR')]['Fourth'].value_counts(); namesCupsF
# Crio o objeto 'wrongCups' e passo como parâmetro o 'namesCups'.
wrongCupsW = list(namesCupsW.index); wrongCupsW
wrongCupsR = list(namesCupsR.index); wrongCupsR
wrongCupsT = list(namesCupsT.index); wrongCupsT
wrongCupsF = list(namesCupsF.index); wrongCupsF
# Crio o objeto 'correctCups', passando como parâmetro o 'namesCups' com a função split 
# sempre que a expressão 'FR' aparecer em 'wrongCups', removendo o 'FR'.
correctCupsW = [namesCupsW.split(' FR')[0] for namesCupsW in wrongCupsW]; correctCupsW
correctCupsR = [namesCupsR.split(' FR')[0] for namesCupsR in wrongCupsR]; correctCupsR
correctCupsT = [namesCupsT.split(' FR')[0] for namesCupsT in wrongCupsT]; correctCupsT
correctCupsF = [namesCupsF.split(' FR')[0] for namesCupsF in wrongCupsF]; correctCupsF
# Agora estou criando uma função para fazer a substituição (correção) dentro do meu data set, 'dfCups1'.
for index, wr in enumerate(wrongCupsW):
    dfCups1 = dfCups1.replace(wrongCupsW[index], correctCupsW[index])

for index, wr in enumerate(wrongCupsR):
    dfCups1 = dfCups1.replace(wrongCupsR[index], correctCupsR[index])

for index, wr in enumerate(wrongCupsT):
    dfCups1 = dfCups1.replace(wrongCupsT[index], correctCupsT[index])

for index, wr in enumerate(wrongCupsF):
    dfCups1 = dfCups1.replace(wrongCupsF[index], correctCupsF[index])
# Se eu olhar novamente cada variável, não devo encontrar a expressão 'FR' junto com 'Germany'.
namesCupsW = dfCups1[dfCups1['Winner'].str.contains('Germany FR')]['Winner'].value_counts(); namesCupsW
namesCupsR = dfCups1[dfCups1['Runners-Up'].str.contains('Germany FR')]['Runners-Up'].value_counts(); namesCupsR
namesCupsT = dfCups1[dfCups1['Third'].str.contains('Germany FR')]['Third'].value_counts(); namesCupsT
namesCupsF = dfCups1[dfCups1['Fourth'].str.contains('Germany FR')]['Fourth'].value_counts(); namesCupsF
dfCups1<jupyter_output><empty_output><jupyter_text>Resolvido o problema dos nomes, podemos ver alguns dados interessantes sobre as copas do mundo. Por exemplo, das 21 copas do mundo já realizadas, cinco países foram sede pelo menos duas vezes. Porém, apesar da realização de 21 copas, apenas 16 países sediaram copas do mundo.<jupyter_code>len(dfCups1)<jupyter_output><empty_output><jupyter_text>3. Análise Exploratória dos Dados Cinco países sediaram a copa do mundo em pelo menos duas oportunidades, entre elas o Brasil, que é a equipe que mais títulos conquistou, e a Alemanha, que é a equipe que mais aparece entre os quatro finalistas em toda a história.Dos países Sul-Americanos, apenas quatro deles sediaram copas. Além do Brasil, o Uruguai, Chile e Argentina. O México (América do Norte) é outro país Latino Americano que sediou a copa duas vezes.Ao todo, apenas 16 países sediaram copas do mundo de futebol.<jupyter_code># Países que mais sediaram copas do mundo
country = dfCups1['Country'].value_counts(); country
len(country)<jupyter_output><empty_output><jupyter_text>O Brasil é a equipe com mais títulos mundiais (5 títulos), seguido pela Alemanha e Itália com 4. Argentina, França e Uruguai tem 2 títulos enquanto Inglaterra e Espanha tem uma conquista cada.Temos apenas 8 equipes vencedoras, sendo três delas da América do Sul.<jupyter_code># Equipes com mais títulos mundiais
winner = dfCups1['Winner'].value_counts(); winner
len(winner)<jupyter_output><empty_output><jupyter_text>Das dez equipes que foram vice campeãs, a Alemanha chegou 4 vezes nessa posição, seguida pela Holanda (que não tem título mundial) e Argentina com 3 vices cada. Das equipes finalistas, Checoslováquia, Hugria, Suécia, Croácia e Holanda até o momento não conseguiram se sagrar campeãs mundiais de futebol.<jupyter_code># Equipes que mais foram vice campeãs
runners_up = dfCups1['Runners-Up'].value_counts(); runners_up
len(runners_up)<jupyter_output><empty_output><jupyter_text>Ao longo das copas do mundo, tivemos 14 equipes diferentes em terceiro lugar e 16 em quarto lugar. Destaca-se a Alemanha com 4 aparições na terceira colocação e o Uruguai com 3 aparições no quarto lugar.<jupyter_code># Equipes que mais chegaram em terceiro lugar
third = dfCups1['Third'].value_counts(); third
len(third)
# Equipes que mais chegaram em quarto lugar
fourth = dfCups1['Fourth'].value_counts(); fourth
len(fourth)
# Agora vamos separar todos os finalistas de copa do mundo em um único data set.
listFinalist = dfCups1.iloc[:, 2:6]<jupyter_output><empty_output><jupyter_text>Apenas por curiosidade, vou listar as estatísticas descritivas do data set. Ele mostra que temos 8 equipes únicas campeãs, 10 equipes únicas vice campeãs, 14 equipes únicas na terceira colocação e 16 na quarta colocação.Outra estatística apresentada é qual a equipe que aparece mais vezes em cada colocação. Nesse caso o Brasil é a equipe com maior números de títulos, a Alemanha é a que mais aparece na segunda e terceira colocações e o Uruguai é a que mais aparece em quarto lugar.<jupyter_code>listFinalist.describe()<jupyter_output><empty_output><jupyter_text>Vou concatenar os quatro conjuntos de dados criados anteriormente, como exercício, e depois vou fazer uma contagem para ver qual equipe que mais aparece entre os finalistas.<jupyter_code>df_concat = pd.concat([winner, runners_up, third, fourth], axis = 1)
df_concat<jupyter_output><empty_output><jupyter_text>O problema é que ao fazer isso, quando a equipe não figura em uma determinada colocação é gerado um valor NaN. Esse problema é superado com o 'fillna()'.<jupyter_code>df_concat.update(df_concat['Winner'].fillna(0))
df_concat.update(df_concat['Runners-Up'].fillna(0))
df_concat.update(df_concat['Third'].fillna(0))
df_concat.update(df_concat['Fourth'].fillna(0))
df_concat<jupyter_output><empty_output><jupyter_text>Agora eu posso acrescentar uma coluna 'Total' e apresentar a soma das vezes em que a equipe chegou na fase final das copas.<jupyter_code>df_concat['Total'] = df_concat.sum(axis=1)<jupyter_output><empty_output><jupyter_text>A Alemanha é a equipe que mais apareceu na fase final das Copas do Mundo Fifa. O Brasil é a segunda equipe que mais apareceu enquanto o terceiro lugar fica com a Itália. Dos demais Sul-Americanos, Uruguai e Argentina apareceram 5 vezes cada e o Chile apareceu uma única vez.<jupyter_code>df_concat.sort_values('Total', ascending=False)<jupyter_output><empty_output><jupyter_text>Vamos fazer mais algumas análises, agora com os dados numéricos (número de gols, quantidades de equipes, partidas disputadas e público total da copa.<jupyter_code># Primeiro vou copiar o data set para um novo, 
# a fim de preservar as alterações feitas até agora e poder treinar outras manipulações.
dfCups2 = dfCups1.copy()<jupyter_output><empty_output><jupyter_text>O grande problema é que os dados numéricos estranhamente não estão apresentando as estatísticas corretamente. Aparentemente esses dados não são numéricos. Por isso primeiro vou converter as colunas em numérico para depois verificar as estatísticas descritivas.A média de gols em uma copa do mundo é de 120,76 por competição, tendo uma amplitude grande, entre 70 e 171. Essa amplitude larga se deve ao fato de que ao longo das copas a quantidade de equipes participantes e jogos disputados variou consideravelmente, influenciando essa estatística calculada e as outras como veremos adiante.<jupyter_code>dfCups2['GoalsScored'] = pd.to_numeric(dfCups2['GoalsScored'])
dfCups2['GoalsScored'].describe()<jupyter_output><empty_output><jupyter_text>A primeira copa do mundo tinha apenas 13 participantes e a partir de 1998 passou a contar com 32 participantes.<jupyter_code>dfCups2['QualifiedTeams'] = pd.to_numeric(dfCups2['QualifiedTeams'])
dfCups2['QualifiedTeams'].describe()<jupyter_output><empty_output><jupyter_text>Da mesma forma como a quantidade de equipes participantes evoluiu ao longo do tempo, consequentemente a quantidade de jogos disputados também se alterou. Na primeira copa do mundo tivemos apenas 17 jogos disputados. A partir de 1998 passamos a ter 64 jogos em cada competição.<jupyter_code>dfCups2['MatchesPlayed'] = pd.to_numeric(dfCups2['MatchesPlayed'])
dfCups2['MatchesPlayed'].describe()<jupyter_output><empty_output><jupyter_text>Como a coluna 'Attendace' é um dtype object, e eu quero numérico, e tem pontos separando os milhares, utilizo o comando abaixo pra converter e transformar os pontos em vírgula (milhar separado por vírgula ao invés de pontos).<jupyter_code>dfCups2['Attendance'] = pd.to_numeric(dfCups2['Attendance'].str.replace('.',''))
dfCups2['Attendance'].describe()<jupyter_output><empty_output><jupyter_text>O problema é que o resultado é um dtype float64, com números científicos. Pra remover essa formatação eu uso a função abaixo.Com isso podemos ver que o público médio é de quase 2 milhões de pessoas, variando entre 363 mil (copa da Itália em 1934) até 3.587 mil (copa dos Estados Unidos em 19940.<jupyter_code>dfCups2["Attendance"].describe().apply(lambda x: format(x, ',.2f'))<jupyter_output><empty_output><jupyter_text>Análise gráfica Vou adicionar alguns gráficos apenas como exercício, para ter uma opção visual dos resultados discutidos acima, usando para isso o pacote Seaborn.<jupyter_code>fig, ax = plt.subplots(figsize = (10,5))
sns.despine(right = True)
g = sns.barplot(x = 'Year', y = 'Attendance', data = dfCups2)
g.set_xticklabels(g.get_xticklabels(), rotation = 80)
g.set_title('Total e público nos estádios por ano')
fig, ax = plt.subplots(figsize = (10,5))
sns.despine(right = True)
g = sns.barplot(x = 'Year', y = 'QualifiedTeams', data = dfCups2)
g.set_xticklabels(g.get_xticklabels(), rotation = 80)
g.set_title('Quantidade de equipes classificadas para a copa do mundo por ano')
fig, ax = plt.subplots(figsize = (10,5))
sns.despine(right = True)
g = sns.barplot(x = 'Year', y = 'GoalsScored', data = dfCups2)
g.set_xticklabels(g.get_xticklabels(), rotation = 80)
g.set_title('Gols marcados por ano')
fig, ax = plt.subplots(figsize = (10,5))
sns.despine(right = True)
g = sns.barplot(x = 'Year', y = 'MatchesPlayed', data = dfCups2)
g.set_xticklabels(g.get_xticklabels(), rotation = 80)
g.set_title('Jogos disputados por ano')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.08528784648187633, 'fraction_numerical': 0.01581951991196093, 'mean_word_length': 6.137947962690231, 'pattern_counts': {'":': 0, '<': 85, '<?xml version=': 0, '>': 85, 'https://': 1, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '21', 'dir': 'jupyter-structured-clean-dedup', 'id': '11144', 'license': 'MIT', 'n_tokens_mistral': 5282, 'n_tokens_neox': 5023, 'n_words': 1696, 'path': 'FIFA.ipynb', 'repo_name': 'vanderleik/fifa_world_cup', 'size': '14539'}