python rapide - Fabrice Maurel

Présentation cours
●
18 h CM (F. Maurel) + 16 h TD/TP (F. Maurel / T. Roy)
– 5/6 h Python
– 2,5/2 h Introduction à l'IHM (démarche participative
centrée utilisateur) + Mise en place des groupes
– 2,5/2 h : Méthodes de conception / Brainstorming
– 2,5/2 h : Maquettage
– 5,5/4 h : Prototypage python
fabrice.maurel@info.unicaen.fr
thibault.roy@info.unicaen.fr
http://www.info.unicaen.fr/~fmaurel

Présentation Python (1)
●
●
●
●
●
●
●
●
Portable (Unix, MacOs, Windows...), Jpython (bytecode
Java)
Gratuit et utilisable dans les projets commerciaux
Syntaxe très simple et types de données évoluées (3 à
5 fois plus court que C ou C++)
Gestion automatisée de la mémoire (mécanisme de
comptage de références)
Pas de pointeurs explicites
Optionnellement multi-threadé
Orienté objet avec héritage multiple et surcharge des
opérateurs
Système d'exception pour la gestion des erreurs

Présentation Python (2)
●
●
●
●
●
●
●
Dynamique, orthogonal, réflectif et
introspectif
Dynamiquement typé
Deux implémentations : interprété, compilateur
générant du bytecode java
Extensible
Bibliothèque standard complète
Évolution continue
Bon choix pour le traitement de XML

Premier pas (1)
●
Typage dynamique
– Séparateur décimal : .
– Division Euclidienne ou décimale : /
– Modulo : %
– Puissance : **
– Type (objet) : retourne le type de l'objet
●
Affectation
– Simple : var = val
– Multiple : var1 = var2 = var3 = val
– Parallèle : var1,var2,var3 = val1,val2,val3
– Combinée : +=, *=, /=, -=

Premier pas (2)
● Comparaison : ==, !=, >, =,

Premier pas (3)
● Commentaires : #...................
●
Extension conseillée pour un fichier python : .py
● -*- coding:Latin-1 -*- ou -*- coding:Utf-8 -*-
● Importation de modules (math, random, ...) :
– import module (==> module.nomFonction)
– from module import nomFonction
– from module import *
● Éditeurs conseillés sous Linux :
– Idle + F5
– Emacs + python nomprogramme

Principaux types de données (1)
● Données numériques (mutables) :
– Integer
– Long (nombre de chiffre significatif quelconque
limité uniquement par la taille de la mémoire
disponible sur l'ordinateur utilisé)
– Float (3.14, 10., .001, 1e100, 3.14e-10)
● Données alphanumériques (non mutables) :
– String
– s="chaine" ou s='chaine'
– Opérateur de concaténation : +
– Opérateur d'appartenance : in

Principaux types de données (2)
●
Les autres séquences
– Les listes (mutables) :
● List
● l=[1,2,3,"chaine",[1,4],3.14,4,5]
● Opérateur de concaténation : +
● fonctions : l=range(deb,fin,pas), len(l)
– Les tuples (non mutables):
● Tuple
● t=(1,2,3,"chaine",[1,4],3.14,4,5)
● Opérateur de concaténation : +
– Les dictionnaires (mutables, non ordonnés) :
●
●
Dict
d={c1:v1,c2:v2,c3:v3}

Structures de contrôle (1)
● Conditionnelle :
if condition :
instructions
elif condition :
instructions
else :
instructions
● L'instruction while :
●
while condition:
instructions
Instruction de sortie forcée d'une boucle : break

Structures de contrôle (2)
●
L'instruction for élément in séquence
– L'itération traite successivement tous les éléments
d'une séquence donnée (caractères d'une chaîne,
éléments d'une liste, clés d'un dictionnaire)
– for car in "chaîne":print car,
– for elem in [1,2,3]:print elem,
– for cle in {1:"a",2:"b",3:"c"}:print cle,
– for i in range(len(l)) (==> parcours des index de l)
● Création originale de liste :
– [c+c for c in "chaine" if c

●
●
●
●
●
●
●
●
Les chaînes
Concaténation : "a"+"b"
Répétition : "a"*4
Indexage de ch : de 0 à len(ch)-1
Accès à 1 élément de ch : ch[index]
Extraction d'un slice : ch[n:m],ch[:m],ch[n:]
Création d'une copie de ch : ch[:]
Non modifiable et comparable
Quelques fonctions intégrées : len, float, int
● opérateur de formatage : %
● Caractères spéciaux : \n, \t, \b ...

Les listes / les tuples
●
●
●
●
Concaténation, répétition, indiçage, accès et
slicing identique au chaîne.
Les listes sont modifiables (potentiellement par
slicing avancé : insertion, suppression,
remplacement de tranches)
Fonctions intégrées : len, del
Les tuples ont les mêmes propriétés que les
listes à l'exception de celles qui peuvent
provoquer une modification.

Les dictionnaires
●
●
●
●
Non ordonné ==> la saisie n'implique pas un
ordre des paires clé/valeur
Fonctions intégrés : del, len
Accès/modification : dico[clé]=valeur
Parcours avec le for clé in dico mais aucune
prévision possible de l'ordre de traitement des
clés.

Les fonctions originales
def nomDeLaFonction(p1=v1,p2=v2,...):
"description de la fonction"
instructions
return val (optionnel !)
Attention : passage automatiquement par valeur pour les entiers
et les flottants mais automatiquement par référence pour les
listes et les dictionnaires !
●
Nombre de variable arbitraire : def f(*args)
● Corps d'un programme python :
if __name__ == "__main__":
nomDeLaFonction(p2=v3,p1=v4)

Gestion des erreurs
● Mécanisme de traitement des exceptions :
try:
instruction1 sous réserve
except:
instructions2 si erreur pendant instruction1
else:
instructions3 si pas d'erreur pendant instruction1
● Lever une exception :
raise nomException, "message optionnel"

Gestion des fichiers
● Choix du répertoire courant :
from os import chdir
chdir("chemin relatif ou absolu")
● Ouverture d'un fichier en lecture ou en écriture :
f=open(nomFichier,'a' ou 'r')
●
●
●
●
●
Fermeture d'un fichier : f.close()
Écriture dans un fichier : f.write("chaine")
Lecture dans un fichier : t=f.read(nbCar)
Lecture ligne à ligne : t=f.readline()
Lecture des lignes restantes : t=f.readlines()

Les méthodes
●
●
●
●
Toutes les données sont en fait des objets et
ont comme les fichiers un certain nombre de
méthodes définies.
dir(objet) : liste des méthodes de l'objet
help(méthode) : l'aide sur la méthode
String : split, join, find, count, lower, append...
● List : sort, append, reverse, index, remove, ...
● Dict :keys, values, has_key, items, copy, get, ...

Les classes
Class NomDeClasse(object):
"description de la classe"
def __init__(self, arg1,arg2):
"description"
self.attribut1=arg1
self.attribut2=arg2
if __name__ == "__main__":
arg1,arg2=val1,val2
c=NomDeClasse(arg1,arg2)

Héritage
●
Héritage simple
Class NomDeClasse(superClasse):
...
●
Héritage multiple
Class NomDeClasse(superClasse1,superClasse2):
...
●
Variables brouillées : __var ou __var_

La surcharge des opérateurs
●
Surcharge des méthodes comme (a chercher
avec la fonction dir) :
– __repr__
– __str__
– __getitem__
– __setitem__
– __add__
– __mul__
– __div__
– __sub__