根据python案例，累计犯规次数已到危险？

wen python案例 2026-08-07 3

本文目录导读：

基础版：简单累计判断
进阶版：带时间窗口的累计
实战版：完整比赛监控系统
使用示例
实时监控与提醒
智能辅助决策

我来分析Python中处理累计犯规次数的逻辑,帮你设计一个完整的判罚系统：

基础版：简单累计判断

class FoulCounter:
    def __init__(self, danger_threshold=5, suspend_threshold=8):
        self.foul_count = 0
        self.danger_threshold = danger_threshold  # 危险警告线
        self.suspend_threshold = suspend_threshold  # 停赛线
    def add_foul(self, foul_type="普通"):
        """记录一次犯规"""
        self.foul_count += 1
        status = self.get_status()
        print(f"犯规类型：{foul_type}，当前累计：{self.foul_count}次")
        print(f"状态：{status}")
        return status
    def get_status(self):
        """获取当前犯规状态"""
        if self.foul_count >= self.suspend_threshold:
            return "停赛处罚"
        elif self.foul_count >= self.danger_threshold:
            return "危险警告"
        elif self.foul_count >= self.danger_threshold - 2:
            return "接近危险"
        else:
            return "正常"

进阶版：带时间窗口的累计

from datetime import datetime, timedelta
from collections import deque
class SmartFoulTracker:
    """智能犯规追踪器 - 考虑时间窗口"""
    def __init__(self, time_window_days=7, danger_count=3, suspend_count=5):
        self.foul_records = deque()  # 存储犯规时间
        self.time_window_days = time_window_days
        self.danger_count = danger_count
        self.suspend_count = suspend_count
        self.foul_types = {"黄牌": 1, "红牌": 3, "技术犯规": 2, "违体犯规": 2}
    def add_foul(self, foul_type, time=None):
        """添加犯规记录"""
        if time is None:
            time = datetime.now()
        # 计算犯规权重
        weight = self.foul_types.get(foul_type, 1)
        # 添加记录
        self.foul_records.append({
            "time": time,
            "type": foul_type,
            "weight": weight
        })
        self._clean_old_records()
        # 计算当前风险
        risk_analysis = self.analyze_risk()
        return risk_analysis
    def _clean_old_records(self):
        """清理过期记录"""
        cutoff = datetime.now() - timedelta(days=self.time_window_days)
        while self.foul_records and self.foul_records[0]["time"] < cutoff:
            self.foul_records.popleft()
    def analyze_risk(self):
        """分析整体风险"""
        # 统计最近时间窗口内的总权重
        total_weight = sum(record["weight"] for record in self.foul_records)
        count = len(self.foul_records)
        # 判断风险等级
        if total_weight >= self.suspend_count:
            risk_level = "🚫 停赛处罚"
        elif total_weight >= self.danger_count:
            risk_level = "⚠️ 高度危险"
        elif count >= self.danger_count - 1:
            risk_level = "⚡ 接近危险"
        elif count >= self.danger_count - 2:
            risk_level = "👁️ 需要关注"
        else:
            risk_level = "✅ 安全"
        return {
            "foul_count": count,
            "total_weight": total_weight,
            "risk_level": risk_level,
            "time_remaining": self._get_time_remaining()
        }
    def _get_time_remaining(self):
        """计算记录过期剩余时间"""
        if not self.foul_records:
            return "无记录"
        oldest = self.foul_records[0]["time"]
        expiry = oldest + timedelta(days=self.time_window_days)
        remaining = expiry - datetime.now()
        return f"{remaining.days}天{remaining.seconds//3600}小时"

实战版：完整比赛监控系统

class MatchFoulSystem:
    """比赛犯规监控系统"""
    def __init__(self, game_type="足球"):
        self.game_type = game_type
        self.players = {}
        # 不同比赛的规则
        self.rules = {
            "足球": {"黄牌": 1, "红牌": 3, "danger": 3, "suspend": 5},
            "篮球": {"普通犯规": 1, "技术犯规": 2, "违体犯规": 3, "danger": 5, "suspend": 8},
            "冰球": {"小罚": 2, "大罚": 5, " misconduct": 10, "danger": 10, "suspend": 20}
        }
    def add_player(self, player_id, name):
        """添加球员"""
        self.players[player_id] = {
            "name": name,
            "fouls": [],
            "total_weight": 0,
            "warnings": 0,
            "is_ejected": False
        }
        print(f"已添加球员：{name}")
    def record_foul(self, player_id, foul_type, minutes, quarter):
        """记录犯规"""
        if player_id not in self.players:
            print("球员不存在")
            return
        player = self.players[player_id]
        if player["is_ejected"]:
            print(f"⚠️ {player['name']}已被罚出场，不能再记录犯规")
            return
        # 获取规则
        rules = self.rules.get(self.game_type, self.rules["足球"])
        weight = rules.get(foul_type, 1)
        # 记录犯规
        foul_info = {
            "type": foul_type,
            "weight": weight,
            "minute": minutes,
            "quarter": quarter
        }
        player["fouls"].append(foul_info)
        player["total_weight"] += weight
        # 检查是否达到警告线
        check_result = self.check_status(player_id)
        self.print_status(player_id, check_result)
        return check_result
    def check_status(self, player_id):
        """检查球员状态"""
        player = self.players[player_id]
        rules = self.rules.get(self.game_type, self.rules["足球"])
        result = {
            "total_weight": player["total_weight"],
            "is_danger": False,
            "is_suspended": False,
            "message": ""
        }
        # 风险预警
        if player["total_weight"] >= rules["danger"]:
            result["is_danger"] = True
            result["message"] += f"累积达到{rules['danger']}次犯规，存在风险！"
            if player["total_weight"] >= rules["suspend"]:
                result["is_suspended"] = True
                result["message"] += f"累积达到{rules['suspend']}次犯规，需要停赛！"
                player["is_ejected"] = True
        return result
    def print_status(self, player_id, status):
        """打印球员状态"""
        player = self.players[player_id]
        print(f"\n{'='*40}")
        print(f"球员：{player['name']}")
        print(f"累计犯规权重：{status['total_weight']}")
        # 颜色警示
        if status["is_suspended"]:
            print("🔴 严重警告：已达到停赛标准！")
        elif status["is_danger"]:
            print("🟡 警告：已进入危险区域！")
        elif status["total_weight"] >= self.rules[self.game_type]["danger"] - 1:
            print("🟠 注意：即将达到危险水平！")
        else:
            print("🟢 正常")
        # 显示犯规明细
        print(f"\n犯规详情：")
        for foul in player["fouls"][-5:]:  # 显示最近5次
            print(f"  - {foul['type']} (权重：{foul['weight']})")
        # 显示剩余余地
        rules = self.rules[self.game_type]
        remaining = rules["danger"] - status["total_weight"]
        if remaining > 0:
            print(f"距离危险线还有：{remaining}次犯规的空间")
        else:
            print("已超过危险线！")

使用示例

# 使用示例
if __name__ == "__main__":
    # 创建系统
    match = MatchFoulSystem("足球")
    # 添加球员
    match.add_player("P001", "梅西")
    match.add_player("P002", "C罗")
    # 模拟犯规
    print("\n📋 比赛开始\n")
    # 连续犯规测试
    test_fouls = [
        ("普通犯规", "P001", 23, "上半场"),
        ("黄牌", "P001", 35, "上半场"),
        ("黄牌", "P001", 58, "下半场"),
        ("技术犯规", "P001", 67, "下半场"),
        ("犯规", "P001", 75, "下半场")
    ]
    for foul_type, player_id, minute, phase in test_fouls:
        print(f"{phase}第{minute}分钟，{foul_type}：")
        match.record_foul(player_id, foul_type, minute, phase)
        print()

实时监控与提醒

import threading
import time
class FoulMonitor:
    """实时犯规监控器"""
    def __init__(self, max_fouls=3, warning_distance=1):
        self.max_fouls = max_fouls
        self.warning_distance = warning_distance
        self.monitoring = {}
    def start_monitoring(self, player_id):
        """开始监控特定球员"""
        self.monitoring[player_id] = {
            "fouls": 0,
            "last_warning": None,
            "triggered": False
        }
    def monitor(self, player_id):
        """监控逻辑"""
        if player_id not in self.monitoring:
            self.start_monitoring(player_id)
        player_data = self.monitoring[player_id]
        # 实时检查
        while player_data["fouls"] < self.max_fouls:
            current_fouls = player_data["fouls"]
            distance = self.max_fouls - current_fouls
            if distance <= self.warning_distance and not player_data["triggered"]:
                print(f"⚠️ 【警告】球员{player_id}还有{distance}次犯规将被罚出场！")
                player_data["triggered"] = True
            # 模拟等待新的犯规事件
            time.sleep(5)
        print(f"⚡ 【紧急】球员{player_id}已达到犯规上限，必须换下！")

智能辅助决策

class FoulPredictor:
    """犯规风险预测器"""
    def __init__(self):
        self.historical_data = []
    def predict_risk(self, player_data):
        """预测球员后续犯规风险"""
        # 这里可以使用机器学习算法进行预测
        # 简单示例：根据比赛时间、场上比分、球员状态等
        time_factor = self._get_time_factor(player_data)
        pressure_factor = self._get_pressure_factor(player_data)
        risk_score = (time_factor * 0.4 + pressure_factor * 0.6) * 100
        if risk_score > 80:
            return "高风险：建议提前换下"
        elif risk_score > 60:
            return "中风险：需要密切关注"
        else:
            return "低风险：可继续比赛"
    def _get_time_factor(self, data):
        """时间因素分析"""
        # 比赛后期更容易犯规
        minute = data["minute"]
        return minute / 90  # 归一化到0-1
    def _get_pressure_factor(self, data):
        """比赛压力分析"""
        # 落后时更容易犯规
        score_diff = data["score_diff"]
        if score_diff < 0:
            return 0.8 + (abs(score_diff) * 0.05)
        else:
            return 0.3

这些代码提供了完整的犯规监控方案，可以根据实际需求选择使用,关键是：