1ereNSI/representation_construits/evaluation/TP05_Football_aide.md

# Aide - TP05 Football

## Rappels utiles

### Structure des tuples
```python
# Joueur = (nom, poste, note_globale, stats)
joueur = effectif[0]
nom = joueur[0]          # "Mbappe"
poste = joueur[1]        # "ATT"
note = joueur[2]         # 91
stats = joueur[3]        # {"vitesse": 97, "tir": 89, ...}

# Acces direct
vitesse = joueur[3]["vitesse"]
```

### Parcourir une liste de tuples
```python
for joueur in effectif:
    nom = joueur[0]
    poste = joueur[1]
    note = joueur[2]
    stats = joueur[3]
    print(nom, "-", poste, "- Note:", note)
```

### Filtrer une liste de tuples
```python
attaquants = []
for j in effectif:
    if j[1] == "ATT":
        attaquants.append(j)
```

---

## Exercice 1

### 1.1 - Affichage joueur
- Verifiez si c'est un gardien (`poste == "GK"`) car les stats sont differentes

```python
def afficher_joueur(joueur):
    nom = joueur[0]
    poste = joueur[1]
    note = joueur[2]
    stats = joueur[3]

    print(nom, "(", poste, ") - Note:", note)

    if poste == "GK":
        print("  Plongeon:", stats["plongeon"])
        print("  Reflexes:", stats["reflexes"])
    else:
        print("  Vitesse:", stats["vitesse"])
        print("  Tir:", stats["tir"])
```

### 1.2 - Filtrage par poste
```python
def joueurs_par_poste(eff, poste):
    filtre = []
    for j in eff:
        if j[1] == poste:
            filtre.append(j)
    # Trier par note (indice 2) decroissante
    filtre = sorted(filtre, key=lambda j: j[2], reverse=True)
    return filtre
```

### 1.3 - Meilleur dans une stat
```python
def meilleur_stat(eff, stat):
    meilleur = None
    max_val = -1

    for joueur in eff:
        nom = joueur[0]
        stats = joueur[3]
        if stat in stats and stats[stat] > max_val:
            max_val = stats[stat]
            meilleur = nom

    return (meilleur, max_val)
```

---

## Exercice 2

### 2.1 - Generer le XI
```python
def generer_xi(eff, formation):
    xi = {}
    for poste, nb_joueurs in formation.items():
        # Recuperer les joueurs de ce poste, tries par note
        candidats = joueurs_par_poste(eff, poste)
        # Prendre les n meilleurs
        xi[poste] = candidats[:nb_joueurs]
    return xi
```

### 2.2 - Note moyenne ponderee
```python
def note_equipe(xi):
    poids = {"ATT": 1.2, "MIL": 1.1, "DEF": 1.0, "GK": 0.9}
    total_pondere = 0
    total_poids = 0

    for poste, joueurs in xi.items():
        for j in joueurs:
            note = j[2]
            p = poids[poste]
            total_pondere = total_pondere + note * p
            total_poids = total_poids + p

    return total_pondere / total_poids
```

### 2.3 - Equipe specialisee
```python
def score_priorite(joueur, priorite):
    stats = joueur[3]
    if priorite == "offensive":
        return stats.get("tir", 0) + stats.get("dribble", 0)
    elif priorite == "defensive":
        return stats.get("defense", 0) + stats.get("physique", 0)
    elif priorite == "technique":
        return stats.get("passe", 0) + stats.get("dribble", 0)
    return 0
```

---

## Exercice 3 (Bonus)

### 3.1 - Statistiques des matchs
```python
def stats_matchs(matchs):
    victoires = 0
    nuls = 0
    defaites = 0
    buts_pour = 0
    buts_contre = 0

    for match in matchs:
        adversaire = match[0]
        score_eq = match[1]
        score_adv = match[2]
        buteurs = match[3]

        buts_pour = buts_pour + score_eq
        buts_contre = buts_contre + score_adv

        if score_eq > score_adv:
            victoires = victoires + 1
        elif score_eq == score_adv:
            nuls = nuls + 1
        else:
            defaites = defaites + 1

    return {
        "victoires": victoires,
        "nuls": nuls,
        "defaites": defaites,
        "buts_pour": buts_pour,
        "buts_contre": buts_contre,
        "difference": buts_pour - buts_contre,
        "points": victoires * 3 + nuls
    }
```

### 3.2 - Classement buteurs
```python
def classement_buteurs(matchs):
    compteur = {}
    for match in matchs:
        buteurs = match[3]
        for buteur in buteurs:
            if buteur not in compteur:
                compteur[buteur] = 0
            compteur[buteur] = compteur[buteur] + 1

    # sorted renvoie une liste de tuples triee
    return sorted(compteur.items(), key=lambda x: x[1], reverse=True)
```

### 3.3 - Performance joueur
- Trouvez le joueur dans l'effectif pour ses stats
- Comptez ses buts dans les matchs
- Identifiez ses points forts (>= 85) et faibles (<= 60)

---

## Pieges a eviter

1. **Gardiens differents** : les GK n'ont pas les memes stats (pas de "vitesse", mais "plongeon", "reflexes"...)
2. **Tuples immutables** : vous ne pouvez pas modifier un tuple, creez-en un nouveau si besoin
3. **Division par zero** : verifiez que le diviseur est > 0
4. **Acces par indice** : joueur[0] = nom, joueur[1] = poste, joueur[2] = note, joueur[3] = stats