Blog ENI : Toute la veille numérique !
-25€ dès 75€ sur les livres en ligne, vidéos... avec le code FUSEE25. J'en profite !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Python 3
  3. Manipulation de données
Extrait - Python 3 Les fondamentaux du langage (4e édition)
Extraits du livre
Python 3 Les fondamentaux du langage (4e édition)
3 avis
Revenir à la page d'achat du livre

Manipulation de données

Manipuler des fichiers

1. Ouvrir un fichier

Python étant à l’origine conçu pour réaliser des opérations système, il est naturellement pourvu d’outils très fournis, très simples d’utilisation et très efficaces. En un mot, pythoniques. Et ils ont été améliorés tout au long de l’évolution du langage. Voici la manière basique d’ouvrir un fichier :

>>> with open('test.txt') as f: 
...     pass # Travailler sur le contenu du fichier 
... 

Que représente f ?

>>> with open('test.txt') as f: 
...     type(f) 
...     type.mro(type(f)) 
...     dir(f) 
...  
<class '_io.TextIOWrapper'> 
[<class '_io.TextIOWrapper'>, <class '_io._TextIOBase'>, <class '_io._IOBase'>, 
<class 'object'>] 
['_CHUNK_SIZE', '__class__', '__delattr__', '__doc__', '__enter__', '__eq__',  
'__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__',  
'__gt__', '__hash__', '__init__', '__iter__', '__le__', '__lt__', '__ne__',  
'__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', 
'__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', 
'_checkSeekable', '_checkWritable', 'buffer', 'close', 'closed', 'detach',  
'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering'...

Utilitaire de sauvegarde

Un programme peut avoir une ou plusieurs manières de se terminer. Il peut également se terminer par une exception. Pour ces raisons, il faut prévoir un moyen d’effectuer des actions quelle que soit la manière dont le programme se termine (cela ne fonctionne pas lorsque Python est terminé par des signaux externes non pris en compte ou des erreurs fatales).

>>> datas = {} 
>>> @atexit.register 
... def quit(): 
...     print('Sauvegarde des données') 
... 

Exécuter [Ctrl] + d dans la console pour la quitter et tester la fonctionnalité.

Lire un fichier de configuration

Les fichiers de configuration peuvent être de différentes structures. Certains sont en XML et dans ce cas, il faut utiliser un parser XML pour récupérer les informations utiles (comme les fichiers zcml de zope) ou les fichiers de configuration de beaucoup d’applications Java, comme Sonar, par exemple.

Les autres sont les fichiers classiques CONF pour Unix ou INI pour Windows, mais également Unix (php.ini, par exemple).

Il existe un module spécifique qui permet de lire les fichiers INI tels que ceux que l’on peut trouver sous Windows. En voici un :

$ cat /tmp/test.ini 
[SQL] 
backoffice_url = postgres://user:pass@host/base 
frontoffice_url = postgres://user:pass@host/base 
 
[EXPORT] 
directory = '/var/saves/csv/' 
filename = 'export_%s.txt' 
 
[SERVER] 
port = 8016 
webdav = yes 
sftp = yes 

Voici comment parser ce fichier :

>>> import configparser 
>>> parser = configparser.ConfigParser() 
>>> parser.read('/tmp/test.ini') 
['/tmp/test.ini'] 

Ensuite, il est aisé de récupérer les différentes sections :

>>> parser.sections() 
['SQL', 'EXPORT', 'SERVER'] 

Le parseur est utilisable comme un dictionnaire et chaque section aussi :

>>> parser['SQL'] 
<Section: SQL> 
>>> [k for k in parser['SQL'].keys()] 
['backoffice_url', 'frontoffice_url'] 
>>> parser['SQL']['backoffice_url'] 
'postgres://user:pass@host/base' 

Et comme les dictionnaires, on dispose des méthodes get permettant de fournir une valeur de substitution si la clé (paramètre de configuration) n’est pas présente dans le fichier de configuration...

Format d’export/import

1. CSV

CSV est l’abréviation de Comma Separated Values et est, à l’origine un fichier textuel présentant des données séparées par des virgules. Cependant, la virgule pouvant être utilisée au sein d’une valeur, et d’autres problématiques pouvant survenir en fonction du contenu des données et des habitudes de représentation inhérentes aux différents langages, d’autres formatages ont vu le jour. Ils sont appelés dialectes. Voici les grands principes qui sont vrais quel que soit le dialecte :

  • Les données sont présentées sous forme tabulaire.

  • Chaque ligne du fichier CSV correspond à une ligne du tableau.

  • Chaque colonne du fichier CSV est délimitée à droite et à gauche par le séparateur ou (exclusif) par une fin de ligne.

  • La première ligne du fichier peut être utilisée pour contenir les en-têtes des colonnes, mais ceci n’est en rien obligatoire.

  • En fonction du formalisme, il peut être admis que toutes les lignes n’aient pas le même nombre de colonnes ou bien cela peut être considéré comme une erreur.

De manière à manipuler des données réelles, qui ont un sens et que l’on est susceptible d’aller manipuler, voici un lien pour télécharger des données sur les communes, régions et départements français (http://www.insee.fr/fr/methodes/nomenclatures/cog/telechargement.asp).

Python dispose des outils nécessaires pour accéder à bas niveau aux données d’un fichier CSV, mais il dispose également des outils nécessaires pour représenter ces données à l’aide de simples listes et dictionnaires qui sont des objets courants Python et très...

Compresser et décompresser un fichier

1. Tarfile

Compresser un fichier est un moyen de diminuer sa taille sans aucune perte d’information. Pour cela, il existe différents algorithmes qui sont utilisables en Python.

Avant de les aborder, il faut savoir qu’il est possible de compresser plusieurs fichiers par ces mêmes algorithmes tout simplement en accolant les fichiers les uns derrière les autres d’une manière réversible pour ensuite passer l’algorithme de compression sur le fichier unique ainsi obtenu. Les fichiers unitaires sont alors nommés membres du fichier global. Pour obtenir une archive contenant des fichiers déjà compressés (fichiers PNG ou ODT par exemple, un tar est suffisant).

L’algorithme permettant de réaliser cette opération est tar et la bibliothèque Python tarfile permet de travailler avec de tels fichiers.

Soient les deux fichiers suivants :

$ cat /tmp/fichier1.txt 
Première ligne 
Seconde ligne 
$ cat /tmp/fichier2.txt 
Première ligne 
Deuxième ligne 
Troisième ligne 

Voici comment construire un fichier tar :

>>> import tarfile 
>>> with tarfile.open('/tmp/test.tar', 'w') as f: 
...     f.add('/tmp/fichier1.txt') 
...     f.add('/tmp/fichier2.txt') 
... 

Le résultat est :

$ cat /tmp/test.tar 
tmp/fichier1.txt0000644000175000017500000000003611641322375013470 
0ustar  schsch00000000000000Première ligne 
Seconde ligne 
tmp/fichier2.txt0000644000175000017500000000006111641322424013462 
0ustar  schsch00000000000000Première ligne 
Deuxième ligne 
Troisième ligne 

Cette opération est très proche d’un travail sur un fichier classique.

Il est également possible de lire un fichier...

Outils de manipulation de données

1. Générer des nombres aléatoires

Une suite de nombres aléatoires est une suite de nombres telle que le prochain nombre de la liste ne puisse être prédit de manière déterministe (autres nombres de la liste, considérations matérielles…).

Si trouver trois ou quatre nombres aléatoires est plutôt trivial, pouvoir fournir une grande quantité de nombres aléatoires devient une réelle problématique qui est une des plus complexes à résoudre et qui fait le bonheur des mathématiciens.

Le langage Python propose un module dédié à la génération de nombres aléatoires et qui est très orienté vers l’utilisateur puisqu’il propose des fonctionnalités vraiment adaptées aux besoins réels de l’utilisateur. Voici le module à importer :

>>> import random 

La fonctionnalité classique est de choisir un nombre compris entre deux bornes :

>>> random.randint(512, 1024) 
909 

En Python, cela se fait très simplement et les bornes sont incluses parmi les choix possibles. D’habitude, c’est cette base-là qui est utilisée pour tout les autres types de besoins. Par exemple, pour choisir un élément dans une liste, on compte le nombre d’éléments et on choisit un nombre qui correspond à l’indice de l’élément choisi dans la liste. Ceci est fastidieux. En Python, il faut être élégant, rapide et déterminé :

>>> colors = ['bleu', 'jaune', 'rouge', 'vert', 'violet',  
'orange', 'marron', 'blanc', 'noir'] 
>>> random.choice(colors) 
'jaune'...

Cryptographie légère

1. Nombre aléatoire sécurisé

Pour des besoins purement cryptographiques, il est utile de pouvoir générer des séquences d’octets de manière aléatoire et le module random n’offre pas suffisamment de garanties de son caractère aléatoire. Ceci est suffisant pour les besoins classiques d’un programme, mais pas pour la cryptographie.

En effet, aucun système informatique ne peut générer des nombres absolument aléatoires. Il vient toujours un seuil à partir duquel la génération devient prévisible. Il existe cependant des normes permettant d’en générer qui soient suffisamment sécurisés :

import ssl 
ssl.RAND_bytes(128) 

C’est donc par cette méthode qu’il faut générer un nombre aléatoire dans un contexte lié à la cryptographie.

Il existe également un module Python dédié à ces problématiques de cryptographie et qui contient un module random renforcé. Il s’installe ainsi :

$ pip install pycrypto 

Et il s’utilise ainsi :

>>> from Crypto.Random import random 
>>> random.choice([1, 2, 3]) 
2 

Ce module contient toutes les fonctions usuelles, mais la gestion de l’aléatoire est plus sécurisée. Vous remarquerez cependant que les règles de nommage ne sont pas respectées, car le module devrait être en lettres minuscules.

2. Fonctions de chiffrement

Le module hashlib permet d’offrir les fonctions de hachage usuelles qui toutes respectent la même interface.

Une fonction de hachage permet d’obtenir une signature à partir d’une séquence de bytes qui peut être une chaîne de caractères d’un encodage particulier ou un fichier....