python案例如何预测点球大战胜负走向？

wen python案例 2026-09-07 2

本文目录导读：

基于历史数据的统计预测
机器学习预测模型
蒙特卡洛模拟进行整场比赛预测
进阶分析：关键因素影响
实时预测函数
使用建议

我来提供一个基于统计和机器学习方法的点球大战预测案例。

基于历史数据的统计预测

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report
import matplotlib.pyplot as plt
import seaborn as sns
# 创建模拟的点球数据
np.random.seed(42)
def generate_penalty_data(n_samples=1000):
    """生成模拟的点球数据"""
    data = {
        'shooter_accuracy': np.random.uniform(0.6, 0.95, n_samples),  # 射手命中率
        'shooter_experience': np.random.randint(1, 15, n_samples),     # 射手经验（年）
        'shooter_pressure': np.random.uniform(0.5, 1.0, n_samples),    # 射手抗压能力
        'goalkeeper_reflex': np.random.uniform(0.7, 1.0, n_samples),   # 门将反应
        'goalkeeper_experience': np.random.randint(1, 12, n_samples),  # 门将经验
        'goalkeeper_height': np.random.uniform(1.75, 2.05, n_samples), # 门将身高(m)
        'weather': np.random.choice(['clear', 'rain', 'wind', 'snow'], n_samples),
        'crowd_noise': np.random.uniform(0.5, 1.0, n_samples),         # 噪声分贝
        'match_duration': np.random.randint(90, 120, n_samples),       # 比赛进行时间
        'round_number': np.random.randint(1, 6, n_samples)             # 当前轮次
    }
    # 根据特征计算进球概率
    # 这里用简单的函数模拟真实概率
    penalty_prob = (
        0.6 * data['shooter_accuracy'] +
        0.15 * data['shooter_experience'] / 14 +
        0.1 * data['shooter_pressure'] -
        0.15 * data['goalkeeper_reflex'] -
        0.08 * data['goalkeeper_height'] / 2.05 -
        0.05 * (data['crowd_noise'] > 0.8)  # 高噪声降低命中率
    )
    # 加入天气影响
    weather_effect = {
        'clear': 0.05,
        'rain': -0.03,
        'wind': -0.02,
        'snow': -0.05
    }
    for idx, weather in enumerate(data['weather']):
        penalty_prob[idx] += weather_effect[weather]
    # 归一化到0.4-0.9之间
    penalty_prob = np.clip(penalty_prob, 0.3, 0.95)
    # 生成进球结果
    goals = np.random.binomial(1, penalty_prob)
    data['penalty_goal'] = goals
    return pd.DataFrame(data)
# 生成数据
df = generate_penalty_data(1000)
# 数据探索
print("数据概述：")
print(df.head())
print("\n进球率统计：")
print(f"总体进球率: {df['penalty_goal'].mean():.2%}")

机器学习预测模型

# 特征工程和编码
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
def prepare_features(df):
    """准备特征数据"""
    # 数值特征
    numeric_features = ['shooter_accuracy', 'shooter_experience', 'shooter_pressure',
                       'goalkeeper_reflex', 'goalkeeper_experience', 'goalkeeper_height',
                       'crowd_noise', 'match_duration', 'round_number']
    # 分类特征
    categorical_features = ['weather']
    # 创建预处理管道
    preprocessor = ColumnTransformer(
        transformers=[
            ('num', StandardScaler(), numeric_features),
            ('cat', OneHotEncoder(drop='first'), categorical_features)
        ])
    X = preprocessor.fit_transform(df.drop('penalty_goal', axis=1))
    y = df['penalty_goal']
    return X, y, preprocessor
# 准备数据
X, y, preprocessor = prepare_features(df)
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 训练多个模型
models = {
    'Logistic Regression': LogisticRegression(random_state=42),
    'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42)
}
# 训练和评估
results = {}
for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    y_pred_proba = model.predict_proba(X_test)[:, 1]
    accuracy = accuracy_score(y_test, y_pred)
    results[name] = {
        'model': model,
        'accuracy': accuracy,
        'predictions': y_pred_proba
    }
    print(f"\n{name} 模型表现：")
    print(f"准确率: {accuracy:.2%}")
    print(classification_report(y_test, y_pred))

蒙特卡洛模拟进行整场比赛预测

def simulate_penalty_shootout(model, preprocessor, team_a_players, team_b_players, n_simulations=1000):
    """
    蒙特卡洛模拟点球大战
    参数:
    - model: 训练好的模型
    - preprocessor: 预处理器
    - team_a_players: A队球员特征列表
    - team_b_players: B队球员特征列表
    - n_simulations: 模拟次数
    """
    results = {'A_win': 0, 'B_win': 0, 'A_penalty_miss': [], 'B_penalty_miss': []}
    for sim in range(n_simulations):
        a_score = 0
        b_score = 0
        a_missed = []
        b_missed = []
        # 点球大战最多5轮（标准规则），之后突然死亡
        max_rounds = 10  # 保守估计
        i = 0
        while i < max_rounds:
            # A队射门
            if i < len(team_a_players):
                player_a = team_a_players[i % len(team_a_players)]
                player_a['round_number'] = i + 1
                prob_a = model.predict_proba(
                    preprocessor.transform(pd.DataFrame([player_a])))[0][1]
                if np.random.random() < prob_a:
                    a_score += 1
                else:
                    a_missed.append(i + 1)
            # B队射门
            if i < len(team_b_players):
                player_b = team_b_players[i % len(team_b_players)]
                player_b['round_number'] = i + 1
                prob_b = model.predict_proba(
                    preprocessor.transform(pd.DataFrame([player_b])))[0][1]
                if np.random.random() < prob_b:
                    b_score += 1
                else:
                    b_missed.append(i + 1)
            i += 1
            # 检查是否结束
            if (i >= 5 and (abs(a_score - b_score) > (10 - i) or 
               (i > 5 and a_score != b_score))):
                break
        # 判断胜负
        if a_score > b_score:
            results['A_win'] += 1
        elif b_score > a_score:
            results['B_win'] += 1
        else:
            # 突然死亡
            while True:
                i += 1
                if np.random.random() < 0.76:  # 平均命中率
                    a_score += 1
                if np.random.random() < 0.76:
                    b_score += 1
                if i >= 10 and a_score != b_score:
                    break
            if a_score > b_score:
                results['A_win'] += 1
            else:
                results['B_win'] += 1
        results['A_penalty_miss'].extend(a_missed)
        results['B_penalty_miss'].extend(b_missed)
    return results
# 示例：创建两队球员特征
def create_team_players(team_name, base_accuracy=0.75):
    """创建模拟球队队员"""
    players = []
    for i in range(5):
        player = {
            'shooter_accuracy': np.clip(base_accuracy + np.random.normal(0, 0.05), 0.6, 0.95),
            'shooter_experience': np.random.randint(2, 12),
            'shooter_pressure': np.random.uniform(0.6, 1.0),
            'goalkeeper_reflex': np.random.uniform(0.7, 0.9),
            'goalkeeper_experience': np.random.randint(2, 10),
            'goalkeeper_height': np.random.uniform(1.85, 2.00),
            'crowd_noise': 0.8,
            'match_duration': 94,
            'weather': 'clear'
        }
        players.append(player)
    return players
# 创建两队
team_a = create_team_players('A', base_accuracy=0.82)
team_b = create_team_players('B', base_accuracy=0.78)
# 使用随机森林模型进行预测
best_model = results['Random Forest']['model']
predictions = simulate_penalty_shootout(
    best_model, 
    preprocessor, 
    team_a, 
    team_b, 
    n_simulations=1000
)
# 可视化结果
print("\n点球大战预测结果（基于1000次模拟）：")
print(f"A队胜率: {predictions['A_win']/10:.1f}%")
print(f"B队胜率: {predictions['B_win']/10:.1f}%")
# 绘制预测结果
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
# 胜率饼图
labels = ['A队胜', 'B队胜']
sizes = [predictions['A_win'], predictions['B_win']]
colors = ['#ff9999', '#66b3ff']
axes[0].pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%', startangle=90)
axes[0].set_title('点球大战预测胜率')
# 失球分布（当球员失手时）
axes[1].hist(predictions['A_penalty_miss'], alpha=0.5, label='A队失手轮次', bins=10)
axes[1].hist(predictions['B_penalty_miss'], alpha=0.5, label='B队失手轮次', bins=10)
axes[1].set_xlabel('轮次')
axes[1].set_ylabel('次数')
axes[1].set_title('失手分布')
axes[1].legend()
plt.tight_layout()
plt.show()

进阶分析：关键因素影响

# 分析关键影响因素
importance_model = RandomForestClassifier(n_estimators=100, random_state=42)
importance_model.fit(X_train, y_train)
# 获取特征重要性
feature_names = (numeric_features + 
                 [f'weather_{val}' for val in 
                  df['weather'].unique() if val != df['weather'].unique()[0]])
importances = pd.DataFrame({
    'feature': feature_names,
    'importance': importance_model.feature_importances_
}).sort_values('importance', ascending=False)
# 可视化特征重要性
plt.figure(figsize=(10, 6))
plt.barh(importances['feature'][:10], importances['importance'][:10])
plt.xlabel('重要性')'点球进球关键影响因素')
plt.gca().invert_yaxis()
plt.tight_layout()
plt.show()
print("\n影响点球命中最重要的因素：")
print(importances.head(5).to_string(index=False))

实时预测函数

def predict_penalty_outcome(player_data, model, preprocessor):
    """
    预测单次点球的进球概率
    参数:
    - player_data: 球员和场景的字典
    - model: 训练好的模型
    - preprocessor: 预处理器
    返回: 进球概率和置信度
    """
    # 准备输入数据
    input_df = pd.DataFrame([player_data])
    # 标准化并预测
    X_input = preprocessor.transform(input_df)
    proba = model.predict_proba(X_input)[0]
    return {
        'goal_probability': proba[1],
        'miss_probability': proba[0],
        'confidence': max(proba)  # 置信度
    }
# 示例：预测单次点球
example_penalty = {
    'shooter_accuracy': 0.85,      # 顶尖射手
    'shooter_experience': 10,       # 丰富经验
    'shooter_pressure': 0.9,       # 高压环境下表现好
    'goalkeeper_reflex': 0.75,      # 普通门将
    'goalkeeper_experience': 5,
    'goalkeeper_height': 1.92,
    'crowd_noise': 0.9,            # 主场噪声
    'match_duration': 95,
    'weather': 'clear'
}
result = predict_penalty_outcome(example_penalty, best_model, preprocessor)
print(f"点球进球概率: {result['goal_probability']:.2%}")
print(f"点球不进概率: {result['miss_probability']:.2%}")
print(f"预测置信度: {result['confidence']:.2%}")