【大数据】—FIFA世界杯探索性分析（EDA）

引言

足球，作为全球最受欢迎的运动之一，拥有庞大的粉丝群体和深远的文化影响。自1930年首届FIFA世界杯举办以来，这项赛事已经成为全球体育盛事，吸引了数十亿观众的目光。世界杯不仅是各国足球技艺的较量，更是国家荣誉和民族自豪感的体现。随着大数据时代的到来，我们有机会从新的视角审视这项赛事，利用数据分析揭示比赛背后的趋势和模式。

背景

在数据科学领域，探索性数据分析（Exploratory Data Analysis，简称EDA）是一种用于理解数据集特征的重要方法。分析师可以识别数据中的模式、关联和异常，为进一步的统计建模和决策提供依据。FIFA世界杯作为一项历史悠久的国际足球赛事，其数据集包含了丰富的信息，如球队表现、球员统计、比赛结果等，为进行EDA提供了理想的素材。

数据集信息

本次研究的数据来源于Kaggle（点击本文标题下方可免费下载），数据集共有3个表格。

开始探索……

读入数据：

# 导入pandas库，这是一个强大的数据处理和分析工具，提供了易于使用的数据结构和数据分析工具。  
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)    
# 导入matplotlib.pyplot模块，这是Python的一个绘图库，提供了类似于MATLAB的绘图系统。  
import matplotlib.pyplot as plt    
# 导入seaborn库，这是基于matplotlib的一个高级绘图库，提供了更多的绘图功能和美化选项。  
import seaborn as sns    
# 启用Jupyter Notebook中的matplotlib内联显示模式，这样绘制的图形会直接嵌入到Notebook中。  
%matplotlib inline    
# 导入plotly库，这是一个基于Web的交互式图表库，允许创建丰富的、交互式的数据可视化图表。  
import plotly as py    
# 导入cufflinks库，这是一个用于Pandas DataFrame的Plotly绘图接口，可以让Pandas DataFrame直接通过cufflinks的API绘制Plotly图表。  
import plotly.express as px
# 导入Python的os模块，它提供了许多与操作系统交互的功能，比如文件路径操作、环境变量访问等。  
import os    
# 使用os模块中的walk函数遍历'/kaggle/input'目录及其所有子目录。  
# os.walk()生成一个三元组(dirpath, dirnames, filenames)。  
# dirpath是一个字符串，表示当前正在遍历的这个目录的路径。  
# dirnames是一个列表，内容是该目录下的所有子目录的名字（不包括路径，只是名字）。  
# filenames是一个列表，内容是该目录下的所有非目录文件的名字（同样只是名字，不包括路径）。  
# 注意：在您的代码中，dirnames参数被忽略（用_表示），因为这里只关心文件名和目录名。  
for dirname, _, filenames in os.walk('/Users/c/Downloads/archive/'):  
    # 对于os.walk()遍历到的每一个目录（包括'/kaggle/input'本身及其所有子目录），  
    # 执行以下循环，遍历该目录下的所有文件（不包括子目录）。  
    for filename in filenames:  
        # 使用os.path.join()函数将目录名（dirname）和文件名（filename）组合成完整的文件路径。  
        # 然后，打印这个完整的文件路径。  
        print(os.path.join(dirname, filename))

获取3个数据集文件路径：

players = pd.read_csv("/Users/c/Downloads/archive/WorldCupPlayers.csv")
matches = pd.read_csv("/Users/c/Downloads/archive/WorldCupMatches.csv")
world_cup = pd.read_csv("/Users/c/Downloads/archive/WorldCups.csv")
display(players.head(1), matches.head(1), world_cup.head(1))

分别展示数据集第一行数据信息：
分展别示数据的整体信息：

查看数据缺失情况：
matches数据集有3720个缺失值，我们将它删除并显示后5行：
这里要对数据进行一下说明，自 1930 年首届世界杯以来，每四年进行一次，但 1942 年和 1946 年世界杯因第二次世界大战而没有举行，所以数据有缺失值，本文旨在给大家展示方法，得出的结论只是针对现有的数据进行的分析，并不代表真实结果。

三个数据集都需要清洗和处理，细节很多，我就不一一介绍，只介绍主要的地方，感兴趣的可以看代码上方#后面的注释：

# 定义一个列表，包含了一些旧的（可能是错误的或需要更新的）名称  
old_name = ['Germany FR', 'Maracan� - Est�dio Jornalista M�rio Filho', 'Estadio do Maracana']  
# 注释：这里的列表包含了三个字符串，其中第二个和第三个字符串可能包含了编码问题（如特殊字符的显示错误），这可能是由于文件编码或数据传输时的问题导致的。    
# 定义一个列表，包含了与old_name中每个元素相对应的新的（正确的）名称  
new_name = ['Germany', 'Maracan Stadium', 'Maracan Stadium']  
# 注释：这个列表与old_name列表一一对应，每个元素都是对应旧名称的更正或标准化版本。    
# 将old_name列表中的所有元素添加到变量wrong中  
wrong = wrong + old_name  
# 注释：这行代码的目的是将old_name列表中的所有元素追加到wrong列表中，以收集所有需要被更正或更新的旧名称。    
# 将new_name列表中的所有元素添加到变量correct中   
correct = correct + new_name  
wrong,correct

# 遍历wrong列表，对每个旧名称进行替换  
for index, wr in enumerate(wrong):  
    # 使用replace方法将world_cup中的旧名称wr替换为correct列表中对应位置的正确名称  
    # 注意：这里假设world_cup是一个字符串或支持.replace()方法的数据类型  
    # enumerate(wrong)会生成一个包含索引和值的元组，index是索引，wr是当前迭代的旧名称  
    world_cup = world_cup.replace(wrong[index], correct[index])  
    # 注释：这行代码会更新world_cup变量的值，使其包含所有已替换的名称。  
  
# 再次遍历wrong列表，这次是对matches变量进行替换  
for index, wr in enumerate(wrong):  
    # 使用replace方法将matches中的旧名称wr替换为correct列表中对应位置的正确名称  
    # 注意：这里假设matches也是一个字符串或支持.replace()方法的数据类型  
    matches = matches.replace(wrong[index], correct[index])  
    # 注释：这行代码会更新matches变量的值，使其包含所有已替换的名称。  
  
# 第三次遍历wrong列表，这次是对players变量进行替换  
for index, wr in enumerate(wrong):  
    # 使用replace方法将players中的旧名称wr替换为correct列表中对应位置的正确名称  
    # 注意：这里假设players也是一个字符串或支持.replace()方法的数据类型  
    players = players.replace(wrong[index], correct[index])  
    # 注释：这行代码会更新players变量的值，使其包含所有已替换的名称。 
    names = matches[matches['Home Team Name'].str.contains('rn">')]['Home Team Name'].value_counts()
names

# 合并冠军、亚军、季军的得奖频数，缺失值填充0，转为整数。
teams = pd.concat([winner, runnerup, third], axis=1)
teams.fillna(0, inplace=True)
teams = teams.astype(int)
teams.columns = ['winner', 'runnerup', 'third']
teams

以上代码，分别计算每个国家得冠军、亚军、季军的次数，合并成一张表格，缺失的部分填充0，详见下表：

老爱看足球的朋友们应该认识上面的英文代表哪个国家，我能看懂1/3！

探索性分析（EDA）：

import plotly.graph_objects as go  
  
# 假设teams DataFrame已经正确构建，并且包含'winner'、'runnerup'、'third'三列  
  
# 设置柱状图的x轴（即球队名称，这里假设每行代表一个球队）  
x = teams.index  # 如果teams的索引就是球队名称  
  
# 设置柱状图的y轴数据，这里有三组数据，每组对应一个奖项  
y_winner = teams['winner']  
y_runnerup = teams['runnerup']  
y_third = teams['third']  
  
# 创建柱状图  
fig = go.Figure(data=[  
    go.Bar(name='Winner', x=x, y=y_winner),  
    go.Bar(name='Runner-up', x=x, y=y_runnerup),  
    go.Bar(name='Third Place', x=x, y=y_third)  
])  
  
# 设置图表标题和x、y轴标签  
fig.update_layout(  
    title='FIFA 世界杯胜率统计',  
    xaxis_title='国家队名称',  
    yaxis_title='获奖数量',  
    barmode='group'  # 将柱状图设置为分组模式，以便在同一x轴位置上堆叠显示不同的奖项  
)  
  
# 显示图表  
fig.show()

根据表格数据绘制柱状图，今天数据可视化都是可以交互的，巴西最多，拿了5个冠军，还分别拿了2个亚军和2个季军。

# 从matches DataFrame中选择主队相关信息并移除缺失值  
home = matches[['Home Team Name', 'Home Team Goals']].dropna()  
# 从matches DataFrame中选择客队相关信息并移除缺失值  
away = matches[['Away Team Name', 'Away Team Goals']].dropna()    
# 重命名列名  
home.columns = ['Countries', 'Goals']  
# 注意：这里直接使用home的列名来设置away的列名，而不是再次调用home.columns（虽然这样也可以，但直接赋值更清晰）  
away.columns = ['Countries', 'Goals']    
# 使用concat来合并home和away DataFrame，ignore_index=True用于重置索引  
goals = pd.concat([home, away], ignore_index=True)
# 按国家进行分组计算进球总数，并降序排列。
goals = goals.groupby('Countries').sum().sort_values(by = 'Goals', ascending=False).reset_index()
goals

计算每个国家的进球总数，见下表：
提取进球最多的前20个国家数据可视化：
最多的哪个英文应该是德国战车吧，没具体查过全凭印象。

# 绘制 Attendance Per Year  
fig1 = go.Figure(data=go.Bar(  
    x=world_cup['Year'],  
    y=world_cup['Attendance'],  
    text=world_cup['Attendance'],  # 显示在条形图上的文本  
    textposition='auto'  # 自动调整文本位置  
))  
fig1.update_layout(  
    title='每年观赛人数',  
    xaxis_title='年度',  
    yaxis_title='观赛人数',  
    barmode='group',  # 对于这个单一条形图，barmode 设置为 'group' 是默认且不需要的，但保持一致性  
    xaxis=dict(  
        tickangle=80  # 旋转 x 轴标签  
    )  
)  
fig1.show()  
  
# 绘制 Qualified Teams Per Year  
fig2 = go.Figure(data=go.Bar(  
    x=world_cup['Year'],  
    y=world_cup['QualifiedTeams'],  
    text=world_cup['QualifiedTeams'],  
    textposition='auto'  
))  
fig2.update_layout(  
    title='每年获奖球队',  
    xaxis_title='年度',  
    yaxis_title='获奖球队',  
    xaxis=dict(  
        tickangle=80  
    )  
)  
fig2.show()  
  
# 绘制 Goals Scored by Teams Per Year  
fig3 = go.Figure(data=go.Bar(  
    x=world_cup['Year'],  
    y=world_cup['GoalsScored'],  
    text=world_cup['GoalsScored'],  
    textposition='auto'  
))  
fig3.update_layout(  
    title='每年球队进球数',  
    xaxis_title='年度',  
    yaxis_title='进球数',  
    xaxis=dict(  
        tickangle=80  
    )  
)  
fig3.show()  
  
# 注意：最后一个图表的标题可能有误，应该是 'Matches Played Per Year'  
# 绘制 Matches Played Per Year  
fig4 = go.Figure(data=go.Bar(  
    x=world_cup['Year'],  
    y=world_cup['MatchesPlayed'],  
    text=world_cup['MatchesPlayed'],  
    textposition='auto'  
))  
fig4.update_layout(  
    title='每年比赛场次',  
    xaxis_title='年度',  
    yaxis_title='比赛场次',  
    xaxis=dict(  
        tickangle=80  
    )  
)  
fig4.show()

从上面几个图可以看到，1940至1950年有缺口，是因为二战有2届世界杯没有举行，数据缺失。

# 使用pandas的concat函数将两个DataFrame（home和away）沿着列（axis=1）方向合并。
goals = pd.concat([home, away], axis=1)    
# 使用fillna函数将合并后的DataFrame中的NaN值替换为0。  
# 这通常用于处理缺失数据，确保后续计算不会因为NaN值而出错。  
goals.fillna(0, inplace=True)    
# 创建一个新列'Goals'，其值为'Home Team Goals'列和'Away Team Goals'列的和。  
# 这将计算出每场比赛的总进球数。  
goals['Goals'] = goals['Home Team Goals'] + goals['Away Team Goals']    
# 使用drop函数删除'Home Team Goals'和'Away Team Goals'这两列。  
# 这样做是为了减少DataFrame的冗余列，只保留我们需要的'Goals'列。  
# axis=1表示操作是在列上进行的。  
goals = goals.drop(labels = ['Home Team Goals', 'Away Team Goals'], axis = 1).reset_index()
goals.columns = ['Year', 'Country', 'Goals']
goals = goals.sort_values(by = ['Year', 'Goals'], ascending = [True, False])
goals

上面代码分别计算了每支球队主队和客队进球总数，并合并至一张表格，详见下表：

top5 = goals.groupby('Year').head()
top5.head(10)

按年份进行分组计算，每组只显示前5行数据，显示表格前10行数据，详见下图：

# 从goals DataFrame中提取年份和进球数的值，分别赋值给x和y变量。     
x, y = goals['Year'].values, goals['Goals'].values  
  
# 初始化一个空列表data，用于存储每个国家进球数的Bar对象。  
data = []  
  
# 遍历top5 DataFrame中不重复的国家名（或队伍名）。  
for team in top5['Country'].drop_duplicates().values:  
    # 对于每个国家，从top5 DataFrame中筛选出该国家的数据，并分别获取年份和进球数。  
    year = top5[top5['Country'] == team]['Year']  
    goal = top5[top5['Country'] == team]['Goals']  
      
    # 使用Plotly的go.Bar对象创建一个新的条形图，其中x轴为年份，y轴为进球数，name为国家的名字。  
    # 注意：这里实际上并没有直接使用之前从goals DataFrame中提取的x和y值，而是为每个国家重新提取了数据。  
    data.append(go.Bar(x = year, y = goal, name = team))  
  
# 设置图形的布局。barmode设置为'stack'，表示条形图将堆叠显示。  
# 标题设置为'Top 5 Teams with most Goals'，并且不显示图例（因为每个国家的颜色已经足够区分）。  
layout = go.Layout(barmode = 'stack', title = '进球最多的前5支球队—堆叠柱状图', showlegend = False)  
  
# 使用Plotly的go.Figure对象创建一个图形，其中data为之前构建的包含所有国家条形图的列表，layout为设置的布局。  
fig = go.Figure(data = data, layout = layout)  
  
# 显示图形。这将打开一个浏览器窗口（或标签页）来展示堆叠条形图。  
fig.show()

下图每个柱子的5种颜色分别代表进球最多的前5支球队，我鼠标指向的橙色位置显示的是法国队在1958年进了23个球。

matches['Year'] = matches['Year'].astype(int)
# 使用 'groupby' 方法对 'matches' DataFrame 进行分组，根据 'Stadium'（体育场）和 'City'（城市）列的值来分组。  
# 然后，对于每个分组，计算 'Attendance'（观众人数）列的平均值。  
# reset_index() 方法用于将分组后的结果转换回 DataFrame，其中原来的分组键（'Stadium' 和 'City'）成为新的列。  
# 最后，使用 sort_values 方法按 'Attendance' 列的值降序排序结果，以便最高的平均观众人数排在最前面。  
std = matches.groupby(['Stadium', 'City'])['Attendance'].mean().reset_index().sort_values(by='Attendance', ascending=False)
top10 = std[:10]

# 使用 Plotly 创建条形图  
fig = go.Figure(data=[go.Bar(  
    y=top10['Stadium'],  
    x=top10['Attendance'],  
    orientation='h',  # 水平条形图  
    text=top10['City'],  # 显示在条形图上的文本（城市名）  
    textposition='outside',  # 文本位置在条形图外部  
    marker_color='blue'  # 条形图颜色  
)])  
  
# 设置图表布局  
fig.update_layout(  
    title='平均上座率最高的体育场',  
    xaxis_title='平均上座人数',  
    yaxis_title='体育馆名称',  
    height=600,  
    width=800,  
    barmode='stack'  # 如果你想要堆叠条形图（这里其实不需要，因为只有一个系列），否则可以去掉  
)  
  
# 自定义文本显示（这里我们已经在 go.Bar 中设置了 text 和 textposition）  
# 如果你需要更复杂的文本格式化，可以在这里添加额外的 text 或 annotation  
  
# 显示图表  
fig.show()  

下图展示了平均观看比赛的人数最多的球场：

# 计算 City 列中前 20 个最常见城市的出现次数  
city_counts = matches['City'].value_counts()[:20]  
city_counts_df = city_counts.reset_index()  
city_counts_df.columns = ['City', 'Frequency']  # 重命名列以更清晰地表示它们的内容  
# 自定义颜色列表  
custom_colors = ['#FF6384', '#36A2EB', '#FFCE56', '#FF7F50', '#90EE90']   
fig = px.bar(city_counts_df, 
             x='City',
             y='Frequency',
             title='比赛最多的城市 Top 20',
             orientation='v',
             color_discrete_sequence=custom_colors)  
fig.update_layout(xaxis_title='城市名称', yaxis_title='赛事次数')  
fig.update_layout(  
    xaxis_showgrid=True,  
    yaxis_showgrid=True,  
    xaxis_gridcolor='lightgrey',  # 设置x轴网格线的颜色  
    xaxis_gridwidth=0.2,            # 设置x轴网格线的宽度  
    xaxis_griddash='dash',        # 设置x轴网格线的样式为虚线  
    yaxis_gridcolor='lightgrey',  
    yaxis_gridwidth=0.2,  
    yaxis_griddash='dash'  
)
  
# 显示图表  
fig.show()

下图提取了比赛最多城市 Top 20:

gold = world_cup["Winner"]  
silver = world_cup["Runners-Up"]  
bronze = world_cup["Third"]  
  
# 计算奖牌数  
gold_count = gold.value_counts().reset_index()  
gold_count.columns = ['Country', 'WINNER']  
  
silver_count = silver.value_counts().reset_index()  
silver_count.columns = ['Country', 'SECOND']  
  
bronze_count = bronze.value_counts().reset_index()  
bronze_count.columns = ['Country', 'THIRD']  
  
# 合并数据  
podium_count = gold_count.merge(silver_count, on='Country', how='outer').merge(bronze_count, on='Country', how='outer').fillna(0)   
  
# 确保所有国家都有数据（如果需要的话）  
# 注意：这里可能不需要再次重新索引，因为合并操作已经处理了这个问题  
# 但如果你想要确保包含特定的国家列表，你可以再次使用reindex  
  
# 绘制堆叠柱状图  
fig = go.Figure(data=[  
    go.Bar(name='Gold', x=podium_count['Country'], y=podium_count['WINNER'], marker_color='gold'),  
    go.Bar(name='Silver', x=podium_count['Country'], y=podium_count['SECOND'], marker_color='silver', base=podium_count['WINNER']),  
    go.Bar(name='Bronze', x=podium_count['Country'], y=podium_count['THIRD'], marker_color='brown', base=podium_count['WINNER'] + podium_count['SECOND'])  
])  
  
# 更新布局  
fig.update_layout(barmode='stack',  
                  xaxis_title='国家',  
                  yaxis_title='奖牌数量',  
                  title='各国奖牌数量—堆叠柱状图',  
                  xaxis=dict(tickangle=45, tickfont=dict(size=14)),  
                  yaxis=dict(titlefont=dict(size=14)),  
                  legend=dict(font=dict(size=14)),  
                  width=800,  
                  height=600)  
  
# 显示图表  
fig.show()

下图3分颜色分别代表金牌、银牌、铜牌的数量：

# 提取主客场队伍和进球数，并删除缺失值  
home = matches[['Home Team Name', 'Home Team Goals']].dropna()  
away = matches[['Away Team Name', 'Away Team Goals']].dropna()  
  
# 将主客场数据合并，并调整列名  
home_goals = home.rename(columns={'Home Team Name': 'countries', 'Home Team Goals': 'goals'})  
away_goals = away.rename(columns={'Away Team Name': 'countries', 'Away Team Goals': 'goals'})  
goal_per_country = pd.concat([home_goals, away_goals], ignore_index=True)  
  
# 确保 'goals' 列是整数类型  
goal_per_country['goals'] = goal_per_country['goals'].astype('int64')  
  
# 按国家分组并计算总进球数  
goal_per_country_grouped = goal_per_country.groupby('countries')['goals'].sum().sort_values(ascending=False)  
  
# 绘制条形图  
fig = go.Figure(data=[go.Bar(  
    x=goal_per_country_grouped.index,  # 国家名作为 x 轴  
    y=goal_per_country_grouped.values,  # 进球数作为 y 轴  
    marker_color='blue'  # 条形颜色  
)])  
  
# 设置图形布局  
fig.update_layout(  
    title='国家历史进球总数—柱状图',  
    xaxis_title='国家名',  
    yaxis_title='历史进球总数',  
    xaxis=dict(tickangle=45, tickfont=dict(size=14)),  # 旋转 x 轴标签并设置字体大小  
    yaxis=dict(titlefont=dict(size=14)),  # 设置 y 轴标题字体大小  
    font=dict(size=14),  # 设置全局字体大小  
    width=800,  
    height=600  
)  
  
# 只显示前10名  
fig.update_xaxes(range=[goal_per_country_grouped.index[0], goal_per_country_grouped.index[9]])  
  
# 显示图形  
fig.show()

还是德国队排第一：

# 定义一个函数get_labels，它接受一个包含比赛数据的字典（或DataFrame的行）作为参数  
def get_labels(matches):  
    # 如果主队的进球数大于客队的进球数，则返回'主场胜'  
    if matches['Home Team Goals'] > matches['Away Team Goals']:  
        return '主场胜'  
    # 如果主队的进球数小于客队的进球数，则返回'客场胜'  
    if matches['Home Team Goals'] < matches['Away Team Goals']:  
        return '客场胜'  
    # 如果主队和客队的进球数相等，则返回'平局'  
    return '平局'  
  
# 使用apply函数和lambda表达式，将get_labels函数应用于matches DataFrame的每一行  
# axis=1指定函数应用于DataFrame的横向（即每一行），因为get_labels函数是按行处理数据的  
# 这会创建一个新的Series，其中包含了每场比赛的结果  
matches['outcome'] = matches.apply(lambda x: get_labels(x), axis=1)  
  
# 使用head(2)函数显示修改后的DataFrame的前两行  
# 这有助于验证'outcome'列是否已正确添加到DataFrame中，并包含预期的比赛结果  
matches.head(2)

封装一个函数，新增一列用于存放计算主场胜、客场胜、平局的次数：

# 转换为适合 plotly 的格式  
labels = list(mt.index)  
values = list(mt.values)  
  
# 生成颜色列表，确保颜色数量与标签数量相匹配  
# 如果调色板中的颜色不够，可以循环使用  
n_colors = len(labels)  
color_palette = sns.color_palette('winter_r', n_colors=n_colors)  # 移除 as_cmap=True  
marker_colors = color_palette  # 直接使用生成的颜色列表  
  
# 如果需要循环使用颜色（虽然在这个例子中可能不需要）  
# marker_colors = color_palette * (n_colors // len(color_palette) + 1)[:n_colors]  
  
# 创建饼图  
fig = go.Figure(data=[go.Pie(labels=labels, values=values, hole=.3,  
                             marker=dict(colors=marker_colors),  # 使用 marker 字典来设置颜色  
                             textinfo='label+percent',  
                             insidetextorientation='radial'  
                            )])  
  
# 设置饼图的标题  
fig.update_layout(title_text='主客场球队胜负占比图—饼图',  
                  font_size=14,  # 全局字体大小  
                  title_font_size=16)  # 标题字体大小  
  
# 显示图形  
fig.show()

小结

欧洲杯目前正如火如荼进行中，决定来一篇足球题材的博文，本文探索性分析了1930年至2014年的世界杯部分数据。

创作不易，关注、点赞、评论！