Programmation en Python Cours 2/8

(1)

Cours d’Informatique Scientifique

Programmation en Python Cours 2/8

Laurent Pointal

laurent.pointal @ limsi.fr

@ laposte.net

Source des illustrations: OpenClipArt.org et créations personnelles.

(2)

Programme de la séance

●

Opérations sur les données (syntaxe)

●

Utilisation des résultats d’expressions

●

Les types séquences ordonnées: str tuple list

●

Indexation des séquences ordonnées

●

Opérations sur les listes

●

Séquences d’entiers : range

●

Instruction de boucle while

●

Exemples d’utilisation

●

Instruction de boucle for

●

Exemples d’utilisation

●

Rupture de boucle break et continue

(3)

aurent PointalDépartement Mesures Physiques Cours d’Informatique Scientifique 2/8 3 21

v2.1

Opérations sur les données

En Python: donnée  objet

Application de méthodes spécifiques de traitement pour chaque type d'objet:

objet.methode(arguments…)

Exemples:

"Joe".upper()

"Joe:Student:14.2".split(":") (100).bit_length()

Généralement on utilise les méthodes via des variables:

nom = "Student"

nom.upper()

Utilisation de fonctions génériques:

fonction(arguments…)

Exemples:

len("chaîne")

print("Bornes: [",1," … ",45,"]")

min(8.3,9.1,7.3,11.67)

(4)

Laurent PointalDépartement Mesures Physiques Cours d’Informatique Scientifique 2/8 4 21

v2.1

Utilisation des résultats d’expressions

Affichage print()

Stockage affectation

Utilisation immédiate dans une expression

len("Joe Student")

print("Nb de caractères:",len("Joe Student"))

Expression

longueur = len("Joe Student")

**bord = "#" * (int((80-len("Joe Student"))/2)) print(bord,"Joe Student",bord)**

évaluée à 11

(5)

v2.1

Types conteneurs séquences ordonnées

str - séquence ordonnée, non modifiable, de caractères

"Joe Student"

tuple - séquence ordonnée, non modifiable

(12.3,78.1,True,"Toto") ("un",) () "B",5,"coulé"

list - séquence ordonnée, modifiable

[12.3,78.1,True,"Toto"] ["un"] []

Opérations communes

●

nombre d’éléments : len(séquence)

●

test de présence: valeur in séquence

Si les éléments sont comparables (relation d’ordre)

●

plus grand/plus petit : max(séquence) min(séquence)

●

nouvelle version list triée : sorted(séquence)

●

accès direct aux éléments par leur index…

int

bool

(6)

v2.1

Indexation des éléments de séquences

Une sous-séquence [début:fin] [début:fin:pas]

Joe Student

[index]

[debut:fin]

(11 éléments)

0 1 2 3 4 5 6 7 8 9 10

-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

0 1 2 3 4 5 6 7 8 9 10

-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

11 Pour les séquences ordonnées : str, list, tuple

Exemple avec une chaîne

s = "Joe Student"

s[4] "S" s[6:9] "ude"

s[:3] "Joe" s[7:] "dent"

s[::2] "JeSuet"

…tests dans l'interpréteur (tranche ou slice)

Un élément [index]

(item)

(7)

v2.1

Imbrication de séquences

points = [ (1,3.4), (1.5,5.82), (2.01,9.32), (2.4,7.8) ]

points[1]

Index point: 0 1 2 3

Exemple : une liste de tuples, coordonnées de points

Index chaque coordonnée:

0 1

0 0 1 0 1 0 1

(1.5,5.82) points[1][1] 5.82

points[1][0] 1.5

Exemple : une liste de données démographiques demographie = [

("Orsay",91400,[(2008,16255),(1975,13530),(1901,1904)]), ("Les Ulis",91940,[(2008,24590),(1975,9334)]),

("Saclay",91534,[(2008,3016),(1975,2037),(1901,562)]), ]

demographie[2][2][0] (2008,3016)

demographie[2][2][0][1] ³⁰¹⁶

(8)

v2.1

Opérations sur les listes

Recherche d’index d’un élément, comptage du nombre d’occurences

position = jeux.index("coulé")

nombre = jeux.count("dans l’eau")

Renversement et tri, sur place (la liste est modifiée)

valeurs = [ 3,8,9,4,11,5 ] valeurs.reverse()

valeurs.sort()

“dépilage” d’un élément

val = valeurs.pop() La dernière valeur de la liste est retirée et retournée

list str

prenoms = "jean:kevin:yacine:fréderic"

lstpre = prenoms.split(':') **spre = " * ".join(lstpre)**

['jean','kevin','yacine','fréderic']

**"jean * kevin * yacine * fréderic"**

(9)

v2.1

Construire une suite d’entiers

Définit un ensemble de valeurs entières :

●

range(n)  [ 0 1 2 3 4 … n [

●

range(a,n)  [ a a+1 a+2 a+3 a+4… n [

●

range(a,n,p)  [ a a+1p a+2p a+3p a+4p … n [

Le générateur range

Attention, [ a … n [ n’est pas une syntaxe Python, juste une indication que la dernière valeur est non-inclue dans l’ensemble.

nombres = list(range(100))

On peut créer une liste contenant ces valeurs :

range produit les valeurs au fur et à mesure des besoins

(un “générateur”).

(10)

v2.1

Modifications des listes

Les listes sont modifiables (“mutables”).

On peut changer les éléments :

jeux = ["B",5,"dans l’eau"]

jeux[2] = "touché" # un seul élément

jeux[0:2] = ["C",3] # une tranche (slice) d’éléments

On peut ajouter ou insérer des éléments :

jeux.append( "coulé" ) # un seul élément

jeux.extend( ["E",8,"dans l’eau"] ) # une séquence d’éléments

…tests dans l'interpréteur

jeux.insert( 3,"coulé" ) jeux[3:3] = ["A",2]

del jeux[3:6]

jeux.remove("E") # par valeur d’élément !

On peut supprimer des éléments :

(11)

v2.1

Instruction de boucle while

Exécution tant que une condition est vérifiée.

while condition :

Bloc d'instructions.

Exécuté tant que la condition est vraie.

Chaque passage dans le bloc de traitements est appelé une itération.

On parle de “boucle while”, de “boucle sous condition”…

Attention à s’assurer que la condition puisse à un moment devenir fausse. Sinon c’est une boucle sans fin.

condition

Bloc d'instructions Faux

Vrai

(12)

v2.1

Exemple avec while

valeurs = [ 1,4,2,8,9,5,7,6 ] mini = valeurs[0]

maxi = valeurs[0]

index = 0

while index < len(valeurs):

if valeurs[index] > maxi:

maxi = valeurs[index]

if valeurs[index] < mini:

mini = valeurs[index]

index = index + 1

print("Mini/maxi:", mini, maxi)

On cherche le minimum et le maximum dans une liste non vide.

1 2 3 4 5 6 7 8 9 10 11

Ligne

(13)

v2.1

Boucle de recherche de valeur

# Recherche du moment où 1 devient négligeable pour les flottants.

valeur = 10.0 # Un float !!!

while valeur+1-valeur != 0 : **valeur = valeur * 10**

print("1 négligeable devant",valeur)

# Recherche de l’abscisse du premier point d’ordonnée > 6 points = [ (1,3.4), (1.5,5.82), (2.01,9.32), (2.4,7.8) ] idx = 0

while idx<len(points) and points[idx][1]<=6 : idx = idx + 1

# Après, on peut travailler avec:

if idx>=len(points):

print("Aucune ordonnée >6") else :

print("Point n°",idx," abcisse",points[idx][0])

(14)

v2.1

Instruction de boucle for

Parcours d’une séquence de données avec une variable.

for variable in séquence:

Bloc d'instructions.

Exécuté avec variable valant tour à tour chacune des valeurs de séquence.

On parle de “boucle for”, de “parcours de séquences”…

Plus généralement, for s’utilise avec des objets itérables qui fournissent des valeurs au fur et à mesure qu’on leur demande.

Les séquences sont itérables, tout comme les range.

Permet d'effectuer le bloc de traitements for pour chacun des

éléments de la séquence. Chaque passage dans le bloc de traitements for est appelé une itération.

fin de séquence ?

Bloc d'instructions Faux

Vrai variable = valeur

suivante

(15)

v2.1

Boucle sur une séquence

valeurs = [ 1,4,2,8,9,5,7,6 ] for v in valeurs:

print(v,"\t==> carré:",v2) print("\t==> cube:",v3)

Parcours direct des valeurs, dans l’ordre où elles sont.

points = [ (1,3.4), (1.5,5.82), (2.01,9.32), (2.4,7.8) ] for pt in points:

print("Coordonnées:",pt) x = pt[0]

y = pt[1]

if y>6 :

print("Limite dépassée pour x=",x)

(16)

v2.1

Boucle sur les index d’une séquence

Parcours d’une suite d’entiers correspondant aux index des valeurs dans la séquence, dans l’ordre où elles sont.

points = [ (1,3.4), (1.5,5.82), (2.01,9.32), (2.4,7.8) ] for idx in range(len(points)):

pt = points[idx]

print("Coordonnées:",pt) x = pt[0]

y = pt[1]

if y>6 :

print("Limite dépassée pour x=",x)

# Et là, on peut modifier via l’index points[idx] = (x,6)

print("Points:",points)

Les index: range(len(séquence))

(17)

v2.1

Boucle sur index/valeur d’une séquence

Parcours de (index,valeur) dans la séquence, dans l’ordre.

points = [ (1,3.4), (1.5,5.82), (2.01,9.32), (2.4,7.8) ] for idx,pt in enumerate(points):

print("Coordonnées:",pt) x = pt[0]

y = pt[1]

if y>6 :

print("Limite dépassée pour x=",x)

# Là encore, on peut modifier via l’index points[idx] = (x,6)

print("Points:",points)

Les (index,valeur) : enumerate(séquence)

(18)

v2.1

Boucle sur une partie d’une séquence

La séquence sauf le dernier élément

points = [ (1,3.4), (1.5,5.82), (2.01,9.32), (2.4,7.8) ] for idx in range(len(points)-1):

pt1 = points[idx]

pt2 = points[idx+1]

pente = (pt2[1]-pt1[1]) / (pt2[0]-pt1[0]) print("Pente entre",pt1,"et",pt2,":",pente) La séquence sauf le premier élément

for pt in points[:-1]: …

for idx in range(len(points)-1): …

for pt in points[1:]: …

for idx in range(1,len(points)-1): …

accès au suivant: points[idx+1]

accès au précédent: points[idx-1]

Exemple:

(19)

v2.1

Boucle de création d’une séquence

points = [ (1,3.4), (1.5,5.82), (2.01,9.32), (2.4,7.8) ]

# On part d’une liste vide créée avant la boucle ordonnees = []

# On remplit cette liste dans la boucle for pt in points:

y = pt[1]

ordonnees.append(y)

# Après, on peut travailler avec:

print(points)

print(ordonnees)

print("Ordonnée max:",max(ordonnees))

On veut ne prendre que les ordonnées des points.

(20)

v2.1

Instructions break

Sortie immédiate du bloc d’instructions de la boucle for ou while en cours.

break for ou while :

break

Rupture du flux normal des instructions.

Exemple : recherche d'une valeur 9.0 dans une liste lstvaleurs = [12.3,9.3,18.7,8.1,4.2]