Le PYTHON en bref

On peut manipuler une chaîne de caractères grâce à certaines de ces méthodes. Les plus usitées sont les suivantes :

>Changement de casse

>>> ma_chaine='Hello World'
>>> ma_chaine
'Hello World'
>>> ma_chaine.lower()
'hello world'
>>> ma_chaine.upper()
'HELLO WORLD'

>Mettre la première lettre en majuscule

>>> ma_chaine='hello world'
>>> ma_chaine.capitalize()
'Hello world'

>Séparation de caractères, avec un caractère prédéfini

>>> ma_chaine.split('l')
['He', '', 'o Wor', 'd']

>Concaténation de chaînes, avec un caractère prédéfini

>>> ma_chaine.join('l')
'l'
>>> ma_chaine
'Hello World'

>Trouver la position d'une lettre

>>> ma_chaine = 'Hello world'
>>> ma_chaine.find('w')
6

>Compter le nombre d'occurrences d'un caractère

>>> ma_chaine = 'Hello world'
>>> ma_chaine.count('l')
3

>Supprimer les espaces en début et fin de chaîne

>>> ma_chaine = '    Ceci est un test    '
>>> ma_chaine
'    Ceci est un test    '
>>> ma_chaine.strip()
'Ceci est un test'

>Enfin, tester le type de donnée contenu dans la chaîne (True si vrai, False sinon)

>>>ma_chaine.isalpha()    #Teste s'il n'y a exclusivement que des lettres
>>>ma_chaine.isdigit()    #Teste s'il n'y a que des chiffres
>>>ma_chaine.isalnum()    #Teste s'il y a des caracteres alphanumeriques
>>>ma_chaine.isspace()    #Teste s'il n'y a que des espaces

Il existe également une méthode pour effacer un élément d'une liste, en passant comme paramètre sa valeur

>>>jour_ouvre.remove(4)
>>>print jour_ouvre
[" lundi ", " mardi ", " credi ", " jeudi ", " vendredi ",1,2,3]

Pour réaliser des ajouts, on utilise la méthode append des listes :

>>>jour_ouvre.append(4)
>>>jour_ouvre.append(5)
>>>print jour_ouvre
[" lundi ", " mardi ", " credi ", " jeudi ", " vendredi ",1,2,3,4,5]

Attention : on peut insérer une liste dans une liste. Bien que cela ne soit pas la meilleure manière de procéder, on peut ainsi créer des matrices sommaires.

Il est aussi possible d'insérer un élément dans une liste à une position donnée :

>>>jour_ouvre.insert(5, " samedi ")
>>>print jour_ouvre
[" lundi ", " mardi ", " credi ", " jeudi ", " vendredi ", "samedi ",1,2,3,4,5]

Nous pouvons concaténer deux listes avec la méthode extend :

>>>jour_semaine.extend(jour_ouvre)
>>>print jour_semaine
[" lundi ", " mardi ", " credi ", " jeudi ", " vendredi ", "samedi ",1,2,3,4,5]

Pour supprimer une entrée, on utilise la méthode pop qui renvoie la valeur liée à la clé transmise :

>>>mon_dico.pop(" voiture ")
vehicule automobile

L'encapsulation côté PYTHON est un peu particulière. La notion de privé ou public de certains langages est inconnue.

En effet, PYTHON privilégie le bon sens à la répression. En clair, nous partons du principe que si l'auteur du code indique qu'une variable ne doit pas être accédée depuis l'extérieur du module, alors l'utilisateur ne devra pas chercher à y accéder.

Il est cependant possible de ruser pour faire en sorte que l'utilisateur soit automatiquement redirigé en cas de tentative d'accès non correcte. On utilisera pour cela les accesseurs et les mutateurs.

En PYTHON, voici comment se réalise un héritage de classe.

>>>class MaClasse1:
    #code1
>>>class MaClasse2(Maclasse1):
    #code2

PYTHON respecte l'ensemble des principes de l'héritage. MaClasse2 héritera donc de l'ensemble des caractéristiques de MaClasse1.

La fonction import permet de préciser à PYTHON que vous allez utiliser du code externe et où le trouver. Cas échéant, vous pouvez également préciser quelles fonctions vous désirez importer (from…import…)

import math #importe le module de mathematique
from math import sqrt #importe uniquement la fonction sqrt

La question qui peut se poser ici est l'utilité d'un code tel celui ligne 2. En réalité, il trouve toute son utilité dans des systèmes possédant peu de ressources. Cela permet de contrôler au mieux notre consommation des ressources hôte.

L'instruction self est très importante en PYTHON. En effet, il indique au langage que vous faites référence à l'objet que vous utilisez et non à la classe mère.

Par exemple, prenons deux objets : une Twingo et une A6. Ce sont tous les deux des objets créés à partir de la classe mère voiture. Sans l'utilisation du self, le fait de changer une propriété sur l'objet Twingo n'affecterait pas cet objet, mais directement la classe mère voiture.

Ainsi dans une classe, le premier et/ou seul paramètre des fonctions/procédures sera toujours self. De même, les variables dans une classe devront être précédées de self. On parle alors d'attributs de l'objet.

La notion de self sera précisée par des exemples lors de l'explication des classes ci-après.

Les fonctions et les procédures fonctionnent sur le même principe. La différence réside dans le fait qu'une fonction renvoie un résultat, une procédure ne renvoie rien.

Pour définir une fonction ou une procédure, nous utilisons simplement le mot-clé def :

>>>def ma_fonction():
    print " Hello World !!! "
    return True

Remarque : les parenthèses sont obligatoires, même si aucun argument n'est passé.

Nous pouvons voir ici que nous retournons un booléen. On utilise pour cela le mot-clé return. Si nous désirons renvoyer plusieurs variables, il suffit de les écrire à la suite et de les récupérer dans des variables adaptées :

>>> def ma_fonction(fnom, fprenom):
    return "nom: " + fnom, "prenom: "+fprenom
>>> nom, prenom = ma_fonction("DUPONT", "Jean")
>>> print nom
nom: DUPONT
>>> print prenom
prenom: Jean

Il est également possible de définir une ou plusieurs valeurs par défaut :

>>> def ma_fonction(fnom, fprenom= 'Jean'):
    return "nom: " + fnom, "prenom: "+fprenom
>>> nom, prenom = ma_fonction("DUPONT")
>>> print nom
nom: DUPONT
>>> print prenom
prenom: Jean

Remarque : quand certains paramètres n'ont pas de valeur par défaut, ces paramètres doivent être placés avant ceux possédant une valeur par défaut.

Lorsque nous allons créer un objet, nous nous référerons en fait à une classe. Pour reprendre la définition donnée précédemment, une classe est une brique logicielle de référence.

Pour déclarer une classe en PYTHON, on utilise le mot-clé class. La définition d'une classe doit s'accompagner de sa méthode constructeur :

class MaClasse:
    def __init__(self, param1, param2, …, paramn):
        #code

Le rôle de ce constructeur est de créer un objet copie de la classe lorsque nous définissons un nouvel objet.

Pour créer un objet depuis une classe, il suffit de l'appeler :

>>>mon objet = Maclasse()

IV-K-2-d-i. Les attributs▲

class MaClasse:
    mon_compteur = 0
    def __init__(self, param1, param2, …, paramn):
        MaClasse.mon_compteur += 1
        #code

IV-K-2-d-ii. Les accesseurs▲

_get_ATTRIBUT()

def _get_ATTRIBUT(self):
    """Accesseur de l'attribut'"""
    #Code, finissant souvent par " return self._ATTRIBUT "

IV-K-2-d-iii. Les mutateurs▲

_set_ATTRIBUT()

def _set_ATTRIBUT(self, paramètre):
    """Mutateur de l'attribut"""
    #code, finissant souvent par " self._ATTRIBUT = new_value "

IV-K-2-d-iv. Mise en situation▲

class Twingo:
    """Classe Twingo simplifiée possédant un seul attribut: phares"""

    def __init__(self):
        """Constructeur de la classe Twingo"""
        self._phares = False #Phares éteints par défaut


    def _get_phares(self):
        """Accesseur de l'attribut phares, permet de récupérer l'état des phares'"""
        if self._phares:
            return 'ON'
        else:
            return 'OFF'


    def _set_phares(self, on_off):
        """Mutateur de phares, permet de changer l'etat"""
        if on_off = 'ON':
            self._phares = True
        else:
            self._phares = False
        phares = property(_get_phares, _set_phares)

En PYTHON, un module est un fichier contenant différents codes (fonctions, procédures, classes…) ayant un lien entre eux.

Pour utiliser le code contenu dans un module, on doit l'importer avec le mot-clé import. Cependant, lorsque nous développons un module, il est recommandé de créer la fonction de test du module.

Cette fonction de test a pour but de réaliser un ensemble d'instructions utilisant le code défini dans le module afin de le tester sans avoir besoin d'utiliser un logiciel dédié.

Cette fonction se déclare ainsi :

if __name__ == " __main__ ":

La variable __name__ est une variable système initialisée au lancement de l'interpréteur PYTHON. Si cette dernière vaut __main__, cela signifie que le fichier appelé est le fichier exécuté.

Les packages sont le niveau supérieur des modules. Ils permettent donc de regrouper plusieurs modules.

Dans la pratique, un package n'est rien d'autre qu'un dossier. Ces dossiers peuvent contenir d'autres dossiers (package) ou d'autres fichiers (module).

Tout comme pour les modules, pour les utiliser dans un code, il faut utiliser le mot-clé import. Pour utiliser ensuite un sous-package ou un module du package, on utilise le point « . » afin de modéliser le chemin menant à la fonction ou la procédure que nous désirons utiliser.

IV-K-2-f-i. Composition d'un package▲

Pour reprendre l'exemple des voitures, nous pourrions avoir un package voiture, puis un module par marque (Renaud, Jugeote…), puis une classe par modèle de voiture de la marque (Clio, 504, DS5…).

Chacune de ces classes, représentant une voiture, aurait alors des propriétés et des méthodes qui lui sont propres.

Après avoir ouvert un fichier en écriture, les commandes types à utiliser sont :

mon_pickler = pickle.Pickler(fichier) #Cree le pickler dans le fichier
mon_pickler.dump(objet) #stocke l'objet dans le pickler

Après avoir ouvert un fichier en lecture, nous utiliserons une commande de type :

mon_unpickler = pickle.Unpickler(fichier) #recupere le pickler dans fichier
mon_objet = mon_unpickler.load()

La première de ces méthodes, search, permet de rechercher une REGEX dans une chaîne de caractères.

>>> import re
>>> test = "ma_chaine"
>>> re.search("_cha", test)
<_sre.SRE_Match object at 0xa670870>
>>> re.search("toto", test)
>>>

Comme on peut le constater, rien de très compliqué. Il faut deux paramètres : le premier la REGEX, et le second la chaîne où l'on désire chercher. Si une occurrence est trouvée, re.search nous renvoie une expression. Si aucune occurrence n'est trouvée, alors re.search nous renvoie None.

La méthode sub permet, elle, d'effectuer un remplacement dans une chaîne de caractères.

Il s'agit ni plus ni moins d'une fonction rechercher/remplacer, mais en plus brut.

>>> mail = "toto@masociete.fr"
>>> re.search("^.{1,}(@masociete\.fr){1}$", mail)
<_sre.SRE_Match object at 0xa602860>
>>> re.search("^.{1}(@masociete\.fr){1}$", mail)
>>> re.sub("(@masociete\.fr){1}", "@societe.com", mail)
'toto@societe.com'

Le premier argument de re.sub est la REGEX recherchée, le second la chaîne de remplacement, et le troisième la chaîne où cherche la REGEX et effectue le remplacement.

Nous pouvons ici constater dans cet exemple que la méthode re.sub renvoie le résultat de la substitution.

Le nom des variables ne peut pas commencer par un chiffre. Il ne doit être constitué que de lettres minuscules et les différents mots séparés par des underscores « _ ».

Les règles de nommage des fonctions et des procédures sont identiques à celles des variables.

Les noms des modules et des packages doivent être courts et constitués uniquement de lettres minuscules.

De préférence, il faut éviter d'utiliser des underscores et n'avoir un nom ne tenant qu'en un mot, surtout pour les packages.

IV-O-3-d-i. Le nom des classes▲

IV-O-3-d-ii. Les propriétés et les méthodes▲

Les règles de nommage des exceptions suivent les mêmes règles de nommage que les classes.

En PYTHON, juste après la définition d'une fonction, procédure, classe, ou module, il faut insérer ce qu'on appelle une docstring.

Entourée de triples doubles-quotes, elle donne une description du code que nous écrivons, et peut s'écrire sur plusieurs lignes sans utiliser le caractère de césure. Si vous tapez help(fonction) c'est cette docstring que vous verrez apparaître.

>>> def ma_fonction(a):
    """Multiplie a par 2"""
    print a*a

>>> help(ma_fonction)
Help on function ma_fonction in module __main__:

>>> ma_fonction(a)
Multiplie a par 2

>>> ma_fonction(2)
4

Remarque : mettre une docstring bilingue est souvent apprécié dans les grandes entreprises.

Au début de chaque code, il est important de préciser certaines informations, surtout sur Linux.

Ces informations occupant systématiquement les deux premières sont le chemin de l'interpréteur, ainsi que l'encodage utilisé.

#! /usr/bin/env PYTHON
# -*- coding: utf-8 -*-

La première ligne indique à l'OS où trouver l'interpréteur PYTHON afin de traduire le code. Cela n'est à faire que sous LINUX.

La seconde ligne, non obligatoire, quoique vivement conseillée, permet de préciser à l'interpréteur le type d'encodage que nous utilisons pour le code. En effet, par défaut, les accents ne sont pas autorisés.

Remarque : ici nous avons précisé un encodage ISO. Ce n'est pas le seul puisqu'il existe également l'encodage LATIN1, UTF-8…

Vous l'avez peut-être parfois remarqué lors de l'exécution d'un code en ligne de commande, un petit « exit code: 0 ».

En fait, il s'agit pour l'OS de vous indiquer si votre traitement s'est bien déroulé (0) ou non (1).

En PYTHON, on utilise l'instruction sys.exit(1) pour quitter le programme si l'on sait qu'il va crasher. On s'assure ainsi de bien maîtriser le code, respectant ainsi le principe de la PEP indiquant qu'aucune erreur ne doit passer silencieusement.

De même, nous pouvons connecter le bouton de fermeture à un sys.exit(0) pour indiquer que tout s'est bien déroulé.

Il n'est cependant pas du tout obligatoire d'employer ce genre d'instructions, mais elles existent et il faut le savoir, car cela peut parfois s'avérer utile de les implémenter.

Certaines recommandations complémentaires existent. Par exemple, plutôt utiliser is et is not à la place de == et <>.

De même, il est déconseillé d'utiliser le L minuscule, le O majuscule ou le i majuscule. En effet, selon la police d'écriture ces caractères peuvent parfois mal s'interpréter.

Enfin, les constantes doivent systématiquement être écrites en majuscules : MA_CONSTANTE

En général, outre ces règles, on essaie de toujours faire commencer un nom par un préfixe (souvent une lettre) minuscule, suivie d'un underscore. Cette lettre permet d'identifier en un coup d'œil le type auquel nous avons à faire. En fond orange ceux qui s'avèrent réellement indispensables :

On veillera notamment à bien s'assurer de la présence d'un cartouche complet.

De plus, chaque section sera précédée d'un mini cartouche résumant l'utilité/l'action du code de cette section.

Les sections seront séparées par quatre sauts de lignes et les fonctions/procédures internes à ces sections par deux sauts de lignes.

Les tabulations seront équivalentes à quatre espaces (les éditeurs sont paramétrables à ce niveau en général).

Sous Linux, UNIX, on n'oubliera pas les deux premières lignes, qui doivent OBLIGATOIREMENT se trouver en ligne 1 et 2.

La première permet de stipuler où se trouve l'interpréteur PYTHON. La seconde permet d'indiquer le type d'encodage à utiliser.

En plus de cela, on veillera à bien mettre en place des docstrings, les plus explicites possible.

Enfin, il est important de tenir à jour toutes les docstrings, cartouches et commentaires afin qu'ils correspondent au code en place.

Le module graphique TKInter est considéré comme le module graphique de base de PYTHON.

D'apparence un peu austère, elle ne possède que quelques widgets basiques, suffisants la plupart du temps. Certains autres modules graphiques permettent d'améliorer l'aspect et/ou de rajouter des widgets complémentaires à TKInter, mais cela ne sera pas vu ici.

L'import se fait de la façon suivante :

>>>from tTkinter import *

Créer un tableau multidimensionnel NumPy est simple :

>>>import numpy
>>>tab1 = numpy.array([1,2,3]) #tableau a une dimension
>>>tab2 = numpy.array([[1,2,3],[4,5,6]]) #matrice 3*3
>>>tab2[0][0]
1
>>>tab2[1][2]
6

Il y a aussi possibilité de définir le type des éléments d'un tableau à sa création :

tab3 = numpy.array([1,2,3], dtype='i') #i pour integer

Remarque : un tableau de deux dimensions (matrice) est comparable à un tableau vertical contenant des tableaux horizontaux. Ainsi lors de l'appel d'un élément (ex. : tab2[0][1]), le premier indice correspond à la ligne (emplacement dans le tableau vertical), et le second indice à la place de l'élément dans le tableau horizontal.

Un tableau NumPy se rapprochant des listes, on peut utiliser les mêmes méthodes de manipulation

V-C-2-b-i. Ajout▲

>>>import numpy
>>>tab1=numpy.array([1,2,3])
>>>tab1
array([1,2,3])
>>>numpy.hstack((tab1,4))
array([1,2,3,4])
>>>tab1
array([1,2,3])
>>>tab1=numpy.hstack((tab1,4))
>>>tab1
array([1,2,3,4])

>>>tab2
array([[1,2,3],
           [4,5,6]])
>>>tab2 = numpy.append(tab2, [[7,8,9]], axis = 0)
>>>tab2
array([[1,2,3],
           [4,5,6],
           [7,8,9]])

V-C-2-b-ii. Modification▲

>>>tab2
array([[1,2,3],
           [4,5,6]])
>>>tab2[0][2] = 4
>>>tab2
array([[1,2,4],
           [4,5,6]])

V-C-2-b-iii. SUPPRESSION ▲

>>>tab1
array([1,2,3,4])
>>>tab1 = numpy.delete(tab1,3)
>>>tab1
array([1,2,3])
>>>tab2
array([[1,2,4],
           [4,5,6]])
>>>tab2=numpy.delete(tab2,1,axis = 0)
>>>tab2
array([[1,2,4]])

V-C-2-b-iv. COPIE ▲

>>>tab3 = tab2.copy()

NumPy offre la possibilité de réaliser simplement des transpositions. Pour rappel, il s'agit d'inverser lignes et colonnes d'une matrice ainsi que ses dimensions de fait

>>> tab2.transpose()
array([[1, 4],
           [2, 5],
           [3, 6]])

Il existe également certaines méthodes associées aux tableaux.

Le paramètre axis=1 permet de travailler sur les lignes et axis=0 sur les colonnes et non pas l'ensemble du tableau.

>>> tab2.max()
6
>>> tab2.sum()
21
>>> tab2.sum(axis=1)
array([ 6, 15])
>>> tab2.max(axis=1)
array([3, 6])
>>> tab4=numpy.array([4,2,8,7])
>>> tab4.sort()
>>> tab4
array([2, 4, 7, 8])

Comme indiqué au début de cette partie consacré à NumPy, ce qui va nous intéresser surtout est la capacité à réaliser des opérations de manière simplifiée :

>>> tab2
array([[1, 2, 3],
       [4, 5, 6]])
>>> tab2 = 2 * tab2
>>> tab2
array([[ 2,  4,  6],
       [ 8, 10, 12]])

Dans cet exemple, on peut voir que l'opération effectuée sur le tableau affecte la totalité du tableau. Nous économisons ainsi l'utilisation d'une boucle.

Certaines fonctions fournies par NumPy permettent d'effectuer des opérations complexes sur des matrices

Paramètre	Description
dot(mat1, mat2)	Permet d'effectuer un produit entre matrices
inner(mat1, mat2)	Permet de réaliser un produit scalaire
solve(mat1, mat2)	Permet d'obtenir la solution d'un système linéaire avec : mat1 mat2
numpy.sin(x)	Permet d'obtenir le sinus de l'angle x (existe aussi numpy.arcsin)
numpy.cos(x)	Permet d'obtenir le cosinus de l'angle x
numpyr.tan(x)	Permet d'obtenir la tangente de l'angle x
numpy.pi	Renvoie la valeur de la variable pi
numpy.abs(x)	Renvoie la valeur absolue de x
numpy.ceil(x)	Arrondit à l'entier supérieur
numpy.floor(x)	Arrondit à l'entier inférieur
numpy.round(x)	Arrondit à l'entier le plus proche

Pour créer une courbe, la première chose à faire est de créer un objet pour contenir cette courbe. Cet objet est ici appelé Figure.

Il peut prendre différents paramètres, mais nous les laisserons à leur valeur par défaut. Bien entendu, il faudra auparavant importer le module de matplotlib

from matplotlib.figure import Figure
ma_figure = Figure()

Une fois ce conteneur créé, il faut créer un support de courbe et l'ajouter au conteneur via la méthode add_subplot.

ma_courbe = ma_figure.add_subplot(111)

Comme on peut le voir, cette méthode prend un paramètre. Ce paramètre permet de stipuler l'emplacement de la courbe. En effet, un conteneur peut contenir 1,2,4… courbes.

On définit donc leur emplacement à l'aide de ce paramètre. Ici, 111 signifie que le conteneur aura une définition de 1 courbe en Y, 1 courbe en X, et que ma_courbe occupera la position 1. Si on avait eu 212, on aurait eu 2 courbes en Y, 1 en X, et ma_courbe aurait été la seconde courbe. En résumé donc : YXPosition.

Remarque : si cela vous paraît encore un peu flou, je vous invite à faire quelques tests par vous-même.

Sur ma_courbe nous pouvons ensuite rajouter une ou plusieurs courbes. Nous utiliserons la méthode plot(x, y, paramètres optionnels).

Cette méthode prend en paramètres optionnels, entre autres, un label, une couleur, un type de marqueur pour chaque point ou encore le type et la largeur de ligne. La couleur, le type de ligne et le type de marqueur peuvent être passés en un seul paramètre.

ma_courbe.plot([1,2,3],[1,2,3], 'go--', label='Test1', linewidth=2)

Remarque : on peut voir que pour X et Y, on passe une liste de points. Une courbe se trace en une seule fois, c'est pourquoi on doit passer l'ensemble des points constituant la courbe en une fois. De plus, il faut la même quantité de points entre x et y, sinon vous aurez un message d'erreur.

Dans l'exemple ci-dessus, nous réalisons une ligne de trois points. Le « go-- » signifie que nous traçons la ligne en vert, avec des marqueurs circulaires et que la ligne sera pointillée (cf. tableaux ci-après). La ligne aura une largeur double à la normale. Notre ligne s'appellera « Test1 ».

Il est bien entendu possible de mixer ces symboles afin d'obtenir ce qu'on désire. Par exemple « go- » pour une ligne verte avec des marqueurs circulaires et une ligne solide ; ou encore « r:x » pour une ligne rouge en pointillé, avec des marqueurs en x.

Remarque : en cas d'absence d'information sur un type ou un style, le module prendra des valeurs par défaut.

Il est possible de paramétrer, dans une certaine mesure, les axes du graphique.

Par exemple, on peut définir le Xmin, le Xmax, le Ymin et le Ymax, via la commande axis :

ma_courbe.axis([Xmin,Xmax,Ymin,Ymax])

De même, nous pouvons désactiver l'affichage des axes :

ma_courbe.axis('off')

Les légendes permettent de facilement distinguer les différentes courbes présentes sur un graphique.

Pour cela il suffit d'utiliser la méthode legend(loc='best'). Cette dernière permet d'afficher la légende de la courbe au meilleur endroit possible.

Autre solution sinon, utiliser un coin du graphique.

ma_courbe.legend(loc='upper right')

Chaque axe peut posséder son propre label. Pour donner un label à l'axe X ou Y, on utilise les méthodes set_xlabel et set_ylabel.

ma_courbe.set_xlabel('Axe X')
ma_courbe.set_ylabel('Axe Y')

Il est possible de mettre une grille sur la courbe afin, par exemple, d'en faciliter la lecture. Pour cela, on utilisera la méthode grid. On lui passera comme paramètre :

ma_courbe.grid(color='r', linestyle='-', linewidth=2)

La couleur, le style de ligne sont sur le même principe que pour tracer une courbe.

Pour désactiver la grille, rien de plus simple, il suffit d'appeler grid sans paramètre.

ma_courbe.grid(False)

Il peut être pratique pour tracer, par exemple, une courbe de données chronologiques de travailler directement avec des dates. Pour cela aussi matplotlib peut être utile.

En effet, le module datetime est spécialement là pour ça.

import datetime
import matplotlib
...
x= [datetime.datetime(2011,02,01), datetime.datetime(2011,03,01)]
y=[100,150]
ma_courbe.plot(X,Y,label = 'Ma courbe avec date en X')
ma_figure.autofmt_xdate(bottom=0.2, rotation=30, ha='right')

La dernière ligne mérite une petite explication complémentaire. Elle permet de modifier la position et l'inclinaison des annotations de l'axe X (dans notre cas, les dates).

Les valeurs par défaut placent le texte à 30 °. Mais il est cependant possible de donner un autre angle de rotation.

Dans certains cas, il peut être intéressant d'afficher une image en fond de notre courbe. Pour cela, il existe la méthode imshow. Cette méthode prend comme paramètre une image PIL (cf 3.14.3).

Attention : la résolution peut poser problème. En effet, cette méthode va traduire l'image avec 1 pixel = 1 unité.

imm = Image.open('/home/alex/test.bmp')
ma_courbe.imshow(imm)

Effacer une courbe est très utile, lorsque l'on désire afficher une courbe de manière dynamique, ou simplement recharger une donnée sur un graphique.

Pour cela, la méthode clf est à utiliser.

ma_courbe.clf()

Pour transformer un graphique en image, c'est relativement simple : il suffit d'utiliser la méthode savefig.

Cette méthode peut prendre plusieurs paramètres. Nous ne verrons ici que la version simplifiée.

ma_figure.savefig(" /home/ag/mon_graphe.PNG ")

Remarque : les formats gérés pour l'export sont le png, le pdf, le ps, l'eps et le svg.

Attention : lorsque vous voulez générer des graphiques en masse, n'oubliez jamais de supprimer chaque figure avant de passer à la suivante, car sinon votre mémoire se remplira rapidement. Utilisez pour cela pyplot.close(ma_figure).

Une BDD est constituée de différents éléments.

Tout d'abord la base. C'est elle qui accueille l'ensemble des données. Ces données sont réparties dans des tables. Chaque table est organisée en colonnes.

Chacune de ces colonnes, tables, et bases porte un nom. Le nom des colonnes est propre à une table, et le nom des tables est propre à une base. Par exemple, deux tables de même nom ne peuvent coexister dans une même base, mais peuvent exister dans deux bases distinctes.

Une table peut être comparée à une feuille de Libre Office Calc, où chaque ligne possède un numéro unique, appelé ROW ID. Ce ROW ID est unique pour une ligne donnée, quelle que soit la table, à l'intérieur d'une base.

De plus, chaque table possède un index dit unique. Il peut être comparé à l'index d'un livre, à une exception près : l'index unique d'une table (un tuple sur un ou plusieurs éléments) ne peut contenir de doublons. Cela afin de garantir, ce qu'on appelle l'unicité de la table.

Quand nous cherchons une information, nous utilisons un langage en grande partie standardisé appelé SQL pour Structured Query Language.

Remarque : bien que grandement standardisé, chaque éditeur y va de ses touches personnelles, rendant malheureusement difficile l'interopérabilité. C'est pourquoi je vous invite fortement à utiliser des BDD Open Source telles PostGreSQL ou encore SQLite pour les besoins plus faibles.

Pour reprendre l'exemple d'un fichier classeur, imaginez que vous avez un fichier Calc nommé Carnet, contenant une feuille nommée Amis, contenant 50 lignes. Chacune de ces lignes correspond à l'un de vos amis et contient leur nom, leur prénom, leur adresse, leur mail…

Ici, le fichier Calc correspond à la base, la feuille à la table, et le nom des colonnes… au nom des colonnes. Chacun de vos amis y possède un numéro unique (N° de la ligne).

Maintenant, imaginez que vous ayez besoin de l'adresse d'Albert Dupond. Vous vous dites: « je veux l'adresse d'Albert Dupond qui est stockée dans mon fichier carnet.ods, sur la feuille amis ». Eh bien en SQL ce sera la même chose, sauf qu'on précise le nom des colonnes : « Je cherche l'adresse de la personne dont le nom est Dupond et le prénom Albert dans mon fichier carnet.ods, sur la feuille amis ».

Nous nous arrêterons là pour les explications sur les BDD. Il s'agit surtout d'une présentation succincte (pour ceux qui ne connaîtraient pas encore le sujet), mais néanmoins nécessaire et suffisante pour suivre le reste de ce point sur les BDD.

Pour apprendre le langage SQL, je vous renvoie vers Internet qui contient de nombreux cours fort bien conçus sur le sujet.

Pour se connecter à une base SQLite, on va définir le chemin du fichier SQLite.

ma_base = sqlite3.connect("./BASE.sqlite")

V-F-2-b-i. Curseur▲

mon_curseur = ma_base.cursor()

mon_curseur.execute("SELECT * \
    FROM MA_TABLE \
    WHERE NOM = ? \
    AND PRENOM = ?",\
    (mon_nom, mon_prenom))

V-F-2-b-ii. Récupération des résultats▲

ma_liste = []
for r in mon_curseur:
    ma_liste.append(r[0])

ma_base = sqlite3.connect("./BASE.sqlite")
ma_base.row_factory = sqlite3.Row
mon_curseur = ma_base.cursor()
mon_curseur.execute("SELECT * FROM MA_TABLE)
r = mon_curseur.fetchone()
mon_listing = r.keys()
cur.close()

for r in mon_curseur:
if r["Age"] == None:
    age = 0
else:
    age = int(r["Age"])

Comme indiqué plus haut, une mise à jour en base n'est effective que lorsque l'exécution commit a été exécutée.

ma_base.commit()

Enfin, une fois nos interrogations terminées, il ne reste qu'à se déconnecter. Pour cela, il suffit de fermer le curseur

mon_curseur.close

La connexion à une base est extrêmement simple :

ma_connection=psycopg2.connect(database='test',user="name", \
                   password='mdp',host=127.0.0.1, \
                   port=5432) #par defaut

Vous voyez ici la forme complète. host et port peuvent être facultatifs selon votre utilisation. Le port 5432 est le port par défaut.

Afin de respecter le principe de PYTHON selon lequel « explicite est mieux qu'implicite », je vous invite à toujours utiliser la forme complète.

V-F-3-b-i. Curseur▲

mon_curseur = ma_connection.cursor()
mon_curseur.execute(''SELECT %s FROM DUAL'', ('NULL',))

requete = mon_curseur.mogrify(" SELECT %s FROM DUAL ", ('NULL',))

V-F-3-b-ii. Récupération des résultats▲

a = mon_curseur.fetchone()

V-F-3-b-iii. Lecture de la dernière requête exécutée▲

last_requete = mon_curseur.query

V-F-3-b-iv. Procédures▲

ma_curseur.callproc(ma_procédure(mes_paramètres))

V-F-3-b-v. Gestion d'erreurs▲

try:
    mon_curseur.execute(" Select * from test ")
except Exception, e:
    pass
print e.pgcode, ': ', e.pgerror

Tout comme dans SQLite, la sauvegarde s'effectue via un commit :

ma_connection.commit()

Pour se déconnecter, la procédure est relativement simple. On commence par clore les curseurs ouverts, puis par clore la connexion à la base.

mon_curseur.close()
ma_connection.close()

Remarque : pour savoir si un curseur est clos ou non, on peut utiliser mon_curseur.closed().

Pour passer des arguments, nous utilisons l'attribut sys.argv. Cet attribut est une liste des arguments passés en paramètres.

Imaginons un script nommé script.py. Quand nous l'appelons en lui passant des arguments cela pourrait donner cela :

PYTHON script.py arg1 arg2 arg3 " arg4   arg5 "

Dans ce cas, sys.argv donnerait le retour suivant :

['script.py', 'arg1', 'arg2', 'arg3', 'arg4   arg5']

Comme nous pouvons le voir la distinction entre les différents arguments est réalisée grâce aux espaces. Cependant, il est possible de passe un argument contenant des espaces, à condition de le mettre entre doubles-quotes.

Attention : le premier argument (sys.argv[0]) est toujours le nom du programme.

Pour connaître le nombre d'arguments passés en paramètre, il suffit d'exécuter un len sur l'attribut.

>>>#sur notre exemple, cela donne :
>>>len(sys.argv)
5

V-H-1-b-i. Ouverture et accès aux données▲

import zipfile

mon_zip = zipfile.ZipFile('mon_texte.zip', 'w')
fichier = mon_zip.read('./données.txt') #lecture du fichier
mon_zip.writestr('données.txt', b'ajout de données\n')    #on convertit en binaire
mon_zip.close()

V-H-1-b-ii. Décompression complète▲

import zipfile

mon_zip = zipfile.ZipFile('mon_arch.zip','r')
for fichier in mon_zip.namelist():
    contenu = mon_zip.read(fichier)
    fichier_sortie = open(fichier, 'wb')
    fichier_sortie.write(contenu)
    fichier_sortie.close()
mon_zip.close()

import zipfile

mon_zip = zipfile.ZipFile('mon_arch.zip','r')
mon_zip.extractall('./')    #on passe en parametre le chemin desire
mon_zip.close()

L'entête d'un XML est très simple et en voici un exemple que nous allons analyser. Cet entête s'appelle un PROLOGUE.

<?xml version="1.0" encoding="UTF-8"?>

L'élément suivant est donc le langage utilisé (XML). Nous précisons ensuite la version. À l'heure actuelle seule la version 1 est vraiment utilisée, donc pas de questions à se poser. Enfin, le type d'encodage du fichier. Je vous conseille l'UTF-8, standard européen. Vous trouverez plus d'informations sur l'encodage de caractères sur Wikipédia.

Donc, comme vous pouvez le constater, rien de sorcier ici non plus.

Le corps du fichier même est organisé en arbre. Par arbre, j'entends ramification. Ainsi, chaque balise peut avoir un certain nombre de sous-balises.

Ci-dessous un exemple d'un annuaire codé en XML.

<?xml version= "1.0 " encoding= "utf-8 "?>
<annuaire>
    <personne dpmt= "sciences ">
        <nom> Dupond </nom>
        <prenom> Jean-Baptiste </prenom>
        <tel> 3637 </tel>
    </personne>
    ...
    <personne dpmt= "langue ">
        <nom> Martin </nom>
        <prenom> Michel </prenom>
        <tel> 5354 </tel>
    </personne>
</annuaire>

En XML, les commentaires se font très simplement, avec des « <!-- » pour les commencer et un « --> » pour les clore. Cela permet d'avoir des commentaires sur plusieurs lignes.

<!--  Ceci est un commentaire  -->

La racine, aussi appelée nœud document, est la base du document XML.

Pour prendre une comparaison, un nœud peut être comparé à un dossier ou à un sous-dossier. Le nœud document, lui, est comparable à la racine système (« / » sous Linux).

Les balises permettent de délimiter des zones au sein de l'arbre XML. La différence entre une balise ouvrante et une balise fermante tient à un caractère.

<ma_balise> <!-- balise ouvrante -->
    ...
</ma_balise> <!-- balise fermante -->

Dans le cas où il n'y aurait pas de données entre les balises ouvrantes et fermantes, on peut utiliser un raccourci.

<ma_balise/>

Remarque : dans les faits, je vous recommande d'utiliser exclusivement la première syntaxe, qui sera dans tous les cas plus lisible, et conviendra à toutes les situations.

Les balises n'ont pas le droit de se chevaucher.

<balise1><balise2> ... </balise1></balise2> <!-- Ceci est interdit -->
<balise1><balise2> ... </balise2></balise1> <!-- Ceci est la bonne syntaxe -->

Les attributs, en XML, sont des informations complémentaires que l'on insère dans les balises.

Leur intérêt, par rapport à des sous-balises, est de potentiellement permettre une recherche plus rapide, d'un point de vue XPATH.

<Dupont region= "Bretagne " dpmt= "35 "> <!-- Presence ici de deux attributs -->
...

Les instructions de traitement sont spécifiquement dédiées aux divers traitements de l'information contenue dans le fichier XML. Ces instructions commencent par un « <? » et finissent par un « ?> ».

L'instruction de traitement la plus courante en XML est l'entête.

Le XPATH, correspond à un chemin permettant d'accéder à une donnée bien précise (nœud). Il peut être assimilé à un chemin de fichier complet dans Linux.

Ainsi, si nous reprenons notre exemple de l'annuaire, le XPATH nous donnant le nom des personnes dans le fichier sera le suivant :

/annuaire/personne/nom

On dit qu'on accède aux nœuds « nom ». Cela nous ramène cependant l'ensemble des noms, et pas un en particulier. On aurait également pu utiliser « //nom », mais ce type de notation est ambigu. En effet, il n'y a aucune description des balises mères, ce qui peut provoquer quelques soucis.

Voyons un peu plus en détail les possibilités offertes par le XPATH.

V-J-2-g-i. Sélection d'un nœud précis▲

/annuaire/personne[2] <!-- Récupère la seconde personne du fichier -->
/annuaire.personne[position()<10] <!-- Récupère les 9 premières personnes -->
/annuaire/personne[nom=" Dupond "] <!-- Récupère les nœuds ou le nom vaut Dupond -->

/annuaire/personne[contains(., " Jean ")]

V-J-2-g-ii. Sélection avec attributs▲

/annuaire/personne[@dpmt= "sciences "]

/annuaire/personne/@dpmt

/annuaire/personne[@dpmt=" sciences "]/nom

V-J-2-g-iii. Récupérer toutes les données d'un nœud▲

/annuaire/personne[1]/*

V-J-2-g-iv. Combinaison de XPATH▲

/annuaire/personne/nom | /annuaire/personne/tel

V-J-2-g-v. En bref…▲

Nous n'utiliserons pas la totalité des possibilités offertes par le module. Nous allons ici nous concentrer sur ETREE.

ETREE, pour Element Tree, se rapporte comme son nom l'indique au principe d'arborescence en arbre. Grâce à cela, nous allons utiliser le fichier XML comme une source de données navigables.

Remarque : notez bien ici que j'ai utilisé l'expression « source de données » et non « base de données ». Un fichier XML, pour rappel, n'est nullement une BDD.

from lxml import etree    #import du module

xml_file = etree.parse(" ./annuaire.xml ")    #connexion au fichier XML

La création d'un fichier XML diffère un peu de la création d'un fichier classique.

En effet, nous allons ici procéder en deux étapes. Tout d'abord nous allons créer la structure de notre fichier XML. Ensuite, nous écrirons cette structure au sein même d'un fichier.

Pour la création de la structure, il faut être particulièrement minutieux et respecter un ordre précis, telle l'arborescence d'un arbre.

Ainsi, la première chose à créer est la racine de l'arbre. Ensuite, nous créons les nœuds permettant de générer chaque branche de l'arbre. Enfin, pour finir, nous nous assurons de la bonne indentation du fichier.

from lxml import etree

racine = etree.Element(" annuaire ")    #Creation de la racine
personne1 = etree.SubElement(racine, " personne ")    #Creation d'un nœud
personne1.set(" dpmt ", " sciences ")    #Ajout d'un tag
nom1 = etree.SubElement(personne1, " nom ")
nom1.text = " Dupond "    #Initialisation de la valeur du noeud

file_str = etree.tostring(racine, pretty_print = True)    #Convertion en string
#ecriture dans un fichier texte
...

Analysons un peu plus cet exemple.

Ligne 3, nous créons notre racine, en lui passant le nom de la balise en paramètre.

Ligne 4, nous créons une sous-balise, en passant en paramètre la balise mère, ou nœud père, ainsi que le nom de la balise.

Ligne 5, nous ajoutons un tag sur le même principe. Les paramètres sont le nom du tag et sa valeur.

Ligne 7, nous initialisons la valeur du nœud.

Ligne 9, nous convertissons notre structure, en chaîne de caractères, en précisant que nous voulons que la chaîne soit bien formatée, avec indentations. Pour cela, nous utilisons le paramètre pretty_print.

À partir de la ligne 10, il ne nous reste alors plus qu'à écrire la chaîne de caractères dans un fichier texte, à l'extension .XML.

Une fois connecté au fichier XML, tel que vu précédemment, nous pouvons naviguer au sein des données grâce au XPATH. Nous le ferons grâce à un FOR.

Une fois dans la boucle, nous utiliserons alors diverses méthodes afin de récupérer les informations qui nous intéressent.

for balise in xml_file.xpath(" /annuaire/personne "):
    nom = nalise.xpath(" nom ")
    print nom[0].text

Ci-dessous les principales diverses méthodes qui peuvent vous servir.

V-J-3-d-i. Serialisation et deserialisation▲

V-J-3-d-ii. Méthode générale▲

#!/usr/bin/env PYTHON
from lxml import etree

xml_file=etree.parse("./annuaire.xml")
racine=etree.Element("annuaire")
personne=etree.SubElement(racine,"personne")
prenom=etree.SubElement(personne,"prenom")
for balise in xml_file.xpath("/annuaire/personne[nom=\"Dupond\"]"):
    prenom = balise.xpath("prenom")
    prenom[0].text="Charles"

body = etree.tostring(xml_file, pretty_print = True)
entete = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
contenu = entete + "\n" + body

mon_fichier = open("./annuaire.xml", "w")
mon_fichier.write(contenu)

Dans le cas d'une simple modification de template (par exemple, générer une fiche de données avec un format précis), nous allons utiliser la méthode directe :

1-modification de l'extension en .ZIP ;

2-dézippage ;

3-modification des éléments désirés ;

4-rezippage ;

5-modification de l'extension au format ODF.

Au niveau de la modification d'un template, ce qui va nous intéresser plus particulièrement ce sera content.xml, meta.xml et le dossier Pictures.

meta.xml contient toutes les informations relatives au document : application, titre, description, sujet, mots-clés, auteur, date de création, modèle utilisé…

content.xml est le fichier qui contient le corps du document, autrement dit son contenu entier.

Le dossier Pictures, lui, contient les images du document, auxquelles fait référence content.xml.

La méthode directe consiste à fouiller dans les fichiers XML à la recherche de nos balises (par exemple MON_NOM, MON_PRENOM…).

Ces balises doivent avoir un nom bien particulier et surtout unique au sein du fichier de manière a être sûr de les repérer simplement.

Une fois repérées, il suffit de les remplacer par les valeurs désirées.

Idem pour les images, qui sont prises entre des balises XML <Pictures>. Il suffit de remplacer la référence de l'image entre ces balises XML, puis de déposer l'image dans le dossier Pictures.

Ainsi, en partant d'un fichier odt ou ods, il est très facile de créer des templates de rapport très simplement en substituant simplement texte et image à notre convenance.

Remarque : il existe également des formats de fichiers TEMPLATE en ODF (ott, ots…). Ces formats sont spécifiques à ODF, et visent plutôt à être modifiés via Libre Office (par exemple), ou via une méthode d'interaction complète.

Le constructeur est identique, quel que soit le document :

mon_ods = newdoc(doctype='ods', filename='mon_ods.ods')

Cela se passe de tout commentaire, au vu de la simplicité. Les paramètres sont le type de document à créer, ainsi que le nom du fichier.

Si nous avons vu comment créer un document de toute pièce, il peut être utile aussi de savoir ouvrir un document existant pour le modifier.

mon_odt = ezodf.opendoc('mon_odt.odt')

Ici, seul le nom du document à ouvrir est à fournir.

Voici l'exemple officiel pour créer un ODT basique :

from ezodf import newdoc, Paragraph, Heading

odt = newdoc(doctype='odt', filename='text.odt')
odt.body += Heading("Chapter 1")
odt.body += Paragraph("This is a paragraph.")
odt.save()

Avant de voir plus en détail les principaux éléments pour un ODT, nous allons commenter ce petit exemple.

Ligne 1, nous importons de quoi créer un nouveau document et de quoi créer un titre et un paragraphe. Il s'agit ici de styles prédéfinis.

Ligne 3, nous créons notre document ODT.

Ligne 4, nous ajoutons au corps de notre ODT, un titre en lui passant en paramètre le texte.

Remarque : ce package permet l'utilisation au choix de «  .body += «  ou de « .body.append ». À vous d'utiliser celui que vous préférez.

Ligne 5, nous ajoutons à notre corps de document un paragraphe en passant en paramètre le texte.

Ligne 6 nous sauvegardons notre document.

Pour effectuer un saut de page, il suffit d'utiliser :

odt.body += SoftPageBreak()

Voici l'exemple officiel pour la création d'un ODS :

from ezodf import newdoc, Sheet

ods = newdoc(doctype='ods', filename='spreadsheet.ods')
sheet = Sheet('SHEET', size=(10, 10))
ods.sheets += sheet
sheet['A1'].set_value("cell with text")
sheet['B2'].set_value(3.141592)
sheet['C3'].set_value(100)

pi = sheet[1, 1].value
ods.save()

Ligne 1, nous importons de quoi générer notre ODS.

Ligne 3, nous créons notre fichier CALC.

Ligne 4, nous créons une feuille CALC, en passant en paramètres le nom de la feuille et la taille désirée (lignes puis colonnes).

Ligne 5, nous ajoutons notre feuille à notre fichier CALC.

Ligne 6 à 8, nous remplissons plusieurs cellules de la feuille.

Ligne 10, nous récupérons une valeur dans une cellule. Notez que nous comptons à partir de 0. A0 est donc (0,0), B2 est (1,1)…

Ligne 11, nous sauvegardons notre ODS.

Parmi les autres actions possibles au niveau d'une feuille ODS, nous retrouvons, entre autres les suivantes :

sheets = mon_ods.sheets    #recupere le nom de toutes les feuilles de l'ODS
nom = sheets[0].name        #recupere le nom de la 1ere feuille
count = len(sheets)        #recupere le nombre de feuilles dans l'ODS
rowcount = sheets[0].nrows()    #recupere le nombre de lignes de la feuille
colcount = sheets[0].ncols()    #recupere le nombre de colonnes de la feuille
valeur = sheets[0]['C1']    .value    #recupere la valeur d'une cellule d'une feuille
del sheets[0]            #Supprime la 1ere feuille de l'ODS

Comme cité précédemment, la première chose à faire est de se connecter au flux vidéo. Pour cela nous allons créer un objet dédié à une caméra/webcam :

ma_caméra = cv.CaptureFromCAM(0)

le paramètre passé lors de la création de l'objet est un index permettant de définir quelle caméra utiliser. Lorsqu'il n'y a qu'une seule caméra, il faut passer 0 en paramètre.

Remarque : il existe la possibilité de remplacer le flux vidéo d'une webcam par le flux vidéo d'un fichier. Il ne faut alors pas utiliser cv.CaptureFromCAM(index), mais cv.CaptureFromFile(fichier).

Bien que nous puissions afficher directement le flux vidéo à l'écran, cette solution est rarement retenue.

En effet, passer par une série de snapshot possède un certain nombre d'avantages telles l'application d'un traitement sur image, la possibilité de sauvegarder certains snapshots en direct…

Nous allons donc utiliser un objet nommé « frame ». Dans le monde vidéo, une frame est tout simplement une image. On ne parle donc pas de 25 images/seconde, mais de 25 frames/seconde.

ma_frame = cv.QueryFrame(ma_caméra)

Lorsque nous créons cette frame, nous lui passons en paramètre le flux vidéo auquel elle est liée.

La frame est ainsi l'équivalent d'un snapshot à un instant t du flux vidéo.

Enfin, pour afficher la vidéo, il faut une fenêtre conteneur. Dans vos futurs développements, vous inclurez cela sans nul doute dans une fenêtre GTK ou KDE.

Il existe aussi la possibilité toute simple de l'afficher à l'écran.

cv.NamedWindow("Test_Webcam")

Cela indique à PYTHON que nous utiliserons une fenêtre OpenCV pour l'affichage qui se nommera Test_Webcam.

Il ne reste ensuite plus qu'à afficher le conteneur en lui passant en paramètres la fenêtre à utiliser ainsi que la frame à afficher, puis tourner en boucle.

#! /usr/bin/env PYTHON
# -*- coding: utf-8 -*-

import cv2.cv as cv

if __name__=='__main__':
    ma_caméra = cv.CaptureFromCAM(0)
    cv.NamedWindow("Test_Webcam")
    while True:
        ma_frame = cv.QueryFrame(ma_caméra)
        cv.ShowImage("Test_Webcam", ma_frame)

        if (cv.WaitKey(10) % 0x100) == 113:
            break

Lignes 13 et 14, il s'agit d'une méthode que nous verrons plus loin. Cela permet de lire le clavier et de sortir du programme lorsque la touche « q » est appuyée.

Le premier de ces objets est l'image. En effet, avec OpenCV, il faut différencier image et frame.

SI la frame est bien une image capturée à partir du flux vidéo, on ne peut réaliser aucun traitement dessus. Elle ne peut servir qu'à un affichage direct (comme vu précédemment), ou comme source pour un traitement d'imagerie.

Ces traitements sont nombreux, et nous en verrons quelques-uns, mais l'outil de base est un objet image.

mon_image = cv.CreateImage(cv.GetSize(ma_frame), cv.IPL_DEPTH_8U, 1)

Le premier paramètre est un tuple indiquant la largeur et la hauteur de l'image. La plupart du temps pour éviter tous soucis, nous réalisons un GetSize depuis la source.

Le second argument est le type d'image : 8, 16, 32 ou 64 bits. Cela joue sur l'image finale. Par exemple, une image en nuance de gris sera en 8 bits. À noter qu'il s'agit ici de constante OpenCV.

Remarque : beaucoup de traitements que nous verrons par la suite nécessitent des images de type cv.IPL_DEPTH_8U.

Enfin le dernier paramètre est le nombre de canaux. Entendez ici le nombre de couleurs : 1 pour une image en nuance de gris (grayscale), 3 pour une image classique RGB (couleur), 4 pour une image RGB avec canal alpha (transparence).

Remarque : si votre logiciel nécessitait de charger une photo, par exemple, afin d'y appliquer des traitements via OpenCV, vous pouvez utiliser cv.LoadImage(Fichier, -1).

À noter que la valeur du pixel (x,y) d'une image est accessible via img[x,y], que la largeur de l'image est image.width et sa hauteur image.height.

OpenCV offre la possibilité d'enregistrer les frames sous la forme d'une vidéo de manière très simple.

Il faut tout d'abord créer l'objet dédié.

mon_rec = cv.CreateVideoWriter(" ma_video.avi ", mon_codec, 25,cv.GetSize(ma_frame), 0)

Le premier paramètre est le chemin et le nom de la vidéo. Ici la vidéo sera enregistrée dans le dossier courant.

Le second paramètre est un objet CV_FOURCC. Il s'agit d'un objet auquel on passe en paramètres les quatre lettres du codec désiré.

mon_codec = cv.CV_FOURCC('D','I','V','X')

Les codecs les plus courants sont les suivants :

Le troisième paramètre est le nombre d'images désirées par seconde.

Le quatrième paramètre est la taille de la vidéo. Une fois de plus, on se calera sur la taille de la frame pour éviter tout problème.

Le cinquième et dernier paramètre permet d'indiquer si nous désirons un enregistrement en noir et blanc (0) ou en couleur (1).

Une fois l'objet enregistreur créé, il suffit d'y faire appel via une méthode OpenCV.

cv.WriterFrame(mon_rec, ma_frame)

Dans notre cas d'exemple, au bout de 25 appels à cette méthode, le film possédera donc une seconde de vidéo.

Remarque : dans le cas où vous ne désireriez pas enregistrer une vidéo, mais simplement une image, il faut utiliser la méthode cv.SaveImage(fichier, Image).

Le troisième et dernier objet complémentaire que nous verrons ici est le texte. Il peut être très utile de saisir du texte sur une image pour identifier la date et l'heure, voire le lieu.

Cependant, actuellement seule une police d'écriture est supportée.

Tout comme pour l'enregistrement vidéo, cela aura lieu en deux étapes : création de l'objet puis appel d'une méthode OpenCV.

ma_police = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1,1,0,1,8)

Le premier paramètre est la taille et le type de la police.

Les paramètres 2 et 3 sont les ratios en horizontal et vertical du texte par rapport à sa taille normale (100 % = 1.0).

Le quatrième paramètre est le degré d'inclinaison de l'italique. Sans italique, ce paramètre vaut 0. La valeur 1.0 indique une inclinaison d'environ 45 °.

Le cinquième paramètre sert à gérer le paramètre « GRAS » du texte. Sa valeur par défaut est de 1. Il s'agit d'un entier.

Le dernier paramètre est également un entier, avec comme valeur par défaut 8. Cela permet d'indiquer si le texte doit être souligné ou non.

Une fois l'objet créé selon notre besoin, il ne reste plus qu'à incruster le texte dans l'image. Pour cela nous utiliserons la méthode PutText().

cv.PutText(ma_frame, mon_texte, emplacement_texte, ma_police, 1)

Nous passons plusieurs paramètres à cette méthode.

Tout d'abord, la frame (ou l'image au choix) impactée. Viennent ensuite le texte à afficher, puis l'emplacement du coin inférieur gauche du texte (en pixels).

Suit notre objet police et un paramètre booléen. SI ce dernier vaut 1 (ou True), la référence (le pixel (0,0)) se situe au coin supérieur gauche, sinon au coin inférieur gauche.

OpenCV vous laisse la liberté d'interagir avec le clavier, afin de déclencher des traitements, de sortie du programme…

Pour cela, il faut utiliser la méthode WaitKey(tps_en_ms). Pendant x ms, la méthode écoutera alors le clavier à la recherche d'une touche appuyée.

Le code renvoyé est un entier. Il faut effectuer un masque (% 0x100) avant de le comparer à une valeur décimale (ex. : 113 pour « q »).

Remarque : le WaitKey peut ne pas fonctionner si vous n'avez pas créé de fenêtre conteneur OpenCV. Dans le cas d'une intégration dans une IHM GTK ou autre, pensez à utiliser votre IHM pour interagir avec l'utilisateur.

Il s'agit de la méthode de paramétrage. D'un emploi très simple, elle prend trois paramètres : l'objet de capture, la propriété à modifier, et la nouvelle valeur.

cv.PutText(ma_frame, mon_texte, emplacement_texte, ma_police, 1)

La méthode pour lire le paramétrage, est également très simple d'emploi. Elle prend en paramètres l'objet de capture, ainsi que la propriété désirée.

nb_fps = cv.GetCaptureProperty(ma_caméra,  CV_CAP_PROP_FPS)

Vous trouverez ci-après les principaux types de données que vous trouverez dans OpenCV et dans les pages qui suivent.

Cette méthode permet d'effectuer une soustraction entre deux images puis de passer l'ensemble des pixels en valeur absolue.

Ainsi, les pixels n'ayant pas changé donneront en sortie un pixel blanc, et ceux ayant changé seront en grayscale.

À l'issue de l'application de cette méthode, nous récupérons donc une image dont les pixels non blancs correspondent aux pixels différents entre les deux images.

cv.AbsDiff(img_1, img_2, img_cible)