transparents - Fabrice Maurel

La Programmation Orientée Objet
(POO ou P2O)
Python : approfondissement
Licence 2 – premier semestre
Fabrice Maurel
[email protected]
Bat. Science 3 – Bureau 364 – 02 31 56 73 98
Le comment
Cours : 13 séances de 1h
●
TD : 9 séances de 1,5h
●
TP : 9 séances de 1,5h
●
1ers TD et TP en semaine 2 (semaine du 15 octobre)
●
Évaluation :
Devoir maison
– Examen sur machine
– Examen écrit
–
Le où
●
Ma page :
–
●
La page de Jerzy Kaczmarczuk :
–
●
http://users.info.unicaen.fr/~karczma/matrs/PyObj/
La documentation officielle (intégrée dans idle) :
–
●
http://users.info.unicaen.fr/~fmaurel/html/l1-2-pro/l2.html
http://www.python.org/doc/
D'autres ressources sont directement sur ma
page
Chapitre 0
RAPPELS DE PYTHON
Présentation Python
●
Portable (Unix, MacOs, Windows...)
●
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)
●
Système d'exception pour la gestion des erreurs
●
Dynamiquement typé
●
Interprété
●
Extensible
●
Bibliothèque standard complète
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 : ==, !=, >, <, >=, <=
Entrées / sorties : print (expression suivie de ,
pour ne pas sauter de ligne) / input ou raw_input
Limite des instructions et des blocs définie par la
mise en page (ne pas mélanger tabulation et
caractère d'espacement !) :
Ligne d'entête :
première instruction
................................
dernière instruction
Ligne d'entête : une seule instruction
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
Les fonctions
def nomDeLaFonction(p1=v1,p2=v2,...):
"description de la fonction"
instructions
return val (optionnel !)
Attention : passage automatiquement par valeur pour les entiers,
les flottants et les séquences non mutables mais
automatiquement par référence pour les séquences mutables.
●
Nombre de variable arbitraire : def f(*args)
●
Corps d'un programme python :
if __name__ == "__main__":
nomDeLaFonction(p2=v3,p1=v4)
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 : chaîne1+chaîne2
–
Opérateur d'appartenance : in chaîne
–
Divers sur les chaînes de caractères
●
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:]
●
Quelques fonctions intégrées : len, float, int
●
opérateur de formatage : %
●
Caractères spéciaux : \n, \t, \b ...
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
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"
Exemple
le typage, les exceptions, les entrées/sorties,la
boucle while
C1ex01.py - maFonction1()
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 : +
Constructeur de liste : l=range(deb,fin,pas)
Les tuples (non mutables):
●
●
●
Tuple
t=(1,2,3,"chaine",[1,4],3.14,4,5)
Opérateur de concaténation : +
Divers sur 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)
●
Si l1=[1,2,3], l2=l1 ne produit pas une copie de l1 !!!
●
Création d'une copie de l1 : l2=l1[:]
●
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.
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 :
–
[fonction for élément in sequence if booléen]
Exemple
le for, les listes et le passage par référence
C1ex01.py - maFonction2()
Principaux types de données (3)
●
Les dictionnaires (mutables, non
ordonnés) :
Dict
– d={c1:v1,c2:v2,c3:v3}
– Non ordonné ==> la saisie n'implique pas un
ordre des paires clé/valeur
–
Divers sur les dictionnaires
●
Fonctions intégrés : del, len
●
Accès/modification : dico[clé]=valeur
●
●
Parcours possible avec le for clé in dico mais
aucune prévision possible de l'ordre de
traitement des clés.
Fonctions : keys(),values(),get(clé,defaut)...
Exemple
dictionnaire, module, nombre variable
d'arguments
C1ex01.py - maFonction3()
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()
Exemple
fichiers, création de listes et introduction à
l'opérateur '.'
C1ex01.py - maFonction4()