Traitement des données en tables

pdf : pour impression

En bref : Le format CSV est couramment utilisé pour échanger des données habituellement traitées à l’aide de tableurs ou de logiciels de bases de données principalement. Nous allons apprendre à importer et exporter des données en utilisant ce format.

1. Données en table

De quoi parle-t-on ?

Par “données en table” on entend ce type d’information :

  • correctement importé dans un tableur

    $;$dans un fichier texte

  • sans mise en forme dans un tableur

    $;$dans un tableur

  • sans mise en forme dans un fichier texte

    $;$dans un tableur

Excel et les tableurs évolués réalisent un traitement complexe des données mais on peut toujours exporter un tableau de données vers un fichier au format particulier ou importer un tel fichier.

2. Enregistrements

  • Un enregistrement est une structure de données, de types éventuellement différents, auxquelles ont accède grâce à un nom.

    Exemple : On peut représenter les notes d’un élève dans différentes disciplines à l’aide d’un enregistrement :

    {'Nom' : 'Joe', 'Anglais': '17', 'Info': '18', 'Maths': '16'}
    

    Les champs (ou clés ou attributs) de ces enregistrements sont ici 'Nom', 'Anglais', 'Info' et 'Maths'. On leur associe des valeurs, ici 'Joe', '17', '18' et '16'.

  • En Python, on utilisera principalement les dictionnaires pour représenter les enregistrements.

Les données en table dans un langage de programmation

En python, ce tableau peut prendre différentes formes :

  1. Tableau doublement indexé :

    contacts = [
        ['Duchmol', 'Robert', 'robert@email.com',],
        ['Lemeilleur', 'Franky', 'franky@email.com',],
        ['Poivre', 'Jacques', 'jacque@email.com']
    ]
    
  2. Tableau de dictionnaires :

    contacts = [
        {'Nom': 'Duchmol', 'Prénom', 'Robert', 'email': 'robert@email.com'},
        {'Nom': 'Lemeilleur', 'Prénom', 'Franky', 'email': 'franky@email.com'},
        {'Nom': 'Poivre', 'Prénom', 'Jacques', 'email': 'jacque@email.com'}
    ]
    

Le contenu ne change pas, les manipulations nécessaires pour y accéder si.

Dans certains cas on dispose directement des données (via l’énoncé ou un travail préalable). Parfois on doit importer les données depuis un fichier csv.

Comparaison des formats

Dans le premier cas on accède aux données comme dans un tableau 2D :

  • accéder au premier enregistrement.

    >>> contacts[0]
    ['Nom': 'Duchmol', 'Prénom', 'Robert', 'email': 'robert@email.com']
    
  • quel est le prénom du second contact ?

    >>> contacts[1][1]
    'Franky'
    

Dans le second cas, on accède toujours aux enregistrements par leur indice mais on accède aux valeurs par leur clés.

  • quel est le prénom du second contact ?

    >>> contacts[1]['Prénom']
    'Franky'
    

3. Fichiers CSV

  • Le format CSV (Comma Separated Value) est couramment utilisé pour importer ou exporter des données d’une feuille de calcul d’un tableur. C’est un fichier texte dans lequel chaque ligne correspond à une ligne du tableau, les colonnes étant séparées par des virgules. Il permet donc de représenter une liste d’enregistrements ayant les mêmes champs.

    À noter : Ce format est né bien avant les ordinateurs personnels et le format xls puisque c’est en 1972 qu’il a été introduit.

  • Pour éviter les problèmes dûs à l’absence de standardisation du séparateur décimal (virgule en France, point dans les pays anglo-saxons), on peut paramétrer son tableur pour utiliser le point pour les nombres (français suisse par exemple).

  • Voici un exemple de feuille de calcul.

    A B C D
    1 Nom Anglais Info Maths
    2 Joe 17 18 16
    3 Zoé 15 17 19
    4 Max 19 13 14

Le fichier CSV correspondant est :

'Nom','Anglais','Info','Maths'
'Joe','17','18','16'
'Zoé','15','17','19'
'Max','19','13','14'

4. Lecture de fichiers CSV

  • On peut choisir de représenter en Python les fichiers CSV par des listes de dictionnaires dont les clés sont les noms des colonnes.

  • Avec l’exemple précédent, on définit la liste :

    Table1 = [
        {'Nom': 'Joe','Anglais': '17', 'Info': '18', 'Maths': '16'},
        {'Nom': 'Zoé','Anglais': '15', 'Info': '17', 'Maths': '19'},
        {'Nom': 'Max','Anglais': '19', 'Info': '13', 'Maths': '14'}]
    

    À noter : En utilisant le vocabulaire habituel décrivant une feuille de calcul d’un tableur :

    • une table est une liste de dictionnaires: ici Table1
    • une ligne est un dictionnaire, ici Table1[0]
    • une cellule est une valeur associée à une clé d’un dictionnaire, ici Table1[0]['Info']

5. Import d’un fichier CSV

La méthode à retenir

  • pour l’import on crée une liste de dictionnaires (un par ligne de la table). La première ligne du fichier CSV est considérée comme la ligne des noms des attributs. fichier est une chaîne de caractères donnant le nom du fichier. Par exemple : depuis_csv('Ma_base.csv') pour charger le fichier Ma_base.csv

    import csv
    def depuis_csv(fichier):
        with open(fichier, 'r') as contenu_csv:
            lecteur = csv.DictReader(contenu_csv)
            return [dict(ligne) for ligne in lecteur]
    

6. Exporter vers un fichier CSV avec Python

  • Pour l’export, on entre le nom de la table sous forme de chaîne. On donne l’ordre des colonnes sous forme d’une liste d’attributs.

    def vers_csv(nom_fichier, ordre):
        with open(nom_fichier, 'w') as contenu:
            writer = csv.DictWriter(contenu, fieldnames=ordre)
            table = eval(nom)
            writer.writeheader()  # pour la 1ere lire, celle des attributs
            for ligne in table:
                writer.writerow(ligne)  # ajoute les lignes de la table
    
  • Pour exporter la table Table1 on utilise :

    >>> vers_csv('Table1.csv', ['Nom', 'Anglais', 'Info', 'Maths'])
    

    Python crée alors un fichier Table1.csv au format CSV :

    Nom,Anglais,Info,Maths
    Joe,17,18,16
    Zoé,15,17,19
    Max,19,13,14
    

6. Sélectionner et projeter

On est régulièrement amené à récupérer une partie des données.

  • lorsqu’on souhaite accéder à un ou plusieurs enregistrements vérifiant un critère, on réalise une sélection.
  • lorsqu’on souhaite accéder à toutes les données d’une colonne on réalise une projection.

Exemple de sélection.

Supposons qu’on dispose d’une table enregistrée dans une liste de dictionnaires :

Table1 = [
    {'Nom': 'Joe','Anglais': '17', 'Info': '18', 'Maths': '16'},
    {'Nom': 'Zoé','Anglais': '15', 'Info': '17', 'Maths': '19'},
    {'Nom': 'Max','Anglais': '19', 'Info': '13', 'Maths': '14'},
    {'Nom': 'Bob','Anglais': '12', 'Info': '16', 'Maths': '10'}
]

On souhaite extraire la liste des enregistrements des élèves ayant eu au moins 16 en maths.

On peut le faire “à la main” :

au_moins_16_en_maths = []
for enregistrement in Table1:
    if enregistrement['Maths'] >= 16:
        au_moins_16_en_maths.append(enregistrement)

Le résultat est encore une table :

Table1 = [
    {'Nom': 'Joe','Anglais': '17', 'Info': '18', 'Maths': '16'},
    {'Nom': 'Zoé','Anglais': '15', 'Info': '17', 'Maths': '19'}
]

On peut le faire avec une liste par compréhension :

au_moins_16_en_maths = [enre for enre in Table1 if enre['Maths'] >= 16]

Le résultat est identique.

Exemple de projection

Cette fois, on souhaite récupérer toutes les valeurs pour un champ donné, par exemple toutes les notes de mathématiques.

L’approche est similaire, on crée une liste, on parcourt la table et on ajoute à la liste tous les éléments qui nous intéressent :

  • à la main :

    notes_maths = []
    for enregistrement in Table1:
        notes_maths.append(enregistrement['Maths'])
    
  • par compréhension :

    notes_maths = [enre['Maths'] for enre in Table1]
    

Dans les deux cas le résultat est la liste [16, 19, 14, 10]

Exercices

  1. Adapter la sélection afin de récupérer tous les enregistrements des élèves dont le nom comporte un “o”

  2. Projeter afin de construire la liste des noms puis celle des paires de notes d’info et de maths :

    [(18, 16), (17, 19), (13, 14), (16, 10)]
    

7. Compléments

Cette partie est donnée pour votre culture mais n’est pas à apprendre.

Le format CSV n’est pas le seul utilisé pour enregistrer des données. Il existe d’autres formats de fichiers textes mais aussi une approche beaucoup plus élaborée qui remplit le même objectif : les bases de données.

En terminale on étudiera les bases de données et en particulier le langage SQL.

Ce sont des programmes qui permettent à plusieurs utilisateurs d’accéder aux ressources, de conserver une trace de ce qui est fait sur les données etc.

Les autres formats texte

Citons :

  • CSV, le plus couramment employé, démocratisé par Excel (Microsoft)

  • JSON (Javascript Object Notation)

    {
        "glossary": {
            "title": "example glossary",
            "GlossDiv": {
                "title": "S",
                "GlossList": {
                    "GlossEntry": {
                        "ID": "SGML",
                        "SortAs": "SGML",
                        "GlossTerm": "Standard Generalized Markup Language",
                        "Acronym": "SGML",
                        "Abbrev": "ISO 8879:1986",
                        "GlossDef": {
                            "para": "A meta-markup language, used to create markup languages such as DocBook.",
                            "GlossSeeAlso": ["GML", "XML"]
                        },
                        "GlossSee": "markup"
                    }
                }
            }
        }
    }
    

    Ressemble beaucoup aux dict de Python.

  • XML (eXtensible Markup Language) - . Syntaxe similaire à l’HTML. Difficile à lire pour un “humain”.

    <!DOCTYPE glossary PUBLIC "-//OASIS//DTD DocBook V3.1//EN">
     <glossary><title>example glossary</title>
      <GlossDiv><title>S</title>
       <GlossList>
        <GlossEntry ID="SGML" SortAs="SGML">
         <GlossTerm>Standard Generalized Markup Language</GlossTerm>
         <Acronym>SGML</Acronym>
         <Abbrev>ISO 8879:1986</Abbrev>
         <GlossDef>
          <para>A meta-markup language, used to create markup
    languages such as DocBook.</para>
          <GlossSeeAlso OtherTerm="GML">
          <GlossSeeAlso OtherTerm="XML">
         </GlossDef>
         <GlossSee OtherTerm="markup">
        </GlossEntry>
       </GlossList>
      </GlossDiv>
     </glossary>
    

Mais aussi :

  • YAML (yet another markup language)

    -  martin:
        name: Martin D'vloper
        job: Developer
        skills:
          - python
          - perl
          - pascal
    -  tabitha:
        name: Tabitha Bitumen
        job: Developer
        skills:
          - lisp
          - fortran
          - erlang
    

Contexe

  • Généré par un programme : souvent XML ou JSON
  • Crée à la main depuis un tableur : CSV
  • Utilisé par des machines pour communiquer via une API : JSON
  • Pour stocker des configurations de programme : Yaml, INI, format propriétaire

Importer les données en Python sans utiliser le module CSV

Vous rencontrerez vraisemblablement des variantes de la méthode précédente. Nous allons en présenter rapidement plusieurs. Elles ne sont pas à connaître mais à comprendre.

Créer un tableau doublement indexé

Voyons d’abord comment réaliser chacune des étapes (c’est un attendu) puis comment le faire à l’aide des outils proposés.

CHAMPS = ["nom", "moyenne", "moyenne_brute"]

def lire_fichier_csv(filename, delimiter=','):
  res = []
  with open(filename) as f:
    f.readline() # on zappe la première ligne...
    l = f.readline()
    while l != '':
      args = l.replace('"', '').strip().split(delimiter)
      try:
        enregistrement = []
        for i in range(len(args)):
          enregistrement[i] = args[i]
        res.append(enregistrement)
      except ValueError:
        pass
      l = f.readline()
    return res

liste_csv = lire_fichier_csv('2nde-14-liste.csv', delimiter=';')

Commentaires détaillés sur la fonction lire_fichier_csv

  • ligne 4 : on crée la liste des enregistrements
  • ligne 5 : on ouvre le fichier et on le stocke dans une variable temporaire f
  • ligne 6 : f.readline() : lire une ligne et avancer à la suivante
  • ligne 7 : on a zappé la première ligne et on lit la seconde
  • ligne 5 : tant qu’on a des lignes non vides
  • ligne 9 : on nettoie la ligne : virer les “, les espaces de début et de fin et on sépare la ligne tous les ‘delimiter’
  • ligne 10 : on essaye de créer l’enregistrement
  • ligne 11 : c’est une liste python
  • ligne 13 : on l’ajoute à la liste des enregistrements
  • ligne 16 : si jamais la ligne est imparfaite, on la zappe
  • ligne 17 : on avance à la ligne suivante

Qu’obtient-on ?

Un tableau doublement indexé. Les descripteurs sont enregistrés dans CHAMPS. Ils ne sont pas utilisés dans la fonction d’import.

Variante : vers un tableau de dictionnaire.

Exercice : adapter la première fonction d’import pour qu’elle retourne un tableau de dictionnaires.

Réponse :

CHAMPS = ["nom", "moyenne", "moyenne_brute"]

def lire_fichier_csv(filename, delimiter=',', champs=CHAMPS):
  res = []
  with open(filename) as f:
    f.readline() # on zappe la première ligne...
    l = f.readline()
    while l != '':
      args = l.replace('"', '').strip().split(delimiter)
      try:
        enregistrement = {} # on crée un dictionnaire
        for i in range(len(args)):
          enregistrement[champs[i]] = args[i] # les clés sont les éléments de CHAMPS
        res.append(enregistrement)
      except ValueError:
        pass
      l = f.readline()
    return res

liste_csv = lire_fichier_csv('2nde-14-liste.csv', delimiter=';')