Manipulation de données

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'...

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 :

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...

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...

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'...

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....