Python : les fondamentaux

Introduction

Le choix d’un langage est parfois un parcours sinueux et difficile. Une multitude de langages existent, du plus bas niveau au plus haut, chacun ayant ses caractéristiques. Pour n’en citer que quelques-uns, nous trouverons l’assembleur (différents mnémoniques suivant les architectures : x86, arm, 68000), C, C++, C#, Java, Perl, Ruby, Python...

Quand notre métier est la sécurité informatique, nous devons avoir une bonne vue d’ensemble de ces différents langages ou, au minimum, savoir retrouver l’information si nécessaire. Mais d’expérience, il faut au moins connaître l’assembleur x86 (et x64), le langage C et un langage dit de haut niveau.

Pourquoi choisir Python ?

Il me fallait à l’époque, connaissant l’assembleur et le C, un langage facile à appréhender qui donne un résultat rapide. Suite à plusieurs essais dont Java et C++, le langage Python m’ouvrit les portes du développement et m’apporta l’outil idéal pour mes cours en licence CDAISI (Cyberdéfense et anti-intrusion des systèmes d’information de l’UVHC http://www.univ-valenciennes.fr) et mes audits techniques (pentest) au sein de la société Serval-concept (http://www.serval-concept.com).

La programmation Python a pris maintenant ses lettres de noblesses et Python...

Caractéristiques du langage

Python est :

La bibliothèque standard fournit des modules écrits entièrement en Python. Ces modules sont robustes et facilement utilisables, ils permettent des interactions avec le système d’exploitation et le système de fichiers. Ils fonctionnent sur toutes les plateformes reconnues par Python.

Les modules d’extension, quant à eux, permettent aux applications d’avoir accès à des composants logiciels supplémentaires (réseaux, calcul numérique, traitement de données, traitement d’images…). Ces modules ne sont pas forcément écrits en Python, ils peuvent faire la liaison avec d’autres langages : Cpython (implémentation native), Jython (implémentation de Python en Java), IronPython (implémentation en C# visant .NET et Mono)...

Une documentation est incluse et accessible directement depuis l’interpréteur...

Types de données

Les types de données sont mutables (modifiables) ou immutables (non modifiables).

Les types immutables sont manipulés par recopie de valeurs (nombres, chaînes de caractères et tuples), les types mutables sont manipulés par pointeurs (listes, dictionnaires).

Les types de données Python sont des séquences (chaînes de caractères, tuples et listes) ou des collections (dictionnaires).

Une séquence est une liste ordonnée d’éléments ; une séquence peut être itérée.

1. Les nombres

Les nombres sont de types classiques pour ceux habitués aux langages de programmation. Nous retrouvons les entiers, les longs, les réels, les complexes.

Le typage en Python est dynamique, nul besoin de définir le type de la variable, il se débrouille seul.

Nous pouvons vérifier cela grâce à la fonction type().

Pour tester cela, nous pouvons entrer dans l’interpréteur interactif :

Python nous offre aussi différentes notations comme la notation exponentielle, octale, binaire, hexadécimale.

Le changement de type est dynamique, c’est-à-dire qu’il peut changer au fil de l’exécution du programme (que l’on peut appeler script).

Dans l’exemple ci-dessous, une boucle for est utilisée. Le but ici pour l’instant n’est pas de comprendre cette boucle, mais de voir le changement de type dynamiquement. 

Nous pouvons aussi utiliser les opérateurs classiques tels que le décalage à droite (>>) ou à gauche (<<) et les opérateurs booléens (OU, ET et OU exclusif). Les opérateurs mathématiques classiques sont bien sûr aussi de la partie (addition +, soustraction -, division entière //, multiplication *, modulo % et puissance **).

Nous pouvons convertir des types en d’autres quand cela est possible, grâce aux constructeurs int(), float(), complex(), bin(), hex(), ord()...

Il existe quelques pièges à éviter avec les nombres. Il faut être prudent lors de la division d’entiers et de la définition d’un nombre complexe.

Structures conditionnelles et répétitives

if <condition> : 
    #exécution si la condition est vraie 
elif <autre condition> : 
    #exécution si autre condition vraie 
else : 
    #exécution si les conditions sont fausses.
 

__author__ = 'franckebel' 
#--*--coding:utf-8--*-- 
nbr=raw_input("entrez un nombre") 
while not nbr.isdigit(): 
    print "Veuillez saisir un nombre" 
    nbr=raw_input("entrez un nombre") 
nbr=int(nbr) 
if nbr<10: 
    print "vous avez entré un nombre inférieur à 10" ...

Fonctions, modules et paquets

1. Définition et appel de fonction

Pour définir une fonction, nous utiliserons l’instruction def. Comme tout en Python, l’indentation sera importante pour définir ce qui appartient à la fonction définie.

def ma_fonction : 
    print "je suis dans ma fonction"
 

Le nom de la fonction peut être n’importe quoi excepté les noms réservés par le langage lui-même. Il n’y a pas de normes proprement dites, mais il est conseillé d’utiliser des lettres minuscules, surtout en début du nom.

La fonction bonjour5() est déclarée sans paramètres. Cette fonction contient une boucle while qui affiche bonjour. La boucle se fera 5 fois. Nous n’oublions pas d’utiliser une variable pour vérifier le nombre de boucles qui est bien sûr incrémenté de 1 à chaque passage.

La fonction est appelée en écrivant son nom.

Si nous appelons un nom de fonction qui n’existe pas, nous avons, comme dans l’exemple, une erreur qui s’affiche. Nous verrons plus tard comment gérer ces erreurs.

Nous pouvons appeler cette fonction autant de fois que l’on veut, mais aussi l’appeler dans une autre fonction.

Nous pouvons bien sûr transmettre des paramètres à une fonction, paramètres qui se situeront dans les parenthèses.

Imaginons que nous souhaitions choisir le nombre de fois que nous voulons écrire bonjour. Nous devrons donc indiquer ce nombre à la fonction.

Nous demandons d’abord à l’utilisateur le nombre de fois qu’il souhaite afficher bonjour.

Puis nous appelons la fonction en lui transmettant la variable contenant le nombre.

Dans la fonction, le seul changement est que nous faisons le test du while avec ce nombre.

L’instruction return permet de retourner une valeur.

def carre(x) : 
    return x**2
 

Si nous souhaitons retourner une liste pas exemple (il faudra adapter pour un tuple ou un dictionnaire) :

def carre(x) : 
    return [x**2,x**3]
 

Lors de la définition de la fonction, nous pouvons donner aux paramètres des valeurs par défaut. Si la valeur est présente lors de l’appel, elle est utilisée, sinon c’est...

Les classes

En Python, comme nous l’avons déjà vu, tout est objet : les chaînes, les entiers, les listes, les fonctions, les classes, les modules, etc.

Tout objet est manipulé par référence : une variable contient une référence vers un objet et un objet peut être référencé par plusieurs variables.

Une fonction, une classe, un module sont des espaces de nommage organisés de manière hiérarchique : un module contient des classes qui contiennent des fonctions (les méthodes).

Une classe fonctionnera de la même manière qu’une fonction, c’est-à-dire qu’elle se finira par : et que le bloc lui appartenant sera indenté.

Par convention, le nom d’une classe commence par une majuscule.

Le mot-clé class est utilisé.

Toute méthode est définie comme une fonction avec un premier argument (self) qui représente l’objet sur lequel elle sera appliquée à l’exécution. Le nom est libre, mais on utilise en général self. Une méthode ne prenant pas de paramètres aura donc quand même un argument.

L’instanciation se fait sans mot-clé particulier. Il suffit de faire suivre un nom de classe de parenthèses (contenant ou non des paramètres) pour déclencher une instanciation. L’invocation se fait à l’aide de la notation pointée, un appel de méthode sur une variable référençant un objet.

Les attributs sont définis à leur première affectation. Une variable est considérée comme un attribut si elle est « rattachée » à l’objet : elle est accédée par self. Tout accès à un attribut ou à une méthode de l’objet depuis sa mise en œuvre se fait obligatoirement par la variable self. Le constructeur est une « méthode » nommée __init__. Comme toute méthode, certains de ses paramètres peuvent avoir des valeurs par défaut. Cette possibilité est importante car une classe a un seul constructeur en Python.

class Informatique(object): 
    def...

Manipulation de fichiers

Il nous sera souvent très utile de pouvoir lire le contenu d’un fichier ou d’écrire dans un fichier. Par exemple, lorsque nous souhaitons sauvegarder des informations, si celles-ci ne sont pas trop nombreuses, nous utiliserons un fichier texte.

L’instruction open() permet d’ouvrir un fichier, elle retourne un objet de type File.

Les modes d’ouverture du fichier peuvent être r (read), w (write) et a (append). Nous pouvons ajouter à ces modes b (mode binaire), t (mode texte), + (ouverture en lecture et écriture).

mon_fichier=open("fichier.txt",'a+')
 

La méthode close() permet de fermer un fichier.

Les fichiers texte sont lisibles directement par l’utilisateur, ils contiennent du texte (lettres, ponctuations, nombres...). Leur contenu est souvent divisé en lignes. En environnement Unix, les fichiers de configuration dans /etc sont des exemples de fichiers texte. Il en est de même pour le code source d’un programme Python.

Les fichiers binaires ne contiennent pas (exclusivement) du texte, ils ne peuvent être convenablement traités que par des logiciels spécialisés. Un fichier PDF, une image TIFF ou un MP3 sont quelques exemples de fichiers binaires.

# ouverture en lecture du fichier fichier1.txt  
fichier=open('fichier1.txt','r')
# lecture du fichier
texte=fichier.read() ...

Les exceptions

Nous avons vu au cours de ce livre que, certaines fois, nous nous retrouvions avec une erreur lors du lancement du programme.

>>> nbr = raw_input('veuillez entrer un nombre\n') 
veuillez entrer un nombre 
AZ 
>>> int(nbr) 
Traceback (most recent call last): 
  File "<stdin>", line 1, in <module> 
ValueError: invalid literal for int() with base 10: 'AZ' 
>>>
 

Nous souhaiterions pouvoir gérer ces erreurs. Cela va se faire avec les exceptions. 

Une exception permet de remonter une anomalie à un programme appelant. Cette anomalie peut être une erreur ou un cas particulier.

Une exception est caractérisée par un nom et un message d’erreur permettant d’identifier l’origine de l’erreur.

Python est fourni avec des classes très complètes d’exceptions standards et nous pouvons également créer nos propres exceptions par un mécanisme simple d’héritage d’objet.

L’inconvénient avec les erreurs non gérées dans les programmes est que notre script s’arrête. Nous devons donc trouver un moyen de gérer ces exceptions pour pouvoir pallier cette erreur et continuer notre programme.

try va nous permettre d’essayer un bout de code. Si le bout de code fonctionne, pas de problème, nous continuons notre...

Modules utiles pour la suite du livre

import sys 
print "Ceci est le nom du script: ", sys.argv[0] 
print "Voici le nombre d'arguments: ", len(sys.argv) 
print "Les arguments sont: " , str(sys.argv) 
print "Le premier argument est: " , sys.argv[1]
 

>>> import sys 
>>> sys.platform 
'darwin' 
>>> sys.stdout.write("écriture avec stdout pour ENI") 
écriture...