INTRODUCTION

Chapitre 1

En 1989, Guido Van Rossum commenca à travailler sur Python qui

n’était alors qu’un projet lui servant d’occupation durant les vacances

de Noël pendant lesquelles son bureau était fermé.

Le but de Guido était d’inventer un successeur au langage ABC, un

langage d’aprentissage peu apprécié dans le milieu académique.

Pour cela, il fit appel directement à des utilisateurs Unix habitués au

langage C. il voulu que Python soit facilement utilisable dans d’autres

langages et environnement contrairement à ABC. Il y réussi

globalement…

Le nom Python donné au langage provient d’une série anglaise

appelée « Monty Python Flying Circus »

1. Un petit historique…

2. Apercu de ses caractéristiques…

Gratuit

Python est placé sous Général Public License. Il est facilement downloadable sur www.python.org

Langage Script

Tout comme Perl, Tcl et Rexx, Python fait partie des langages script interpretés contairement à Java, au C/C++ qui sont des langages compilés. Ce qui lui permet

d’être plus rapide au develloppement, de comporter moins de ligne (50% de moins). Par contre, Il est plus lent à l’execution.

Portable

Python est portable entre les differentes variantes de Unix ainsi que sur les OS propiétaires comme Mac OS, BEOs, MS-DOS et les differentes

versions de Windows

Extensible

Au-delà de la multitude de librairies et de modules déjà existente, il est possible d’en dévellopper pour ses propres besoins.

Modulable

Python permet de séparer les programmes en modules qui peuvent être réutilisés dans d'autres programmes en Python

Orienté Objet

Python est orienté-objet. Il supporte l'héritage multiple et la surcharge des opérateurs.

Syntaxe aisée

La syntaxe de Python est très simple et, combinée à de nombreux types de données évolués (comme les listes, dictionnaires,tuples...), ce qui conduit à des

programmes à la fois très compacts et très lisibles. De plus, Python ne nécessite aucune déclaration de variable. Les variables sont créées lors de leur première

assignation.

Peu d’erreurs…

Tout comme Java ou Ada, Python porssède un systeme d’exception qui facilite la gestion des erreurs.

Gestion des ressources

Python gère ses ressources (mémoire, descripteurs de fichiers...) sans intervention du programmeur, par un mécanisme de comptage de références

Case sensitive

Une instruction par ligne

• Scripts d’administration systemes

ex : Les programmes d'administration système spécifiques à la distribution

Red Hat Linux.

•Tous les dévelloppement lié à l’internet et en particulier au web (moteur de

recherche, navigateur…)

ex : moteurs de recherche yahoo et infoseek

•Accès aux bases de donnée (contextuelle)

• Réalisations d’interfaces graphiques utilisateurs.

•Utilisation pour la résolution de calculs scientifiques

ex : Python est notamment utilisé pour les fusée de la NASA

• …

3. Domaines d’application

Le language Python

Parler à Python

https://docs.continuum.io/anaconda

Allons parler à Python...

Que disons-nous?

Phrases ou Lignes

x =2

x =x +2

print x

Variable Opérateur Constante Mot réservé

Instruction d'assignation

Assignation d’une expression

Instruction Print (sur écran)

Programmation de paragraphes

Scripts Python

• Python en mode interactif est pratique pour expérimenter avec des

programmes longs de 3-4 lignes

• La plupart des programmes sont beaucoup plus longs, c’est pourquoi nous

les écrivons dans un fichier afin que python exécute les commandes à partir

de ce fichier

• D’une certaine manière nous “donnons à Python un script”

•Comme convention, nous ajoutons le suffixe “.py”à la fin de ces fichiers pour

indiquer qu’ils contiennent des instructions Python

Ecrire un programme simple

Interactif contre script

•Interactif

• Vous tapez directement dans Python une ligne après l’autre et

vous obtenez la réponse

•Script

• Vous écrivez une suite d’instructions (lignes) dans un fichier en

vous servant d’un éditeur de texte et dites à Python d’exécuter les

instructions du fichier

Etape de programme ou

Flux de programme

• Tout comme une recette ou des instructions d’installation, un

programme est une séquence de pas à faire dans l’ordre

• Certaines étapes sont conditionnelles -elles peuvent être “sautées”

• Parfois une étape ou un groupe d’étapes doivent être répétés

• Parfois nous stockons un ensemble d'étapes qui doivent être

réitérées au besoin à différents endroits du programme (Chapitre 4)

Etapes Sequentielles

Programme:

x = 2

print x

x = x + 2

print x

Sortie:

x = 2

print x

x = x + 2

print x

Quand un programme s’éxecute, il passe d’une étape à la

suivante. En tant que programmeurs, nous mettons en place

des “chemins”que le programme doit suivre. Chapitre 2

Etapes

Conditionnelles

Sortie:

Smaller

Finis

Programme:

x = 5

if x < 10:

print 'Smaller’

if x > 20:

print 'Bigger'

print 'Finis'

x = 5

X < 10 ?

print 'Smaller'

X > 20 ?

print 'Bigger'

print 'Finis'

Oui

Chapitre 3

Oui

Etapes Répétées

Sortie:

Blastoff!

Programme:

n=5

while n>0:

print n

n=n–1

print 'Blastoff!'

n > 0 ?

n = n -1

Les boucles (étapes répétées) ont des variables

d’itération qui changent à chaque cycle de boucle.

Souvent ces variables d’itération suivent une séquence

de nombres.

Non

print 'Blastoff'

Chapitre 5

Oui

n = 5

print n

Variables, Expressions, et

Instructions

Constantes

•Les valeurs fixes telles que les nombres, lettres, et les chaînes

sont appelées “constantes”- parce que leur valeur ne change

pas

•Les constantes numériques sont comme vous les voulez

•Les constantes de chaîne utilisent

l’apostrophe simple (') ou double (")

>>> print 123

123

>>> print 98.6

98.6

>>> print 'Hello world'

Hello world

Les Variables

•Une variable est un nom placé à un endroit de la mémoire où un

programmeur peut stocker des données et récupérer ensuite les

données en utilisant le “nom”de la variable

•Il appartient aux programmeurs de choisir le nom des variables

• Il est possible de changer le contenu d’une variable lors d’une

affectation ultérieure

12.2

x = 12.2

y= 14

Les Variables

12.2

x = 12.2

y= 14

100

x= 100

•Une variable est un nom placé à un endroit de la mémoire où un

programmeur peut stocker des données et récupérer ensuite les

données en utilisant le “nom”de la variable

•Il appartient aux programmeurs de choisir le nom des variables

• Il est possible de changer le contenu d’une variable lors d’une

affectation ultérieure

Les règles de nommage des

Variables Python

• Commencent obligatoirement par une lettre ou un sousligné _

• Contiennent des lettres, des nombres et des souslignés

• Sont sensibles à la case Majuscule-Minuscule

•Bon: spam eggs spam23 _speed

•Mauvais: 23spam #sign var.12

•Divers: spam Spam SPAM

Mots réservés

and del for is raise assert elif

from lambda return break else

global not try class except if or

while continue exec import pass

yield def ﬁnally in print as with

•Vous ne pouvez pas prendre les mots réservés comme noms

de variables / identifiants

Phrases ou Lignes

x=2

x=x+2

print x

Variable Opérateur Constante Mot réservé

Instruction d'assignation

Assignation d’une expression

Instruction Print (sur écran)

Instructions d’assignation

•Nous attribuons une valeur à une variable avec l’instruction

d’assignation (=)

•Une instruction d’assignation consiste d’une expression su le côté

droit et une variable pour stocker le résultat

x= 3.9 *x *( 1 -x)

x = 3.9 * x * ( 1 - x )

0.6

L’expression est à droite. Une fois

que l’expression est évaluée, le

résultat est placé (assigné à) x.

60.

0.9

Une variable est une allocation

mémoire utilisée pour stocker une

valeur (0.6)

x = 3.9 * x * ( 1 - x )

0.6 0.93

L’expression est à droite. Une fois que

l’expression est évaluée, le résultat est

placé (assigné à) la variable, côté

gauche (c-à-d x).

0.93

Une variable est une allocation mémoire

utisée pour stocker une valeur. La valeur

stockée dans une variable peut être mise

à jour en remplaçant la valeur

précédente (0.6) par une nouvelle valeur

(0.93).

Expressions Numériques

•En raison du manque de symboles

mathématiques sur les claviers

d’ordinateur- nous utilisons “le dialecte

de l’ordinateur”pour exprimer les

opérations mathématiques classiques

• L’astérisque est la multiplication

• L’exposant (élévation à la puissance) est

representé différemment qu’en

mathématiques.

Operateur Opération

+Addition

-Soustraction

Multiplication

/Division

** Puissance

Reste (Modulo)

>>> xx = 2

>>> xx = xx +2

>>> print xx

>>> yy = 440 *12

>>> print yy

5280

>>> zz = yy /1000

>>> print zz

>>> jj = 23

>>> kk = jj % 5

>>> print kk

>>> print 4 ** 3

Operateur Opération

+Addition

Soustraction

Multiplication

/Division

** Puissance

%Reste

5 23

4 R 3

Expressions Numériques

Ordre d’évaluation

• Quand nous chaînons les opérateurs ensemble - Python doit

connaître leur ordre de traitement

• Ceci est appelé “priorité des opérateurs”

• Quel est l’opérateur qui “a une priorité” sur les autres ?

x= 1 +2 * 3 -4/ 5 ** 6

Règles de priorité des opérateurs

Règle de la priorité la plus haute à la plus basse:

• Les parenthèses sont toujours respectées

• L’exposant (élévation à la puissance)

•Multiplication, division, et reste

•Addition et soustraction

• De gauche à droite

Parenthèses

Puissance

Multiplication

Addition

De gauche à

droite

Parenthèses

Puissance

Multiplication

Addition

De gauche à

droite

1 + 2 ** 3 / 4 * 5

1 + 8 / 4 * 5

1 + 2 * 5

1 + 10

>>> x = 1 + 2 ** 3 / 4 * 5

>>> print x

>>>

Priorité des operateurs

•Souvenez-vous de les règles du haut vers le bas

• Quand vous écrivez du code -utilisez les parenthèses

• Quand vous écrivez du code - gardez les expressions

mathématiques assez simple pour être comprises

• Décomposez de longues séries d’opérations mathématiques afin de

les rendre plus lisibles

Parenthèses

Puissance

Multiplication

Addition

De gauche à

droite

Question d’examen: x = 1 + 2 * 3 -4

/ 5

La division entière de Python est

étrange!

• La division entière tronque les

décimales

• La division à virgule flottante

produit des nombres à virgules

flottante

>>> print 10 /2

>>> print 9 /2

>>> print 99 / 100

>>> print 10.0 /2.0

5.0

>>> print 99.0 /100.0

0.99

Cela change dans Python 3.0

Mélange de nombres entiers et à

virgules flottantes

•Quand vous effectuez une

opération où une opérande

est un entier et l’autre

opérande est une virgule

flottante, le résulta est une

virgule flottante

• L’entier est converti en une

virgule flottante avant

d’effectuer l’opération

>>> print 99 /100

>>> print 99 /100.0

0.99

>>> print 99.0 /100

0.99

>>> print 1 +2 *3 /

4.0 -5

-2.5

>>>

Que veut donc dire “Type”?

•Dans les variables Python, les

littérals et les constantes ont un

“type”

• Python connaît la différence

entre un nombre entier et une

chaîne

•Par example “+”signifie

“addition”pour les nombres et

“concaténation”pour les chaînes

>>> ddd = 1 + 4

>>> print ddd

>>> eee = 'hello ' +

'there'

>>> print eee

hello there

concaténer = mettre ensemble

Le type est important

>>> eee = 'hello ' + 'there'

>>> eee = eee + 1

Traceback (most recent call last):

File "<stdin>", line 1, in

TypeError: cannot concatenate 'str'

and 'int' objects

>>> type(eee)

>>> type('hello')

>>> type(1)

>>>

• Python connaît chaque “type”

disponible

• Certaines opérations sont

interdites

• Il n’est pas possible “d’ajouter 1”à

une chaîne

• Nous pouvons demander à

Python le type de quelque chose

en utilisant la fonction type()

Plusieurs Types de nombres

•Les nombres ont deux types principaux

• “int” sont des nombres entiers:

-14, -2, 0, 1, 100, 401233

• “float” sont des nombres à virgule

flottante et ont une partie décimale :

-2.5 , 0.0, 98.6, 14.0

• Il y a d’autres types de nombres - ce

sont des variantes des entiers et des

float

>>> xx = 1

>>> type (xx)

>>> temp = 98.6

>>> type(temp)

>>> type(1)

>>> type(1.0)

>>>

Les principaux opérateurs pour les types numériques

Tableau (dans un ordre de priorité croissant):

Conversions de type

•Quand nous utilisons des

entiers et des nombres à

virgule flottante dans une

expression, les entiers sont

implicitement convertis en

float

•On peut contrôler ceci avec les

fonctions “intégrées” int() et

float()

>>> print float(99) /100

0.99

>>> i = 42

>>> type(i)

>>> f = float(i)

>>> print f

42.0

>>> type(f)

>>> print 1 +2 *float(3) /4 -5

-2.5

>>>

Conversions

de chaîne

•On peut utiliser int() et

float() pour faire une

conversion de chaînes à

entiers

•On obtient une erreur si la

chaîne ne contient pas de

caractères numériques

>>> sval = '123'

>>> type(sval)

>>> print sval +1

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: cannot concatenate 'str' and

'int'

>>> ival = int(sval)

>>> type(ival)

>>> print ival + 1

124

>>> nsv = 'hello bob'

>>> niv = int(nsv)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ValueError: invalid literal for int()

Entrées de l’utilisateur

•Nous pouvons instruire

Python de s’arrêter et de

lire les données de

l’utilisateur avec la

fonction input()

•La fonction input()

retourne une chaîne

nam = input(“Qui êtes-vous?”)

print (“Bienvenue”, nam)

Qui êtes-vous? Samy

Bienvenue Samy

Convertir l’entrée

utilisateur

•Si nous voulons lire un

nombre de l’utilisateur,

nous devons le convertir

de chaîne à nombre avec

une fonction de

conversion de type

•Plus tard nous verrons

comment traiter les

mauvaises entrées

inp = input("introduir un numero")

usf = int(inp) + 1

print ("le numero incremente", usf)

Les commentaires dans Python

•Tout ce qui suit # est ignoré par Python

•A quoi sert des commentaires?

• A décrire ce qui se passe dans une séquence de code

• A documenter qui a écrit le code ou d’autres informations auxiliaires

• Désactiver une ligne de code - peut-être temporairement

Opérations sur les chaînes

•Quelques opérateurs s’appliquent aux

chaînes

•+implique “concaténation”

•*implique “concaténation multiples”

• Python sait quand il traite une chaîne ou

un nombre et agit en conséquence

>>> print( “abc” +“123”)

abc123

>>> print(“Hi” *5)

HiHiHiHiHi

>>>

Exercice

Ecrire un programme qui demande à l’utilisateur

ses heures et son taux horaire afin de calculer le

salaire brut.

Combien d’heures?: 35

Taux horaire: 2.75

Paye: 96.25

Exécution Conditionnelle

Etapes Conditionnelles

Sortie:

Smaller

Finis

Programme:

x = 5

if x < 10:

print 'Smaller’

if x > 20:

print 'Bigger'

print 'Finis'

x = 5

X < 10 ?

print 'Smaller'

X > 20 ?

print 'Bigger'

print 'Finis'

Oui

Opérateurs de Comparaison

•Les expressions Booléennes

questionnent et répondent par Oui

ou Non, ce qui nous permet de

contrôler le cours du programme

•Les expressions Booléennes qui

utilisent les opérateurs de

comparaison évaluent par - Vrai /

Faux - Oui / Non

•Les opérateurs de comparaison

contrôlent les variables mais ne les

change pas

Souvenez-vous: “=”sert à l’affectation.

Python Signification

<Inférieur à

<= Inférieur ou égal à

== Egal à

>= Supérieur ou égal à

>Plus grand que

!= Différent de

Opérateurs de Comparaison

x = 5

if x == 5 :

print 'Egal 5'

if x > 4 :

print 'Plus grand que 4’

if x >= 5 :

print 'Plus grand ou égal à 5'

if x < 6 : print 'Inférieur à 6'

if x <= 5 :

print 'Inférieur ou égal à 5’

if x != 6 :

print 'Différent de 6'

Egal à 5

Plus grand que 4

Plus grand ou égal à 5

Inférieur à 6

Inférieur ou égal à 5

Différent de 6

Décisions à sens unique

x = 5

print (“Premier 5”)

if x == 5 :

print (“C’est 5”)

print (“Toujours

5”)

print (“Troisième

5”)

print (“Après 5”)

print (“Avant 6”)

if x == 6 :

print (“C’est 6”)

print (“Toujours

6”)

print (“Troisième

6”)

print 'Après 6'

Premier 5

C’est 5

Toujours 5

Troisième 5

Après 5

Premier 6

Après 6

X == 5 ?

Oui

print 'Toujours 5'

print 'Troisième 5'

Non print 'C’est 5'

Indentation

• Augmenter l’indentation après la déclaration if ou la déclaration for (après : )

• Maintenir l’indentation pour indiquer la portée du bloc (les lignes qui sont

affectées par if/for)

• Ramener l’indentation au retour du niveau de la décaration if ou for afin

d’indiquer la fin du bloc

•Les lignes blanches sont ignorées -elles n’affèctent pas l’indentation

•Les commentaires sur une ligne sont de soit ignorés au regard de

l’indentation

x = 5

if x > 2 :

print 'Bigger than 2'

print 'Still bigger'

print 'Done with 2'

for i in range(5) :

print i

if i > 2 :

print 'Bigger than 2'

print 'Done with i', i

print 'All Done'

augmente / maintient après if ou for

diminue pour indiquer la fin du bloc

x = 5

if x > 2 :

print 'Bigger than 2'

print 'Still bigger'

print 'Done with 2'

for i in range(5) :

print i

if i > 2 :

print 'Bigger than 2'

print 'Done with i', i

print 'All Done'

Pensez au début/fin des blocs

x > 1

print 'Plus que un'

x < 100

print 'Moins que 100'

print 'Tout fait'

Oui

non

x = 42

if x > 1 :

print 'Plus que un'

if x < 100 :

print 'Moins que 100'

print 'Tout fait'

Décisions

imbriquées

Décisions à

deux voies

•Parfois nous voulons faire

une chose si l’expression

est vraie et autre chose si

l'expression est fausse

• C’est comme une

bifurcation sur la route -

nous devons choisir un

chemin ou l’autre mais

pas les deux

x > 2

print 'Bigger'

ouinon

X = 4

print 'Not bigger'

print 'All Done'

Deux voies

utilisant else :

x = 4

if x > 2 :

print 'Bigger'

else :

print 'Smaller'

print 'All done'

x > 2

print 'Bigger'

ouinon

X = 4

print 'Smaller'

print 'All Done'

x > 2

print 'Bigger'

ouinon

X = 4

print 'Smaller'

print 'All Done'

x = 4

if x > 2 :

print 'Bigger'

else :

print 'Smaller'

print 'All done'

Deux voies

utilisant else :

if x < 2 :

print 'Small'

elif x < 10 :

print 'Medium'

else :

print 'LARGE'

print 'All done'

x < 2 print 'Small'

oui

non

print 'All Done'

x<10 print 'Medium'

oui

print 'LARGE'

non

Voies multiples

x = 0

if x < 2 :

print 'Small'

elif x < 10 :

print 'Medium'

else :

print 'LARGE'

print 'All done'

x < 2 print 'Small'

oui

non

X = 0

print 'All Done'

x<10 print 'Medium'

oui

print 'LARGE'

non

Voies multiples

x = 5

if x < 2 :

print 'Small'

elif x < 10 :

print 'Medium'

else :

print 'LARGE'

print 'All done'

x < 2 print 'Small'

oui

non

X = 5

print 'All Done'

x<10 print 'Medium'

oui

print 'LARGE'

non

Voies multiples

x = 20

if x < 2 :

print 'Small'

elif x < 10 :

print 'Medium'

else :

print 'LARGE'

print 'All done'

x < 2 print 'Small'

oui

non

X = 20

print 'All Done'

x<10 print 'Medium'

oui

print 'LARGE'

non

Voies multiples

# No Else

x = 5

if x < 2 :

print 'Small'

elif x < 10 :

print 'Medium'

print 'All done'

if x < 2 :

print 'Small'

elif x < 10 :

print 'Medium'

elif x < 20 :

print 'Big'

elif x< 40 :

print 'Large'

elif x < 100:

print 'Huge'

else :

print 'Ginormous'

Voies multiples

Puzzles à voies multiples

if x < 2 :

print 'Below 2'

elif x < 20 :

print 'Below 20'

elif x < 10 :

print 'Below 10'

else :

print 'Something else'

if x < 2 :

print 'Below 2'

elif x >= 2 :

print 'Two or more'

else :

print 'Something

else'

Quelle ligne ne sera

jamais imprimée à

l’écran?

Boucles et Itérations

Répétition d’opérations

Programme:

n=5

while n>0:

print n

n=n–1

print 'Feu !'

print n

n > 0 ?

Les boucles (répétition d’opérations) possèdent des variables

d’itération dont la valeur change à chaque parcours de la boucle.

Ces variables d’itération sont souvent numériques : leurs valeurs

successives seront alors une séquence de nombres.

Non

print 'Feu !'

Oui

n = 5

print n

Affichage:

Feu !

n = n -1

Une boucle sans fin

(on parle de boucle infinie)

n=5

while n>0:

print 'Laver’

print 'Rincer'

print 'Sècher!'

n > 0 ?

Non

print 'Sècher!'

Oui

n = 5

print 'Laver'

print 'Rincer'

Quel est le problème de cette boucle?

Une autre Boucle

n=0

while n>0:

print 'Laver’

print 'Rincer'

print 'Sècher!'

n > 0 ?

Non

print 'Sècher!'

Oui

n = 0

print 'Laver'

print 'Rincer'

Que fait cette boucle ?

S’échapper d’une boucle

•Le mot-clé break met fin à la boucle courante et réalise un saut vers

l’instruction suivant immédiatement cette boucle.

•Assimilable à un test réalisable n’importe où dans le corps de la

boucle.

> Bonjour

Bonjour

> termine

termine

> fini

Fini!

while True:

ligne =input('> ')

if ligne == 'fini' :

break

print ligne

print 'Fini!'

S’échapper d’une boucle

•Le mot-clé break met fin à la boucle courante et réalise un saut vers

l’instruction suivant immédiatement cette boucle.

•Assimilable à un test réalisable n’importe où dans le corps de la

boucle.

while True:

ligne =input('> ')

if ligne == 'fini' :

break

print ligne

print 'Fini!'

> Bonjour

Bonjour

> termine

termine

> fini

Fini!

True ?

Non

print 'Fini!'

Oui

....

...

while True:

ligne =input('> ')

if ligne == 'fini' :

break

print ligne

print 'Fini!' break

Le mot-clé continue met fin à l’itération actuelle, réalise un saut

vers le début de la boucle et démarre une nouvelle itération.

while True:

ligne =input('> ')

if ligne[0] == '#' :

continue

if ligne == 'fini' :

break

print ligne

print 'Fini!'

> bonjour

bonjour

> # a ne pas afficher

> a afficher!

a afficher!

> fini

Fini!

Terminer une itération avec

“continue”

Terminer une itération avec “continue”

Le mot-clé continue met fin à l’itération actuelle, réalise un saut vers le

début de la boucle et démarre une nouvelle itération

while True:

ligne =raw_input('> ')

if ligne[0] == '#' :

continue

if ligne == 'fini' :

break

print ligne

print 'Fini!'

> bonjour

bonjour

> # a ne pas afficher

> a afficher!

a afficher!

> fini

Fini!

True ?

Non

print 'Fini!'

Oui

while True:

ligne =raw_input('> ’)

if ligne[0] == '#' :

continue

if ligne == 'fini' :

break

print ligne

print 'Fini!' ...

....

continue

Boucle indéfinie

• Les boucles “While” sont qualifiées de “boucles indéfinies” car elles

s’éxécutent jusqu’à ce qu’une condition logique devienne fausse

• Pour les boucles rencontrées jusqu’ici, il est assez facile de

déterminer si elles se termineront ou seront des “boucles infinies”

• Il est parfois plus ardue d’être sûr qu’une boucle se terminera

Boucles définies

• Bien souvent on dispose d’une liste d’éléments, par exemple des

lignes dans un fichier - constituant un ensemble fini d’éléments

•On peut construire une boucle qui sera parcourue une fois pour

chacun des éléments d’un ensemble en utilisant le mot-clé Python

for

• Ces boucles sont appelées “boucles définies” car elles s’exécutent

un nombre fini de fois

•On dit que “les boucles définies itèrent en suivant les éléments d’un

ensemble”

Une boucle définie simple

for iin [5, 4, 3, 2, 1] :

print i

print 'Feu !'

Feu !

Une boucle définie par des chaînes

amis = ['Joseph', 'Glenn', 'Sally']

for ami in amis :

print 'Bonne année :', ami

print 'Fini!'

Bonne année : Joseph

Bonne année : Glenn

Bonne année : Sally

Fini!

Une boucle définie

simple

for iin [5, 4, 3, 2, 1] :

print i

print 'Feu !'

Feu !

Fini?

Oui

print 'Feu !'

print i

Non

valeur i suivante

Les boucles définies ont des variables d’itération explicites

dont la valeur change à chaque parcours de la boucle. Ces

variables d’itération parcourent la séquence ou l’ensemble

les définissant.

Zoom sur “In”

•La variable d’itération “itère”

le long d’une séquence

(ensemble ordonné)

•Le bloc (corps) de code est

exécuté une fois pour

chaque valeur (in) de la

séquence

•La variable d’itération

parcourt l’ensemble des

valeurs de la séquence

for iin [5, 4, 3, 2, 1] :

print i

variable d’itération Séquence de 5 éléments

Fini?

Oui

print i

Non

valeur i suivante •La variable d’itération “itère”le long

d’une séquence (ensemble

ordonné)

•Le bloc (corps) de code est exécuté

une fois pour chaque valeur (in) de

la séquence

•La variable d’itération parcourt

l’ensemble des valeurs de la

séquence

for iin [5, 4, 3, 2, 1] :

print i

Fini?

Oui

print i

Non

valeur i suivante

print i

i = 5

print i

i = 4

print i

i = 3

print i

i = 2

print i

i = 1

for iin [5, 4, 3, 2, 1] :

print i

Boucles définies

• Bien souvent on dispose d’une liste d’éléments, par exemple des

lignes dans un fichier - constituant un ensemble fini d’éléments

•On peut construire une boucle qui sera parcourue une fois pour

chacun des éléments d’un ensemble en utilisant le mot-clé Python

for

• Ces boucles sont appelées “boucles définies” car elles s’exécutent

un nombre fini de fois

•On dit que “les boucles définies itèrent en suivant les éléments d’un

ensemble”

Structure des boucles:

Regardons ce qui se passe

Note: Même si ces exemples sont simples, les

structures présentées ici s’appliquent à toutes les

sortes de boucles

Construire des boucles

“intelligentes”

Quand on est coincé à écrire du

code qui effectue une étape à la

fois, l'astuce est d'avoir une

connaissance claire de ce qui doit

arriver dans la boucle.

Définir la valeur initiale des

variables

Toujours effectuer une

tâche à la fois :

Rechercher, modifier ou

mettre à jour une

variable.

qui agissent sur les données:

Vérifier les variables

Effectuer une boucle dans un

ensemble

print 'Avant'

for thing in [9, 41, 12, 3, 74, 15] :

print thing

print 'Après'

$ python

basicloop.py

Avant

Après

Quel est le plus grand nombre?

le plus grand

(jusqu’à présent) : -1

41 12 974 15

Quel est le plus grand nombre?

Trouver la plus grande valeur

largest_so_far = -1

print 'Avant', largest_so_far

for the_num in [9, 41, 12, 3, 74, 15] :

if the_num > largest_so_far :

largest_so_far = the_num

print largest_so_far, the_num

print 'Après', largest_so_far

$python largest.py

Avant -1

41 41

41 12

41 3

74 74

74 15

Après 74

Nous créons une variable qui contient la plus grande valeur vue jusqu’à présent. Si un

nouveau nombre apparait plus grand, il devient la nouvelle plus grande valeur.

Comptage dans une boucle

compteur = 0

print 'Avant', zork

for thing in [9, 41, 12, 3, 74, 15] :

compteur = compteur + 1

print compteur, thing

print 'Après', compteur

$python countloop.py

Avant 0

1 9

241

312

4 3

5 74

6 15

Après 6

Afin de compter combien de fois une boucle est exécutée, nous introduisons une

variable "compteur" qui est initialisé à 0 et à laquelle nous ajoutons 1 pour chaque

exécution du corps de la boucle.

Addition dans une boucle

accumulateur = 0

print 'Avant', accumulateur

for valeur in [9, 41, 12, 3, 74, 15] :

accumulateur = accumulateur +valeur

print accumulateur, valeur

print 'Après', accumulateur

$python countloop.py

Avant 0

50 41

62 12

65 3

139 74

154 15

Après 154

Nous voulons additionner une valeur que nous rencontrons dans une boucle, nous

introduisons une variable accumulateur initialisée à 0 et nous ajoutons la valeur à la

somme à chaque passage dans la boucle.

Une boucle pour trouver la

moyenne

count = 0

sum = 0

print 'Avant', count, sum

for value in [9, 41, 12, 3, 74, 15] :

count = count + 1

sum = sum + value

print count, sum, value

print 'Après', count, sum,sum / count

$ python averageloop.py

Avant 00

199

250 41

362 12

465 3

5139 74

6154 15

Après 6154 25

La moyenne combine le modéle du comptage et de l’addition et

divise la somme lorsque la boucle se termine.

Filtrer les valeurs dans une boucle

print 'Avant'

for value in [9, 41, 12, 3, 74, 15] :

if value > 20:

print 'Grand nombre',value

print 'Après'

$ python search1.py

Avant

Grand nombre 41

Grand nombre 74

Après

Pour identifier/filtrer une valeur particulière, nous

utiliserons l’instruction if à l'intérieur du corps de la boucle.

Recherche avec la variable

Boolean

found = False

print 'Avant', found

for value in [9, 41, 12, 3, 74, 15] :

if value == 3 :

found = True

print found, value

print 'Après', found

$ python search1.py

Avant False

False 9

False 41

False 12

True 3

True 74

True 15

Après True

Si nous voulons juste chercher et savoir si une valeur a été trouvée, nous utilisons

une variable booléenne initialisée à False puis déclarée comme True dès que nous

avons trouvé ce que nous recherchions.

Quel est le plus petit nombre?

Le plus petit jusqu’à présent: -1

41 12 374 15

Quel est le plus petit nombre?

Quel est le plus grand nombre?

Le plus grand jusqu’à

présent:

941 12 374 15

Quel est le plus petit nombre?

Le plus petit jusqu’à présent: None

Quel est le plus grand nombre?

Le plus grand jusqu’à

présent:

smallest = None

print 'Avant'

for value in [9, 41, 12, 3, 74, 15] :

if smallest is None :

smallest = value

elif value < smallest :

smallest = value

print smallest, value

print 'Après', smallest

$python smallest.py

Avant

941

912

374

315

Après 3

Nous avons encore une variable smallest qui est “la plus petite jusqu'à présent”. Avant

le premier passage dans la boucle smallest est déjà initialisé à None, puis la première

(valeur) value devient smallest (le minimum) .

Trouver la plus petite valeur

Les opérateurs “is” et “is not”

• Python a un opérateurr is qui est

utilisé dans les expressions logiques

• Signifie “est le même que”

• Comparable à == mais dans un sens

plus fort

•is not est également un opérateur

logique

smallest = None

print 'Avant'

for value in [3, 41, 12, 9, 74, 15] :

if smallest is None :

smallest = value

elif value < smallest :

smallest = value

print smallest, value

print 'Après', smallest

La structure try / except

•Délimiter une section de code dangereux avec try et except

•Si le code dans try fonctionne - except est ignoré

•Si le code dans try échoue - le code dans except est exécuté

$ cat notry.py

astr = 'Hello Bob’

istr = int(astr)

print 'First', istr

astr = '123’

istr = int(astr)

print 'Second', istr

$ python notry.py

Traceback (most recent call last):

File "notry.py", line 2, in <module>

istr = int(astr)ValueError: invalid literal

for int() with base 10: 'Hello Bob'

Fait

$ python notry.py

Traceback (most recent call last):

File "notry.py", line 2, in <module>

istr = int(astr)ValueError: invalid literal

for int() with base 10: 'Hello Bob'

programme

s’arrêtte ici

Fait

$ cat notry.py

astr = 'Hello Bob’

istr = int(astr)

print 'First', istr

astr = '123’

istr = int(astr)

print 'Second', istr

Logiciel

Périphériques

d’entrée Unité

Centrale

(UC)

Mémoire

principale

Périphériques

de sortie

Mémoire

secondaire

ordinateur

universel

$ cat tryexcept.py

astr = 'Hello Bob'

try:

istr = int(astr)

except:

istr = -1

print 'First', istr

astr = '123'

try:

istr = int(astr)

except:

istr = -1

print 'Second', istr

$ python tryexcept.py

First -1

Second 123

Quand la première conversion

échoue - il tombe dans la clause

except: et le programme continue.

Quand la seconde conversion

réussie - il saute la clause except:

et le programme continue.

try / except astr = 'Bob'

astr = 'Bob'

try:

print 'Hello'

istr = int(astr)

print 'There'

except:

istr = -1

print 'Done', istr

print 'Hello'

print 'There'

istr = int(astr)

print 'Done', istr

istr = -1

Filet de

sécurité

Exemple try / except

$ python trynum.py

Entrer un nombre:42

Excellent

$ python trynum.py

Entrer un

nombre:fourtytwo

N’est pas un nombre

rawstr = input('Entrer un nombre:')

try:

ival = int(rawstr)

except:

ival = -1

if ival > 0 :

print 'Excellent'

else:

print 'N’est pas un nombre'

Exercice

Récrire votre programme de paie pour donner à

l’employé 1.5 fois le taux horaire pour les heures

travaillées plus de 40 heures.

Entrer les heures: 45

Entrer le taux: 10

Payer: 475.0

475 = 40 * 10 + 5 * 15

Récrire votre programme de paie en utilisant try et

except de sorte qu’il gère les entrées non-numériques.

Entrer les heures: 20

Entrer le taux: neuf

Erreur, s’il vous plaît entrez un numérique

Entrer les heures: quarante

Erreur, s’il vous plaît entrez un numérique

Exercice

Les Fonctions

Les étapes stockées (et

réutilisées)

Sortie:

Hello

Fun

Zip

Hello

Fun

Programme:

def thing():

print 'Hello’

print 'Fun’

thing()

print 'Zip’

thing()

def

print 'Hello'

print 'Fun'

hello()

print “Zip”

On appèle ces morceaux de code réutilisables des “fonctions”

hello():

hello()

Les fonctions dans Python

•Il y a deux sortes de fonctions dans Python.

•Les fonctions intégrées ou prédéfinies qui sont fournies par Python

-input(), type(), float(), int() ...

•Les fonctions que nous définissons et utilisons nous même

•On considère le nom des fonctions intégrées comme de

"nouveaux" mots réservés (on ne les utilise pas pour nommer des

variables)

La définition d’une fonction

•En Python, une fonction est du code réutilisable qui prend un ou des

argument(s) en entrée, réalise des actions, et renvoie un ou des

résultats

• On définie une fonction à l’aide du mot réservé def

•On appelle une fonction en utilisant son nom, des parenthèses, et

un/des argument(s) dans une expression

>>> big = max('Hello world')

>>> print big

>>> tiny = min('Hello world')

>>> print tiny

>>>

big = max('Hello world')

Argument

'w'

Résultat

Assignation

Fonction Max

>>> big = max('Hello world')

>>> print big

max()

function

“Hello world”

(une chaîne)

‘w’

(une chaîne)

Une fonction est une

partie de code. Une

fonction prend une

certaine entrée et produit

une sortie.

Guido a écrit ce code

Fonction Max

def max(inp):

blah

for x in y:

blah

Guido a écrit ce code

>>> big = max('Hello world')

>>> print big

“Hello world”

(une chaîne)

‘w’

(une chaîne)

Une fonction est une

partie de code. Une

fonction prend une

certaine entrée et produit

une sortie.

Conversions de

Type

• Lors de l’utilisation d’un

entier et d’un nombre

flottant dans une expression,

l’entier est implicitement

converti en virgule flottante

•La conversion est possible

avec les fonctions intégrées

int() et float()

>>> print float(99) /100

0.99

>>> i = 42

>>> type(i)

>>> f = float(i)

>>> print f

42.0

>>> type(f)

>>> print 1 +2 *float(3) /4 -5

-2.5

>>>

Conversions

de Chaînes

• Il est possible d’utiliser int()

et float() pour la conversion

entre chaînes et entiers

•On obtiendra une erreur si

la chaîne ne contient pas

de caractères numériques

>>> sval = '123'

>>> type(sval)

>>> print sval +1

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: cannot concatenate 'str'

and 'int'

>>> ival = int(sval)

>>> type(ival)

>>> print ival + 1

124

>>> nsv = 'hello bob'

>>> niv = int(nsv)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ValueError: invalid literal for int()

Construire nos propres Fonctions

• Créer une nouvelle fonction à l’aide du mot-clé def suivi de

paramètres optionnels entre parenthèses.

•Indenter le corps de la fonction

•Cela défini la fonction mais ne va pas exécuter le corps de la

fonction

def print_lyrics():

print "I'm a lumberjack, and I'm okay.”

print 'I sleep all night and I work all day.'

x= 5

print 'Hello'

def print_lyrics():

print "I'm a lumberjack, and I'm okay.”

print 'I sleep all night and I work all day.'

print 'Yo'

x= x+2

print x

Hello

print "I'm a lumberjack, and I'm okay."

print 'I sleep all night and I work all day.'

print_lyrics():

Définitions et Usages

•Une fois la fonction définie, nous pouvons l’appeler (ou l’invoquer)

autant de fois que nous voulons

• C’est le modèle stocker et réutiliser

x= 5

print 'Hello'

def print_lyrics():

print "I'm a lumberjack, and I'm okay.”

print 'I sleep all night and I work all day.'

print 'Yo'

print_lyrics()

x= x+2

print x

Hello

I'm a lumberjack, and I'm okay.

I sleep all night and I work all day.

Arguments

•Un argument est une valeur que nous passons dans la fonction comme

entrée quand nous appelons la fonction

•Nous utilisons les arguments afin de diriger la fonction à faire différents

choses quand nous l’appelons à des moments différents

•Nous mettons les arguments entre parenthèses après le nom de la

fonction

big = max('Hello world')

Argument

Paramètres

Un paramètre est une variable

que nous utilisons dans la

définition de la fonction. C’est

un “titre”qui permet au code

dans la fonction d’accéder aux

arguments pour l’invocation

d’une fonction particulière.

>>> def greet(lang):

... if lang == 'es':

... print 'Hola’

... elif lang == 'fr':

... print 'Bonjour’

... else:

... print 'Hello’

...

>>> greet('en')Hello

>>> greet('es')Hola

>>> greet('fr')Bonjour

>>>

Valeurs de Return

Souvent une fonction aura ses arguments, fera des calculs, pour

retourner une valeur qui servira de valeur à l’appel de fonction dans

l’expression appelante. C’est le rôle du mot-clé return.

def greet():

return "Hello”

print greet(), "Glenn”

print greet(), "Sally"

Hello Glenn

Hello Sally

Arguments,Paramètres, et Resultats

>>> big = max('Hello world')

>>> print big

def max(inp):

blah

for x in y:

blah

return ‘w’

“Hello world”‘w’

Argument

Paramètre

Résultat

Paramètres Multiples / Arguments

• Plus d’un paramètre peut

être défini dans la définition

de la fonction

•Ont ajoute simplement plus

d’arguments quand on

appelle la fonction

•Nous adaptons le nombre

et l'ordre des arguments et

des paramètres

def addtwo(a, b):

added = a+ b

return added

x = addtwo(3, 5)

print x

Fonctions Void (infructueuses)

•Quand une fonction ne retourne pas de valeur, on l’appelle une

fonction "void"

•Les fonctions qui retournent des valeurs sont des fonctions

"fructueuses"

•Les fonctions Void sont "infructueuses"

Fonctions ou pas fonctions...

•Organisez votre code sous forme de “paragraphes”- en capturant

une pensée complète et “nommez la”

• Ne vous répétez pas- Faites que cela fonctionne une fois et alors

réutilisez le

• Si quelque chose devient trop long ou trop complexe, séparez-le en

parties logiques et mettez ces morceaux en fonctions

• Construisez une bibliothèque des opérations que vous répétez

continuellement - peut-être partagez là avec vos ami(e)s...

Exercice

Récrire le programme de calcul de la paie sur la base

d’une fois et demie en heures supplémentaires et

créez une fonction appelée computepay qui prend

deux paramètres ( heures et taux).

Entrer les heures: 45

Entrer le taux: 10

Payer: 475.0

475 = 40 * 10 + 5 * 15

Les Chaînes

Chapitre 6

Le type de

données Chaînes

• Une chaîne est une séquence de

caractères

• Une chaîne utilise les guillemets

simples 'Hello'ou doubles “Hello”

• Entre chaînes, + signifie “concaténer”

• Une chaîne peut aussi contenir des

nombres

• Les nombres au format chaîne peuvent

être convertis en nombre avec int()

>>> str1 = "Hello”

>>> str2 = 'there'

>>> bob = str1 + str2

>>> print bob

Hellothere

>>> str3 = '123'

>>> str3 = str3 + 1

Traceback (most recent call

last): File "<stdin>", line

1, in <module>TypeError:

cannot concatenate 'str' and

'int' objects

>>> x = int(str3) + 1

>>> print x

124

>>>

Lecture et

Conversion

•Il est préférable de lire les

données d’entrée avec strings

pour ensuite convertir ces

données avec le type voulu

•Ceci nous donne plus de contôle

dans les situations où il y a des

erreurs et/ou sur les entrées

erronnées de l’utilisateur

•Pour obtenir un type numérique

avec input() il est nécessaire de

convertir la chaîne

>>> name =input('Enter:')

Enter:Chuck

>>> print name

Chuck

>>> apple =input('Enter:')

Enter:100

>>> x =apple –10

Traceback (most recent call

last): File "<stdin>", line 1,

in <module>TypeError:

unsupported operand type(s) for

-: 'str' and 'int'

>>> x=int(apple) –10

>>> print x

Un coup d’oeil à l’intérieur

des chaînes

• On peut faire appel à un caractère

contenu dans une chaîne en utilisant un

index mis entre crochets

• La valeur de l’index doit être un entier et

le premier élément commence à zéro

• La valeur de l’index peut être le résulat

d’une expression

>>> fruit = 'banana'

>>> letter = fruit[1]

>>> print letter

>>> n= 3

>>> w= fruit[n-1]

>>> print w

Un caractère trop loin

•Vous aurez une erreur python si

vous essayez l’indexation au-

delà de la fin d’une chaîne.

•Soyez donc prudents lors de la

construction des valeurs d’index

et des tranches

>>> zot ='abc'

>>> print zot[5]

Traceback (most recent call

last): File "<stdin>", line

1, in <module>IndexError:

string index out of range

>>>

Les chaînes ont une longueur

•Il y a une fonction intégrée len qui

nous renvoie la longueur de la

chaîne >>> fruit = 'banana'

>>> print len(fruit)

La fonction Len

>>> fruit ='banana'

>>> x= len(fruit)

>>> print x

fonction

len()

'banana'

(une chaîne)

(un nombre)

Guido a écrit ce code

Une fonction est un type

de code stocké pour notre

usage. Une fonction prend

une entrée et produit une

sortie.

def len(inp):

blah

for x in y:

blah

>>> fruit ='banana'

>>> x= len(fruit)

>>> print x

La fonction Len

Une fonction est un type

de code stocké pour notre

usage. Une fonction prend

une entrée et produit une

sortie.

'banana'

(une chaîne)

(un nombre)

Boucler les chaînes

•En utilisant la déclaration

while et une variable

d’itération ,ainsi que la

fonction len, on peut

construire une boucle pour

visualiser individuellement

chaque lettre présente dans

la chaîne

fruit = 'banana'

index = 0

while index < len(fruit):

letter = fruit[index]

print index, letter

index = index +1

0 b

1 a

2 n

3 a

4 n

5 a

•Une boucle définie avec la

déclaration for est beaucoup

plus élégante

•la variable d’itération est

complètement prise en

charge par la boucle for

fruit = 'banana'

for letter in fruit:

print letter

Boucler les chaînes

index = 0

while index < len(fruit) :

letter = fruit[index]

print letter

index = index +1

fruit = 'banana'

for letter in fruit :

print letter

Boucler les chaînes

•Une boucle définie avec la

déclaration for est beaucoup

plus élégante

•la variable d’itération est

complètement prise en

charge par la boucle for

Boucles et comptages

•Voici une boucle simple qui lit

une lettre après l’autre de la

chaîne et qui compte le

nombre de fois où la boucle

rencontre la lettre 'a'

word = 'banana'

count = 0

for letter in word :

if letter == 'a' :

count = count +1

print count

Regardons plus en détail in

for letter in 'banana' :

print letter

Variable d’itération

Chaîne desix caractères

•La variable d’itération

“parcourt” la séquence

(ensemble ordonné)

•Le bloc (corps) du code est

exécuté une fois pour chaque

valeur in de la séquence

•la variable d’itération se

déplace à travers toutes les

valeurs in de la séquence

Fait?

Oui

print letter

Lettre suivante

for letter in 'banana' :

print letter

b a n a n a

La variable d’itération “parcourt” la chaîne. Le bloc du code est

exécuté une fois pour chaque valeur in de la séquence

Non

•On peut aussi prendre en

considération n’importe quelle

section continue d’une chaîne à

l’aide des deux points

•La valeur du second nombre

est au-delà de la fin de la

tranche - “jusqu’à mais non

inclu”

•Si le second nombre est au-

delà de la fin de la chaîne, il

s’arrête à la fin Tranchage de Chaînes

>>> s= 'Monty

Python'

>>> print s[0:4]

Mont

>>> print s[6:7]

>>> print s[6:20]

Python

5 6

•Si on omet le premier

nombre ou le dernier de la

tranche, ils deviennent

respectivement le début ou

la fin de la chaîne

>>> s= 'Monty Python'

>>> print s[:2]

>>> print s[8:]

Thon

>>> print s[:]

Monty Python

5 6

Tranchage de Chaînes

Concaténation de chaîne

•Quand l’opérateur +est

utilisé avec les chaînes, il

signifie "concaténation"

>>> a= 'Hello'

>>> b= a+'There'

>>> print b

HelloThere

>>> c= a+' ' + 'There'

>>> print c

Hello There

>>>

Utiliser in comme opérateur

•Le mot-clé in peut aussi

être utilisé pour vérifier si

une chaîne est contenue

dans une autre chaîne

•L’expression in est une

expression logique qui

retourne True ou False et

peut être utilisée dans une

condition if

>>> fruit = 'banana’

>>> 'n' in fruit

True

>>> 'm' in fruit

False

>>> 'nan' in fruit

True

>>> if 'a' in fruit :

... print 'Found it!’

...

Found it!

>>>

Comparison de chaînes

if word == 'camarade':

print 'D’accord, camarades.'

if word <'camarade':

print 'Ton mot,' +word +', vient avant camarade.’

elif word >'camarade':

print 'Ton mot,' +word +', vient après camarade.’

else:

print 'D’accord, camarades.'

Bibliothèque chaîne

• Python dispose d’un nombre de

fonctions chaînes, lesquelles sont

dans la bibliothèque chaîne (string)

•Ces fonctions sont déjà intégrées dans

chaque chaîne -l’appel à celles-ci se

fait en ajoutant la fonction à la

variable chaîne

•Ces fonctions ne modifient pas la

chaîne d’origine, au lieu de cela elles

renvoient une nouvelle chaîne qui a

été transformée

>>> greet ='Hello Bob'

>>> zap =greet.lower()

>>> print zap

hello bob

>>> print greet

Hello Bob>

>> print 'Hi There'.lower()

hi there

>>>

Recherche d’une chaîne

•On utilise la fonction find() pour

rechercher une sous-chaîne à

l’intérieur d’une chaîne

•find() trouve la première occurrence

de la sous-chaîne

•Si la sous-chaîne n’est pas trouvée,

find() retourne -1

•Rappelez-vous que la position de la

chaîne débute à zéro

>>> fruit ='banana'

>>> pos =

fruit.find('na')

>>> print pos

>>> aa =fruit.find('z')

>>> print aa

-1

Changer tout en MAJUSCULE

•On peut faire la copie d’une

chaîne en minuscule ou majuscule

•Souvent quand on recherche une

chaîne avec find() - on converti

d’abord la chaîne en minuscule

afin de rechercher une chaîne

indépendamment de la casse

>>> greet ='Hello Bob'

>>> nnn = greet.upper()

>>> print nnn

HELLO BOB

>>> www =greet.lower()

>>> print www

hello bob

>>>

Recherche et Substitution

•La fonction replace() agit

comme l’opération

“rechercher et remplacer”

dans un traitement de

texte

•Elle remplace toutes les

occurrences de l’ancienne

chaîne par la nouvelle

chaîne

>>> greet = 'Hello Bob'

>>> nstr =

greet.replace('Bob','Jane')

>>> print nstr

Hello Jane

>>> nstr = greet.replace('o','X')

>>> print nstrHellXBXb

>>>

Suppression des espaces

•Parfois nous voulons supprimer

les espaces au début et/ou à la

fin d’une chaîne

•lstrip() et rstrip() supprime

respectivement les espaces à

gauche ou à droite de la chaîne

•strip() supprime à la fois les

espaces au début et à la fin de la

chaîne

>>> greet =' Hello Bob '

>>> greet.lstrip()

'Hello Bob '

>>> greet.rstrip()

' Hello Bob'

>>> greet.strip()

'Hello Bob'

>>>

>>> line = 'Nous vous souhaitons une bonne journée’

>>> line.startswith('Nous')

True

>>> line.startswith('n')

False

Préfixes

>>> data = 'From stephen.marquard@uct.ac.za Sat Jan 5

09:14:16 2008’

>>> atpos = data.find('@')

>>> print atpos

>>> sppos = data.find(' ',atpos)

>>> print sppos

>>> host = data[atpos+1: sppos]

>>> print host

uct.ac.za

From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008

21 31

Les Listes

Une Liste est une sorte de

Collection

•Une collection nous permet de mettre plusieurs valeurs dans une

seule “variable”

•Une collection est pratique car elle nous permet de transporter plein

de valeurs dans un unique paquet.

amis =[ 'Joseph', 'Glenn', 'Sally' ]

affaires =[ ’chaussettes', ’chemise', 'parfum' ]

Qu’est-ce qui n’est pas une

“Collection”

La plupart de nos variables contiennent une valeur - lorsque nous

ajoutons une autre valeur à notre variable, l’ancienne valeur est

remplacée

$ python

Python 2.5.2 (r252:60911, Feb 22 2008, 07:57:53)

[GCC 4.0.1 (Apple Computer, Inc. build 5363)] on darwin

>>> x= 2

>>> x= 4

>>> print x

Les Constantes de Listes

•Les constantes de listes sont

entourées par des crochets et les

éléments des listes sont séparés par

des virgules

•Une liste d’éléments peut être

n’importe quel objet Python -même

une autre liste

•Une liste peut être vide

>>> print [1, 24, 76]

[1, 24, 76]

>>> print ['red', 'yellow',

'blue']

['red', 'yellow', 'blue']

>>> print ['red', 24, 98.6]

['red', 24, 98.599999999999994]

>>> print [ 1, [5, 6], 7]

[1, [5, 6], 7]

>>> print []

[]

Nous utilisons déjà des listes!

for iin [5, 4, 3, 2, 1] :

print i

print 'off!'

off!

Les Listes et les boucles définies –

les meilleures amies

friends = ['Joseph', 'Glenn', 'Sally']

for friend in friends :

print ’Bonne année:', friend

print ’Fini!'

Bonne année: Joseph

Bonne année: Glenn

Bonne année: Sally

Fini!

Effectuer des recherches

dans les listes

Tout comme les chaînes, nous pouvons atteindre chaque

élément d’une liste grâce à un index specifié dans des crochets

Joseph

>>> amis = [ 'Joseph', 'Glenn', 'Sally' ]

>>> print amis[1]

Glenn

>>>

Glenn

Sally

Les Listes sont

Mutables

• Les chaînes sont “immutables” –

nous ne pouvons pas changer le

contenu d’une chaîne- nous

devons créer une nouvelle

chaîne afin de pouvoir le

modifier

• Les listes sont “mutables’ –nous

pouvons changer un élément

d’une liste en utilisant

l’opérateur index

>>> fruit = 'Banane'

>>> fruit[0]= 'b'

Traceback

TypeError: 'str' object does not

support item assignment

>>> x= fruit.lower()

>>> print x

banane

>>> lotto = [2, 14, 26, 41, 63]

>>> print lotto

[2, 14, 26, 41, 63]

>>> lotto[2]= 28

>>> print lotto

[2, 14, 28, 41, 63]

Quelle est la Longueur d’une

Liste?

•La fonction len() prend comme

paramètre une liste et indique le

nombre d’éléments présents dans la

liste

•En fait len() peut nous indiquer le

nombre d’ éléments présents dans

n’importe quel ensemble ou

séquence (tel que les chaînes de

caractères...)

>>> greet = 'Hello Bob'

>>> print len(greet)

>>> x= [ 1, 2, 'joe', 99]

>>> print len(x)

>>>

Utilisation de la fonction range

•La fonction range nous donne

une liste de nombres qui varient

entre zéro et un de moins que le

paramètre

• Nous pouvons créer un index en

boucle en utilisant for et un

itérateur entier

>>> print range(4)

[0, 1, 2, 3]

>>> amis = ['Joseph', 'Glenn', 'Sally']

>>> print len(amis)

>>> print range(len(amis))

[0, 1, 2]

>>>

Le conte de deux boucles...

amis = ['Joseph', 'Glenn', 'Sally']

for ami in amis :

print ’Bonne année:', ami

for iin range(len(amis)) :

ami = amis [i]

print ’Bonne année:', ami Bonne année: Joseph

Bonne année: Glenn

Bonne année: Sally

>>> amis = ['Joseph', 'Glenn', 'Sally']

>>> print len(amis)

>>> print range(len(amis))

[0, 1, 2]

>>>

Concaténer des listes à l’aide du +

• Nous pouvons créer une nouvelle

liste en additionnant deux listes

existantes

>>> a= [1, 2, 3]

>>> b= [4, 5, 6]

>>> c= a +b

>>> print c

[1, 2, 3, 4, 5, 6]

>>> print a

[1, 2, 3]

Les Listes peuvent être tranchées

à l’aide du :

>>> t= [9, 41, 12, 3, 74, 15]

>>> t[1:3]

[41,12]

>>> t[:4]

[9, 41, 12, 3]

>>> t[3:]

[3, 74, 15]

>>> t[:]

[9, 41, 12, 3, 74, 15]

Souvenez-vous: Tout

comme avec les chaînes, le

deuxième nombre est

“jusqu’à mais sans inclure”

Méthodes des Listes

>>> x= list()

>>> type(x)<type 'list'>

>>> dir(x)['append', 'count', 'extend', 'index',

'insert', 'pop', 'remove', 'reverse', 'sort']

>>>

Créer une liste à partir de zéro

• Nous pouvons créer une liste

et ensuite y ajouter des

éléments en utilisant la

méthode append

•La liste reste ordonnée et les

nouveaux éléments sont

ajoutés en queue de liste

>>> stuff = list()

>>> stuff.append('book')

>>> stuff.append(99)

>>> print stuff

['book', 99]

>>> stuff.append('cookie')

>>> print stuff

['book', 99, 'cookie']

Est-ce que c’est dans (in) une

Liste?

•Python fournit deux

opérateurs qui vous

permettent de vérifier si un

élément se trouve dans une

liste

• Ce sont des opérateurs

logiques qui nous donnent

en réponse True ou False

•Ils ne modifient pas la liste

>>> some = [1, 9, 21, 10, 16]

>>> 9in some

True

>>> 15 in some

False

>>> 20 not in some

True

>>>

Une Liste est une Séquence

Ordonnée

•Une liste peut comprendre

plusieurs éléments et les garder

dans l’ordre jusqu’à ce que nous

décidions d’en changer l’ordre

•Une liste peut être triée

(i.e., son ordre peut être

changer)

• La méthode sort (à la différence

des chaînes) signifie

“trie/organise-toi”

>>> friends = [ 'Joseph', 'Glenn', 'Sally' ]

>>> friends.sort()

>>> print friends

['Glenn', 'Joseph', 'Sally']

>>> print friends[1]

Joseph

>>>

Les Fonctions Internes et les

Listes

•Il y a un nombre de

fonctions dans Python qui

permettent de définir des

listes en tant que paramètres

•Vous souvenez-vous des

boucles que nous avons

contruites? C’est bien plus

simple que cela.

>>> nums = [3, 41, 12, 9, 74, 15]

>>> print len(nums)

>>> print max(nums)

>>> print min(nums)

>>> print sum(nums)

154

>>> print sum(nums)/len(nums)

numlist = list()

while True :

inp = input(’Entrer un nombre: ')

if inp == ’fini' : break

value = float(inp)

numlist.append(value)

moyenne = sum(numlist) / len(numlist)

print ’moyenne:', moyenne

total = 0

count = 0

while True :

inp = input('Entrer un nombre: ')

if inp == ’fini' : break

value = float(inp)

total = total + value

count = count + 1

moyenne = total / count

print ’moyenne:', moyenne

Entrer un nombre: 3

Entrer un nombre: 9

Entrer un nombre: 5

Entrer un nombre: fini

Moyenne: 5.66666666667

Les Chaînes et les Listes : les

meilleures amies

>>> abc = 'With three words'

>>> stuff =abc.split()

>>> print stuff

['With', 'three', 'words']

>>> print len(stuff)

>>> print stuff[0]

With

>>> print stuff

['With', 'three',

'words']

>>> for win stuff :

... print w

...

With

Three

Words

>>>

La méthode Split fractionne une chaîne en plusieurs morceaux et produit une

liste de chaînes. Ces listes de chaînes sont alors à considérer comme étant des

mots. Nous pouvons accèder à un mot ou à une chaîne en particulier en

passant par tous les mots.

>>> line ='A lot of spaces'

>>> etc =line.split()

>>> print etc['A', 'lot', 'of', 'spaces']

>>>

>>> line ='first;second;third'

>>> thing =line.split()

>>> print thing['first;second;third']

>>> print len(thing)

>>> thing =line.split(';')

>>> print thing['first', 'second', 'third']

>>> print len(thing)

>>>

●Lorsque vous ne spécifiez pas de délimiteur, les espaces multiples sont considérés comme

étant un délimiteur

●Vous pouvez spécifiez quel caractère délimiteur utiliser dans le splitting (fractionnement)

Le motif double Split

• Parfois nous fractionnons une ligne d’une façon, puis nous en

selectionnons une partie que nous allons fractionner davantage

['stephen.marquard', 'uct.ac.za']

From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008

words = line.split()

email = words[1]

print pieces[1]

Le motif double Split

['stephen.marquard', 'uct.ac.za']

• Parfois nous fractionnons une ligne d’une façon, puis nous en

selectionnons une partie que nous allons fractionner davantage

From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008

words = line.split()

email = words[1]

pieces = email.split('@')

print pieces[1]

stephen.marquard@uct.ac.za

Le motif double Split

• Parfois nous fractionnons une ligne d’une façon, puis nous en

selectionnons une partie que nous allons fractionner davantage

['stephen.marquard', 'uct.ac.za']

From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008

words = line.split()

email = words[1]

pieces = email.split('@')

print pieces[1]

stephen.marquard@uct.ac.za

'uct.ac.za'

fhand = open('mbox-short.txt')

for line in fhand:

line = line.rstrip()

if not line.startswith('From ') : continue

words = line.split()

print words[2]

Sat

Fri

...

From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008

>>> line = 'From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008’

>>> words = line.split()

>>> print words

['From', 'stephen.marquard@uct.ac.za', 'Sat', 'Jan', '5', '09:14:16', '2008']

>>>

Tuples

Chapitre 10

Les tuples sont comme les listes

• Les Tuples sont un autre type de séquence qui fonctionnent

plus ou moins comme une liste - ils ont des éléments dont

l’index commence à 0

>>> x= ('Glenn', 'Sally', 'Joseph')

>>> print x[2]Joseph

>>> y= ( 1, 9, 2 )

>>> print y

(1, 9, 2)

>>> print max(y)

>>> for iter in y:

... print iter

...

>>>

mais... les tuples sont “immutables”

•Contrairement aux listes, une fois qu’un tuple est créé, son

contenu ne peut être modifié -comme une chaîne

>>> x= [9, 8, 7]

>>> x[2] = 6

>>> print x

>>>[9, 8, 6]

>>>

>>> y= 'ABC'

>>> y[2] = 'D'

Traceback:'str'

object does

not support item

Assignment

>>>

>>> z= (5, 4, 3)

>>> z[2] = 0

Traceback:'tuple'

object does

not support item

Assignment

>>>

Les choses à ne pas faire avec

les tuples

>>> x= (3, 2, 1)

>>> x.sort()

Traceback:

AttributeError: 'tuple' object has no attribute 'sort'

>>> x.append(5)

Traceback:

AttributeError: 'tuple' object has no attribute 'append'

>>> x.reverse()

Traceback:

AttributeError: 'tuple' object has no attribute 'reverse'

>>>

Une histoire de deux séquences

>>> l= list()

>>> dir(l)

['append', 'count', 'extend', 'index', 'insert', 'pop',

'remove', 'reverse', 'sort']

>>> t= tuple()

>>> dir(t)

['count', 'index']

Les tuples sont plus efficaces

• Python n'ayant pas à construire des structures de tuple pour

être modifiable, ils sont plus simples et plus efficaces en termes

d'utilisation de la mémoire et de performances que les listes

•Donc dans notre programme lorsque nous utilisons des

“variables temporaires”, nous préférons les tuples aux listes

Tuples et affectation

• Nous pouvons également mettre un tuple sur le côté gauche

d'une instruction d'assignation

• Nous pouvons même omettre les parenthèses

>>> (x, y) = (4, 'fred')

>>> print y

Fred

>>> (a, b) = (99, 98)

>>> print a

Tuples et dictionnaires

• La méthode items()

dans les dictionnaires

retourne une liste de

(clé, valeur) n-uplets

>>> d = dict()

>>> d['csev'] = 2

>>> d['cwen'] = 4

>>> for (k,v) in d.items():

... print k, v

...

csev 2

cwen 4

>>> tups = d.items()

>>> print tups

[('csev', 2), ('cwen', 4)]

Les tuples sont comparables

•Les opérateurs de comparaison fonctionnent avec les tuples et

les autres séquences. Si le premier élément est égal, Python

continue à l'élément suivant et ainsi de suite, jusqu'à ce qu'il

trouve les éléments qui diffèrent.

>>> (0, 1, 2) <(5, 1, 2)

True

>>> (0, 1, 2000000) <(0, 3, 4)

True

>>> ( 'Jones', 'Sally' ) <('Jones', 'Sam')

True

>>> ( 'Jones', 'Sally') >('Adams', 'Sam')

True

Trier des listes de tuples

• Nous pouvons profiter de la possibilité de trier une liste de

tuples pour obtenir une version triée d'un dictionnaire

• Tout d'abord, nous trions le dictionnaire par la clé à l'aide de la

méthode items()

>>> d= {'a':10, 'b':1, 'c':22}

>>> t= d.items()

>>> t

[('a', 10), ('c', 22), ('b', 1)]

>>> t.sort()

>>> t

[('a', 10), ('b', 1), ('c', 22)]

Utilisation

de sorted()

>>> d= {'a':10, 'b':1, 'c':22}

>>> d.items()

[('a', 10), ('c', 22), ('b', 1)]

>>> t= sorted(d.items())

>>> t

[('a', 10), ('b', 1), ('c', 22)]

>>> for k, v in sorted(d.items()):

... print k, v

...

a 10

b 1

c 22

Nous pouvons le faire

plus directement à l'aide

de la fonction intégrée de

tri qui prend une

séquence en tant que

paramètre et retourne

une séquence triée

Trier par valeurs au lieu de la clé

•Si nous pouvons

construire une liste de

tuples de la forme

(valeur, clé) nous

pouvons trier par valeur

•Nous le faisons avec

une boucle for qui crée

une liste de tuples

>>> c= {'a':10, 'b':1, 'c':22}

>>> tmp = list()

>>> for k, v in c.items() :

... tmp.append( (v, k) )

...

>>> print tmp

[(10, 'a'), (22, 'c'), (1, 'b')]

>>> tmp.sort(reverse=True)

>>> print tmp

[(22, 'c'), (10, 'a'), (1, 'b')]

fhand = open('romeo.txt')

counts = dict()

for line in fhand:

words = line.split()

for word in words:

counts[word] = counts.get(word, 0 ) + 1

lst = list()

for key, val in counts.items():

lst.append( (val, key) )

lst.sort(reverse=True)

for val, key in lst[:10] :

print key, val

Les 10 mots les

plus courants

Version encore plus courte

http://wiki.python.org/moin/HowTo/Sorting

>>> c= {'a':10, 'b':1, 'c':22}

>>> print sorted([(v,k) for k,v in c.items() ])

[(1, 'b'), (10, 'a'), (22, 'c')]

La technique de ”List comprehension” crée une liste

dynamique. Dans ce cas, nous faisons une liste de tuples

inversées, puis nous la trions.

Les Dictionnaires

Qu’est-ce qu’une

Collection?

•Une collection est pratique car elle nous permet de transporter

plusieurs valeurs dans un même paquet.

•Nous avons un paquet de valeurs dans une seule “variable”

• Nous faisons cela en ayant plus d’une place dans la variable

• Nous avons des moyens de trouver les différentes places dans

la variable

Qu’est-ce qui n’est pas une

“Collection”

La plupart de nos variables contiennent une valeur - lorsque nous

ajoutons une autre valeur à notre variable, l’ancienne valeur est

remplacée

$ python

Python 2.5.2 (r252:60911, Feb 22 2008, 07:57:53)

[GCC 4.0.1 (Apple Computer, Inc. build 5363)] on

darwin

>>> x= 2

>>> x= 4

>>> print x

L’histoire des deux Collections…

•La Liste

>Une collection linéaire de valeurs qui restent ordonnées

•Le Dictionnaire

> Un “paquet”de valeurs ayant chacune leur propre

étiquette

Dictionnaires

argent

mouchoirs

calculatrice

parfum

bonbons

http://en.wikipedia.org/wiki/Associative_array

Les Dictionnaires

• Les Dictionnaires sont les collections de données les plus puissantes de Python

• Les Dictionnaires nous permettent de faire rapidement des opérations de type

base de données dans Python

• Les Dictionnaires ont des noms différents selon les différents langages

> Associative Arrays - Perl / PHP

> Properties ou Map ou HashMap - Java

> Property Bag - C# / .Net

http://en.wikipedia.org/wiki/Associative_array

Les Dictionnaires

•Les Listes indexent leur

entrée selon leur position

dans la liste

•Les Dictionnaires sont

comme des sacs -

désordonnés

•Donc nous indexons ces

diverses choses que nous

mettons dans un

dictionnaire grâce au

“lookup tag”

>>> sac = dict()

>>> sac[’argent'] = 12

>>> sac [’bonbons'] = 3

>>> sac [’mouchoirs'] = 75

>>> print sac

{’argent': 12, ’mouchoirs': 75, ’bonbons': 3}

>>> print sac [’bonbons']

>>> sac [’bonbons'] = sac [’bonbons'] + 2

>>> print sac

{’argent': 12, ’mouchoirs': 75, ’bonbons': 5}

Comparons les Listes aux

Dictionnaires

•Les Dictionnaires sont comme les Listes sauf qu’ils utilisent des clés

au lieu des nombres pour rechercher des valeurs

>>> lst = list()

>>> lst.append(21)

>>> lst.append(183)

>>> print lst[21, 183]

>>> lst[0] = 23

>>> print lst[23, 183]

>>> ddd = dict()

>>> ddd['age'] = 21

>>> ddd['cours'] = 182

>>> print ddd

{'cours': 182, 'age': 21}

>>> ddd['age'] = 23

>>> print ddd

{'cours': 182, 'age': 23}

>>> lst = list()

>>> lst.append(21)

>>> lst.append(183)

>>> print lst

[21, 183]

>>> lst[0] = 23

>>> print lst

[23, 183]

>>> ddd = dict()

>>> ddd['age'] = 21

>>> ddd['cours'] = 182

>>> print ddd

{'cours': 182, 'age': 21}

>>> ddd['age'] = 23

>>> print ddd

{'cours': 182, 'age': 23}

[0] 21

[1] 183

lll

Clé Valeur

['cours'] 183

['age'] 21 ddd

Clé Valeur

Liste

Dictionnaire

Les Littérales de Dictionnaires

(Constants)

• Les Littérales de Dictionnaires sont délimitées par des accolades et

comportent une listes de clés : des paires de valeurs

• Vous pouvez créer un dictionnaire vide à l’aide d’accolades vides

>>> jjj = { 'chuck' : 1, 'fred' : 42, 'jan': 100}

>>> print jjj

{'jan': 100, 'chuck': 1, 'fred': 42}

>>> ooo = { }

>>> print ooo

{}

>>>

Quel est le nom le plus fréquent?

csev

zhen

marquard

zhen

cwen

csev

marquard

zhen

marquard

csev

cwen

zhen

Quel est le nom le plus fréquent?

csev

zhen

marquard

zhen

cwen

csev

marquard

zhen

marquard

csev

cwen

zhen

Un dictionnaire: beaucoup de

compteurs possibles

•Une des utilisations courantes des

dictionnaires est celle de compteur qui

nous sert à compter le nombre de fois

que l’on “voit”quelque chose

Key Value

>>> ccc = dict()

>>> ccc['csev'] = 1

>>> ccc['cwen'] = 1

>>> print ccc

{'csev': 1, 'cwen': 1}

>>> ccc['cwen'] = ccc['cwen'] + 1

>>> print ccc

{'csev': 1, 'cwen': 2}

Les Tracebacks des Dictionnaires

• C’est une erreur de référencer une clé qui n’est pas dans un

dictionnaire

• Nous pouvons utiliser l’opérateur in pour vérifier si une clé est dans

le dictionnaire

>>> ccc = dict()

>>> print ccc['csev']

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

KeyError: 'csev'

>>> print 'csev' in ccc

False

Lorsque nous rencontrons un

nouveau nom

•Lorsque nous rencontrons un nouveau nom, nous devons ajouter une

nouvelle entrée au dictionnaire et si c’est la deuxième fois ou plus que

nous rencontrons le même nom, il nous suffit d’ajouter +1 au compte

dans le dictionnaire qui porte le même nom

counts = dict()

names = ['csev', 'cwen', 'csev', 'zqian',

'cwen']

for name in names :

if name not in counts:

counts[name] = 1

else :

counts[name] = counts[name] + 1

print counts {'csev': 2, 'zqian': 1, 'cwen': 2}

La méthode get pour les

dictionnaires

• Cette façon de vérifier si une

clé est déjà dans un

dictionnaire et d’assumer une

valeur par défaut s’il n’y a pas

de clé est tellement courante,

qu’il y a une méthode qui

s’appelle la méthode get() qui

le fait pour nous

if name in counts:

x = counts[name]

else :

x = 0

x = counts.get(name, 0)

La valeur clé de défaut if n’existe pas

(il n’y aura pas de Traceback). {'csev': 2, 'zqian': 1, 'cwen': 2}

Comptage simplifié avec get()

•Nous pouvons utiliser get() et fournir une valeur par défaut de zéro

lorsqu’une clé n’est pas encore dans le dictionnaire – et ensuite il

suffira tout simplement d’ajouter un +1 à cette valeur

counts = dict()

names = ['csev', 'cwen', 'csev', 'zqian', 'cwen']

for name in names :

counts[name] = counts.get(name, 0)+ 1

print counts

Défaut {'csev': 2, 'zqian': 1, 'cwen': 2}

counts = dict()

names = ['csev', 'cwen', 'csev', 'zqian', 'cwen']

for name in names :

counts[name] = counts.get(name, 0)+ 1

print counts

Comptage simplifié avec get()

La manière de Compter

counts = dict()

print ’Entrez une ligne de texte:'

line = raw_input('')

mots = line.split()

print ’Mots:', mots

print ’En train de compter...'

for mot in mots:

counts[mot] = counts.get(mot,0) + 1

print 'Compte', counts

En générale, pour compter les

mots d’une ligne de texte, la

phrase est fractionnée (split) en

mots, puis une analyse de cette

phrase (des mots qu’elle contient)

est lancée en boucle et un

dictionnaire est utilisé afin

d’obtenir le compte de chaque

mot individuellement

Compter des mots

python wordcount.py

Entrez une ligne de texte:

the clown ran after the car and the car ran into the tent

and the tent fell down on the clown and the car

Mots: ['the', 'clown', 'ran', 'after', 'the', 'car',

'and', 'the', 'car', 'ran', 'into', 'the', 'tent', 'and',

'the', 'tent', 'fell', 'down', 'on', 'the', 'clown',

'and', 'the', 'car']

En train de compter…

Compte {'and': 3, 'on': 1, 'ran': 2, 'car': 3, 'into': 1,

'after': 1, 'clown': 2, 'down': 1, 'fell': 1, 'the': 7,

'tent': 2}

Boucles définies et Dictionnaires

•Même si les dictionnaires ne sont pas organisés de façon ordonnée,

nous pouvons écrire une bloucle for qui passe par toutes les entrées

d’un dictionnaire –en fait la boucle, en recherchant les valeurs, prend

en compte toutes les clés du dictionnaire

>>> comptes = { 'chuck' : 1 , 'fred' : 42, 'jan': 100}

>>> for clé in comptes:

... print clé, comptes[clé]

...

jan 100

chuck 1

fred 42

>>>

Récupérer des listes de Clés et de

Valeurs

•Vous pouvez

obtenir une liste de

clés, valeurs, ou

d’objets (les deux) à

partir d’un

dictionnaire

>>> jjj = { 'chuck' : 1 , 'fred' : 42, 'jan': 100}

>>> print list(jjj)

['jan', 'chuck', 'fred']

>>> print jjj.clés()

['jan', 'chuck', 'fred']

>>> print jjj.valeurs()

[100, 1, 42]

>>> print jjj.objets()

[('jan', 100), ('chuck', 1), ('fred', 42)]

>>>

Qu’est-ce qu’un 'tuple'? – arrive

bientôt...

Bonus: Deux Variables d’Itération!

• Nous passons en boucle à

travers une paire de clé-

valeur dans un

dictionnaire en utilisant

*deux* variables

d’itération

• Pour chaque itération, la

première variable est la

clé et la seconde est la

valeur correspondante à la

clé

>>> jjj = { 'chuck' : 1 , 'fred' : 42,

'jan': 100}

>>> for aaa,bbb in jjj.items() :

... print aaa, bbb

...

jan 100

chuck 1

fred 42

>>>

[chuck] 1

[fred] 42

aaa bbb

[jan] 100

Lire des Fichiers

Chapitre 7

Logiciel

Périphériques

d’entrée-sortie

Unité

Centrale

(UC)

Mémoire

Principale

Mémoire

Secondaire

Il est temps de trouver

des Data avec lesquelles

s’entraîner!

ensuite?

if x < 3: print

From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008

Return-Path: <postmaster@collab.sakaiproject.org>

Date: Sat, 5 Jan 2008 09:12:18 -0500To:

source@collab.sakaiproject.orgFrom:

stephen.marquard@uct.ac.zaSubject: [sakai] svn commit: r39772 -

content/branches/Details:

http://source.sakaiproject.org/viewsvn/?view=rev&rev=39772

...

Fichiers R

Traitement de Fichiers

• Un fichier texte peut être considéré comme étant une séquence de

lignes

From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008

Return-Path: <postmaster@collab.sakaiproject.org>

Date: Sat, 5 Jan 2008 09:12:18 -0500

To: source@collab.sakaiproject.org

From: stephen.marquard@uct.ac.za

Subject: [sakai] svn commit: r39772 - content/branches/

Details: http://source.sakaiproject.org/viewsvn/?view=rev&rev=39772

http://www.py4inf.com/code/mbox-short.txt

Ouvrir un Fichier

• Avant de pouvoir lire le contenu du fichier, nous devons dire à

Python avec quel fichier nous désirons travailler et l’informer des

changements que nous voulons faire

• Nous faisons cela grâce à la fonction open()

•La fonction open() nous rend un “file handle”– une variable utilisée

afin d’effectuer des opérations sur un fichier

• Similaire à “File -> Open”du programme de traitement de texte

Word

Utiliser la fonction open()

•handle = open(nomdufichier, mode)

>Nous permet d’acquérir un handle utilisé pour manipuler des

fichiers

>Nomdufichier est une chaîne de caractères

>Le mode (de traitement) est optionnel et devrait être 'r' si nous

avons l’intention de lire le fichier et 'w' si nous avons l’intention

d’écrire dans le fichier

fhand = open('mbox.txt', 'r')

Qu’est-ce que l’Handle?

>>> fhand = open('mbox.txt')

>>> print fhand

Quand des Fichiers sont introuvables

>>> fhand = open('stuff.txt')

Traceback (most recent call last): File

"<stdin>", line 1, in <module>IOError: [Errno 2]

No such file or directory: 'stuff.txt'

Le Caractère newline

• Nous utilison un caractère

particulié qui s’appelle le

“newline” afin d’indiquer

quand une ligne s’arrête

• Dans les chaînes de

caractères, nous l’écrivons \n

•Newline représente un

caractère – pas deux

>>> stuff = 'Hello\nWorld!'

>>> stuff

'Hello\nWorld!'

>>> print stuff

Hello

World!

>>> stuff = 'X\nY'

>>> print stuff

>>> len(stuff)3

Traitement de Fichiers

• Un fichier texte peut être considéré comme étant une séquence de

lignes

From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008

Return-Path: <postmaster@collab.sakaiproject.org>

Date: Sat, 5 Jan 2008 09:12:18 -0500

To: source@collab.sakaiproject.org

From: stephen.marquard@uct.ac.za

Subject: [sakai] svn commit: r39772 - content/branches/

Details: http://source.sakaiproject.org/viewsvn/?view=rev&rev=39772

Traitement de Fichiers

•Un texte contient des newlines à la fin de chaque ligne

From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008\n

Return-Path: <postmaster@collab.sakaiproject.org>\n

Date: Sat, 5 Jan 2008 09:12:18 -0500\n

To: source@collab.sakaiproject.org\n

From: stephen.marquard@uct.ac.za\n

Subject: [sakai] svn commit: r39772 - content/branches/\n

Details: http://source.sakaiproject.org/viewsvn/?view=rev&rev=39772\n

Le gestionnaire de fichiers est une

Séquence

•Un gestionnaire de fichiers ( file handle)

utilisé pour lire peut être traité comme

étant une séquence dans laquelle

chaque ligne est une chaîne dans la

séquence.

•Nous pouvons utiliser la déclaration for

pour qu’elle soit répétée tout au long

d’une séquence

•Souvenez-vous : une séquence est un

ensemble ordonné

xfile = open('mbox.txt')

For fromage in xfile:

print fromage

Compter les lignes d’un Fichier

•Ouvrer un fichier à lire

(uniquement)

•Utiliser une boucle for pour lire

chaque ligne

•Compter les lignes et imprimer

le nombre de lignes

fhand = open('mbox.txt')

count = 0

for line in fhand:

count = count + 1

print ’Compteur de lignes:', count

$python open.py

Compteur de lignes: 132045

Lire le Fichier *Entièrement*

•Nous pouvons lire le fichier

entièrement (avec les

“newlines” apparantes) en le

transformant en une unique

chaîne de caractères

>>> fhand = open('mbox-short.txt')

>>> inp = fhand.read()

>>> print len(inp)94626

>>> print inp[:20]

From stephen.marquar

Rechercher dans un Fichier

•Nous pouvons mettre une

déclaration if dans notre

boucle for afin d’imprimer

seulement les lignes qui

correspondent à des critères

définis

fhand = open('mbox-short.txt')

for line in fhand:

if line.startswith('From:') :

print line

OOPS!

Que font tous ces

interlignes içi?

From: stephen.marquard@uct.ac.za

From: louis@media.berkeley.edu

From: zqian@umich.edu

From: rjlowe@iupui.edu

...

OOPS!

Que font tous ces

interlignes içi? From: stephen.marquard@uct.ac.za\n

From: louis@media.berkeley.edu\n

From: zqian@umich.edu\n

From: rjlowe@iupui.edu\n

...

•Chaque ligne d’un fichier a

une newline à son bout

• La déclaration print ajoute

une nouvelle ligne après

chaque ligne

Rechercher dans un Fichier

(déterminé)

•On peut retirer les blancs du

côté droit d’une chaîne de

caractères en utilisant la

fonction rstrip() présente dans la

bibliothèque des chaînes

• L’interligne est considéré

comme étant un “blanc” et

donc il est supprimé

fhand = open('mbox-short.txt')

for line in fhand:

line = line.rstrip()

if line.startswith('From:') :

print line

From: stephen.marquard@uct.ac.za

From: louis@media.berkeley.edu

From: zqian@umich.edu

From: rjlowe@iupui.edu

....

Sauter des lignes avec la déclaration

continue

•Nous pouvons

commodément sauter

une ligne en utilisant la

déclaration continue

fhand = open('mbox-short.txt')

for line in fhand:

line = line.rstrip()

if not line.startswith('From:') :

continue

print line

L’utilisation de in pour selectionner

des lignes

•Nous pouvons chercher

une chaîne de caractères

n’importe où dans une

ligne en en faisant un

critère de recherche

fhand = open('mbox-short.txt')

for line in fhand:

line = line.rstrip()

if not '@uct.ac.za' in line :

continue

print line

From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008

X-Authentication-Warning: set sender to stephen.marquard@uct.ac.za using –f

From: stephen.marquard@uct.ac.za

Author: stephen.marquard@uct.ac.za

From david.horwitz@uct.ac.za Fri Jan 4 07:02:32 2008

X-Authentication-Warning: set sender to david.horwitz@uct.ac.za using -f...

Recherche du nom d’un Fichier

fname = raw_input('Entre le nom du fichier: ')

fhand = open(fname)

count = 0

for line in fhand:

if line.startswith(’Objet:') :

count = count + 1

print ’Il y avait', count, ’lignes comportant l’objet de votre recherche dans', fname

Entrer le nom d’un fichier: mbox.txt

Il y avait 1797 lignes comportant l’objet de votre

recherche dans mbox.txt

Entrer le nom d’un fichier: mbox-short.txt

Il y avait 27 lignes comportant l’objet de votre

recherche dans mbox-short.txt

Nom de fichier erroné

fname = raw_input('Entrer le nom d’un fichier: ')

try:

fhand = open(fname)

except:

print ’Le fichier ne peut être ouvert:', fname

exit()

count = 0

for line in fhand:

if line.startswith(’Objet:') :

count = count + 1

print ’Il y avait', count, ’lignes comportant l’objet de votre recherche dans:', fname

Entrer le nom d’un fichier: mbox.txt

Il y avait 1797 lignes comportant l’objet de votre

recherche dans mbox.txt

Entrer le nom d’un fichier: na na boo boo

Le fichier ne peut être ouvert: na na boo boo

Résumé

•Stockage secondaire

•Ouvrir un fichier –Traiter un fichier

•La structure d’un fichier -caractère

newline

•Lire un fichier ligne par ligne en

utilisant une boucle

•Rechercher des

lignes

•Lire les noms de

fichiers

•Faire face aux

fichiers erronés

Remerciements / Contributions

(www.dr-chuck.com) of the University of Michigan School of

Information and open.umich.edu and made available under a

Creative Commons Attribution 4.0 License. Please maintain this

last slide in all copies of the document to comply with the

attribution requirements of the license. If you make a change,

feel free to add your name and organization to the list of

contributors on this page as you republish the materials.

Initial Development: Charles Severance, University of Michigan

School of Information

Translation: Stephanie Kamidian

...