découverte du langage python dans tous ses aspects

Introduction au langage python
Niveau : debutant
Thierry GAYET - 21 / 05 / 2022

Plan de la formation
Introduction au langage Python
Installation de Python et des modules complémentaires
Les instructions du langage
Le traitement des exceptions
Les fonctions en Python
La portée des objets
Les modules
La manipulation des fichiers
La programmation objet en Python
Les expressions rationnelles
Programme externe, et thread
Les interfaces utilisateurs graphiques (GUI)
Quelques règles d'écriture
The Zen of Python

Introduction au langage Python

Historique 1/2
L’auteur Guido van Rossum, employé au CWI
1989 Ecriture de la première version du langage durant
ses vacances des fêtes de Noël.
1991 sortie de la version 0.9.0
1995 il est employé au CNRI
1999 le CNRI et DARPA lance le projet Computer Programming
for Everybody (CP4E), Python est utilisé pour enseigner la
programmation
Travail ensuite à BeOpen
2000 création de l’ équipe PythonLab
2001 création de la Python Sofware Foundation (PSF)
Décembre 2008 version 3.0
Guido van Rossum est nommé « Dictateur bienveillant à vie »
Depuis 2005 il travail pour Google

Les langages ayant influencés
Python

Techniques de production des
programmes
La compilation : on effectue la traduction d’un code source en un
langage objet puis on assemble les différents objets pour obtenir
un exécutable sur une machine au travers d’un éditeur de lien.
Inconvénient : il faut refaire le processus à chaque modification.
Avantage : c’est rapide à l’exécution
L
’interprétation : Chaque ligne source est analysée et exécutée.
Avantage : Pas de code objet , pas d’édition de lien
Inconvénient : Plus lent car on doit interpréter à chaque fois
Technique mixe : On traduit le langage source en un code
intermédiaire et on exécute de code intermédiaire (bytecode)
Inconvénient : c’est toujours de l’interprété
Avantage : c’est plus rapide que l’interprétation du source, c’est
portable au niveau du bytecode

La technique de production de
Python
Python utilise la technique mixte : Interprétation du bytecode
compilé
Le bytecode qui est une forme intermédiaire est portable sur toute
machine muni d’une machine virtuelle Python.
Il est cependant possible de compiler le bytecode.
Code source Compilateur ByteCode Interpréteur Résultat

Installation de Python et des
modules complémentaires

Installation de Python
Python peut s'installer sur des machines Unix, Windows et Mac.
Pour chaque système d'exploitation on trouve des paquetages
permettant l'installation (apt, rpm, … ). Il est necessqire d’avoir des
droits admin.
Le site officiel est python.org
Deux versions sont disponibles : la branche 2.7.x et la branche
3.2.x, nous avons :
●
La version 2.7.x (obsolete !!!)
●
La version 3.x (3.6, 3.8, … )
Vous prouvez trouver cette documentation sous python.org/doc

Installez Python 3.6 ou toute autre version ulterieure à l'aide du gestionnaire de
package de votre distribution. Le nom de la commande et du package varie :
Sur les dérivés Debian, comme Ubuntu, utilisez APT :
$ sudo apt install -y python3.7 build-essential libssl-dev libffi-dev python3-dev
python3-venv python3-setuptools python3-pip libpython3-dev python-pip-whl
python3.8-dev python3-dev python3-wheel
Sur Red Hat et dérivés, utilisez YUM :
$ sudo yum install python37
Sur SUSE et dérivés, utilisez ZYPPER :
$ sudo zypper install python3-3.7
Ouvrez une invite de commande ou un shell, et exécutez la commande suivante pour
vérifier que Python est installé correctement :
$ python3 –version ou python3 -V
Python 3.7.3

Installation de Python
Une fois installé, il faut penser à ajouter le chemin d'accès de l'installation
dans la variable d'environnement PATH pour que python soit accessible
mais c’est fait automatiauement dans les versions recentes des
distributions GNU/Linux) :
Ceci vous permet dans une fenêtre de commande de lancer l'application
Python et de rentrer directement dans l'interpréteur Python.

Il existe deux editeurs qui sont utilises par les professionnels developpant avec le
langage python.
Le premier etant l’editeur Pycharm de l’editeur JETBRAIN (la version
communautaire suffit) :
●
https://www.jetbrains.com/fr-fr/pycharm/download/#section=linux
Le second est visual code :
●
https://code.visualstudio.com/Download
●
https://vscodium.com/

pip ou pip3 est un script fourni par Python Packaging Authority permettant l’installation
de modules additionnels pour python.
Pour l’installez l'interface de ligne de commande, téléchargez le script d'installation
depuis pypa.io (https://www.pypa.io/) :
$ curl -O https://bootstrap.pypa.io/get-pip.py
Une fois télécharge et installez de la facon suivante:
$ python3 get-pip.py --user
Collecting pip
Downloading pip-8.1.2-py2.py3-none-any.whl (1.2MB)
Collecting setuptools
Downloading setuptools-26.1.1-py2.py3-none-any.whl (464kB)
Collecting wheel
Downloading wheel-0.29.0-py2.py3-none-any.whl (66kB)
Installing collected packages: pip, setuptools, wheel
Successfully installed pip setuptools wheel
$ pip3 --version
pip 8.1.2 from ~/.local/lib/python3.7/site-packages (python 3.7)

Les paquets Python peuvent être installés en tapant :
$ pip3 search package_name
$ pip3 install package_name
Ici, package_name peut faire référence à n’importe quel paquet ou bibliothèque Python,
comme Django pour le développement web ou NumPy pour le calcul scientifique.
Donc si vous souhaitez installer NumPy, vous pouvez le faire avec la commande :
$ pip3 install numpy

Python possede son gestionnaire de paquets : https://pypi.org/
Exemple de recherche sur une classe gerant des listes chainees :

Installation d’autres paquetages
En plus de l'installation de base de Python il est possible d'installer des
paquetages spécifiques pour bénéficier de nouveaux modules.
L'installation des paquetages supplémentaires s'effectuent soit selon le
standard Python qui consiste à disposer d'un fichier setup.py dans le
répertoire où se trouve le paquetage à installer soit sous la forme d'un
exécutable à lancer.
Pour l'installation standard on lance la commande suivante en étant
positionné dans le répertoire où se trouve le fichier setup.py :
Exemple sur le package issue de pypi (necessite setuptools) :
$ wget
https://files.pythonhosted.org/packages/1a/68/abdafbb6d48fa9cb70
8637dc2b731a24e6d03658389ec514034ccbc0c2f5/linked_list_vf-0.0.1.
tar.gz
$ tar zxvf
linked_list_vf-0.0.1.tar.gz && cd linked_list_vf-0.0.1/
$ python3 setup.py install

Les environnements virtuels vous permettent d’avoir un espace isolé sur votre ordinateur pour les
projets Python, ce qui garantit que chacun de vos projets peut avoir son propre ensemble de
dépendances qui ne perturbera aucun de vos autres projets.
La mise en place d’un environnement de programmation permet de mieux contrôler les projets
Python et de voir comment différentes versions de paquets sont traitées. C’est particulièrement
important lorsque vous travaillez avec des paquets tiers.
Vous pouvez mettre en place autant d’environnement de programmation Python que vous le
souhaitez. Chaque environnement est essentiellement un répertoire ou un dossier sur votre serveur
qui contient quelques scripts pour qu’il agisse comme un environnement.
Bien qu’il existe quelques moyens de réaliser un environnement de programmation en Python, nous
utiliserons ici le module venv, qui fait partie de la bibliothèque standard Python 3. Installons venv en
tapant :
$ sudo apt install -y python3-venv
Une fois cela installé, nous sommes prêts à créer des environnements. Choisissons le répertoire
dans lequel nous voulons placer nos environnements de programmation Python, ou bien créons un
nouveau répertoire avec mkdir, comme dans :
$ mkdir env && cd env/
Une fois que vous êtes dans le répertoire où vous souhaitez que les environnements résident, vous
pouvez créer un environnement en exécutant la commande suivante :
$ python3 -m venv my_env

Essentiellement, pyvenv configure un nouveau répertoire qui contient quelques éléments que nous pouvons
visualiser avec la commande ls :
$ ls my_env
Output
bin include lib lib64 pyvenv.cfg share
Ensemble, ces fichiers permettent de s’assurer que vos projets sont isolés du contexte plus large de votre
serveur, de sorte que les fichiers système et les fichiers de projet ne se mélangent pas. C’est une bonne
pratique pour le contrôle de version et pour s’assurer que chacun de vos projets a accès aux paquets
particuliers dont il a besoin. Python Wheels, un format de package intégré pour Python qui peut accélérer
votre production de logiciels en réduisant le nombre de fois dont vous avez besoin pour compiler, se
trouvera dans le répertoire de partage Ubuntu 20.04.
Pour utiliser cet environnement, vous devez l’activer, ce que vous pouvez réaliser en tapant la commande
suivante qui appelle le script activate :
$ source my_env/bin/activate
Votre invite de commande sera maintenant préfixée par le nom de votre environnement, dans ce cas il
s’appelle my_env. Selon la version de Debian Linux que vous utilisez, votre préfixe peut apparaître quelque
peu différemment, mais le nom de votre environnement entre parenthèses doit être la première chose que
vous voyez sur votre ligne :
Ce préfixe nous indique que l’environnement my_env est actuellement actif, ce qui signifie que lorsque nous
créons des programmes ici, ils n’utiliseront que les paramètres et les paquets de cet environnement
particulier.
Remarque : dans l’environnement virtuel, vous pouvez utiliser la commande python au lieu de python3, et
pip au lieu de pip3 si vous préférez. Si vous utilisez Python 3 sur votre machine en dehors d’un
environnement, vous devrez utiliser exclusivement les commandes python3 et pip3.
Après avoir suivi ces étapes, votre environnement virtuel est prêt à être utilisé.

Le langage Python a ete standardise vis un ensemble de documents appeles
PEP pour Python Enhancement Proposals :
●
https://peps.python.org/pep-0000/
Les plus importantes etant :
●
https://peps.python.org/pep-0008/
●
https://nguyen.univ-tln.fr/share/Python/pep8.pdf
●
https://www.python.org/dev/peps/pep-0257/
●
https://www.python.org/dev/peps/pep-0001
●
●
●
●
https://www.diegor.it/2017/06/15/the-must-read-pythons-peps/
Import this
import antigravity

Pour que le systeme sache que le script doit etre execute par un interpreteur
python il faut rajouter la ligne suivante au tout debut de chaque fichier .py :
#!/usr/bin/env python3
Cette ligne s’appelle un SHEBANG, et permet de de rendre un script
autonome et pouvoir le lancer directement :
$ ./mon_script.py
Sinon, sans ce shebang, il sera necessaire de prefixer le nom du script avec
l’interpreteur :
$ python3 ./mon_script.py
De plus, pour que l’on puisse rajouter des commentaires avec des accents il
faut rajouter une seconde ligne :
# -*- coding:utf8 -*-

Un script python peut avoir des commandes en vrac
print(“hello)
print(“comment”)
print(“ca”)
print(“va”)
print(“?”)
Il est cependant possible de structurer le code en rajoutant un point d’entree
qui sera appele :
if __name__ == '__main__':
print(“Ceci est le point d’entree du script”)

Code source : les commentaires
Le code source est destiné à être lu par un être humain donc doit
être écrit de manière à faciliter la lecture.
Les parties de code non triviales doivent être commentés, en
Python un commentaire commence par un # et ce qui suit jusqu’à
la fin de la ligne est ignoré par le compilateur.
#----------------------------------------------
# un commentaire sur plusieurs ligne prefixe
# chacune avec un dieze
#----------------------------------------------
5 * 4 # un autre commentaire
“””
un autre bloc de commentaires
“””

Code source : Les expressions
booléennes
On distingue deux possibilités True et False. Attention la première
lettre est en majuscule.
Avec les opérateurs de comparaison : ==, !=, <, <=, >, >=
• Les opérateur logiques et de comparaison ne peuvent prendre
que deux valeurs : False et True
1 > 5 # False
9 <= 15 < 20 # True
• Opérateurs logiques : and, or et not
(9 == 9) or (10> 100) # True dès le premier membre
(6 > 9) and (4 == 4) # False dès le premier membre

Code source : le type entier 1/2
Opérations arithmétiques
• Les entiers longs, limités par la taille de la RAM
20 + 3 # 23
20 – 3 # 17
20 * 3 # 60
20 ** 3 # 8000
20 / 3 # 6 (division entière)
20 % 3 # 2 (modulo)
2 ** 50 # 1125899906842624L
2 ** 80L # 1208925819614629174706176L
2 ** long(80) # 1208925819614629174706176L

Code source : le type entier 2/2
Opérations sur les bases (8, 10, 16, … ) :
06 + 02 # 8 (8 en base 10)
oct(6+2) # ’010’ (dix en octal)
0x6 + 0x4 # 10
hex(6+4) # '0xa’ (en hexadécimal)
int('10110’,2) # 22
int('10110’,3) # 93

Code source : le type flottant
Pour un flottant on peut utiliser la notation point décimal ou
exponentielle :
1.368
5e9
3.59871e-10
• Supporte les mêmes opérations que les entiers à l’exception de :
22.0 / 3 # 7.333333333333333
22.0 // 3 # 7.0 (division entière forcée)
• Les opérations mathématique usuelles (au travers du module
math) :
cos(pi/4) # 0.7071067811865476

Code source : le type complexe
On écrit les complexes en notation cartésienne.
Is sont constitués de deux flottants :
●
la partie réelle
●
et la partie imaginaire, la partie imaginaire étant suffixée par la
lettre j
1j
(5+3j) + (6-8j) # (11-5j)
(5+3j).real # 5.0
(5.3j).imag # 3.0

Code source : les données et les
variables
Variable : C’est le nom donné à une valeur
Du point de vue informatique c’est la référence à une adresse
mémoire.
Avec Python il est utilise d’initialiser toute valeur par un type
undefinit pour la detection d’erreurs, a savoir None :
ma_variable = None
Par convention les noms des variables sont écrites en minuscule,
elles commencent par une lettre ou le caractère souligné, et
éventuellement par des lettres, chiffres ou caractère souligné mais
on fait ce aue l’ont veut.
Elles doivent évidemment être différents des mots réservés de
Python pour eviter d’interferrer.

Code source : l’affectation
Pour affecter une valeur à une variable on utilise le signe =
Le membre de gauche reçoit le membre de droite
x = 2 # x reçoit la valeur 2
• La valeur d’une variable peut évoluée dans le temps
• la valeur précédente est perdue
x = x + 1 # 3 (incrémentation)
x = x - 1 # 2 (décrémentation)

Code source : autres formes
d’affectation
On peut rencontrer d’autres formes comme :
x = 2 # la forme de base
x += 2 # idem à x = x + 2 si x existe déjà
x = y = 5 # cibles multiples de droite à gauche
x, y = 3.5, 8.7 # affectation par position (tuple)
x, y = [3.5, 8.7] # affectation par position (liste)
x, y = y, x # échange des valeurs de x et y

Code source : les entrées
Pour effectuer une entrée au clavier on peut utiliser input()
Elle effectue un typage dynamique
Et permet d’afficher une invite :
x = input("Entrez une valeur entière : ")
• Ou utiliser raw_input() pour forcer la saisie en mode texte :
x = raw_input("Entrez une valeur flottante : ")
f = float(x) # conversion en flottant
f = float(raw_input("Entrez une valeur flottante : "))

Code source : et les sorties
Pour effectuer une sortie on utilise l'instruction print :
x = 5
y = 3
print(x) # 5
print("somme: ", x + y) # 8
print("différence : ", x – y) # 2
print("produit : ", x * y ) # 15
print("produit : %d" % (x * y)) # 15
• Le séparateur virgule (,) permet d'éviter de retourner à la ligne

Code source : les séquences
Une séquence est un conteneur ordonné d'éléments indicé par un
entier
En Python il existe trois types de séquences prédéfinis :
●
les chaînes (normales, brutes ou Unicodes)
●
les listes
●
les tuples

Code source : les chaînes de caractères
différentes notations
c1 = "L'information de la chaîne"
c2 = 'avec des "apostrophes" !!'
c3 = """Usage :
-h : aide
-q : quitter"""
r1 = r'une chaîne en mode raw'
u1 = u"une chaîne unicode"

Code source : les chaînes de caractères, les
opérations
La longueur d'une chaîne
c1 = "abcdef"
len(c1) # 6
• Concaténation de deux chaînes
c2 = "ghijkl"
c3 = c1 + c2 # abcdefghijkl
• La répétition de chaînes
c4 = "help! "
c5 = c4 * 3 # 'help ! help ! help ! '

Code source : les chaînes de caractères, les méthodes
1/3
Le découpage d'une chaîne :
c1 = "une ligne à découper"
c1.split(' ') # ['une', 'ligne', 'à', 'découper']
• la concaténation de deux chaînes :
'-'.join(['c'est', 'à', 'dire']) # "c'est-à-dire"
• la recherche de position dans une chaîne
'abracadabra'.find('bra') # 1 (premier indice à 0)
• le nombre d'occurence dans une chaîne
'abracadabra'.count('bra') # 2

2/3
Convertir en minuscule
"MINUSCULE".lower() # 'minuscule'
• Convertir en majuscules
'majuscule'.upper() # 'MAJUSCULE'
• La première lettre en majuscule
'bruno'.capitalize() # 'Bruno'
• Toutes les premières lettres en majuscule
'ceci est un titre'.title() # 'Ceci Est Un Titre'
• L'inversion de la casse
'fRANK'.swapcase() # 'Frank'

3/3
L'inversion de la casse
'fRANK'.swapcase() # 'Frank'
• La suppression de caractères en début et fin
" Trop d'espaces ".strip(' ') # "Trop d'espace"
• Le remplacement d'une chaîne par une autre
'abracadabra'.replace('a', 'o') # 'obrocodobro'

Code source : les chaînes de caractères, l'indiçage
La position dans une chaîne s'effectue en donnant entre crochet la position en
commençant à zéro
c1 = 'abcdefg'
c1[0] # 'a'
c1[3] # 'd'
c1[-1] # 'g' (si négatif on commence par la fin)
• On peut effectuer l'extraction d'une partie de la chaîne
c1[1:4] # 'bcd'
c1[3:] # 'defg'
c1[:3] # 'abc'
• Une chaîne de caractères n'est pas modifiable
a b c d e f g
0 1 2 3 4 5 6 7
c1 =

Code source : les chaînes de caractères, le formatage
Le formatage d'une chaîne ressemble au format du langage C
x = 25
"%d en base 10 : %d" % (x, x) # '25 en base 10 : 25'
"%d en base 8 : %o" % (x, x) # '25 en base 8 : 31'
"%d en base 16 : %x" % (x, x) # '25 en base 8 : 19'
pi = 3.141592655897931
print "%4.2f" % (pi) # 3.14
print "%.4e" % (pi) # 3.1415e+000
print "%g" % (pi) # 3.14159

Code source : les chaînes de caractères, les
principaux formats
%d : un entier signé
%u : un entier non-signé
%o : un octal (non-signé)
%x : un hexadécimal (non-signé)
%s : une chaîne de caractères
%f : un flottant
%e : un flottant, sous forme exponentiel
%g : un flottant, sous forme 'optimal' suivant sa longueur
Il est possible de contrôler l'affichage en spécifiant le nombre de
caractères désiré, "%3d" affiche un entier sous la forme de 3
caractères, "%03d" même chose mais en complétant devant par
des zéro, "%7.2f" un flottant sur 7 caractères avec 2 chiffres après
le point décimal.

Code source : les chaînes de caractères,
brutes et Unicode
En Python il existe d'autres méthodes pour coder des chaînes de
caractères :
Les chaîne brutes, ce sont des chaînes précédées de la lettre r ou
R, les caractères d'échappement comme ou n ne sont pas
interprétés.
Les chaînes en Unicode sont précédées de u ou U
Les chaînes en Unicode brut sont précédées de ur

Code source : les listes
Une liste est une collection hétérogène d'éléments ordonnés et
modifiables séparés par une virgule et entourée de crochets
couleurs = ['rouge', 'vert', 'bleu', 'jaune' ]
print couleurs # ['rouge', 'vert', 'bleu', 'jaune']
print couleurs[0] # 'rouge'
print couleurs[1] # 'vert'
couleur[1] = 7
print couleurs # ['rouge', 7, 'bleu', 'jaune'])
list1 = [1, 2, 5.0]
list2 = ['a', 'b', 'c']
list3 = [list1, list2] # une liste de liste
print list3 # [[1, 2, 5.0], ['a', 'b', 'c']]

Code source : les listes, méthodes et accès
L'indiçage d'une liste s'effectue de la même manière qu'une chaîne
de caractères
nombres = [5, 1, 9 ,30, 18]
nombres.sort() # [1, 5, 9 , 18, 30]
nombres.append(10) # [1, 5, 9 , 18, 30, 10]
nombres.reverse() # [10, 30, 18, 9, 5, 1]
nombres.index(18) # 2
nombres.remove(30) # [10, 18, 9, 5, 1]
nombres[1:3] # [18, 9]
nombres[:2] # [10, 18]
nombres[:] # [10, 18, 9, 5, 1]
nombres[-1] # 1

Code source : les listes, initialisation
chose = [] # une liste vide
trucMuch = [2]*4 # [2, 2, 2, 2]
range(5) # crée la liste [0, 1, 2, 3 , 4]
range(5,8) # crée la liste [5, 6, 7]
range(2, 11, 2) # crée la liste [2, 4, 6, 8, 10]
chose = range(7) # [0, 1, 2, 3 , 4, 5, 6]
print 3 in chose # True

Code source : les listes, le découpage "slicing"
bois = ['chêne', 'acacia', 'peuplier']
bois[2:2] = ['platane'] # insertion en 3iéme position
bois[4:4] = ['bouleau'] # insertion en 5iéme position
print bois # ['chêne', 'acacia', 'platane', 'peuplier', 'bouleau']
bois[2:4] = [] # effacement par liste vide
print bois # ['chêne', 'acacia', 'bouleau']
bois[1:3] = ['sapin']
print bois # ['chêne', 'sapin']
bois[1:] = ['châtaigné', 'pommier', 'poirier']
print bois # ['chêne', 'châtaigné', 'pommier', poirier']
Pour insérer ou supprimer des éléments, le membre de gauche doit
obligatoirement indiquer une tranche,
Le membre de droite doit aussi être une liste

Code source : les tuples
unTuple = ('chêne', 15, ["plaine", 1200])
Un tuple est une collection hétérogène d'éléments ordonnés et
immuable séparés par une virgule et entourée de parenthèses
• Un tuple s'utilise comme une liste, mais son parcours est plus
rapide
• Généralement on utilise le tuple pour définir des constantes
• Un tuple n'est pas modifiable

Code source : les dictionnaires
dico= {} # dictionnaire vide
dico['un'] = 'one'
dico['deux'] = 'two'
dico['trois'] = 'three'
print dico # {'un':'one', 'trois':'three', 'deux':'two'}
print dico['un'] # 'one'
del dico['un']
print dico # {'trois':'three', 'deux':'two'}
dico['quatre'] = 'four'
print dico # {'quatre': 'four', 'trois': 'three', 'deux': 'two'}
Un dictionnaire est un couple clef : valeur entouré d'accolades

Code source : les dictionnaires, les méthodes
dico.keys() # ['quatre', 'trois', 'deux']
dico.values() # ['four', 'three', 'two']
dico.iterkeys() # itérateur sur les clefs
dico.itervalues() # itérateur sur les valeurs associées
dico.iteritems() # itérateur clef, valeur
[('quatre','four'), ('trois','three'), ('deux','two')]
dico.has_key('un') # False
dico.has_key('quatre') # True
Les méthodes suivantes sont spécifiques aux dictionnaires :
• Les dictionnaires ne sont pas ordonnés
• On ne peut donc pas les indicer

Code source : les dictionnaires, les itérateurs
for key in dico.iterkeys() :
print key # 'quatre' 'trois' 'deux'
for value in dico.itervalues() :
print value # 'four' 'three' 'two'
for keyValue in dico.iteritems()
print keyValue # ('quatre','four'), ('trois','three'),
('deux','two')
Les itérateurs sont des objets spécifiques permettant de parcourir
un dictionnaire :

Code source : les ensembles
x = set ('abcd')
y = set('bdx')
Les ensembles sont gérés par la fonction set() :
'c' in x # True : appartenance
x – y # set(['a', 'c']) : différence
x | y # set(['a', 'c', 'b', 'd', 'x']) : union
x & y # set(['b', 'd']) : intersection
• Les opérations :

Code source : le problème des références 1/3
i = 1
message = "mon message"
L'opération d'affectation est plus complexe qu'il n'y parait
• L'affectation réalise en fait plusieurs opérations :
1.crée et mémorise un nom de variable dans l'espace de noms
courant (une adresse)
2.lui attribut dynamiquement un type bien déterminé
3.crée et mémorise une valeur (le membre de droite)
4.établi un lien entre le nom de la variable et l'adresse de la
valeur correspondante

a = [1, 2, 3]
b = a # une référence sur a
b.append(4)
print a # [1, 2, 3, 4]
Si un objet modifiable est affecté, tout changement sur un objet
modifiera l'autre
a
b
1, 2, 3
b.append(4)
a
b
1, 2, 3, 4

import copy
a = [1, 2, 3]
b = a # une référence sur a
b.append(4)
print a # [1, 2, 3, 4]
c = copy.copy(a) # une copie de l'objet a
c.append(5)
print a # [1, 2, 3, 4]
print b # [1, 2, 3, 4]
print c # [1, 2, 3, 4, 5]
Il faut utiliser le module copy pour obtenir une vraie copie d'un
objet

Les instructions de
branchement

Code source : if … [elif] … [else]
if x < 0:
print "x est négatif"
elif x % 2:
print "x est positif et pair"
else :
print "x n'est ni négatif ni pair"
# pour un booléen
if x: # 'if s is True' ou 'if x == True'
Contrôler une alternative

Code source : while … [else]
cpt = 0
while x > 0 :
x = x // 2 # division avec troncature
cpt += 1
print "l'approximation de log2(x) est %d" % (cpt)
n = input('Entrez un entier [1..10] : ')
while (n < 1) or (n > 10) :
n = input('Entrez un entier [1..10] S.V.P. : ')
Répéter du code

Code source : for… [else]
for c in 'Hello' :
print c, # H e l l o
for x in [1, 'H', 5.269] :
print x, # 1 H 5.269
for x in xrange(5) :
print x, # 0 1 2 3 4
Parcourir une séquence

Code source : Les listes compréhension 1/2
result = [x+1 for x in uneSequence]
# donne le même résultat que :
result = []
for x in uneSequence :
result.append(x+1)
Une liste compréhension est une expression permettant de générer
de manière très compacte une liste
Elle revient à une boucle for qui construirait la même liste en
utilisant la méthode append()
• Forme 1 :

Code source : Les listes compréhension 2/2
result = [x+y for x in uneSequence for y in uneAutre]
result = []
for y in uneAutre :
result.append(x+y)
result = [x+1 for x in uneSequence if x > 12]
result = []
if x > 12 :
result.append(x+1)
• Forme 2 :
• Forme 3 :

Code source : break
for x in xrange(1, 11) :
if x == 5 :
break
print x,
print "nBoucle for interrompue pour x = %d" % (x)
# affiche
# 1 2 3 4
# Boucle for interrompue pour x = 5
• Le break permet d'interrompre immédiatement le traitement
d'une boucle for ou d'un while

Code source : continue
for x in xrange(1, 11) :
if x == 5 :
continue
print x,
print "nLa boucle for a sauté la valeur 5"
# affiche
# 1 2 3 4 6 7 8 9 10
# Boucle for a sauté la valeur 5
• Le continue permet de reprendre immédiatement à la ligne de
l'en-tête d'une boucle for ou d'un while

Le traitement des exceptions
en Python

Code source : gestion des exceptions, try … except …
[else]
from math import sin
for x in xrange(-3, 4) :
try :
print '%.3f' % (sin(x)/x)
except :
print 1.0, # gère l'exception en 0
• Permet de traiter des erreurs levées par Python en cours
d'exécution

Code source : gestion des exceptions, try … finally …
f = open(unFichier, "r")
try :
traitementFichier(f)
finally:
f.close()
• Permet d'effectuer un traitement qu'il y ait eu ou non la levée
d'une exception.
• La clause finally met en place un gestionnaire de nettoyage
• Il ne peut y avoir qu'une clause finally et pas de clause else

Code source : gestion des exceptions, raise
if not 0 <= x <= 1 :
raise ValueError, "x n'est pas dans l'interval [0 .. 1]"
• L'instruction raise permet de lever volontairement une exception

Code source : fonctions, déclaration
def nomDeLaFontion(<paramétres>) :
<blocInstructions>
• Une fonction est un groupe d'instructions regroupé sous un nom et
s'exécutant à la demande
• le <blocInstruction> est obligatoire, s'il ne fait rien on doit utiliser
l'instruction pass
def carre(x) :
return x*x
print carre(4) # 16 : appel de la fonction carre

Code source : fonctions, passage des paramètres
def maFonction(x, y, z) :
pass
maFonction(3, 'e', 5.6) # x=3, y='e', z=5.6
• Chaque argument dans la définition d'une fonction correspond,
dans l'ordre, à un paramètre de l'appel

Code source : fonctions, paramètres par défaut
def maFonction(x, y, z=0.0) :
pass
maFonction(3, 'e', 5.6) # x=3, y='e', z=5.6
maFonction(3, 'e') # x=3, y='e', z=0.0
• Dans une fonction il est possible d'avoir des paramètres par
défaut
maFonction(3, y='e', z=5.6) # x=3, y='e', z=5.6
maFonction(3, y='e') # x=3, y='e', z=0.0
• Les appels peuvent se faire par paramètre nommé

Code source : fonctions, paramètres passage par
tuple
def somme(*args) :
resultat = 0
for x in args : resultat += x
return resultat
print somme(5) # 5
print somme(5, 10, 15) # 30
def somme(a, b, c ) :
return a+b+c
x = [5, 10, 15]
print somme(*x) # 30

Code source : fonctions, paramètres passage d'un
dictionnaire
def unDic(**kargs) :
return kargs
print unDic(a=5, b=58) # affiche : {'a':5, 'b':58}
nombres = {'un':1, 'deux':2, 'trois':3}
print unDic(**nombres) # affiche : {'un': 1, 'trois': 3, 'deux':
2}

Code source : La portée des objets
• Les noms des objets sont créés lors de leur première affectation.
• Leur portée dépend où ils sont déclarés
• On distingue la portée globale correspondant au module
__main__ qui maintient un dictionnaire des objets globaux, on
peut y accéder grâce à l'instruction globals() qui fournit les
couples variable : valeur.
• La portée locale, ce sont les objets internes aux fonctions et aux
classes. L'instruction locals() fournit le couples variable :
valeur.
• Les objets globaux ne sont pas modifiables dans les portées
locales
• La portée interne correspond aux noms prédéfinis de Python.
• La recherche s'effectue dans l'ordre suivant :
 Local (fonction) les noms définis dans le def d'une fonction
 Globale (module) les noms affectés à la base d'un module et les
noms déclarés global dans une fonction
 Interne (Python) les noms prédéfinis comme open, close, len
…

Code source : exemples de portées
# x et maFonc sont affectés dans le module : globaux
def maFonc(y): # y et z sont affectés dans maFonc : locaux
z = x + y
return z
x = 99
print maFonc(1) # affiche : 100
def maFonc(y): # x, y et z sont affectés dans maFonc: locaux
x = 5 # nouvel x local, masque le x global
z = x + y
return z
x = 99
def maFonc(y): # y et z sont affectés dans maFonc: locaux
global x # permet de modifier x
x += 5
z = x + y
return z
x = 99

Code source : Les modules
• Un module est un fichier indépendant qui permet de créer des
bibliothèques de fonctions ou de classes
• Le fait de créer des modules permet :
 La réutilisation du code
 la réalisation de services et de données partagés
 d'effectuer la partition de l'espace de noms
 la documentation et les tests peuvent être intégrés aux
modules.

Code source : Les modules, import
• Il existe deux méthodes pour effectuer l'importation d'un module
dans un programme
 import <nomDeModule> qui effectue l'importation de la totalité
des objets du module
import wx
 from <nomDeModule> import obj1, … qui effectue
l'importation des objets spécifiés du module
from math import pi, sin, cos

Code source : Fichier ou modules ?
• N'importe quel fichier python est considéré comme un module
• Un module peut être importé et lancé par lui même
if __main__ == '__main__' :
print "Ce programme est lancé par lui-même"
else :
print "Je suis importé par un autre module"

Code source : Manipulation des fichiers
• Le type fichier est connu du langage Python
• Par défaut les fichiers sont ouverts en mode texte
• Il faut préciser l'attribut 'b' pour traiter le fichier en mode binaire
f1 = open("monFichier", 'r') # ouverture en lecture
f2 = open("monFichier", 'w') # ouverture en écriture
f3 = open("monFichier", 'a') # ouverture en ajout
f4 = open("monFichier", 'br') # ouverture en lecture binaire
f1.close() # fermeture du fichier

Code source : Manipulation des fichiers, écriture
• Les méthodes d'écritures
f1 = open("monFichier", 'w')
s1 = 'foo'
f1.write(s1) # on écrit la chaîne s1 dans f1
l1 = ["x", "y", "z"]
f1.writlines(l1) # on écrit les chaînes de l1 dans f1
print >> f1, "ajout de la chaîne" # écrit dans f1 en mode ajout

Code source : Manipulation des fichiers, lecture
• Les méthodes de lecture
f1 = open("monFichier", 'r')
s = f1.read() # lit tous le fichier
s = f1.read(n) # lit au plus n octets
s = f1.readline() # lit la ligne suivante
s = f1.readlines() # lit toutes les lignes sous forme d'une liste
# lecture et affichage des lignes d'un fichier
for s in f1 :
print s

La programmation objet en
Python

la programmation Orientée Objet
(POO)
Python est non seulement un langage procédurale, mais aussi un
langage objet.
En fait, pour Python, tout est objet
En Python on défini un objet au travers du mot réservé class
Un objet class s'appel de la même manière qu'une fonction. L'objet
créé, appelé instance, sait à quelle classe il appartient
Une classe possède des attributs, des données et des fonctions, ces
dernières s'appellent des méthodes
Python définit des méthodes spéciales (internes) visible qvec la
fonction dir()
Une classe peut hériter d'une au plusieurs autres classes

la programmation OO :
class
En Python il existe une classe de base nommée object.
Toute classe créée, si elle n'hérite pas d'autres classes devrait au
moins hériter de la classe object.
On dit que object est l'ancêtre de tous les autres types.
Une classe est constituée d'un en-tête et d'un corps
La classe comporte un nom, la liste des classes dont elle hérite et
éventuellement d'une docstring associée
Le corps est obligatoirement indenté
class CMaClasse(object) :
'''Documentation de CMaClasse'''
INFO = (5,)
• CMaClasse est le nom de la classe, par convention une classe
débute par une majuscule, pour ma part je débute toujours mes
classes par un C majuscule.
• INFO est un attribut de la classe CMaClasse, il est local à
CMaClasse

instanciation
Pour créer un objet on appel le nom de sa classe
o1 = CMaClasse() # o1 est un objet de CMaClasse
print(dir(o1)) # affiche les attributs de l'objet o1
print(o1.INFO) # affiche (5,)
o1.INFO = 10 # modification de l'attribut d'instance !!!
print(CMaClasse.INFO) # affiche (5,), l'attribut de classe n'est pas changé
o1.x = 55 # création d'un nouvel attribut d'instance
o2 = CMaClasse() # o2 est un nouvel objet de CMaClasse
print(o2.INFO) # affiche (5,)
print(o2.x) # AttributeError: type object 'CMaClasse' has no attribute 'x'
print(o1) # <__main__.CMaClasse object at 0x025A3BF0>
print(o2) # <__main__.CMaClasse object at 0x025A35F0>

espace de noms
Les espaces de noms son implémentés par des dictionnaires pour
les modules, les classes et les instances
print CMaClasse.__dict__ # {'INFO': (5,), '__dict__': <attribute '__dict__' of
'CMaClasse' objects>, '__module__': '__main__', '__weakref__': <attribute '__wea
kref__' of 'CMaClasse' objects>, '__doc__': 'La documentation de CMaClasse'}
print dir(o2) # ['INFO', '__class__', '__delattr__', '__dict__', '__doc__',
'__format__', '__getattribute__', '__hash__', '__init__', '__module__',
'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__', '__weakref__']
• En premier on affiche le dictionnaire lié à la classe CMaClasse
• Puis les attributs liés à une instance de CMaClasse

Les méthodes
Une méthode se déclare comme une fonction dans le corps d'une
classe.
Elle dispose toujours d'un premier paramètre obligatoire qui
représente l'objet sur lequel la méthode sera appliquée.
Par convention ce premier paramètre s'appel self. Le nom est
arbitraire, vous pouvez lui en donner un autre
'''
Documentation de CmaClasse
'''
INFO = (5,)
x = 45
def affiche(self) : # déclaration de la méthode affiche
self.y = 12 # un nouvel attribut de l'instance
print(CMaClasse.x) # l'attribut de la classe
print(self.y)
o1 = CMaClasse()
o1.affiche() # 45 12 (affiche reçoit o1 comme valeur pour le paramètre self)

méthodes spéciales
Un certain nombre de méthodes ont des noms prédéfinis, elles sont
précédées et suivis de deux caractères de soulignement
Elles permettent :
●
d'initialiser un objet instancier
●
de modifier son affichage
●
de surcharger des opérateurs
●
…

la programmation OO : __init__
Cette méthode appelee «constructeur » de l’objet est appelée lors
de l'instanciation d'un objet, elle permet d'effectuer certaines
opérations d'initialisation nécessaires à l'objet :
def __init__(self, n) :
self.x = n # initialisation de l'attribut d'instance x
o1 = CMaClasse(10) # paramètre obligatoire affecté au paramètre n
print(o1.x) # 10

la programmation OO : __del__
Cette méthode appelee «destructeur» de l’objet est appelée lors
de la destruction ou de la liberation d'un objet en memoire, elle
permet d'effectuer certaines opérations de nettoyage :
def __del__(self) :
del self.x # libere le parametre x
o1 = CMaClasse(10) # paramètre obligatoire affecté au paramètre n
del o1

la programmation OO : surcharge
La surcharge permet à un opérateur de posséder un sens
différents suivant le type des opérandes.
Quand on effectue :
x = 1 + 3
s = "azerty" + "qwerty"
• on utilise la surcharge de l'opérateur + qui effectue une addition
entière pour le premier cas et une concaténation de chaîne de
caractères pour le deuxième cas
• Python dispose de méthodes de surcharges pour :
 tous les types (__call__, __str__, __cmp__, …)
 tous les nombres (__add__, __mul__, __div__, …)
 les séquences (__len__, __iter__, __delitem__…)

la programmation OO : Exemple de
surcharge
On veut gérer des vecteurs et effectuer de opérations.
class CVecteur(object) :
def __init__(self, x, y) :
self.x = x
self.y = y
def __add__(self, autre) : # addition vectorielle
return CVecteur(self.x + autre.x, self.y + autre.y)
def __str__(self) : # affichage d'un vecteur
return "vecteur(%f, %f)" % (self.x, self.y)
v1 = CVecteur(2.2, 3.3)
v2 = CVecteur(4.5, 5.8)
print v1 + v2 # affiche : vecteur(6.700000, 9.100000)

Héritage et polymorphisme
L'héritage est un mécanisme permettant de se servir d'une ou
plusieurs classes existantes pour créer une nouvelle classe. Cette
nouvelle classe disposant de fonctionnalités supplémentaires ou
différentes.
Le polymorphisme est la capacité pour une méthode portant le
même nom et appartenant à des classes différentes héritées
d'effectuer un travail différent. C'est ce que l'on appel la surcharge.

la programmation OO : problème d'héritage
1/3
Exemple, si A hérite de B et C, dans cet ordre, et que B et C
héritent de D.
La résolution classique recherche dans l'ordre A, B, D, C, D.
D est recherché avant C donc si une méthode de D est redéfinie
dans C elle ne sera jamais vue.
C'est l'héritage en diamant
A
C
B
D
A
C
B
D
object
Méthode classique Nouvelle Méthode

problème d'héritage 2/3
class D(object) :
def methode(self) :
print "D.methode"
class B(D) :
def methode(self) :
print "B.methode"
D.methode(self)
class C(D) :
def methode(self) :
print "C.methode"
D.methode(self)
class A(B, C) :
def methode(self) :
print "A.methode"
B.methode(self)
C.methode(self)
x = A()
x.methode()
# Affiche :
# A.methode
# B.methode
# D.methode
# C.methode
# D.methode

la programmation OO : problème d'héritage
3/3
class D(object) :
def methode(self) :
print "D.methode"
class B(D) :
def methode(self) :
print "B.methode"
super(B,self).methode()
class C(D) :
def methode(self) :
print "C.methode"
super(C,self).methode()
class A(B, C) :
def methode(self) :
print "A.methode"
super(A,self).methode()
x = A()
x.methode()
# Affiche :
# A.methode
# B.methode
# C.methode
# D.methode

objets privés 1/2
En python il n'existe pas la même notion qu'en C++ ou Java sur les
attributs privés, publiques, protégés
Les objets d'une classe qui commence par un simple sous-ligné
sont, par convention, des objets protégés, mais aucun contrôle
n'est effectué par le langage, ils sont en fait aussi publiques que
des objets sans sous-ligné.
Pour être privé, un objet doit commencé par deux sous-lignés, à
l'exception des objets qui commencent et se terminent par deux
sous-lignés
Ceci est valable aussi bien pour les attributs d'une classe que pour
les méthodes.

la programmation OO : objets privés 2/2
def __init__(self) : # méthode publique
self.x = None # objet (attribut) publique
self._y = "" # objet (attribut) protégé par convention
self.__z = 10 # objet (attribut) privé
def __uneMethode(self, a): # méthode privée
self.x = a # autorisé
self._y += "%s" %(a) # autorisé
self.__z += 2 # autorisé
def __str__(self):
return "CMaClasse x=%s, _y='%s', __z=%s" % (self.x,
self._y, self.__z)
o1 = CMaClasse()
o1.x = 4 # l'attribut x de l'instance prend la valeur 4
print o1 # CMaClasse x=4, _y='', __z=10
o1._y = "ma chaîne"
print o1 # CMaClasse x=4, _y='ma chaîne', __z=10
print o1.__z # AttributeError: 'CMaClasse' object has no
attribute '__z'
o1.__z = 15 # nouvel attribut __z de o1
print o1 # CMaClasse x=4, _y'=ma chaîne', __z=10
print o1.__z # 15
o1.__uneMethode(15) # AttributeError: 'CMaClasse' object has
no attribute '__uneMethode'

Les expressions rationnelles :
définition
Une expression rationnelle (ou expression régulière qui est un
terme impropre) est une chaîne représentant un motif recherché.
Python offre le module re pour manipuler les expressions
rationnelles.
Ici on effectuera un survol des possibilités des expressions
rationnelles, pour plus d'informations sur leur utilisations vous
pouvez vous référer au livre de Jeffrey Friedl (ed O'Reilly) Maîtrise
des expressions régulières.
Un motif doit respecter une syntaxe particulière
Les caractères alphabétiques et numériques correspondent à eux-
mêmes
Certains caractères de ponctuation ont une signification
particulière, ils sont désactivés s'ils sont précédés d'un anti-slash
()
Certains caractères alphabétiques ont une signification particulière
s'ils sont précédés d'un anti-slash ()
Le caractère anti-slash est représenté par deux anti-slashes ()

module re 1/2
En Python les expressions rationnelles sont traitées par le module
re
Pour faciliter l'écriture des expressions rationnelles on les déclare
dans des chaînes brutes r' ', r" " ou r""" """
Une expression rationnelle doit être compilée avant d'être utilisée ;
re.compile, cette fonction retourne un objet permettant de
manipuler l'expression rationnelle.
• soit r = re.compile(motif[, flags]) l'expression rationnelle compilée :
 r.findall(s[,pos[,endpos]]) : renvoie une liste de chaînes
représentant chacune des sous chaînes de s, r ne doit pas contenir de
groupe
 r.match(s[,pos[,endpos]]) : renvoie un objet correspondance si une
sous-chaîne de s correspond au motif
 r.search(s[,pos[,endpos]]) : renvoie un objet correspondance pour
la sous-chaîne la plus à gauche de s
 r.split(s[,maxsplit]) : renvoie une liste des division de s par r
 r.sub(repl,s[,count]) : renvoie une copie de s où les
correspondances avec r sont remplacées par repl
 r.subn(repl,s[,count]) :renvoie une paire (nouvelleChaîne,n)

module re 2/2
L'objet de correspondance (c) retourné par match, search disposent des
attributs :
c.pos : l'indice de s de début de la recherche
c.endpos : l'indice de s de la fin de la recherche
c.lastgroup : le nom du dernier groupe de correspondance
c.lastindex : l'indice du dernier groupe qui a correspondu
c.re : l'expression rationnelle r utilisée
c.string : la chaîne s passée
c.start (groupid=0),
c.end (groupid=0),
c.span (groupid=0) : méthodes retournant les indices des bornes dans
c.string de la sous-chaîne capturée par groupid, si c.string[i:j],
c.start retourne i, c.end retourne j et c.span retourne (i,j)
c.expand(template) : équivalent à sub()
c.group([groupid[,*groupids]]) : renvoie la sous-chaîne capturée par
groupid, ou un tuple si plusieurs groupes
c.groups([default=None]) : renvoie un tuple de sous-chaînes des
différents groupes. None au contenu de default si le groupe n'a pas
participé à la reconnaissance.
c.groupdict ([default=None]) : renvoie un dictionnaire des groupes
nommés (la clef) de sous-chaînes trouvées.

exemples
import re
r = re.compile(r'(w+) (w+)')
s = "Bruno Normand, consultant"
m = r.match(s)
m.group() # 'Bruno Normand'
m.group(1) # 'Bruno'
m.group(2) # 'Normand'
m.group(1,2) # ('Bruno', 'Normand')
r = re.compile(r'(?P<firstName>w+) (?P<lastName>w+)')
m = r.match(s)
m.group('firstName') # 'Bruno'
m.group('lastName') # 'Normand'
email = "tony@tiremove_thisger.net"
m = re.search("remove_this", email)
email[:m.start()] + email[m.end():] # tony@tiger.net

Programme externe : module
subprocess
Lancer un programme externe s'effectue avec Popen du module
subprocess.
from subprocess import Popen, PIPE
cmd = ["diff", repNew, repOld]
fd = open(TMP_FILE, "w")
pipe = Popen(cmd, stdout=fd, stderr=PIPE, universal_newlines=True)
print pipe.communicate()[1] # récupérer la sortie de stderr
fd.close()

Programme externe : module wx
Lancer un programme externe dans un GUI est très simple en
utilisant les interfaces fournis par wx.
import wx
import time
...
class CPanelShell(wx.Panel):
...
def startShell(self):
if self.__process is not None :
self.__process = wx.Process(self)
self.__shellPid = wx.execute("/bin/bash", wx.EXEC_ASYNC, self.__process)
time.sleep(0.001)
def execCommande(self, cmd):
self.__process.GetOutputStream().write(str(cmd) + 'n')
def __inIdle(self, evt):
stream = self.__process.GetInputStream()
if stream.CanRead() :
self.__appendMessage(stream.read())
stream = self.__process.GetErrorStream()
if stream.CanRead() :
self.__appendMessage(stream.read())
def __del__(self):
self.__process.Detach()
self.__process.CloseOutput()
self.__process = None

Les threads 1/2
Python offre la possibilité de gérer des thread au travers du module
thread
Un thread est en fait une fonction qui s'exécute "en parallèle" de
votre programme principal.
On se défini une fonction ou une méthode d'une classe qui sera
exécutée par le thread en utilisant la fonction suivante
thread.start_new_thread(fonction,(p1,…))
Vous pouvez aussi utiliser le module threading qui est une
surcouche au module thread et offrant des fonctionnalités
permettant de créer des threads timer, lancer un thread, gérer des
sémaphores, des locks …
Pour lancer un thread on doit le créer avec la classe Thread :
Thread(groupe=None, target=None, name=None, args=(), kwargs=None,
verbose=None)
import threading
def maFonction(p1,…) :
...
monThread = threading.Thread(target=maFonction, args=(p1,...)) #
création du thread
monThread.start() # lancement du thread
monThread.join() # attendre la fin du thread

Les threads 2/2
Un thread s'exécute "en parallèle" cela implique non seulement
qu'on doit lui laisser du temps pour qu'il s'exécute, mais qu'il doit
aussi laisser du temps aux autres threads et au programme
principal pour qu'ils s'exécutent.
import threading
import time
def threadTest():
global i
while not stop:
i = i**2+1
print i
time.sleep(0.01)
stop = False
i = 0
thread=threading.Thread(target=threadTest)
thread.start()
stop = True
thread.join()
print i

Les interfaces utilisateurs
graphiques (GUI)

GUI
Par défaut lors de l'installation de Python un GUI est installé :
Tkinter, et Tix (22,41%)
Tix ajoute la gestion des Combobox, Notebook, Metter, Balloon
Auxquels on peut rajouter Pmw, car l'interface Tkinter est faible.
Il existe d'autres GUI :
wxPython (33.33%): interface de wx, écrit en C++, avec Python
(celui que j'utilise) http://wxpython.org/download.php
pyGtk (14.94%): interface de GTK, écrit en C, avec Python
http://www.pygtk.org/downloads.html
pyQt (14,94%): interface de QT, écrit en C++, avec Python
http://www.riverbankcomputing.co.uk/software/pyqt/download
Les autres interfaces sont plus l'utilisation de Python dans d'autres
langages
PythonForDelphi (1,72%)interface avec Delphi
Jython interface avec Java
IronPython interface avec .Net
Les pourcentages sont ceux du site Developpez.com sur l'utilisation des GUI en Python

RAD
BoaConstructor (wxPython)
http://boa-constructor.sourceforge.net/Download.html
PythonCard (wxPython)
http://sourceforge.net/projects/pythoncard/files/
Visualwx (wxPython) wxGlade (wxPython)
http://wxglade.sourceforge.net/
WxDesigner (wxPython) payant
http://www.wxdesigner-software.de/download.html
GuiBuilder (Tkinter) http://sourceforge.net/projects/spectcl/files/
nécessite Pmw http://sourceforge.net/projects/pmw/files/

IDE
PyScripter éditeur/débogueur version 32/64bits
PyDev plugin pour Eclipse
IDLE éditeur fourni avec Python
SciTE éditeur
Komodo Edit éditeur écrit en Java
Leo éditeur écrit en Python et Tkinter
SPE éditeur puissant écrit en Python et wxPython par le
développeur de Blender animation graphique 2D/3D

règles d'écritures : Forme du
code
Indentation : Utilisez 4 espaces pour l’indentation
Tabulation : Préférez les espaces. Espaces/Tabulation ne pas les
mélanger dans un même projet
Limitez vos lignes à 80 caractères
Quand c’est possible découpez vos lignes après un séparateur
plutôt que l’antislash
1 appel_d_une_fonction(parametre_1, parametre_2,
2 parametre_3, parametre_4):
3 ...
1 # oui
2 un_long_calcul = variable +
3 taux * 100
4
5 # non
6 un_long_calcul = variable
7 + taux * 100

règles d'écritures : Forme du
code
La définition d'une classe commence par une majuscule
(personnellement je la précède de la lettre C en majuscule).
Les méthodes et fonctions commencent par une minuscule et la
première lettre de chaque mot commence par une majuscule.
Dans les classes cachez les méthodes et les objets que vous ne
voulez pas exporter en les précédents d'un double souligné.
Dans les classes pensez à définir la méthode __str__ qui retourne
une image des objets de la classe, utile quand on effectue un print
d'un objet qui par défaut affiche instance de la classe Cx à
l'adresse yyyyy

règles d'écritures :
documentation
Les modules doivent disposer d'une entête et d'une docstring
associée.
Pour chaque fonction, classe et méthode utilisez les docstring pour
donner des explications sur le rôle des ces différents éléments.
Pour chaque fonction et méthode de classe formater la docstring
pour qu'elle soit interprétable par epydoc, ceci vous permettra de
générer la documentation de vos projets de manière simple (voir
exemple page suivante)

règles d'écritures : exemple
# -*- coding: ISO-8859-15 -*-
#-------------------------------------------------------------------------------
# Name: AnalAda.py
# Author: Bruno NORMAND
# RCS-ID: $Id$
# Copyright: (c) 2011 Bruno NORMAND
# Licence: GPL
#-------------------------------------------------------------------------------
'''Ce module se charge d'effectuer l'analyse de fichiers ADA pour en déterminer les fonctions et
procédures contenues dans les paquetages.'''
class CAdaCapture():
'''Cette classe se charge de mémoriser les informations capturées'''
def __init__(self, typeAda, index, rule, ignoreCase=False):
'''Cette méthode initialise les objets de la classe.
@param typeAda: Le nom du type donné
@type typeAda: I{B{unicode}}
@param index: Le numéro de la ligne dans le fichier où a été trouvée la
correspondance
@type index: I{B{int}}
@param rule: L'objet retourné de la recherche
@type rule: I{B{_sre.SRE_Pattern}}
@param ignoreCase: Indicateur à I{B{True}} si l'on ignore la case lors
des comparaisons.
@type ignoreCase: I{B{bool}}'''
...

PEP 20 The Zen of Python
tgayet@tgayet-Latitude-5420:~$ python
Python 2.7.18 (default, Mar 8 2021, 13:02:45)
[GCC 9.3.0] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
>>> import antigravity
>>> Opening in existing browser session.

découverte du langage python dans tous ses aspects

Recommandé

Recommandé

Contenu connexe

Similaire à découverte du langage python dans tous ses aspects

Similaire à découverte du langage python dans tous ses aspects (20)

découverte du langage python dans tous ses aspects