{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Du traitement des données en table aux bases de données - CORRECTION" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ressources** : " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Sommaire**\n", "* 1. Généralités\n", " * 1.1 Historique\n", " * 1.2 Organisation d'une table\n", " * 1.3 Objectifs\n", "* 2. Construction d'une table et traitement de ses données\n", " * 2.1 Construction\n", " * 2.2 Traitement des données\n", "----" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", "
Cette activité est un préalable aux travaux pratiques sur les bases de données relationnelles. Le vocabulaire utilisé (attribut, enregistrement, requête, etc.) est celui employé lors de leur interrogation. A la fin de chaque exercice, la référence faite aux bases de données est identifiée par l'icône ci-contre.\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Généralités\n", "### 1.1 Historique\n", "\n", " \n", " \n", " \n", " \n", "

L'organisation tabulaire des données est très répandue. Les tables documentées les plus anciennes sont des livres de comptes déjà présents dans l'Égypte des pharaons.

Aujourd'hui, cette organisation est utilisée par les bulletins scolaires, les résultats de match ou les relevés d'un compte bancaire qui indiquent pour chaque opération, sa date, son montant et sa nature (débit ou crédit).

En informatique, la manipulation de données en tables depuis un langage de programmation est utilisée dans de nombreux domaines : calcul scientifique, intelligence artificielle, programmation Web, bio-informatique, informatique financière, etc.

\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.2 Organisation d'une table\n", "Dans ce notebook, les tables représentent des **collections d'éléments**. Une **ligne** est un élément enregistré dans la collection ou **enregistrement**. Les **colonnes** sont les **attributs** d'un élément (également notées champs ou descripteurs). La première ligne est le **schéma de la table**.\n", "\n", "![table.png](img/table.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.3 Objectifs\n", "On veut **construire** la table de données ci-dessous à partir d'un fichier CSV et **coder** des **requêtes** en Python répondant à des **interrogations** telles que :\n", "* Le prénom \"Brian\" est-il dans la table ?\n", "* Quels scientifiques ont pour prénom Alan ?\n", "* Quels sont le nom et le prénom des scientifiques nés entre 1900 et 1920,\n", "etc.\n", "\n", "![table.png](img/scientifiques.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Construction d'une table et traitement de ses données\n", "### 2.1 Construction\n", "La première opération concernant les données en table est le **chargement des données**. Celles-ci sont souvent chargées à partir d'un fichier au format CSV (**Comma-Separated Values**) relativement simple :\n", "* les fichiers CSV sont des fichiers texte,\n", "* chaque ligne du fichier correspond à une ligne de la table,\n", "* chaque ligne est séparée en champs au moyen d'une virgule, d'un point-virgule ou d'une barre verticale,\n", "* toutes les lignes du fichier ont le même nombre d'attributs,\n", "* la première ligne peut représenter des noms d'attributs ou commencer directement avec les données,\n", "* on peut utiliser des guillemets pour délimiter le contenu des attributs.\n", "\n", "La **bibliothèque standard** Python propose un module **csv** contenant des fonctions pour lire et écrire des fichiers CSV." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# --------------------------- A FAIRE UNIQUEMENT dans GOOGLE COLABORATORY ------------------------------------------------ \n", "# Faites une copie de ce notebook dans votre drive et renommez-le : table_classe_nom_prénom.ipynb\n", "# Pour télécharger le fichier \"scientifiques.csv\" sur le bureau de votre PC, utilisez le lien : \n", "# https://webge.fr/doc/tnsi/tp/BDD/scientifiques.csv\n", "# puis décommentez et exécutez les deux lignes ci-dessous pour importer \"scientifiques.csv\" dans le répertoire \n", "# colab Notebooks de votre compte Google\n", "# ------------------------------------------------------------------------------------------------------------------------\n", "# from google.colab import files\n", "# data_to_load = files.upload()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Le code suivant charge le contenu du fichier *scientifiques.csv* dans une variable nommée *scientifiques*. **Exécutez-le**." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import csv\n", "with open('scientifiques.csv',encoding='utf-8') as fichier:\n", " scientifiques = list(csv.DictReader(fichier, delimiter=\";\"))\n", "print(scientifiques)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", "
La fonction DictReader renvoie des dictionnaires ordonnés que nous utiliserons comme des dictionnaires. La variable scientifiques contient donc un tableau de dictionnaires. On constate que le schéma de la table n'est pas stocké dans le tableau, mais a été utilisé pour créer les clés des dictionnaires.\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", "
DictReader charge les données dans la table sous la forme de chaînes de caractères. Si on veut les utiliser en tant que nombres, comme les attributs jour, mois et année, pour les comparer ou faire des opérations, il faut les convertir ( on dit aussi transtyper ).\n", "
    \n", "
  • La fonction int() convertit une donnée en entier.
    • \n", "
  • La fonction float() convertit une donnée en décimal.
    • \n", "
\n", "On propose le code ci-dessous. Exécutez-le.\n", "
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def valide(enregistrement): # Validation des données : transtypage\n", " nom = enregistrement['nom']\n", " prenom = enregistrement[\"prenom\"]\n", " jour = int(enregistrement[\"jour\"])\n", " mois = int(enregistrement[\"mois\"])\n", " annee = int(enregistrement[\"annee\"])\n", " projet = enregistrement[\"projet\"]\n", " return{\"nom\": nom, \"prenom\": prenom, \"jour\": jour, \"mois\": mois, \"annee\": annee, \"projet\": projet}\n", "\n", "scientifiques = [valide(enregistrement) for enregistrement in scientifiques]\n", "print(scientifiques)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", "
Vous noterez que les nombres situés dans la table scientifiques ne sont plus entourés par des guillemets ! \n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.2 Traitement des données\n", "Une fois les données chargées dans une table, il devient possible de les **traiter** à l'aide des fonctions de manipulation de tableaux. On peut ainsi réaliser des **opérations** telles que : \n", "* extraire des données de la table, \n", "* tester la présence de certaines d'entre-elles,\n", "* faire des statistiques. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", "
Lorsque nous utiliserons une base de données et le langage SQL, ce type d'opération sera appelé REQUÊTE.
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Exercice 1. Un prénom est-il présent dans la table ?\n", "> On cherche à répondre à une question du type : \"Y a t'il au moins une personne ayant pour prénom Brian dans la table ?\"
\n", ">\n", "> **Complétez** la fonction ***present(prenom, table)*** dans le cadre ci-dessous pour qu'elle renvoie Vrai si le prénom passé en paramètre est présent dans la table et Faux sinon.\n", ">\n", "> *Exemples d'affichage attendus (=> indique le résultat renvoyé)*
\n", "> - Entrer un prénom : Brian
\n", "> => Il y a au moins un(e) Brian dans la table.
\n", "> - Entrer un prénom : Audrey
\n", "> => Aucun(e) Audrey n'est dans la table." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", "
Python est un langage à typage dynamique, c'est-à-dire qu'il n'est pas nécessaire de préciser le type des données. Depuis la version 3.5, il est possible de fournir des indicateurs de type (str,bool, etc.) lors de la définition des fonctions. Cette possibilité est utilisée dans ce notebook pour faciliter la compréhension du code.\n", "
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# CORRECTION\n", "def present(prenom: str, table: list) -> bool: # prenom est de type chaîne de caractères, table est de type liste, \n", " # la fonction renvoie un booléen\n", " for enregistrement in table: # Sélection des enregistrements dans la table\n", " if enregistrement[\"prenom\"].lower() == prenom.lower(): \n", " return True # si le prénom est celui passé en paramètre alors on renvoie Vrai\n", " return False # sinon on renvoie Faux\n", "\n", "# Affichage à compléter\n", "prenom = input(\"Entrer un prénom : \")\n", "if (present(prenom, scientifiques)):\n", " print(f\"Il y a au moins un(e) {prenom} dans la table.\")\n", "else:\n", " print(f\"Aucun(e) {prenom} n'est dans la table.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", "
La fonction present(prenom, table) peut être améliorée en renvoyant le nombre de fois qu'un même prénom est présent dans la table. Faites cette amélioration en complétant le code de la fonction presents(prenom, table) ci-dessous.\n", "
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# CORRECTION\n", "def presents(prenom: str, table: list) -> int: # renvoie le nombre nb d'occurence du prénom dans la table\n", " nb = 0\n", " for enregistrement in table:\n", " if (enregistrement[\"prenom\"]).lower() == prenom.lower():\n", " nb += 1\n", " return nb\n", "\n", "# Affichage à compléter\n", "prenom = input(\"Entrer un prénom : \")\n", "print(f\"Il y a {presents(prenom,scientifiques)} {prenom} dans la table\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", " \n", "
Dans le langage SQL la requête SELECT COUNT(attribut) FROM table WHERE attribut=valeur, appliquée à la table scientifiques (contenue dans une base de données), donnerait le même résultat.

Exemple
SELECT COUNT(prenom) FROM scientifiques WHERE prenom=\"Brian\"
renvoie 1.
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Exercice 2. Sélection du(es) nom(s) correspondant à un prénom
\n", "> On cherche à répondre à une question du type : \"Quel est le nom du(es) scientifique(s) ayant pour prénom Brian ?\"
\n", ">\n", "> **Créez** la fonction ***nom(prenom, table)*** qui renvoie la liste des noms des scientifiques ayant pour prénom celui passé en paramètre.\n", ">\n", "> *Exemples d'affichages attendus*
\n", "> - Entrer un prénom : Brian => ['Kernighan']
\n", "> - Entrer un prénom : Alan => ['Turing', 'Perlis']
\n", "> - Entrer un prénom : Audrey => []" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# CORRECTION\n", "def noms(prenom: str, table: list) -> list:\n", " t = [] # tableau recevant le(s) nom(s) correspondant au prénom\n", "\n", " for enregistrement in table:\n", " if enregistrement[\"prenom\"] == prenom:\n", " t.append(enregistrement[\"nom\"])\n", "\n", " # [t.append(enregistrement[\"nom\"]) for enregistrement in table if enregistrement[\"prenom\"] == prenom]\n", " return t\n", "\n", "# Affichage à compléter\n", "prenom = input(\"Entrer un prénom : \")\n", "noms(prenom,scientifiques)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", " \n", "
Dans le langage SQL la requête SELECT attribut1, attribut2, ..., attributn FROM table WHERE attribut=valeur, appliquée à la table scientifiques, donnerait le même résultat.

Exemple
SELECT nom FROM scientifiques WHERE prenom=\"Alan\"
renvoie Turing, Perlis.
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", "
La fonction nom(prenom, table) sélectionne l'attribut nom des personnes avec le même prénom. Dans le prochain exercice, vous allez généraliser ce cas particulier à tous les attributs de la table. \n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Exercice 3. Sélection d'un attribut en fonction de la valeur d'un autre
\n", "> On souhaite répondre aux questions suivantes en utilisant la même fonction :
\n", "> * Quel est le prénom des scientifiques nés en juin ? \n", "> * Quel est le nom des scientifiques dont le prénom est Alan ?\n", "> * Quel est le nom des scientifiques nés le premier jour du mois ? etc.
\n", "\n", ">**Créez** la fonction ***selection(attribut1,table,attribut2,valeur)*** qui renvoie la liste attribut1 pour laquelle attribut2 = valeur.\n", ">\n", "> *Exemples d'affichages attendus*
\n", "> - Prénom des scientifiques nés en juin => ['Alan', 'Blaise']
\n", "> - Nom des scientifiques dont le prénom est Alan => ['Turing', 'Perlis']
\n", "> - Nom des scientifiques nés le premier jour du mois => ['Kernighan', 'Perlis']" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# CORRECTION\n", "def selection(attribut1: str, table: list, attribut2: str, valeur) -> list:\n", " t = [] # tableau contenant la ou les valeurs de attribut1 pour attribut2 = valeur\n", "\n", " for enregistrement in table:\n", " if enregistrement[attribut2] == valeur:\n", " t.append(enregistrement[attribut1])\n", " \n", " # [t.append(enregistrement[attribut1]) for enregistrement in table if enregistrement[attribut2] == valeur]\n", " return t\n", "\n", "# Affichage à compléter\n", "# 1. Prénom des scientifiques nés en juin\n", "print(selection(\"prenom\", scientifiques, \"mois\", 6))\n", "# 2. Nom des scientifiques dont le prénom est Alan\n", "print(selection(\"nom\",scientifiques,\"prenom\",\"Alan\"))\n", "# 3. Nom des scientifiques nés le premier jour du mois\n", "print(selection(\"nom\", scientifiques, \"jour\", 1))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", " \n", "
Dans le langage SQL la requête SELECT attribut1, attribut2, ..., attributn FROM table WHERE attribut=valeur, appliquée à la table scientifiques, donnerait le même résultat.

Exemple avec résultat partiel
SELECT nom FROM scientifiques WHERE mois=6
renvoie Alan, Blaise, Tim.
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", "
La fonction selection(attribut1,table,attribut2,valeur) renvoie les données de la colonne attribut1 pour lesquelles attribut2=valeur. Il pourrait être intéressant de renvoyer des données situées dans plusieurs colonnes. C'est le travail demandé dans le prochain exercice.\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Exercice 4. Sélection de plusieurs attributs en fonction de la valeur d'un autre \n", "> On cherche à répondre à une question du type : \"Quels sont le nom et le prénom des scientifiques nés le premier jour du mois ?\"\n", ">\n", ">**Créez** la fonction ***selection2(lstattrib,table,attribut,valeur)*** qui renvoie les valeurs des attributs situés dans la liste *lstattrib* si attribut = valeur.\n", ">\n", "> *Exemples d'affichages attendus*
\n", "> - Nom et prénom des scientifiques nés le premier jour du mois => [['Kernighan', 'Brian'], ['Perlis', 'Alan']]
\n", "> - Nom, prénom et projet des scientifiques nés en juin => [['Turing', 'Alan', 'codes secrets'], ['Pascal', 'Blaise', 'machine arithmétique']]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# A compléter\n", "def selection2(lstattrib: list, table: list, attribut: str, valeur) -> list:\n", " t = []\n", " tt = []\n", " for enregistrement in table:\n", " if enregistrement[attribut] == valeur:\n", " for atbut in lstattrib:\n", " t.append(enregistrement[atbut])\n", " tt.append(t.copy())\n", " t.clear()\n", " return tt\n", "\n", "# Affichage à compléter\n", "# 1. Nom des scientifiques dont le prénom est Alan\n", "print(selection(\"nom\",scientifiques,\"prenom\",\"Alan\"))\n", "# 2. Nom et prénom des scientifiques nés le premier jour du mois\n", "t_attributs=[\"nom\",\"prenom\"]\n", "print(selection2(t_attributs,scientifiques,\"jour\", 1))\n", "# 3. Nom, prénom et projet des scientifiques nés en juin\n", "t_attributs=[\"nom\",\"prenom\",\"projet\"]\n", "print(selection2(t_attributs,scientifiques,\"mois\", 6))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", " \n", "
Dans le langage SQL la requête SELECT attribut1, attribut2, ..., attributn FROM table WHERE attribut=valeur, appliquée à la table scientifiques, nous permettrait d'obtenir le même résultat.

Exemple
SELECT nom, prenom FROM scientifiques WHERE jour=1
renvoie ['Kernighan', 'Brian'], ['Perlis', 'Alan'].
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Exercice 5. Sélection d'attributs et comparaisons\n", "> On cherche à répondre à une question du type : \"Quels sont le nom et le prénom des scientifiques nés avant 1900 ?\"\n", ">\n", "> Les comparaisons à prendre en compte sont : **>, <, ==, >=, <=** et seront notées respectivement 1, 2, 3, 4, et 5.\n", ">\n", ">**Créez** la fonction ***selection3(lstattrib,table,attribut,comparaison,valeur)*** dans le cadre ci-dessous.
\n", ">\n", "> *Exemples d'affichages attendus*
\n", "> - Nom et prénom des scientifiques nés avant 1900 => [['Pascal', 'Blaise'], ['Jacquard', 'Joseph Marie']]
\n", "> - Nom et prénom des scientifiques nés après 1920 => [['Kernighan', 'Brian'], ['Torvald', 'Linus'], ['Knuth', 'Donald'], ['Hamilton', 'Margaret'], ['Perlis', 'Alan']]
\n", "> - Nom, prénom et projet des scientifiques nés en juin => [['Turing', 'Alan', 'codes secrets'], ['Pascal', 'Blaise', 'machine arithmétique']]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# CORRECTION Version 1 partielle\n", "\n", "def selection3(lstattrib: list, table: list, attribut: int, opcomparaison: int, valeur: int) -> list:\n", " t = []\n", " tt = []\n", " for enregistrement in table:\n", " if opcomparaison == 1: # supérieur\n", " if enregistrement[attribut] > valeur:\n", " for atbut in lstattrib:\n", " t.append(enregistrement[atbut])\n", " tt.append(t.copy())\n", " t.clear()\n", " elif opcomparaison == 2: # inférieur \n", " if enregistrement[attribut] < valeur:\n", " for atbut in lstattrib:\n", " t.append(enregistrement[atbut])\n", " tt.append(t.copy())\n", " t.clear()\n", " elif opcomparaison == 3: # égale\n", " if enregistrement[attribut] == valeur:\n", " for atbut in lstattrib:\n", " t.append(enregistrement[atbut])\n", " tt.append(t.copy())\n", " t.clear()\n", " # etc.\n", " return tt\n", "\n", "# Affichage\n", "operation = {\"sup\": 1, \"inf\": 2, \"egal\": 3, \"supegal\": 4, \"infegal\": 5}\n", "t_attributs = [\"nom\", \"prenom\"]\n", "# 1. Nom et prénom des scientifiques nés avant 1900\n", "print(selection3(t_attributs, scientifiques, \"annee\", operation[\"inf\"], 1900))\n", "# 2. Nom et prénom des scientifiques nés après 1920\n", "print(selection3(t_attributs, scientifiques, \"annee\", operation[\"sup\"], 1920))\n", "# 3. Nom, prénom et projet des scientifiques nés en juin\n", "t_attributs=[\"nom\",\"prenom\",\"projet\"]\n", "print(selection3(t_attributs,scientifiques,\"mois\", operation[\"egal\"], 6))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", " \n", "
Dans le langage SQL la requête SELECT attribut1, attribut2, ..., attributn FROM table WHERE attribut opcomp valeur, appliquée à la table scientifiques, donnerait le même résultat.

Exemple avec affichage partiel
SELECT nom, prenom FROM scientifiques WHERE annee < 1900
renvoie ['Pascal', 'Blaise'], ['Jacquard', 'Joseph Marie'], ['Lovelace', 'Ada'], ['Babbage', 'Charles'], ['Boole', 'George'].
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Correction Version 2 !!!!\n", "\n", "tt = [] # liste de listes contenant le résultat de la requête\n", "\n", "def addenreg(enregistrement: dict, attribut: int, lstattrib: list) -> list:\n", " t = [] # Une sélection prise dans un enregistrement satisfaisant la comparaison\n", " # faite dans selection3\n", " for atbut in lstattrib:\n", " t.append(enregistrement[atbut])\n", " tt.append(t.copy())\n", " t.clear()\n", "\n", "def selection3V2(lstattrib: list, table: list, attribut: int, opcomparaison: int, valeur: int) -> list:\n", " tt.clear()\n", " for enregistrement in table:\n", " if opcomparaison == 1: # supérieur\n", " if enregistrement[attribut] > valeur:\n", " addenreg(enregistrement, attribut, lstattrib)\n", " elif opcomparaison == 2: # inférieur\n", " if enregistrement[attribut] < valeur:\n", " addenreg(enregistrement, attribut, lstattrib)\n", " elif opcomparaison == 3: # égal\n", " if enregistrement[attribut] == valeur:\n", " addenreg(enregistrement, attribut, lstattrib)\n", " elif opcomparaison == 4: # supérieur ou égal\n", " if enregistrement[attribut] >= valeur:\n", " addenreg(enregistrement, attribut, lstattrib)\n", " elif opcomparaison == 5: # inférieur ou égal\n", " if enregistrement[attribut] <= valeur:\n", " addenreg(enregistrement, attribut, lstattrib)\n", " return tt\n", "\n", "# Affichage\n", "operation = {\"sup\": 1, \"inf\": 2, \"egal\": 3, \"supegal\": 4, \"infegal\": 5}\n", "t_attributs = [\"nom\", \"prenom\"]\n", "# 1. Nom et prénom des scientifiques nés avant 1900\n", "print(selection3V2(t_attributs, scientifiques, \"annee\", operation[\"inf\"], 1900))\n", "# 2. Nom et prénom des scientifiques nés après 1920\n", "print(selection3V2(t_attributs, scientifiques, \"annee\", operation[\"sup\"], 1920))\n", "# 3. Nom, prénom et projet des scientifiques nés en juin\n", "t_attributs=[\"nom\",\"prenom\",\"projet\"]\n", "print(selection3V2(t_attributs,scientifiques,\"mois\", operation[\"egal\"], 6))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Activité 6. Sélection d'attributs et encadrements\n", "> On souhaite répondre à une question du type : \"Quels sont le nom et le prénom des scientifiques nés entre 1900 et 1920 ?\"\n", ">\n", "> Les comparaisons à prendre en compte sont : **aucune, >, <, ==, >=, <=** et seront notées respectivement 0, 1, 2, 3, 4, et 5.
\n", ">\n", "> **Créez** la fonction ***selection4(lstattrib,table,attribut,opcomparaisoninf,opcomparaisonsup,valeurmin,valeurmax)*** dans le cadre ci-dessous.
\n", "> - *opcomparaisoninf* : opération de comparaison avec la borne inférieure.
\n", "> - *opcomparaisonsup* : opération de comparaison avec la borne supérieure.
\n", ">\n", "> *Exemples d'affichage attendus*
\n", "> - Nom et prénom des scientifiques nés avant 1900 => [['Pascal', 'Blaise'], ['Jacquard', 'Joseph Marie']]
\n", "> - Nom et prénom des scientifiques nés entre 1900 (inclus) et 1920 (inclus) => [['Hopper', 'Grace'], ['Turing', 'Alan']]
\n", "> - Nom, prénom et date de naissance des scientifiques nés entre le premier (compris) et le 15 (exclus) du mois\n", "> => [['Kernighan', 'Brian', 1, 1, 1942], ['Hopper', 'Grace', 9, 12, 1906], ['Knuth', 'Donald', 10, 1, 1938], ['Perlis', 'Alan', 1, 4, 1922], ['Jacquard', 'Joseph Marie', 7, 7, 1752]]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# CORRECTION\n", "def selection4(lstattrib: list, table: list, attribut: int, opcomparaisoninf: int, opcomparaisonsup:int, \n", " valeurmin: int, valeurmax: int) -> list:\n", " tt.clear()\n", " for enregistrement in table:\n", " if opcomparaisoninf == 1 and opcomparaisonsup == 0: # supérieur & aucune\n", " if enregistrement[attribut] > valeurmin:\n", " addenreg(enregistrement, attribut, lstattrib)\n", " elif opcomparaisoninf == 2 and opcomparaisonsup == 0: # inférieur & aucune\n", " if enregistrement[attribut] < valeurmin:\n", " addenreg(enregistrement, attribut, lstattrib)\n", " elif opcomparaisoninf == 3 and opcomparaisonsup == 0: # égal & aucune\n", " if enregistrement[attribut] == valeurmin:\n", " addenreg(enregistrement, attribut, lstattrib)\n", " elif opcomparaisoninf == 4 and opcomparaisonsup == 0: # supérieur ou égal & aucune\n", " if enregistrement[attribut] >= valeurmin:\n", " addenreg(enregistrement, attribut, lstattrib)\n", " elif opcomparaisoninf == 5 and opcomparaisonsup == 0: # inférieur ou égal & aucune\n", " if enregistrement[attribut] <= valeurmin:\n", " addenreg(enregistrement, attribut, lstattrib)\n", " elif opcomparaisoninf == 4 and opcomparaisonsup == 5: # supérieur ou égal & inférieur ou égal\n", " if enregistrement[attribut] >= valeurmin and enregistrement[attribut] <= valeurmax:\n", " addenreg(enregistrement, attribut, lstattrib)\n", " elif opcomparaisoninf == 4 and opcomparaisonsup == 2: # supérieur ou égal & inférieur\n", " if enregistrement[attribut] >= valeurmin and enregistrement[attribut] < valeurmax:\n", " addenreg(enregistrement, attribut, lstattrib)\n", " # etc.\n", " return tt\n", "\n", "# Affichage\n", "operation = {\"aucune\": 0, \"sup\": 1, \"inf\": 2, \"egal\": 3, \"supegal\": 4, \"infegal\": 5}\n", "t_attributs = [\"nom\", \"prenom\"]\n", "# 1. Nom et prénom des scientifiques nés avant 1900\n", "print(selection4(t_attributs, scientifiques, \"annee\", operation[\"inf\"], operation[\"aucune\"], 1900,0))\n", "# 2. Nom et prénom des scientifiques nés après 1920\n", "print(selection4(t_attributs, scientifiques, \"annee\", operation[\"sup\"], operation[\"aucune\"], 1920 , 0))\n", "# 3. Nom et prénom des scientifiques nés entre 1900 et 1920\n", "print(selection4(t_attributs, scientifiques, \"annee\", operation[\"supegal\"], operation[\"infegal\"], 1900 , 1920))\n", "# 4. Nom, prénom et date de naissance des scientifiques nés entre le premier (compris) et le 15 (exclus) du mois\n", "t_attributs = [\"nom\", \"prenom\",\"jour\",\"mois\",\"annee\"]\n", "print(selection4(t_attributs, scientifiques, \"jour\", operation[\"supegal\"], operation[\"inf\"], 1 , 15)) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", " \n", "
Dans le langage SQL la requête SELECT attribut1, attribut2, ..., attributn FROM table WHERE attribut opcomp1 valeur1 AND attribut opcomp2 valeur2 , appliquée à scientifiques2, donnerait le même résultat.

Exemple avec affichage partiel
SELECT nom, prenom FROM scientifiques2 WHERE annee >= 1900 AND annee <= 1920
renvoie ['Hopper', 'Grace'], ['Turing', 'Alan'], ['Shannon', 'Claude'].
" ] }, { "cell_type": "code", "execution_count": null, "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.10.5" } }, "nbformat": 4, "nbformat_minor": 4 }