Programmation Python

DSC551
 {"List of Chapters":"Liste des chapitres"}
Chapitre 1: Choses très basiques
Chapitre 2 : Conditionnels
Chapitre 3 : Fonctions
Chapitre 4 : Itération
Chapitre 5 : Chaînes
Chapitre 6 : Types de données de collection
Chapitre 7 : Fonctions avancées
Chapitre 8 : Gestion des exceptions
Chapitre 9 : Modules Python
Chapitre 10 : Fichiers
Chapitre 11 : Documentation
Chapitre 12 : Classes
Chapitre 13 : Programmation CGI
 Avertissements

Cette note a été écrite par C. D. Sherrill, janvier

2010

Édité par Mohd Razif Bin Shamsuddin

 Ressources
Ces notes sont basées sur des informations provenant de plusieurs
sources:
Apprendre Pythonndédition, Mark Lutz et David Ascher
(O'Reilly, Sebastopol, CA, 2004) (Complet. Difficile à obtenir
sous forme de lecture rapide)

“Dive Into Python,”Mark Pilgrim ([Link]

2004)
Comment penser comme un informaticien : Apprendre avec
Python,"2ndédition, Jeffrey Elkner, Allen B. Downey, et
Chris Meyers ([Link]
Programmation en Python 3 : Une introduction complète à la
Langue Python, Mark Summerfeld (Addison-Wesley,
Boston, 2009
[Link]
 Pourquoi Python ?

Langage de haut niveau, peut faire beaucoup avec relativement

petit code
Supposément plus facile à apprendre que son principal
competitor, Perl
Assez populaire parmi les langages de haut niveau
Soutien solide pour la programmation orientée objet
Support pour l'intégration avec d'autres langues
 Chapter 1: Very Basic Stuff
Exécution de programmes Python

Variables
Impression
Opérateurs
Entrée
Comments
Portée
 Choses très basiques
Vous pouvez exécuter des programmes python à partir de fichiers, tout comme
perl ou scripts shell, en tapant "python
"[Link]" à la ligne de commande. Le fichier peut
contient juste les commandes python.
Ou, on peut invoquer le programme directement par
taper le nom du fichier, "[Link]", si cela
a comme première ligne quelque chose comme
#!/usr/bin/python (comme un script shell... fonctionne comme
tant que le fichier a les autorisations d'exécution définies

Alternativement, vous pouvez entrer dans un shell python et

exécutez des commandes python de manière interactive, en tapant
python
 Bonjour, le monde !

Commençons ! Voici un exemple de Python

le programme fonctionne en tant que script :

#!/usr/bin/python

print "Bonjour, le monde"

Si cela est sauvegardé dans un fichier [Link], alors définissez l'exécution

permissions sur ce fichier (chmod u+x [Link] dans
Unix/Linux), et exécutez-le avec "./[Link]"
Lorsqu'il est exécuté, ce programme imprime

Bonjour, le monde
 Plus d'informations sur l'impression

>>> print 'bonjour:', x, x**2, x**3

hello: 4 16 64
\t est un caractère de tabulation
>>> print "2**2 =", ",2**2
2**2 = 4
Terminer une instruction d'impression par une virgule
supprime la nouvelle ligne, donc le prochain affichage
La déclaration continue sur la même ligne
Peut imprimer dans un fichier ouvert (plus tard) comme ça :
imprimer >> outfile, message
 Autres choses amusantes

Exemple [Link]
#!/usr/bin/perl
imprimer 1+3
pi = 3.1415926
imprimer pi
message = "Hello, world"
imprimer le message

Output:
4
3.1415926
Bonjour, le monde
 Types de variables
Dans l'exemple précédent, « pi » et « message » sont des variables.
mais l'un est un nombre à virgule flottante, et l'autre est une chaîne.
Remarquez que nous n'avons pas déclaré les types dans notre exemple. Python
a cependant décidé des types pour les variables.
En réalité, les "variables" en python sont en fait des références d'objet.
La raison pour laquelle nous n'avons pas besoin de déclarer les types est qu'un
reference might point to a different type later.

[Link] :
x=42
y=”hello”
imprimer x,y # imprime 42 bonjour
print x,y # imprime 42 42
 Types de variables
Exemple [Link] :
pi = 3.1415926
message = "Hello, world"
i=2+2

imprimer type(pi)
imprimer le type(message)
imprimer le type(i)

Output:
<type 'float'>
<type 'str'>
<type 'int'>
 Noms de variables

Peut contenir des lettres, des chiffres et des underscores

Doit commencer par une lettre

Ne peut pas être un des mots réservés de Python
keywords: and, as, assert, break, class,
continue, def, del, elif, else, except, exec, finally,
for, from, global, if, import, in, is, lambda, not, or,
pass, print, raise, return, try, while, with, yield
 Plus sur les noms de variables

Les noms commençant par un underscore (_V) sont

non importé du module import *
déclaration
Noms commençant et se terminant par 2 underscores
sont des noms spéciaux définis par le système (par exemple,
__V__)
Les noms commençant par 2 underscores (mais
sans les traits de soulignement finaux) sont locaux à une classe
(__V)
Un seul soulignement (_) par lui-même dénote le
résultat de la dernière expression
 Opérateurs
+ addition
soustraction
/ division
exponentiation
% modulus (reste après division)
Opérateurs de comparaison dans le Chapitre 2
 Opérateurs
Exemple [Link]
imprime 2*2
imprimer 2**3
imprimer 10%3
imprimer 1.0/2.0
imprimer 1/2

Output:
4
8
1
0,5
0
Notez la différence entre la division en virgule flottante et
division entière dans les deux dernières lignes
 += mais pas ++
Python a incorporé des opérateurs comme +=, mais
++ (ou --) ne fonctionnent pas en Python
 Conversion de type
int(), float(), str(), et
bool() se convertit en
entier, flottant
chaîne, et booléen
(Vrai ou Faux) types
respectivement
Exemple [Link] : Output:
imprimer 1.0/2.0 0,5
imprimer 1/2 0
imprimer float(1)/float(2) 0,5
imprimer int(3.1415926) 3
imprimer str(3.1415926) 3.1415926
imprimer bool(1) Vrai
print bool(0) Faux
 Opérateurs agissant sur des chaînes

Ni!Ni!Ni!
Ni!Ni!Ni!
bonjour monde!
bonjour le monde!
 Entrée au clavier
Exemple [Link]
i = input("Entrez une expression mathématique : ")
imprimer i
j = input("Entrez la même expression : ")
imprimer j

Output:
localhost(atelier)% ./[Link]
Entrez une expression mathématique : 3+2
3+2
Entrez la même expression : 3+2
5
 Commentaires
Tout ce qui se trouve après un symbole # est traité comme un
comment
C'est comme Perl
 Chapitre 2 : Conditionnels
True and False booleans
Opérateurs de comparaison et logiques
si, elif, et sinon
 Booleans: True and False
>>> type (Vrai)
<type 'bool'>
>>> type (vrai)
Traceback (dernier appel le plus récent):
Fichier "<stdin>", ligne 1, dans <module>
NameError: le nom 'true' n'est pas défini
>>> 2+2==5
Faux
Remarque : Vrai et Faux sont de type bool.
la capitalisation est requise pour les booléens !
 Expressions booléennes
Une expression booléenne peut être évaluée comme Vraie
ou Faux. Une expression évalue à Faux si cela
est...
le constant Faux, l'objet Aucun, un vide
séquence ou collection, ou un élément numérique de
value 0
Tout le reste est considéré comme vrai
 Opérateurs de comparaison

== : est égal à?
!= : différent de
> : plus grand que
< : moins que
>= : supérieur ou égal à
≤ : moins que ou égal à
est : deux références font-elles référence au même objet ?
(Voir le chapitre 6)
 Plus sur les comparaisons

Peut-on faire des comparaisons en « chaîne » :

>>> a = 42
0 <= a <= 99
Vrai
 Opérateurs logiques
and, or, not

>>> 2+2==5 ou 1+1==2

Vrai
>>> 2+2==5 et 1+1==2
Faux
non(2+2==5) et 1+1==2
Vrai
Remarque : Nous n'utilisons PAS &&, ||, !, comme en C !
 Si les déclarations

Exemple [Link]
si (1+1==2) :
print ("1+1==2")
Je l'ai toujours pensé !
sinon :
Ma compréhension des mathématiques doit être défaillante !

Instruction simple en une ligne :

si (1+1==2): imprimer ("Je peux additionner!")
 instruction elif
Équivalent de "sinon si" en C
Exemple [Link] :
x=3
si (x == 1):
un
elif (x == 2):
imprimer ("deux")
sinon :
beaucoup
 Chapitre 3 : Fonctions
Définir des fonctions
Valeurs de retour
Variables locales
Fonctions intégrées
Fonctions des fonctions
Passer des listes, des dictionnaires et des mots-clés à
fonctions
 Fonctions
Définissez-les dans le fichier au-dessus du point où ils sont
utilisé
Le corps de la fonction doit être indenté
de manière cohérente (4 espaces est typique en Python)
exemple : [Link]
def carré(n):
retourner n*n

print "The square of 3 is ",

imprimer le carré(3)

Output:
Le carré de 3 est 9
 L'instruction def
L'instruction def est exécutée (c'est pourquoi
les fonctions doivent être définies avant d'être
utilisé)
définit un objet et lui attribue un nom à
référez-vous à cela; la fonction pourrait être assignée
un autre nom, les noms des fonctions peuvent être stockés dans
une liste, etc.
Peut-on mettre une déclaration de fonction à l'intérieur d'une instruction if,
etc !
 Plus sur les fonctions
Les arguments sont facultatifs. Plusieurs arguments sont
séparés par des virgules.
S'il n'y a pas de déclaration de retour, alors "None" est
retourné. Les valeurs de retour peuvent être des types simples ou
les tuples. Les valeurs de retour peuvent être ignorées par le
appellant.
Les fonctions sont « sans type ». Peut être appelé avec
arguments de tout type, tant que le
les opérations dans la fonction peuvent être appliquées au
arguments. Cela est considéré comme une bonne chose dans
Python.
 Les variables de fonction sont locales
Les variables déclarées dans une fonction n'existent pas en dehors
cette fonction
Exemple [Link]
def carré(n):
m = n*n
retourner m

Le carré de 3 est
imprimer le carré(3)
imprimer m

Output:
Fichier "./[Link]", ligne 9, dans <module>
imprimer m
NameError: name 'm' is not defined
 Portée
Les variables assignées dans une fonction sont locales à celle-ci.
appel de fonction
Les variables assignées en haut d'un module sont globales à
ce module ; il n'y a que "global" dans un module
Dans une fonction, Python essaiera de faire correspondre une variable
nom à un assigné localement dans la fonction ; si cela
échoue, il essaiera dans la définition de fonction englobante (def)
déclarations (si approprié) ; si cela échoue, il essaiera de
résoudre le nom dans le scope global (mais la variable
doit être déclaré global pour que la fonction puisse
le changer). Si aucun de ceux-ci ne correspond, Python va chercher
à travers la liste des noms intégrés
 Exemple de portée

[Link]

a = 5 # global

def func(b):
c=a+b
retourner c

imprimer func(4) # donne 4+5=9

imprimer c # non défini
 Exemple de portée

[Link]

a = 5 # mondial

déf func(b):
c global
c=a+b
retourner c

imprimer func(4) 4+5=9

imprimer c maintenant c'est défini (9)
 Par valeur / par référence

Tout en Python est une référence. Cependant,

notez également que les objets immuables ne sont pas
modifiable --- donc changements vers les objets immuables
dans une fonction, change seulement quel objet le
le nom indique (et n'affecte pas l'appelant,
à moins que ce ne soit une variable globale)

Pour les objets immuables (par exemple, les entiers, les chaînes de caractères,
dans le cas des tuples), Python se comporte comme un passage par valeur de C

Pour les objets mutables (par exemple, les listes), Python agit comme
C se passe par pointeur ; changements en place à
les objets mutables peuvent affecter l'appelant
 Exemple
[Link]

def f1(x,y):
x=x*1
y=y*2
imprimer x, y # 0 [1, 2, 1, 2]

def f2(x,y):
x=x*1
y[0] = y[0] * 2
imprimer x, y # 0 [2, 2]

a=0
b = [1,2]
f1(a,b)
imprimer a, b # 0 [1, 2]
f2(a,b)
imprimer a, b # 0 [2, 2]
 Valeurs de retour multiples

Can return multiple values by packaging them

dans un tuple

def undeuxtrois(x):
retourner x*1, x*2, x*3

imprimer unetrois(3)

3, 6, 9
 Fonctions intégrées
Plusieurs fonctions intégrées utiles. Exemple
[Link]

imprimer pow(2,3)
imprimer abs(-14)
print max(1,-5,3,0)

Output:
8
14
3
 Fonctions de fonctions
Exemple [Link] Output:
def estpair(x,f): Vrai
si (f(x) == f(-x)) : Faux
retourner Vrai
sinon :
retourner Faux

def carre(n):
retourner(n*n)

def cube(n):
return(n*n*n)

imprimer estpair(2, carré)

imprimer estpair(2,cube)
 Arguments par défaut

Comme C ou Java, vous pouvez définir une fonction pour fournir un

valeur par défaut pour un argument s'il n'y en a pas
specified

def print_error(num_ligne, message="erreur"):

imprimer "%s à la ligne %d" % (message, ligneo)

imprimer_erreur(42)

erreur à la ligne 42
 Fonctions sans valeurs de retour
Toutes les fonctions en Python retournent quelque chose. Si un
si la déclaration de retour n'est pas donnée, alors par défaut,
Python renvoie None
Attention à affecter une variable au résultat d'un
fonction qui retourne None. Par exemple, le
la fonction append de la liste modifie la liste mais ne
not return a value:
a = [0, 1, 2]
b = [Link](3)
imprimer b
Aucun
 Chapitre 4 : Itération
boucles while
boucles for
fonction range
Contrôle de flux dans les boucles : break, continue, pass
et la "boucle else"
 tandis que
Exemple [Link]
i=1
tant que i < 4 :
imprimer i
i += 1
Output:
1
2
3
 pour
Exemple [Link]
pour i dans range(3):
imprimer i,

output:
0, 1, 2
range(n) renvoie une liste d'entiers de 0 à n-1.
range(0,10,2) renvoie une liste 0, 2, 4, 6, 8
 Contrôle de flux dans les boucles

Structure générale d'une boucle :

tandis que <énoncé> (ou pour <élément> dans <objet>):
<déclarations dans la boucle>
si <test1>: sortir sortir de la boucle maintenant
si <test2>: continuer # retourner au début de la boucle maintenant
si <test3>: passer # ne fait rien !
sinon :
<autres déclarations> # si on sort de la boucle sans
faire une pause
 Using the“loop else”
Une instruction else après une boucle est utile pour
prendre soin d'un cas où un article n'est pas trouvé
dans une liste. Exemple : search_items.py :

pour i dans la plage(3):

si i == 4 :
J'ai trouvé 4 !
pause
sinon :
Je me fiche de
sinon :
J'ai cherché mais je n'ai jamais trouvé 4 !
 pour ... dans
Utilisé avec des types de données de collection (voir le chapitre 6)
qui peut être itéré (“itérables”):
pour nom dans [“Mutasem”, “Micah”, “Ryan”]:
si nom[0] == "M":
imprimez le nom, "commence par un M"
sinon :
imprimer nom, "ne commence pas par M"
Plus d'informations sur les listes et les chaînes plus tard
 Parcours parallèles
Si nous voulons parcourir 2 listes (plus tard)
parallèle, peut utiliser zip :
A = [1, 2, 3]
B = [4, 5, 6]
pour (a,b) dans zip(A,B) :
imprimer a, "*", b, "=", a*b

output:
1*4=4
2 * 5 = 10
3 * 6 = 18
 Chapitre 5 : Chaînes
Les bases des chaînes

Séquences d'échappement

Tranches
Citations en bloc
Mise en forme
Méthodes de chaîne
 Notions de base sur les chaînes
Les chaînes peuvent être délimitées par des guillemets simples ou doubles

Python utilise Unicode, donc les chaînes ne sont pas limitées à l'ASCII
personnages
Une chaîne vide est désignée par le fait de n'avoir rien entre
délimiteurs de chaîne (par exemple, '')
On peut accéder aux éléments des chaînes de caractères avec [], en utilisant l'indexation.
commencer à zéro :
serpents
k
Remarque : il n'est pas possible d'aller dans l'autre sens --- il n'est pas possible de définir "snakes"[3] = 'p' à
modifier une chaîne ; les chaînes sont immuables
a[-1] obtient le dernier élément de la chaîne a (indices négatifs)
travailler à travers la chaîne à l'envers depuis la fin
Des chaînes comme a = r'c:\home\[Link]' (commençant par un r
les caractères avant les délimiteurs) sont des chaînes « brutes » (interpréter
littéralement)
 Plus de notions de base sur les chaînes
Conversion de type :
>>> int("42")
42
>>> str(20.4)
20,4
Comparez les chaînes avec l'opérateur d'égalité, ==
(comme en C et C++):
a = "bonjour"
>>> b ="bonjour"
>>> a == b
Vrai
>>>location =“Chattanooga“+“Tennessee”
>>>location
Chattanooga, Tennessee
 Séquences d'échappement

Échapper Sens
\\ \
\' '
\” “
nouvelle ligne
\t onglet
\N{id} identifiant unicode dbase
\uhhhh unicode 16-bit hex
Uhhhh... Unicode 32 bits hex
Hex valeurs de chiffres hh
Octet nul (contrairement au C, ne met pas fin
chaîne
 Citations en bloc

Les chaînes multilignes utilisent des triples guillemets :

Quatre-vingts ans et sept ans
... il y a longtemps, nos pères ont donné naissance à ceci
... continent, une nouvelle nation, conçue dans
... Liberté, et dédié à la proposition
... que tous les hommes sont créés égaux.
 Formatage de chaîne
Syntaxe de mise en forme :
format % objet-à-formater
>>> greeting =“Hello”
%s. Bienvenue dans Python.
Bonjour. Bienvenue dans python.
Remarque : le formatage crée une nouvelle chaîne (parce que les chaînes sont immuables)

Le formatage avancé de style printf de C fonctionne. Peut formater plusieurs

variables en une chaîne en les rassemblant dans un tuple (liste séparée par des virgules)
délimité par des parenthèses) après le caractère % :
La note pour %s est %4.1f
La note de Tom est de 76,1

Les formats de chaînes peuvent faire référence aux clés du dictionnaire (plus tard) :
Bob a obtenu un 82
Bob a eu 82
 Parcourir une chaîne
Une chaîne est considérée comme une collection de caractères,
et donc il a certaines propriétés en commun avec
d'autres collections comme les listes et les tuples (voir
ci-dessous).
>>> pour c dans "serpents" : print c,
...
serpents

'a' dans "serpents"

Vrai
 Tranches
Tranche : obtenir une sous-chaîne de la position i à j-1 :
“serpents”[1:3]
'na'
Les deux arguments d'une tranche sont optionnels ; a[:] va
il suffit de fournir une copie de la chaîne a
 Méthodes de chaîne
Les chaînes sont des classes avec de nombreuses méthodes intégrées.
Ces méthodes qui créent de nouvelles chaînes doivent
être assigné (puisque les chaînes sont immuables, elles
ne peut pas être modifié sur place).
[Link]()
[Link](largeur)
[Link](sous-chaîne [, idx-démarrage [, idx-fin]])
[Link](sous-chaîne [, début [, fin]])
[Link](), [Link](), [Link](), [Link](),
[Link]()
[Link](sequence)
Et bien d'autres !
 méthode de remplacement

Ne remplace vraiment pas (les chaînes sont immuables)

mais crée une nouvelle chaîne avec le remplacement
effectué
a = "abcdefg"
>>> b = [Link]('c', 'C')
>>> b
abCdefg
a
abcdefg
 Plus d'exemples de méthodes
[Link] :
Il a trouvé cela ennuyeux et il est parti
loc = [Link]("ennuyeux")
a = a[:loc] + "fun"
imprimer un

b = ' and '.join([“cars”,“trucks”,“motorcycles”])

imprimer b
c = [Link]()
imprimer c

d = [Link]("et")
imprimer d

Sortie :
Il a trouvé cela amusant
voitures et camions et motos
["voitures","et","camions","et","motos"]
["voitures","camions","motos"]
 Expressions régulières

Les expressions régulières sont un moyen de faire des motifs

correspondance. Le concept de base (et la plupart des
la syntaxe de l'expression régulière actuelle) est le
même en Java ou Perl
 Syntaxe des expressions régulières

•Syntaxe commune des expressions régulières :

. Matches any char but newline (by default)
^ Correspond à le début d'une chaîne
$ Correspond à la fin d'une chaîne
* N'importe quel nombre de ce qui précède ceci
+ Un ou plusieurs de ce qui précède ceci
Ou
\w Tout caractère alphanumérique
\d Tout chiffre
\s Tout caractère d'espace
(Remarque : \W correspond à des caractères NON alphanumériques, \D à des NON chiffres, etc.)

[aeiou] correspond à l'un des a, e, i, o, u

junk Correspond à la chaîne 'junk'
 Exemple de Regexp simple
importer re #importer le module d'expressions régulières

infile = open("[Link]", 'r')

lignes = [Link]()
[Link]()
# remplacez tous les PSI3 par des PSI4
matchstr = [Link](r"PSI3",
[Link])
pour ligne dans lignes :
line = [Link](r'PSI4', line)
imprimer la ligne,
 Exemple simple d'expression régulière

•Dans l'exemple précédent, nous ouvrons un fichier et lisons tout le

lignes (voir le chapitre à venir), et nous remplaçons tous les PSI3
instances avec PSI4
Le module d'expressions régulières doit être importé
Nous devons « compiler » l'expression régulière avec
[Link](). Le caractère "r" ici et ci-dessous signifie traiter
cette chaîne en tant que "brute" (nous évite d'avoir à échapper)
caractères de barre oblique inversée avec une autre barre oblique inversée

•[Link] (re.I) est un argument optionnel. Un autre

serait [Link] (re.S ; le point correspondrait aux nouvelles lignes ; par
par défaut, ce n'est pas le cas). Un autre est [Link] (re.M), qui
fait que ^ et $ correspondent après et avant chaque saut de ligne dans un
chaîne
 Plus sur les Regexps
L'étape [Link]() est optionnelle (plus efficace si vous faites beaucoup de regexps)

•Peut utiliser [Link](regex, sujet) ou [Link](regex, sujet) comme alternative

syntaxe
•[Link]() ne cherche une correspondance qu'au début d'une ligne ; pas be
pour faire correspondre l'ensemble de la chaîne, juste le début

•[Link]() tente de correspondre à travers la chaîne jusqu'à ce qu'il trouve une correspondance

•[Link](regex, sujet) renvoie un tableau de tous les correspondances non superposées;

alternativement, peut faire
pour m dans [Link](regex, sujet)
•Match(), search(), finditer(), et findall() ne supportent pas le troisième optionnel.
argument des indicateurs de correspondance regex ; peut commencer le regex par (?i), (?s), (?m), etc.
au lieu
 [Link]()
•[Link](regex, sujet) retourne un tableau de chaînes. Les chaînes
sont toutes les parties du sujet à l'exception des parties qui correspondent. Si
deux correspondances sont adjacentes dans le sujet, alors split() va
include an empty string.
•Exemple :
line =“Upgrade the PSI3 program to PSI4. PSI3 was an
excellent programme.
matchstr = [Link](“PSI3”, line)
pour i dans matchstr :
imprimer i
>>> Améliorer le
>>> programme pour PSI4.
c'était un excellent programme.
 Fonctions d'objet de correspondance

•Search() et match() renvoient un objet MatchObject.

Cet objet a quelques fonctions utiles :
groupe() : retourne la chaîne correspondante
start(): position de départ du match
fin(): position de fin de la correspondance
span(): tuple contenant le (début, fin)
positions du match
 Exemple d'objet Match

line = "Now we are upgrading the PSI3 program"

matchstr = [Link]("PSI3", ligne)
Match commence au caractère
Match se termine au caractère
print "Avant le match: ", ligne[0:[Link]()]
print "Après le match:", ligne[[Link]():]
 Groupes de capture

Les parenthèses dans une expression régulière désignent

"groupes de capture" qui peuvent être accédés par
numéro ou par nom pour obtenir la correspondance
(capturé) texte
•Nous pouvons nommer les groupes de capture avec
(?P<name>)
Nous pouvons également tirer parti des guillemets triples
chaînes (qui peuvent s'étendre sur plusieurs lignes) à
définir l'expression régulière (qui peut
inclure des commentaires) si nous utilisons le [Link]
option
 Exemple de groupes de capture
infile = open("[Link]", 'r')
lignes = [Link]()
[Link]()
# la chaîne de caractères entre triples guillemets peut s'étendre sur plusieurs lignes

restring = """[ \t]* # espace facultatif au début

(?P<key>\w+) # nommer le mot correspondant 'key'

[ ]*=[ ]* # signe égal avec espaces facultatifs

(?P<value>.+) # some non-whitespace after = is 'value'
"""
matchstr = [Link](restring, [Link] | [Link])
pour ligne dans lignes :

pour match dans [Link](ligne):

print "clé =", [Link]("clé")

print ", valeur =", [Link]("value")
Chapitre 6 : Types de données de collection

Tuples
Listes
Dictionnaires
 Tuples
Les tuples sont une collection d'éléments de données. Ils peuvent
être de différents types. Les tuples sont immuables comme
Les listes sont comme des tuples mais sont mutables.
>>>“Tony”,“Pat”,“Stewart”
('Tony', 'Pat', 'Stewart')
Python utilise () pour désigner les tuples ; nous pourrions aussi
utiliser (), mais si nous n'avons qu'un seul élément, nous devons
Utilisez une virgule pour indiquer qu'il s'agit d'un tuple : ("Tony",)

Un tuple vide est désigné par ()

Il faut entourer le tuple de () si nous voulons le passer.
tout ensemble comme un argument à une fonction
 Listes
Comme des tuples, mais mutables, et désignés par
crochets au lieu de parenthèses
[1, 3, 5, 7, 11]
[1,3,5,7,11]
>>> [0, 1, 'boom']
[0, 1, 'boom']
Une liste vide est []
Ajouter un élément :
>>> x = [1, 2, 3]
>>> [Link]("fait")
>>> imprimer x
[1, 2, 3, 'done']
 Les listes et les tuples contiennent des objets
Références
Les listes et les tuples contiennent des références d'objet.
Puisque les listes et les tuples sont également des objets, ils peuvent
être imbriqué

>>> a=[0,1,2]
>>> b=[a,3,4]
>>> print b
[[0, 1, 2], 3, 4]
>>> print b[0][1]
1
>>> print b[1][0]
... TypeError: 'int' object is unsubscriptable
 Liste d'exemples

[Link]
x=[1,3,5,7,11]
print x
print "x[2]=" , x[2]
x[2] = 0
remplacer 5 par 0, x =
[Link](13)
Après l'ajout, x =
[Link](1) # retire le 1, pas l'élément à la position 1 !!
Après avoir supprimé l'élément 1, x =
[Link](1,42)
imprimer "Insérer 42 à l'élément 1, x = ", x

Output:
[1, 3, 5, 7, 11]
x[2]= 5
Remplacer 5 par 0, x = [1, 3, 0, 7, 11]
Après ajout, x = [1, 3, 0, 7, 11, 13]
Après avoir retiré l'élément 1, x = [3, 0, 7, 11, 13]
Insérer 42 à l'élément 1, x = [3, 42, 0, 7, 11, 13]
 Indexation
Indexation pour une liste
>>> x=[1,3,5,7,11]
>>> x[2]
5
>>> x[2]=0
>>> x
[1, 3, 0, 7, 11]
Peut indexer un tuple de la même manière, mais ne peut pas
changez les valeurs parce que les tuples sont
immutable
Les tranches fonctionnent comme pour les chaînes (rappel de l'index dernier de)
la tranche n'est pas incluse)
>>> x[2:4]
[0,7]
 L'opérateur += pour les listes

>>> a = [1, 3, 5]
>>> a += [7] # a += 7 échoue
>> a
[1,3,5,7]
a += ["la-fin"] # mettez cela aussi dans [] !
>>>a
la-fin
 Dictionaries
Collections non ordonnées où les éléments sont
accédé par une clé, et non par la position dans la liste
Comme un hachage en Perl
Collection d'objets arbitraires ; utiliser l'objet
références comme des listes
Emboîtable
Peut grandir et rétrécir sur place comme des listes
Concaténation, découpage et autres opérations
cela dépend de l'ordre des éléments ne pas
travailler sur des dictionnaires
Construction et accès au dictionnaire
Example:
>>> jobs = {'David':'Professor',
'Sahan':'Postdoc', 'Shawn':'Grad student'}
>>> jobs['Sahan']
Postdoctorant
Peut changer d'endroit
>>> jobs['Shawn'] = 'Postdoc'
>>> emplois['Shawn']
Postdoctorat
Listes de clés et de valeurs
>>> [Link]és()
['Sahan', 'Shawn', 'David'] # note order is diff
>>> [Link]()
["Postdoc","Postdoc","Professeur"]
>>> [Link]()
[["Sahan","Postdoctorant"],["Shawn","Postdoctorant"]]
('David', 'Professor')]
 Opérations courantes de dictionnaire

Supprimer une entrée (par clé)

del d['nomdelaclée']
Ajouter une entrée
d['newkey'] = newvalue
Vérifiez si une clé est dans le dictionnaire
d.contient_clé('keyname') ou 'keyname' dans d
La méthode get() est utile pour renvoyer une valeur mais sans échouer
(retourne None) si la clé n'existe pas (ou peut fournir
une valeur par défaut)
[Link]('keyval', défaut)
update() fusionne un dictionnaire avec un autre
(écrasant les valeurs avec la même clé)
[Link](d2) [la version dictionnaire de
concatenation
 Exemple de dictionnaire

Parcourir un dictionnaire par clés :

bookauthors = {'Gone with the Wind':

Margaret Mitchell
'Aeneid': 'Virgil',
'Odyssey': 'Homer'}
pour livre dans auteursdelivre :
imprimer le livre, 'par', auteursDuLivre[auteurDuLivre]

output:
Gone with the Wind by Margaret Mitchell
Énéide par Virgile
L'Odyssée d'Homère
Construire des dictionnaires à partir de listes

Si nous avons des listes séparées pour les clés et

valeurs, nous pouvons les combiner en un dictionnaire
en utilisant la fonction zip et un constructeur de dictionnaire :

keys = ['david', 'chris', 'stewart']

values = ['504', '637', '921']
D = dict(zip(clés, valeurs))
 Clés plus générales
Les clés n'ont pas besoin d'être des chaînes ; elles peuvent être n'importe quoi.
type de données immuable, y compris les tuples
Cela pourrait être bon pour représenter des données éparses.
matrices, par exemple
Matrix = {} commencer un dictionnaire vide
Matrix[(1,0,1)] = 0.5 # key is a tuple
Matrix[(1,1,4)] = 0.8
 Longueur des collections
len() renvoie la longueur d'un tuple, d'une liste ou d'un
dictionnaire (ou le nombre de caractères d'un
chaîne):
>>>len(("Tony",))
1
>>>len("Tony")
4
>>>len([0, 1, 'boom'])
3
 L'opérateur "est"
Les "variables" en Python sont en réalité des références d'objet.
L'opérateur "est" vérifie si ceux-ci
les références se réfèrent au même objet (note : pourrait
avoir deux objets identiques qui ne sont pas le
même objet...)
Les références aux constantes entières doivent être
identiques. Les références aux chaînes peuvent ou non
se référer au même objet. Deux
des objets identiques et mutables ne sont pas nécessairement
le même objet
 [Link]
x = "hello"
y = "hello"
imprimer x est y Vrai ici, pas nécessaire.

x = [1,2]
y = [1,2]
imprimer x est y Faux (même si identique)
x = (1,2)
y = (1,2)
print x is y Faux (même si
identique, immuable
x = []
imprimer x n'est pas None Vrai (liste, même si
empty)
 opérateur "in"
Pour les types de données de collection, l'opérateur « in »
détermine si quelque chose est un membre de
la collection (et "pas dans" tests si ce n'est pas un
membre):
>>> team = (“David”,“Robert”,“Paul”)
"Howell" dans l'équipe
Faux
« Stewart » pas dans l'équipe
Vrai
 Itération : pour ... dans
Pour traverser un type de collection, utilisez for ... in
>>> nombres = (1, 2, 3)
>>> pour i dans les nombres : print i,
...
123
 Copying collections
L'utilisation de l'assignation crée juste une nouvelle référence
à la même collection, par exemple,
A = [0,1,3]
B = A # B est une référence à A. Changer B va
# changer A
C = A[:] faire une copie
B[1] = 5
C[1] = 7
A, B, C
( [0, 5, 3], [0, 5, 3], [0, 7, 3])
Copier un dictionnaire avec [Link]()
 Chapitre 7 : Fonctions avancées
Passage de listes et de dictionnaires de mots-clés à
fonctions
Fonctions Lambda
appliquer()
carte()
filtrer()
réduire()
Compréhensions de liste
 Passer des listes en tant qu'arguments

Des listes peuvent être passées dans des cas où il peut y avoir
être un nombre variable d'arguments
[Link]
def somme(*args):
result = 0
pour arg dans args :
resultat += arg
retourner le résultat

imprimer somme(1,2,3)
6
 Arguments de mot-clé
L'appelant d'une fonction peut placer les arguments
dans le bon ordre (« arguments positionnels »), mais
alternativement, certains arguments peuvent être
désigné par des mots-clés
Remarque : cet exemple appelle la fonction avec le
arguments dans le mauvais ordre, mais le
les arguments sont passés avec la syntaxe des mots-clés donc cela
peu importe
def print_hello(prenom="", nom=""):
print "Bonjour, %s %s" % (prenom, nom)
imprimer_bonjour(nom_de_famille="Sherrill",
firstname="David")
Bonjour, David Sherrill
 Mélange de mots-clés et de positions
arguments
Une autre utilisation de l'opérateur * est de désigner
que tous les arguments après doivent être des mots-clés
arguments
C'est nouveau pour Python 3 ?
def surface(x, y, *, unites="pouces"):
imprimer x*y, "carré %s" % unités
area(2,3,”centimeters”)
6 centimètres carrés
 Passer des dictionnaires aux fonctions
Les dictionnaires seront abordés plus tard.
[Link] :
def imprimer_dictionnaire(**kwargs):
pour clé dans [Link]és() :
imprimer "%s = %s" % (clé, kwargs[clé])
user_info = dict(name="David", uid=593,
homedir="/home/users/david")
print_dict(**informations_utilisateur) # note : besoin de ** ici !!

output: (note: dictionary entries are unordered)

uid = 593
name = David
homedir = /home/users/david
 Arguments de dictionnaire
Remarque : les dictionnaires peuvent être passés comme arguments
même aux fonctions "normales" souhaitant des paramètres positionnels
arguments !
[Link]
def surface(x, y, unités="pouces"):
print x*y, "carré %s" % unités
area_info = dict(x=2, y=3, units="centimeters")
zone(**zone_info)
6 centimètres carrés
 Fonctions Lambda

Version abrégée de l'instruction def, utile pour

l'insertion de fonctions et d'autres situations où
il est pratique de garder le code de la fonction
près de l'endroit où c'est nécessaire

Ne peut contenir qu'une expression dans la fonction

définition, pas un bloc d'instructions (par exemple, pas de si)
déclarations, etc)
Une lambda renvoie une fonction ; le programmeur
peut décider s'il faut ou non attribuer cela
function to a name
 Exemple de Lambda

Exemple simple :

>>> def somme(x,y): return x+y

>>> ...
>>> somme(1,2)
3
>>> sum2 = lambda x, y: x+y
>>> somme2(1,2)
3
 appliquer()
Dans des contextes très généraux, vous ne savez peut-être pas
en avance combien d'arguments doivent être obtenus
passé à une fonction (peut-être la fonction elle-même
est construit dynamiquement)

La fonction apply() appelle une fonction donnée avec un

liste d'arguments regroupés dans un tuple :
def somme(x, y): return x+y
appliquer(somme, (3, 4))
7
Apply can handle functions defined with def or
avec lambda
 Appliquer() plus généralement

Apply peut prendre un troisième argument qui est un dictionnaire

d'arguments de mot-clé

def nomargs(*args, **kwargs): print(args, kwargs)

args = (1.2, 1.3)
kargs = {'a': 2.1, 'b': 3.4}
apply(nameargs, args, kwargs)
(1.2, 1.3) {'a': 2.1000, 'b': 3.4000}
 carte
Map appelle une fonction donnée sur chaque élément de
une séquence
[Link] :
def doubler(x): return x*2
a = [1, 2, 3]
imprimer carte(double, a)
[2,4,6]
Ou bien :
imprimer carte((lambda x: x*2), a)
[2, 4, 6]
 Plus de carte

Peut également appliquer une carte à des fonctions prenant plus

qu'un argument ; puis travaillez avec deux ou plusieurs
listes

imprimer carte((lambda x, y: x+y), [1,2,3], [4,5,6])

[5,7,9]
 filtre
Tout comme la fonction map, la fonction filter fonctionne sur les listes.
Contrairement à map, cela ne renvoie qu'une liste sélectionnée de
éléments qui correspondent à un certain critère.

Obtenez uniquement des nombres pairs :

filtrer((lambda x: x%2==0), range(-4,4))
[-4, -2, 0, 2] # rappeler que la plage n'inclut pas le dernier
valeur donnée dans la plage
 réduire
Reduce est comme map mais il réduit une liste à un
valeur unique (chaque opération agit sur le résultat)
de la dernière opération et du prochain élément dans le
liste)

réduire((lambda x, y: x+y), [0, 1, 2, 3, 4])

10
 Compréhensions de listes

Ce ne sont pas vraiment des fonctions, mais elles peuvent

remplacer des fonctions (ou des mappages, des filtres, etc.)
[x**2 pour x dans range(9)]
[0, 1, 4, 9, 16, 25, 36, 49, 64]
>>> [x**2 pour x dans range(10) si x%2 == 0]
[0,4,16,36,64]
[x+y for x in [1,2,3] for y in [100,200,300]]
[101, 201, 301, 102, 202, 302, 103, 203, 303]
 Générateurs et Itérateurs

Parfois, il peut être utile de retourner un seul

valeur à la fois, au lieu d'une séquence entière.
Un générateur est une fonction qui est écrite pour
retourner des valeurs une à la fois. Le générateur peut
calculez la valeur suivante, enregistrez son état, puis
reprendre là où il s'était arrêté lorsqu'il est rappelé.
Syntaxiquement, le générateur ressemble juste à un
fonction, mais elle "rend" une valeur au lieu de
retournant un (une instruction de retour serait
terminer la séquence)
 Exemple de générateur

>>> def carrés(x):

... pour i dans la plage(x):
... produit i**2
>>> pour i dans les carrés(4):
... imprime i,
...
0149
Peut obtenir le prochain élément de la séquence à partir de la fonction next() :

z = carrés(4)
[Link]()
0
[Link]()
1
 Persistance de la valeur par défaut mutable
arguments
Les arguments par défaut mutables persistent entre
appels à la fonction (comme les variables statiques en C)
Cela peut ne pas être le comportement souhaité

Sinon, copiez le défaut au début de la

function body to another variable, or move the
expression de valeur par défaut dans le corps de la
fonction
 Chapitre 8 : Gestion des exceptions

Bases de la gestion des exceptions

 Gestion des exceptions de base
Une "exception" est une erreur (type reconnu), et
« gestion » est ce que vous faites lorsque cette erreur se produit
Syntaxe générale :
essayer :
code-que-vous-voulez-exécuter
sauf exception1 [comme variable1]:
bloc exception1
...
sauf exceptionN [comme variableN] :
bloc exceptionN
S'il y a une erreur, si c'est de type d'exception 1, alors variable1
devenant un alias de l'objet d'exception, puis
le bloc exception1 s'exécute. Sinon, Python essaie
types d'exception 2 ... N jusqu'à ce que l'exception soit attrapée, ou sinon
le programme s'arrête avec une exception non gérée (un
la trace des appels sera imprimée avec le texte de l'exception)
L'optionnel [en tant que variable] ne fonctionnera pas avec les anciennes versions de Python
 Exemple d'exception
[Link]
essayer :
i = int("serpents")
imprimer "l'entier est", i
sauf ValueError :
imprimer "oups ! valeur invalide"
 Autres exceptions
Une EOFError est levée à la fin d'un fichier
Une erreur IndexError se produit si nous utilisons un index invalide
for a string/collection, e.g., if we try to get
argv[1] s'il n'y a qu'une seule ligne de commande
argument (le comptage commence à zéro)
Une erreur TypeError se produit lorsque, par exemple, on compare deux
types incomparables
 Chapitre 9 : Modules Python
Notions de base des modules
Importation et depuis…instructions d'importation
Modification des données dans les modules

Rechargement des modules

Modules de paquets
__name__ and __main__
Importer comme déclaration
 Bases du module
Chaque fichier en Python est considéré comme un module. Tout
dans le fichier est encapsulé dans un espace de noms (qui
est le nom du fichier)
.e
rh
ci ie
m
cfztip
o
r,)e
rh
ci ia
P
e
m
u
fo
é
cd
e
o
ru
a
(n
sa
o
u
d
tl
et ensuite accéder aux fonctions ou aux données de ce module par
préfixé par le nom du module, suivi d'un point
u
n
m
e
m
r:o
td
u
P
ilp
o
ru
r
importer sys
(note : pas d'extension de fichier)

Peut importer des modules définis par l'utilisateur ou certains "standards"

modules comme sys et random
Tout programme Python a besoin d'un fichier "de niveau supérieur" qui
importe tous les autres modules nécessaires
 Bibliothèque standard Python

Il y a plus de 200 modules dans le Standard

Bibliothèque
Consultez le Manuel de Référence de la Bibliothèque Python,
inclus dans l'installation de Python et/ou
disponible à[Link]
 Quelle importation a

Une instruction d'importation fait trois choses :

- Trouve le fichier pour le module donné
- Le compile en bytecode
- Exécute le code du module pour construire des objets (haut-
code de niveau, par exemple, initialisation de variables

Le nom du module n'est qu'un simple nom ; Python utilise

un chemin de recherche de module pour le trouver. Il recherchera : (a) le
répertoire du fichier de niveau supérieur, (b) répertoires dans le
variable d'environnement PYTHONPATH, (c) standard
répertoires, et (d) répertoires listés dans les fichiers .pth
(un répertoire par ligne dans un fichier texte brut) ; le chemin peut
être répertorié en imprimant [Link]
 Le module sys
Impression des arguments de la ligne de commande,
[Link]
importer sys
cmd_options = [Link]
i=0
pour cmd dans cmd_options :
imprimer "Argument "+ i + " = " + cmd
i += 1
output:
localhost(Chapitre8)% ./[Link] test1 test2
Argument 0 = ./[Link]
Argument 1 = test1
Argument 2 = test2
 Le module random
importer aléatoire

deviner = [Link](1,100)
imprimer deviner
dinner = [Link]([“meatloaf”,“pizza”,
tourte au poulet
imprimer le dîner
 importer vs de ... importer
L'importation entraîne un module entier ; vous devez le qualifier.
les noms par le nom du module (par exemple, [Link])
« importer de » copie les noms du module dans le
module actuel ; pas besoin de les qualifier (remarque : ces
sont des copies, pas des liens, vers les noms originaux)

de module_x importation de déchets

junk() # pas module_x.junk()

de module_x import * # obtient tout le niveau supérieur

# noms du module_x
 Changement de données dans les modules

Réassigner une nouvelle valeur à un nom récupéré d'un

module does not change the module, but changing a
une variable mutable d'un module fait :

de module_x importer x,y

x = 30 # ne change pas x dans module_x

y[0] = 1 # changes y[0] in module_x
This works just like functions
ta
irp
o
u
r,e
rh
icie
frd
a
u
n
stu
e
n
m
o
h
a
b
cn
g
le
rle
n
g
té
e
lrP
o
u
r
utilisez import (sans "from") et qualifiez la variable :
module_x.x = 30 (mais cela brise l'encapsulation des données)
 Rechargement des modules

Le code de niveau supérieur d'un module n'est exécuté que la première fois que le
le module est importé. Les importations suivantes ne le font pas.
anything.
La fonction de rechargement force un rechargement et une nouvelle exécution d'un
module; peut utiliser si, par exemple, un module change tandis qu'un
Le programme Python est en cours d'exécution

reload reçoit un objet module existant

recharger(module_x) # module_x doit avoir été
# précédemment importé
recharger modifie l'objet module sur place
le rechargement n'affecte pas les déclarations from..import précédentes
(ils désignent toujours les anciens objets)
 Paquets de module
Lors de l'utilisation de l'importation, nous pouvons donner un répertoire

un chemin au lieu d'un simple nom. Un répertoire de

Le code Python est connu sous le nom de « package » :

import [Link]
ou
de [Link] importer x
chercherai un fichier dir1/dir2/[Link]
Note : dir1 doit être dans l'un des répertoires
dans le PYTHONPATH
Remarque : dir1 et dir2 doivent être des noms simples, pas
en utilisant une syntaxe spécifique à la plateforme (par exemple, pas de C:\)
 Fichiers __init__.py de package
Lors de l'utilisation de paquets Python (syntaxe de chemin d'annuaire pour
importations), chaque répertoire dans le chemin doit avoir un
__init__.py fichier
Le fichier pourrait être vide

S'il n'est pas vide, le fichier contient du code Python ; la première fois que Python
les importations via ce répertoire, cela exécutera le code dans le
__init__.py fichier
Dans l'exemple [Link], un espace de noms dir1.dir2 maintenant
existe qui contient tous les noms assignés par le __init__.py de dir2
fichier
Le fichier peut contenir une liste "__all__" qui spécifie ce qui est
exporté par défaut lorsqu'un répertoire est importé avec from*
déclaration
 Encapsulation des données

Par défaut, les noms commençant par un

le soulignement ne sera pas copié dans une importation
déclaration (elles peuvent encore être modifiées si accessibles
directement)
Alternativement, on peut lister les noms à être
copié à l'importation en les assignant à une liste
appelé __all__:
__all__ = [“x1”,“y1”,“z1”] # export only these
this list is only read when using the from *
syntaxe
 __name__ et __main__
Lorsqu'un fichier est exécuté en tant que programme de niveau supérieur, il est
__name__ est défini sur "__main__" lorsqu'il démarre
Si un fichier est importé, __name__ est défini sur le
nom du module tel que l'importateur le voit
Peut utiliser ceci pour emballer un module en tant que bibliothèque,
mais permettez-lui aussi de fonctionner de manière autonome, en vérifiant

si __nom__ == '__main__':
fais_quoi_que_ce_soit() # exécuter en mode autonome
 Importer comme

Vous pouvez renommer un module (à partir du point de

vue de l'importateur) en utilisant :
import longmodulename comme shortname,
où shortname est l'alias de l'original
nom du module
L'utilisation de cette syntaxe nécessite que vous utilisiez le court

nom par la suite, pas le long nom

Peut aussi faire
du module importez longname en tant que nom
 Le rechargement peut ne pas affecter « depuis »

importations
Des noms de copies, et ne conserve pas de lien
retour au module original
Lorsque le rechargement est exécuté, il change le module, mais
pas de copies qui ont été faites sur un original
depuis le module import XX
déclaration
Si c'est un problème, importez l'ensemble du module
et utilisez la qualification par nom ([Link]) à la place
 Chapitre 10 : Fichiers
Opérations de base sur les fichiers
 Ouverture d'un fichier

ouvrir(nom_fichier, mode)
où filename est une chaîne Python, et mode est
une chaîne Python, 'r' pour lire, 'w' pour écrire, ou
'a' pour ajouter
 Opérations de fichiers de base

Opérations de base :

outfile = open('[Link]', 'w')

infile = open('[Link]', r')
 Opérations de base sur les fichiers

Opérations de base
output = open('[Link]', 'w')
input = open('[Link]', 'r')
A = [Link]() lire le fichier entier dans une chaîne
A = entré[Link](N) # lire N octets
A = [Link]() # lire la ligne suivante
A = [Link]() # lire le fichier dans une liste de
# strings
[Link](A) # Écrire la chaîne A dans le fichier
[Link](A) # Écrire une liste de chaînes
[Link]() # Fermer un fichier
 Redirection de stdout
Les instructions d'impression vont normalement vers stdout
(« sortie standard », c'est-à-dire l'écran)
La sortie standard peut être redirigée vers un fichier :

importer sys
[Link] = open('[Link]', 'w')
imprimer message # apparaîtra dans [Link]

Sinon, pour imprimer juste quelques éléments dans un fichier :

imprimer >> logfile, message # si logfile ouvert
 Exemples d'analyse de fichiers
Tout d'un coup :

infile = open("[Link]", 'r')

lignes = [Link]()
[Link]()

pour ligne dans lignes :

imprimer ligne,

Ligne par ligne (syntaxe abrégée évitant les appels de readline) :

infile = open(“[Link]”, 'r')

pour ligne dans infile

imprimer la ligne

[Link]()
 Chapitre 11 : Documentation
Comments
répertoire
Chaînes de documentation
 Commentaires
Comme nous l'avons vu, tout ce qui vient après un caractère # est
considéré comme un commentaire
 dir
La fonction dir imprime tous les attributs d'un
objet (voir plus tard)

>>> import sys

>>> dir(sys)
['__displayhook__', '__doc__',
'__excepthook__', '__name__', '__stderr__',
'__stdin__', '__stdout__', '_current_frames',
'_getframe', 'api_version', 'argv',
...
>>> dir([]) # a list
["__ajouter__","__classe__","__contient__","..."]
["ajouter","compter","étendre","index","..."]
 docstrings
Chaines en haut des fichiers de module, en haut des fonctions,
et le haut des classes devient "docstrings" qui sont
inséré automatiquement dans l'attribut __doc__ de le
objet
Vous pouvez utiliser des guillemets simples ou doubles réguliers pour délimiter le
chaîne, ou peut utiliser des guillemets triples pour une chaîne multilignes

par ex., :
def somme(x, y):
Cette fonction ajoute simplement deux nombres
retourner x+y

print la somme.__doc__
Cette fonction ajoute simplement deux nombres
 Docstrings pour les objets intégrés
Peut imprimer les docstrings pour les fonctions intégrées de Python
objets

>>> importer sys

>>> print sys.__doc__
 PyDoc
PyDoc est un outil qui peut extraire les docstrings
et les afficher de manière agréable, soit par l'aide
commande, ou via une interface GUI/HTML
>>> aide(liste)
 Documentation sur le web
Consultez [Link]
 Chapitre 12 : Classes
Introduction aux classes
des choses
déchet
 Introduction aux classes
•Une "classe" est un type de données défini par l'utilisateur. Elle contient (ou
encapsule) certaines "données membres", et elle a également
choses associées qu'il peut faire, ou « fonctions membres ».
•Si une classe est une spécialisation (ou un sous-type) d'une catégorie plus générale
classe, il est dit d'hériter de cette classe; cela peut donner une classe
accès aux données/méthodes membres d'une classe parent
•Ces concepts généraux sont essentiellement les mêmes en C++, Java,
etc.
•Les classes sont intégrées à Python depuis le début. Pour les objets-
programmation orientée objet (c'est-à-dire, programmation utilisant des classes),

Python est supérieur à Perl dans ce sens.

 Définir des classes
Une classe est définie par :
classe nom_de_classe :
suite-de-code
ou
classe nom_de_classe(classe_de_base):
suite-de-code
•La suite de définition de classe (bloc de code) peut
contiennent des définitions de fonctions membres, etc.

•base_classes contiendrait toutes les classes qui

cette classe hérite de
 Données des membres
•Attributs de classe (données membres) définis dans le
la définition de la classe elle-même est commune à la classe
(remarque : le bloc de code dans une définition de classe
s'exécute en fait la première fois que la définition de la classe
est rencontré, et non lorsque des objets de classe
sont instanciés)
•Attributs de classe définis pour un objet spécifique de
une certaine classe se tient uniquement avec cela
objet particulier (souvent défini en utilisant le "self"
mot-clé, voir ci-dessous)
 Exemple de classe
classe Étudiant :

course = "CHEM 3412"

def __init__(self, nom, test1=0, test2=0):

[Link] = name

self.test1 = test1

self.test2 = test2

def calculer_moyenne(self):

retourner ((self.test1 + self.test2) / 2)

def imprimer_données(self):

imprimer "La note de %s en %s est de %4.1f" %

([Link], [Link], self.calculer_moyenne())

David = Student("David", 90, 100)

Bob = Étudiant("Bob", 60, 80)

David.imprimer_données()

Bob.imprimer_données()
 Commentaires sur l'exemple de l'élève

•Appeler une fonction avec le même nom que le

le nom de la classe crée un objet de cela
classe; la fonction réelle appelée est le __init__
fonction au sein de la classe (__init__ est la classe
constructeur)
Chaque fois que le constructeur est appelé, un différent
un objet de ce type est créé ; ces différents
les objets auront généralement des membres différents
données
 Commentaires sur l'exemple d'élève

•Note that the course name is kept common to all

étudiants (toutes les instances de la classe)
Cependant, les deux notes de test sont spécifiques à chacun
étudiant
Le mot-clé « self » a le même rôle que « this » dans
C++/Java --- cela pointe vers une instance spécifique de la
classe. Il est automatiquement fourni en premier
argument à toute fonction membre de classe, et cela doit
être utilisé lors de la référence à des données/fonctions de membre
d'une classe (même si ce sont des données membres partagées entre tous
instances d'une classe)
 Surcharge des opérateurs

•Certains opérateurs (comme ==, +, -, *) peuvent être

surcharge pour travailler sur des types de données définis par l'utilisateur
(classes) ainsi que des types intégrés comme les entiers
•Pour voir si deux objets sont égaux, surchargez le
opérateur == et implémenter une fonction qui
peut comparer deux instances de votre utilisateur-
type de données défini (classe). Cela se fait par
définir la fonction __eq__ pour la classe; voir
exemple suivant
 Point exemple
classe Point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y

def __eq__(self, autre):

return self.x == other.x et self.y == other.y

a = Point()
b = Point(1,1)

imprimer a==b
 Fancier équivaut à vérifier

Nous pourrions être un peu plus en sécurité et nous assurer que

la comparaison est en réalité entre deux objets de
même type, sinon retourner un drapeau indiquant
que cette comparaison n'est pas implémentée par notre
Classe Point :

si pas isinstance(other, Point):

renvoyer non implémenté
sinon
retourne self.x == other.x et self.y == other.y
 Surcharge d'autres comparaisons
•Il existe d'autres opérateurs de comparaison que nous pouvons
surcharge pour les types de données définis par l'utilisateur :

__lt__(self, other) x < y

__le__(self, autre) x<= y
__eq__(self, other) x == y
__ne__(self, other) x != y
__ge__(self, other) x >= y
__gt__(self, other) x > y
 Pas de surcharge des signatures d'appel

Dans d'autres langages comme le C++, nous pouvons surcharger

les fonctions membres se comportent différemment selon
sur combien d'arguments (et quels types de
les arguments) sont passés à la fonction
•Python ne fonctionne pas comme ça : la dernière foncti
défini avec un nom donné est celui qui sera
utilisé
classe A :
déf méthode(self, x):
…
def methode(self, x, y):
cette définition remplace la précédente
 Héritage

Une classe peut hériter d'une autre classe,

permettant une hiérarchie de classes

•Si la classe A hérite de la classe B, alors la classe B est

une superclasse de la classe A, et la classe A
a automatiquement accès à tous les membres
données et fonctions membres de la classe B
•Si la classe A redéfinit certaines fonctions membres ou
les données des membres qui sont également présentes dans la classe B,

alors la définition dans A prévaut sur

cela dans la classe B
 Inheritance Example
classe Classe1 :
def __init__(self, data=0):
[Link] = data

def afficher(self):
imprimer [Link]
classe Classe2(HéritageClasse1):
def carré(self):
[Link] = [Link] * [Link]

a = Classe2(5)
[Link]() # fonction membre spécifique à la Classe2
[Link]() # fonction membre héritée de Classe1
 Syntaxe alternative pour les appels de méthode

•Au lieu d'appeler des méthodes à travers leurs objets, nous pouvons également
appelez-les par le nom de la classe :
x = SomeClass()
x.méthode1()
-ou-
SomeClass.méthode1(x)
Utile si nous devons garantir qu'un constructeur de superclasse
fonctionne aussi bien que le constructeur de sous-classe :
classe Class2(Class1):
def __init__(self, données):
Class1.__init__(self, données)
...nouveau code pour Class2 ici...
 __getitem__
Nous pouvons surcharger la syntaxe d'indexation des tableaux avec __getitem__

classe testit:
def __getitem__(self, n):
retourner [Link][n]

A = testit()
[Link] =“junk”

A[1]
'u'
 __getattr__ and __setattr_
•Ces fonctions attrapent les références d'attributs pour
une classe. __getattr__ attrape toutes les tentatives de
obtenir un attribut de classe (via, par exemple, [Link], etc.)
et __setattr__ intercepte toutes les tentatives de définir un
attribut de classe (par exemple, [Link] = "Bob")

•Doit faire attention à __setattr__, car tout

les instances de [Link]=value deviennent
self.__setattr__('attr', valeur), et cela peut
empêcher d'écrire du code tel que
[Link]=valeur dans la définition de __setattr__ !
 Utiliser __setattr__

Classe SomeClass :
def __setattr__(self, attr, value):
self.__dict__[attr] = value

cela évite la syntaxe comme [Link] = valeur

que nous ne pouvons pas avoir dans la définition
 __str__ et __repr__
__str__ est destiné à fournir une représentation "conviviale" de
la classe pour l'impression

__repr__ est censé fournir une chaîne qui pourrait être

interprété comme code pour reconstruire l'instance de la classe

classe Nombre :
def __init__(self, data):
[Link] = data
def __repr__(self):
return 'Nombre(%s)' % [Link]

a = Nombre(5)
imprimer un
Nombre(5)
 destructeurs

•__del__ est un destructeur, qui est appelé

automatiquement lorsqu'une instance est en cours de
supprimé (il n'est plus utilisé, et c'est
l'espace est récupéré pendant "les ordures"
collection")
•Python normally cleans up the memory used
par une instance automatiquement, donc ce genre de
il n'est généralement pas nécessaire de mettre dans un
destructeur ; par conséquent, ils peuvent être moins nécessaires
que dans, par exemple, C++
 Chapitre 13 : Programmation CGI

Introduction aux programmes CGI

Packages CGI Python

Exemple de script de formulaire CGI
 Introduction à la programmation CGI

CGI : Interface de passerelle commune

•Doit généralement être exécuté à partir de
/var/www/cgi-bin sur un serveur web
Standard pour les scripts Web et les formulaires Web

•Sortie : la première ligne de sortie doit identifi

le texte comme HTML. Le reste devrait (habituellement)
en fait par HTML formaté
Il y a deux manières de transmettre des informations
à un script web : GET et POST
 Sortie
•Première ligne :
print"Content-type: text/html\n"# besoin \n
•Tout le reste sera transmis pour
interprétation par le navigateur web du client. Simple
le texte s'imprimera généralement correctement, mais typiquement vous voulez

formatter en HTML
(HTML)
•Ces notes n'expliqueront pas le HTML de base ; cel
l'information est facile à trouver ailleurs
 Entrée
•GET : les paires mot-clé/valeur peuvent venir dans
par le protocole "GET". Ils sont transmis
au script en tant qu'extensions à l'URL, par exemple :
[Link]
•POST : Les données sont transmises via un formulaire q
commence avec ce code HTML :
<FORM method=POST action="[Link]">
 Astuces d'entrée GET
•Avec GET, faites attention car certains
les caractères doivent être "échappés" s'ils doivent
être transmis dans l'URL. Cela peut être
fait facilement et automatiquement par

import urllib
tmpstr = '<a href="[Link]?name=s">' % \
(urllib.quote_plus(nom))
•Pendant que nous y sommes, les articles allant dans
HTML peut également nécessiter d'être échappé ; cela peut être fait.

cela avec [Link](). Fait surtout, mais pas

exactement, la même chose que urllib.quote_plus()
Exemple de formulaire
• htmlform = """ Entrée POST
»<FORM method=POST action="[Link]">
»<P>
> <table>
<tr><td>Nom :</td>
<td><input type=text name=name size=40 value="%(name)s" /></td></tr>
<tr><td>Emploi :</td>
<td><input type=text name=job size=40 value="%(job)s" /></td></tr>
»<tr><td>Years with company:</td>
»<td>
<select name=years value=%(years)s>
»<option value="1" %(years1)s>1</option>
»<option value="2" %(years2)s>2</option>
»<option value="3" %(years3)s>3</option>
»</select>
»</td></tr>
»<tr><td>Gestionnaire :</td>
<td><input type=checkbox name=manager value="1"
%(managerchecked)s></td>
»</tr>
»<tr><td><input type="submit" name="send" value="Submit"></td>
»"""
imprimer htmlform % suppdata
 Lire l'entrée
Python fournit un module unifié qui peut
analyser à la fois les entrées GET et POST (ou les deux
simultanément)

import cgi # pour analyser le CGI

import cgitb # pour imprimer les messages d'erreur CGI
[Link]()

form = [Link]() # analyser le formulaire

 Lire l'entrée
•Extraire les données du formulaire

data = {}
pour champ dans ('nom', 'emploi', 'années', 'responsable'):
si non form.has_key(champ) :
data[field] = ""
sinon :
si type(form[field]) != liste :
data[field] = form[field].value
sinon : # fusionner les listes en chaîne avec des et
values = [[Link] for x in form[field]]
data[field] = ' and '.join(values)
 Lire l'entrée

J'aime séparer les « métadonnées » des données.

'send' field will be set if the form got submitted
(pas la première fois que le formulaire est affiché à l'utilisateur)

suppdata = {}
pour champ dans ('envoyer',):
si pas form.has_key(champ):
suppdata[field] = ""
sinon :
si type(form[field]) != liste:
suppdata[field] = form[field].value
sinon :
values = [[Link] for x in form[field]]
suppdata[field] = ' and '.join(values)
 Lire l'entrée
•Remplissez plus de données supplémentaires ; référez-vous à
le formulaire HTML pour voir où tout cela va dans
le formulaire
si data['manager'] == "1":
suppdata['managerchecked'] = "checked"
sinon :
suppdata['managerchecked'] = ""

suppdata['years1'] = ""
suppdata['years2'] = ""
suppdata['years3'] = ""

si data['years'] == "1":
suppdata['years1'] = "selected"
elif data['years'] == "2":
suppdata['years2'] = "selected"
elif data['years'] == "3":
suppdata['years3'] = "selected"

# fusionner toutes les données{} dans suppdata{}

[Link]àjour(données)
Le reste du script ([Link])
si (suppdata['send'] == "Soumettre"):
# effectuez tous les tests des données du formulaire ici

si (data['name'] == "" ou data['job'] == "") :

imprimer html_header
imprimer htmlform % suppdata
Erreur : vous devez remplir les champs nom et emploi !
imprimer le pied de page HTML

sinon :
Téléchargez des données dans une base de données ici
# imprimer ok à l'utilisateur
imprimer en-tête_html
Ajouter des données à la base de données.<br />
print "nom=%s, travail=%s, années=%s.<br />\n" % \
(data['name'], data['job'], data['years'])
print "Est",
si (données['manager'] == "1"):
imprime "un manager.<br />\n"
sinon :
pas un gestionnaire.<br />
Nouvelles données soumises !<br />
imprimer le pied de page html

sinon : # si cela n'a pas été soumis

imprimer l'en-tête html
imprimer htmlform % suppdata
imprimer pied de page html