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 for

●

Exemples d’utilisation

●

Instruction de boucle while

●

Exemples d’utilisation

●

Rupture de boucle break et continue

(3)

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

v2.0

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 20

v2.0

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.0

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.0

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.0

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.0

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 :

(9)

v2.0

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"**

(10)

v2.0

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”).

(11)

v2.0

Instruction de boucle for

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

for variable in séquence :

optionnel

else :

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

Bloc exécuté si la sortie de la boucle for se fait

normalement à la fin du traitement des valeurs.

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.

(12)

v2.0

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)

(13)

v2.0

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))

(14)

v2.0

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)

(15)

v2.0

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:

(16)

v2.0

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.

(17)

v2.0

Instruction de boucle while

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

while condition :

optionnel

else :

Bloc exécuté tant que la condition est vraie.

Bloc exécuté si la sortie de la boucle while se fait

normalement lorsque la condition devient fausse.

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.

(18)

v2.0