TP1_Analyse_des_donnees.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c08dddf1",
   "metadata": {},
   "source": [
    "# TP1 : Analyse des données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "047a794f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       0    1    2    3               4\n",
      "0    5.1  3.5  1.4  0.2     Iris-setosa\n",
      "1    4.9  3.0  1.4  0.2     Iris-setosa\n",
      "2    4.7  3.2  1.3  0.2     Iris-setosa\n",
      "3    4.6  3.1  1.5  0.2     Iris-setosa\n",
      "4    5.0  3.6  1.4  0.2     Iris-setosa\n",
      "..   ...  ...  ...  ...             ...\n",
      "145  6.7  3.0  5.2  2.3  Iris-virginica\n",
      "146  6.3  2.5  5.0  1.9  Iris-virginica\n",
      "147  6.5  3.0  5.2  2.0  Iris-virginica\n",
      "148  6.2  3.4  5.4  2.3  Iris-virginica\n",
      "149  5.9  3.0  5.1  1.8  Iris-virginica\n",
      "\n",
      "[150 rows x 5 columns]\n"
     ]
    }
   ],
   "source": [
    "import pandas as np\n",
    "import numpy as np\n",
    "\n",
    "#une fonction qui charge le dataset\n",
    "\n",
    "def charge(file):\n",
    "    dataset = []\n",
    "    with open(file, 'r') as file:\n",
    "        for line in file:\n",
    "            IDF_STR = line.strip()  # Supprime les sauts de ligne et les espaces en début et fin de ligne\n",
    "            SEPARATEUR = \",\"\n",
    "            IDF_STR_ARRAY = IDF_STR.split(SEPARATEUR)\n",
    "            IDF_DOUBLE_ARRAY = [float(x) if i < len(IDF_STR_ARRAY) - 1 else x for i, x in enumerate(IDF_STR_ARRAY)]\n",
    "            dataset.append(IDF_DOUBLE_ARRAY)\n",
    "    return dataset\n",
    "\n",
    "\n",
    "## test\n",
    "file = \"Dataset-Exos.txt\"\n",
    "donnees = charge(file)\n",
    "\n",
    "# Affichage du résultat\n",
    "for row in donnees:\n",
    "    print(row)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7fd271e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nombre de lignes dans le dataset : 150\n",
      "Nombre de colonnes dans le dataset : 5\n",
      "Attribut 1: Type = numérique  float\n",
      "Attribut 2: Type = numérique  float\n",
      "Attribut 3: Type = numérique  float\n",
      "Attribut 4: Type = numérique  float\n",
      "Attribut 5: Type = chaîne de caractères\n",
      "Minimum global : 0.1 | Maximum global : 7.9\n"
     ]
    }
   ],
   "source": [
    "#une fonction qui retourne les informations  dataset\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "def info(dataset):\n",
    "    # Nombre de lignes et de colonnes\n",
    "    nb_lignes = len(dataset)\n",
    "    nb_colonnes = len(dataset[0]) if nb_lignes > 0 else 0\n",
    "    \n",
    "    print(f\"Nombre de lignes dans le dataset : {nb_lignes}\")\n",
    "    print(f\"Nombre de colonnes dans le dataset : {nb_colonnes}\")\n",
    "      # Déterminer le type de chaque attribut\n",
    "    types_attributs = []  # Liste pour stocker le type de chaque attribut\n",
    "    for att in range(nb_colonnes):\n",
    "        attribut_type = None\n",
    "        for row in dataset:\n",
    "            if att < len(row):\n",
    "                if isinstance(row[att], (int)):\n",
    "                    attribut_type = \"numérique  entier\"\n",
    "                elif isinstance(row[att], (float)):\n",
    "                    attribut_type = \"numérique  float\"\n",
    "                elif isinstance(row[att], str):\n",
    "                    attribut_type = \"chaîne de caractères\"\n",
    "        \n",
    "        types_attributs.append(attribut_type)\n",
    "    \n",
    "    for att, attribut_type in enumerate(types_attributs):\n",
    "        print(f\"Attribut {att + 1}: Type = {attribut_type}\")\n",
    "    \n",
    "    #Le min et le max\n",
    "    valeurs = []  # Liste pour stocker toutes les valeurs numériques du dataset\n",
    "    for row in dataset:\n",
    "        for att in row:\n",
    "            if isinstance(att, (int, float)):\n",
    "                valeurs.append(att)\n",
    "    \n",
    "    if valeurs:\n",
    "        minatt = min(valeurs)\n",
    "        maxatt = max(valeurs)\n",
    "        print(f\"Minimum global : {minatt} | Maximum global : {maxatt}\")\n",
    "    else:\n",
    "        print(\"Le dataset ne contient aucune valeur numérique.\")\n",
    "        \n",
    "    \n",
    "        \n",
    "      \n",
    "     \n",
    "    \n",
    "   \n",
    "    \n",
    "\n",
    " # test\n",
    "info(donnees)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c3380450",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Les tendances centrales des attributs :\n",
      "L'attribut : 1\n",
      "(moyenne:5.843333333333335 mode :5.0  medianne :5.8 )\n",
      "Les tendances centrales des attributs :\n",
      "L'attribut : 2\n",
      "(moyenne:3.0540000000000007 mode :3.0  medianne :3.0 )\n",
      "Les tendances centrales des attributs :\n",
      "L'attribut : 3\n",
      "(moyenne:3.7586666666666693 mode :1.5  medianne :4.35 )\n",
      "Les tendances centrales des attributs :\n",
      "L'attribut : 4\n",
      "(moyenne:1.1986666666666672 mode :0.2  medianne :1.3 )\n",
      "Les tendances centrales des attributs :\n",
      "L'attribut : 5\n",
      "(moyenne:None mode :None  medianne :None )\n"
     ]
    }
   ],
   "source": [
    "#une fonction qui calcule les tendances centrales (mode ,medianne , moyenne)\n",
    "def mediane(valeurs):\n",
    "    valeurs_triees = sorted(valeurs)\n",
    "    n = len(valeurs_triees)\n",
    "    \n",
    "    if n % 2 == 0:\n",
    "        # Si le nombre de valeurs est pair, la médiane est la moyenne des deux valeurs du milieu.\n",
    "        milieu_gauche = valeurs_triees[n // 2 - 1]\n",
    "        milieu_droit = valeurs_triees[n // 2]\n",
    "        mediane = (milieu_gauche + milieu_droit) / 2\n",
    "    else:\n",
    "        # Si le nombre de valeurs est impair, la médiane est la valeur du milieu.\n",
    "        mediane = valeurs_triees[n // 2]\n",
    "    \n",
    "    return mediane\n",
    "def mode(valeurs):\n",
    "    compteur = {}  # Dictionnaire pour compter la fréquence de chaque valeur\n",
    "    \n",
    "    for valeur in valeurs:\n",
    "        if valeur in compteur:\n",
    "            compteur[valeur] += 1\n",
    "        else:\n",
    "            compteur[valeur] = 1\n",
    "    \n",
    "    mode = max(compteur, key=compteur.get)  # Trouver la valeur avec la fréquence la plus élevée\n",
    "    return mode\n",
    "\n",
    "\n",
    "def tendance(dataset):\n",
    " for att in range(len(dataset[0])): \n",
    "    print(\"Les tendances centrales des attributs :\")\n",
    "    print(f\"L'attribut : {att+1}\")\n",
    "    valeurs = []  # Liste pour stocker les valeurs numériques de l'attribut\n",
    "    \n",
    "    # Parcourir le dataset pour extraire les valeurs numériques de l'attribut spécifié\n",
    "    \n",
    "    for row in dataset:\n",
    "        \n",
    "        if att < len(row) and isinstance(row[att], (int, float)):\n",
    "            valeurs.append(row[att])\n",
    "    \n",
    "    resultats = {}  # Dictionnaire pour stocker les résultats\n",
    "    \n",
    "    if valeurs:\n",
    "        resultats['moyenne'] = sum(valeurs) / len(valeurs)  # Calcul de la moyenne\n",
    "        resultats['mediane'] = mediane(valeurs)  # Calcul de la médiane\n",
    "        resultats['mode'] = mode(valeurs)  # Calcul du mode\n",
    "    else:\n",
    "        resultats['moyenne'] = None\n",
    "        resultats['mediane'] = None\n",
    "        resultats['mode'] = None\n",
    "\n",
    "    print(f\"(moyenne:{resultats['moyenne']} mode :{resultats['mode']}  medianne :{resultats['mediane']} )\")\n",
    "\n",
    "tendance(donnees)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8ad263e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "#une fonction qui calcule les quartiles\n",
    "def quartile(dataset):\n",
    "\n",
    "    for att in range(len(dataset[0])): \n",
    "      valeurs = []  # Liste pour stocker les valeurs numériques de l'attribut\n",
    "    \n",
    "    # Parcourir le dataset pour extraire les valeurs numériques de l'attribut spécifié\n",
    "    \n",
    "      for row in dataset:\n",
    "        if att < len(row) and isinstance(row[att], (int, float)):\n",
    "            valeurs.append(row[att])\n",
    "    \n",
    "      valeurs_triees = sorted(valeurs)\n",
    "      n = len(valeurs_triees)\n",
    "      print(f\"L'attribut : {att+1}\")\n",
    "      if valeurs:\n",
    "        \n",
    "        Q0=min(valeurs)\n",
    "        Q1=valeurs[int(n/4)+1]\n",
    "        Q2=mediane(valeurs)\n",
    "        Q3=valeurs[int(3*n/4)+1]\n",
    "        Q4=max(valeurs)\n",
    "        print(f\"(Q0 : {Q0} | Q1:{Q1}  | Q2:{Q2}  | Q3:{Q3}  | Q4:{Q4}\")\n",
    "        \n",
    "      else:\n",
    "        print(\"le typee est non calculable\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3698c896",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L'attribut : 1\n",
      "(Q0 : 4.3 | Q1:4.4  | Q2:5.8  | Q3:5.7  | Q4:7.9\n",
      "L'attribut : 2\n",
      "(Q0 : 2.0 | Q1:3.0  | Q2:3.0  | Q3:2.5  | Q4:4.4\n",
      "L'attribut : 3\n",
      "(Q0 : 1.0 | Q1:1.3  | Q2:4.35  | Q3:5.0  | Q4:6.9\n",
      "L'attribut : 4\n",
      "(Q0 : 0.1 | Q1:0.2  | Q2:1.3  | Q3:2.0  | Q4:2.5\n",
      "L'attribut : 5\n",
      "le typee est non calculable\n"
     ]
    }
   ],
   "source": [
    "quartile(donnees)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "cbf5bd5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L'attribut : 1\n",
      "nombre de valeur manquantes : 0, le pourcentage: 0.0%\n",
      "L'attribut : 2\n",
      "nombre de valeur manquantes : 0, le pourcentage: 0.0%\n",
      "L'attribut : 3\n",
      "nombre de valeur manquantes : 0, le pourcentage: 0.0%\n",
      "L'attribut : 4\n",
      "nombre de valeur manquantes : 0, le pourcentage: 0.0%\n",
      "L'attribut : 5\n",
      "nombre de valeur manquantes : 0, le pourcentage: 0.0%\n"
     ]
    }
   ],
   "source": [
    "#une fonction qui calcule le nombre et le pourcentage de valeurs manquantes\n",
    "def valeurmanq(dataset):\n",
    " for att in range(len(dataset[0])): \n",
    "    nb_lignes = len(dataset)\n",
    "    print(f\"L'attribut : {att+1}\")\n",
    "    \n",
    "    \n",
    "    cpt=dataset[att].count(None)\n",
    "   \n",
    "    pourcentage=(cpt/nb_lignes)*100\n",
    "    \n",
    "    print(f\"nombre de valeur manquantes : {cpt}, le pourcentage: {pourcentage}%\")\n",
    "    \n",
    "\n",
    "    \n",
    "    \n",
    "\n",
    "valeurmanq(donnees)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83d36569",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8bdf3a29",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03abdd6f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}