{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cell-0",
   "metadata": {},
   "source": [
    "# TP Évaluation - Gestion d'équipe de Football\n",
    "\n",
    "**Durée : 1h30**\n",
    "\n",
    "**Nom :** \n",
    "\n",
    "**Prénom :**\n",
    "\n",
    "---\n",
    "\n",
    "Dans ce TP, vous allez créer un système de gestion d'équipe de football.\n",
    "\n",
    "**Compétences évaluées :**\n",
    "- Manipulation de tuples et listes\n",
    "- Dictionnaires et structures imbriquées\n",
    "- Algorithmes de sélection"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell-1",
   "metadata": {},
   "source": [
    "## Données initiales\n",
    "\n",
    "**Exécutez cette cellule avant de commencer.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell-2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Effectif de l'equipe\n",
    "# Chaque joueur est un tuple : (nom, poste, note_globale, stats)\n",
    "# stats est un dictionnaire avec les caracteristiques\n",
    "\n",
    "effectif = [\n",
    "    (\"Mbappe\", \"ATT\", 91, {\"vitesse\": 97, \"tir\": 89, \"passe\": 80, \"dribble\": 92, \"defense\": 36, \"physique\": 78}),\n",
    "    (\"Griezmann\", \"ATT\", 87, {\"vitesse\": 80, \"tir\": 86, \"passe\": 84, \"dribble\": 88, \"defense\": 56, \"physique\": 72}),\n",
    "    (\"Dembele\", \"ATT\", 86, {\"vitesse\": 93, \"tir\": 78, \"passe\": 82, \"dribble\": 90, \"defense\": 32, \"physique\": 63}),\n",
    "    (\"Thuram\", \"ATT\", 84, {\"vitesse\": 86, \"tir\": 80, \"passe\": 72, \"dribble\": 82, \"defense\": 42, \"physique\": 84}),\n",
    "    (\"Tchouameni\", \"MIL\", 86, {\"vitesse\": 74, \"tir\": 72, \"passe\": 80, \"dribble\": 76, \"defense\": 82, \"physique\": 86}),\n",
    "    (\"Kante\", \"MIL\", 88, {\"vitesse\": 78, \"tir\": 66, \"passe\": 75, \"dribble\": 81, \"defense\": 87, \"physique\": 82}),\n",
    "    (\"Rabiot\", \"MIL\", 82, {\"vitesse\": 72, \"tir\": 75, \"passe\": 79, \"dribble\": 80, \"defense\": 76, \"physique\": 80}),\n",
    "    (\"Camavinga\", \"MIL\", 83, {\"vitesse\": 82, \"tir\": 64, \"passe\": 78, \"dribble\": 82, \"defense\": 76, \"physique\": 78}),\n",
    "    (\"Hernandez\", \"DEF\", 85, {\"vitesse\": 84, \"tir\": 65, \"passe\": 76, \"dribble\": 78, \"defense\": 82, \"physique\": 82}),\n",
    "    (\"Upamecano\", \"DEF\", 84, {\"vitesse\": 80, \"tir\": 48, \"passe\": 62, \"dribble\": 58, \"defense\": 86, \"physique\": 88}),\n",
    "    (\"Konate\", \"DEF\", 84, {\"vitesse\": 78, \"tir\": 42, \"passe\": 56, \"dribble\": 52, \"defense\": 87, \"physique\": 86}),\n",
    "    (\"Saliba\", \"DEF\", 86, {\"vitesse\": 76, \"tir\": 38, \"passe\": 65, \"dribble\": 60, \"defense\": 88, \"physique\": 84}),\n",
    "    (\"Maignan\", \"GK\", 87, {\"plongeon\": 88, \"reflexes\": 89, \"placement\": 84, \"jeu_pied\": 78}),\n",
    "    (\"Lloris\", \"GK\", 85, {\"plongeon\": 86, \"reflexes\": 87, \"placement\": 86, \"jeu_pied\": 72})\n",
    "]\n",
    "\n",
    "# Formation 4-3-3 : nombre de joueurs par poste\n",
    "formation = {\n",
    "    \"GK\": 1,   # Gardien\n",
    "    \"DEF\": 4,  # Defenseurs\n",
    "    \"MIL\": 3,  # Milieux\n",
    "    \"ATT\": 3   # Attaquants\n",
    "}\n",
    "\n",
    "# Historique des matchs : (adversaire, buts_pour, buts_contre, buteurs)\n",
    "matchs = [\n",
    "    (\"Allemagne\", 2, 1, [\"Mbappe\", \"Griezmann\"]),\n",
    "    (\"Belgique\", 3, 0, [\"Mbappe\", \"Mbappe\", \"Dembele\"]),\n",
    "    (\"Espagne\", 1, 2, [\"Thuram\"]),\n",
    "    (\"Italie\", 2, 2, [\"Griezmann\", \"Mbappe\"]),\n",
    "    (\"Portugal\", 0, 1, []),\n",
    "    (\"Angleterre\", 3, 1, [\"Mbappe\", \"Griezmann\", \"Dembele\"])\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell-3",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Exercice 1 - Gestion de l'effectif (25 min)\n",
    "\n",
    "### 1.1 Affichage des joueurs (4 pts)\n",
    "\n",
    "Écrivez une fonction `afficher_joueur(joueur)` qui affiche un joueur de manière formatée.\n",
    "\n",
    "Exemple pour un joueur de champ :\n",
    "```\n",
    "Mbappe (ATT) - Note: 91\n",
    "  VIT:97 | TIR:89 | PAS:80 | DRI:92\n",
    "```\n",
    "\n",
    "Pour les gardiens (poste \"GK\"), afficher leurs stats spécifiques (plongeon, reflexes, etc.)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell-4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def afficher_joueur(joueur):\n",
    "    # Extraire les infos du tuple\n",
    "    nom = joueur[0]\n",
    "    poste = joueur[1]\n",
    "    note = joueur[2]\n",
    "    stats = joueur[3]\n",
    "    \n",
    "    print(nom, \"(\" + poste + \") - Note:\", note)\n",
    "    \n",
    "    if poste == \"GK\":\n",
    "        # Afficher stats gardien\n",
    "        # Votre code ici\n",
    "        pass\n",
    "    else:\n",
    "        # Afficher stats joueur de champ\n",
    "        # Votre code ici\n",
    "        pass\n",
    "\n",
    "# Tests\n",
    "afficher_joueur(effectif[0])  # Joueur de champ\n",
    "print()\n",
    "afficher_joueur(effectif[12])  # Gardien"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell-5",
   "metadata": {},
   "source": [
    "### 1.2 Filtrage par poste (4 pts)\n",
    "\n",
    "Écrivez une fonction `joueurs_par_poste(effectif, poste)` qui renvoie la liste des joueurs d'un poste donné, triés par note décroissante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell-6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def joueurs_par_poste(effectif, poste):\n",
    "    joueurs = []\n",
    "    \n",
    "    for joueur in effectif:\n",
    "        if joueur[1] == poste:\n",
    "            joueurs.append(joueur)\n",
    "    \n",
    "    # Trier par note (indice 2) decroissante\n",
    "    joueurs = sorted(joueurs, key=lambda j: j[2], reverse=True)\n",
    "    return joueurs\n",
    "\n",
    "# Test\n",
    "print(\"Attaquants :\")\n",
    "for j in joueurs_par_poste(effectif, \"ATT\"):\n",
    "    print(\" \", j[0], \"-\", j[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell-7",
   "metadata": {},
   "source": [
    "### 1.3 Meilleur dans une stat (4 pts)\n",
    "\n",
    "Écrivez une fonction `meilleur_stat(effectif, stat)` qui renvoie le tuple `(nom_joueur, valeur)` du joueur ayant la meilleure valeur pour cette statistique.\n",
    "\n",
    "*Attention : les gardiens n'ont pas les mêmes stats que les joueurs de champ.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell-8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def meilleur_stat(effectif, stat):\n",
    "    meilleur_nom = None\n",
    "    meilleure_valeur = -1\n",
    "    \n",
    "    for joueur in effectif:\n",
    "        nom = joueur[0]\n",
    "        stats = joueur[3]\n",
    "        \n",
    "        # Verifier si le joueur a cette stat\n",
    "        if stat in stats:\n",
    "            valeur = stats[stat]\n",
    "            # Votre code ici\n",
    "            pass\n",
    "    \n",
    "    return (meilleur_nom, meilleure_valeur)\n",
    "\n",
    "# Tests\n",
    "print(\"Plus rapide :\", meilleur_stat(effectif, \"vitesse\"))\n",
    "print(\"Meilleur tireur :\", meilleur_stat(effectif, \"tir\"))\n",
    "print(\"Meilleurs reflexes :\", meilleur_stat(effectif, \"reflexes\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell-9",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Exercice 2 - Composition d'équipe (35 min)\n",
    "\n",
    "### 2.1 Générer le XI de départ (6 pts)\n",
    "\n",
    "Écrivez une fonction `generer_xi(effectif, formation)` qui génère automatiquement le meilleur XI possible.\n",
    "\n",
    "Pour chaque poste, sélectionner les meilleurs joueurs (par note globale) en respectant le nombre requis.\n",
    "\n",
    "Renvoie un dictionnaire `{poste: [liste des joueurs sélectionnés]}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell-10",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generer_xi(effectif, formation):\n",
    "    xi = {}\n",
    "    \n",
    "    for poste, nb_joueurs in formation.items():\n",
    "        # Recuperer les joueurs de ce poste, tries par note\n",
    "        candidats = joueurs_par_poste(effectif, poste)\n",
    "        \n",
    "        # Prendre les n meilleurs\n",
    "        # Votre code ici\n",
    "        pass\n",
    "    \n",
    "    return xi\n",
    "\n",
    "# Test\n",
    "xi = generer_xi(effectif, formation)\n",
    "print(\"=== XI de depart ===\")\n",
    "for poste, joueurs in xi.items():\n",
    "    print(poste + \":\")\n",
    "    for j in joueurs:\n",
    "        print(\"  -\", j[0], \"(\", j[2], \")\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell-11",
   "metadata": {},
   "source": [
    "### 2.2 Note moyenne du XI (5 pts)\n",
    "\n",
    "Écrivez une fonction `note_equipe(xi)` qui calcule la note moyenne de l'équipe sélectionnée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell-12",
   "metadata": {},
   "outputs": [],
   "source": [
    "def note_equipe(xi):\n",
    "    total_notes = 0\n",
    "    nb_joueurs = 0\n",
    "    \n",
    "    for poste, joueurs in xi.items():\n",
    "        for joueur in joueurs:\n",
    "            # Votre code ici\n",
    "            pass\n",
    "    \n",
    "    if nb_joueurs == 0:\n",
    "        return 0\n",
    "    \n",
    "    return round(total_notes / nb_joueurs, 1)\n",
    "\n",
    "# Test\n",
    "print(\"Note de l'equipe :\", note_equipe(xi))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell-13",
   "metadata": {},
   "source": [
    "### 2.3 Statistiques des matchs (6 pts)\n",
    "\n",
    "Écrivez une fonction `stats_matchs(matchs)` qui renvoie un dictionnaire avec :\n",
    "- `\"victoires\"` : nombre de victoires\n",
    "- `\"nuls\"` : nombre de matchs nuls\n",
    "- `\"defaites\"` : nombre de défaites\n",
    "- `\"buts_pour\"` : total des buts marqués\n",
    "- `\"buts_contre\"` : total des buts encaissés"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell-14",
   "metadata": {},
   "outputs": [],
   "source": [
    "def stats_matchs(matchs):\n",
    "    victoires = 0\n",
    "    nuls = 0\n",
    "    defaites = 0\n",
    "    buts_pour = 0\n",
    "    buts_contre = 0\n",
    "    \n",
    "    for match in matchs:\n",
    "        adversaire = match[0]\n",
    "        bp = match[1]  # buts pour\n",
    "        bc = match[2]  # buts contre\n",
    "        \n",
    "        buts_pour = buts_pour + bp\n",
    "        buts_contre = buts_contre + bc\n",
    "        \n",
    "        if bp > bc:\n",
    "            victoires = victoires + 1\n",
    "        elif bp == bc:\n",
    "            nuls = nuls + 1\n",
    "        else:\n",
    "            # Votre code ici\n",
    "            pass\n",
    "    \n",
    "    return {\n",
    "        \"victoires\": victoires,\n",
    "        \"nuls\": nuls,\n",
    "        \"defaites\": defaites,\n",
    "        \"buts_pour\": buts_pour,\n",
    "        \"buts_contre\": buts_contre\n",
    "    }\n",
    "\n",
    "# Test\n",
    "stats = stats_matchs(matchs)\n",
    "print(\"Bilan :\", stats[\"victoires\"], \"V\", stats[\"nuls\"], \"N\", stats[\"defaites\"], \"D\")\n",
    "print(\"Buts :\", stats[\"buts_pour\"], \"-\", stats[\"buts_contre\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell-15",
   "metadata": {},
   "source": [
    "### 2.4 Classement des buteurs (6 pts)\n",
    "\n",
    "Écrivez une fonction `classement_buteurs(matchs)` qui renvoie une liste de tuples `(joueur, nb_buts)` triée par nombre de buts décroissant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell-16",
   "metadata": {},
   "outputs": [],
   "source": [
    "def classement_buteurs(matchs):\n",
    "    # Dictionnaire pour compter les buts par joueur\n",
    "    buts_par_joueur = {}\n",
    "    \n",
    "    for match in matchs:\n",
    "        buteurs = match[3]  # liste des buteurs\n",
    "        for buteur in buteurs:\n",
    "            if buteur not in buts_par_joueur:\n",
    "                buts_par_joueur[buteur] = 0\n",
    "            buts_par_joueur[buteur] = buts_par_joueur[buteur] + 1\n",
    "    \n",
    "    # Convertir en liste de tuples et trier\n",
    "    classement = []\n",
    "    for joueur, buts in buts_par_joueur.items():\n",
    "        classement.append((joueur, buts))\n",
    "    \n",
    "    classement = sorted(classement, key=lambda x: x[1], reverse=True)\n",
    "    return classement\n",
    "\n",
    "# Test\n",
    "print(\"Classement des buteurs :\")\n",
    "for i, (joueur, buts) in enumerate(classement_buteurs(matchs), 1):\n",
    "    print(\" \", i, \".\", joueur, \":\", buts, \"but(s)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell-17",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Exercice 3 - Bonus (20 min)\n",
    "\n",
    "### 3.1 Points forts et faibles (5 pts)\n",
    "\n",
    "Écrivez une fonction `analyser_joueur(joueur)` qui renvoie un dictionnaire avec :\n",
    "- `\"points_forts\"` : liste des stats >= 85\n",
    "- `\"points_faibles\"` : liste des stats <= 60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell-18",
   "metadata": {},
   "outputs": [],
   "source": [
    "def analyser_joueur(joueur):\n",
    "    stats = joueur[3]\n",
    "    points_forts = []\n",
    "    points_faibles = []\n",
    "    \n",
    "    for stat, valeur in stats.items():\n",
    "        if valeur >= 85:\n",
    "            points_forts.append(stat)\n",
    "        # Votre code ici pour les points faibles\n",
    "        pass\n",
    "    \n",
    "    return {\n",
    "        \"points_forts\": points_forts,\n",
    "        \"points_faibles\": points_faibles\n",
    "    }\n",
    "\n",
    "# Test\n",
    "analyse = analyser_joueur(effectif[0])  # Mbappe\n",
    "print(\"Analyse de Mbappe :\")\n",
    "print(\"  Points forts :\", analyse[\"points_forts\"])\n",
    "print(\"  Points faibles :\", analyse[\"points_faibles\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell-19",
   "metadata": {},
   "source": [
    "### 3.2 Rechercher un joueur (4 pts)\n",
    "\n",
    "Écrivez une fonction `rechercher_joueur(effectif, nom)` qui renvoie le joueur correspondant au nom (ou None si non trouvé)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell-20",
   "metadata": {},
   "outputs": [],
   "source": [
    "def rechercher_joueur(effectif, nom):\n",
    "    for joueur in effectif:\n",
    "        if joueur[0] == nom:\n",
    "            return joueur\n",
    "    return None\n",
    "\n",
    "# Test\n",
    "joueur = rechercher_joueur(effectif, \"Kante\")\n",
    "if joueur:\n",
    "    afficher_joueur(joueur)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell-21",
   "metadata": {},
   "source": [
    "### 3.3 Performance d'un joueur (5 pts)\n",
    "\n",
    "Écrivez une fonction `performance_buteur(nom, matchs)` qui renvoie le nombre de buts et la moyenne de buts par match pour un joueur donné."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell-22",
   "metadata": {},
   "outputs": [],
   "source": [
    "def performance_buteur(nom, matchs):\n",
    "    nb_buts = 0\n",
    "    nb_matchs = len(matchs)\n",
    "    \n",
    "    for match in matchs:\n",
    "        buteurs = match[3]\n",
    "        for buteur in buteurs:\n",
    "            if buteur == nom:\n",
    "                nb_buts = nb_buts + 1\n",
    "    \n",
    "    moyenne = 0\n",
    "    if nb_matchs > 0:\n",
    "        moyenne = round(nb_buts / nb_matchs, 2)\n",
    "    \n",
    "    return {\n",
    "        \"buts\": nb_buts,\n",
    "        \"matchs\": nb_matchs,\n",
    "        \"moyenne\": moyenne\n",
    "    }\n",
    "\n",
    "# Test\n",
    "perf = performance_buteur(\"Mbappe\", matchs)\n",
    "print(\"Performance de Mbappe :\")\n",
    "print(\"  Buts :\", perf[\"buts\"])\n",
    "print(\"  Moyenne par match :\", perf[\"moyenne\"])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}