module m1207 programmation python -...
TRANSCRIPT
Module M1207
Programmation PythonRemy CHOLLET*, [email protected] BARAS, [email protected] GOEURIOT, [email protected] MARTIN, [email protected]
Version 2017
Table des matieres
Chapitre 1 Introduction 4
1 L’informatique en R&T 41.1 Les modules d’informatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.2 Planning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.3 Outils a disposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2 Definition 52.1 L’informatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.2 Les langages de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.3 Le langage Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.4 Temoignage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.5 Pour aller plus loin ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Chapitre 2 Variables et expression 8
3 Variables 83.1 Qu’est ce qu’une variable? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83.2 Type d’une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83.3 Affectation d’une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93.4 Conversion de type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4 Expression 104.1 Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104.2 Operateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104.3 Priorite des operateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1
5 Instructions 115.1 Instructions d’affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125.2 Instructions de sortie : affichage console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125.3 Instruction d’entrees : lecture d’une saisie clavier . . . . . . . . . . . . . . . . . . . . . . . . . . . 155.4 Modules et fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
6 Programme Python 17
Chapitre 3 Structures alternatives (ou conditionnelles) 19
7 Expressions booleennes 197.1 Le type booleen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197.2 Expressions booleennes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
8 Structure alternative elementaire : Si sinon 208.1 Principe et syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
9 Structure conditionnelle elementaire : Si 229.1 Principe et syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
10 Structure alternative multiple : si ... ou si ... sinon 2310.1 Principe et syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2310.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
11 Structures alternatives imbriquees 2411.1 Bilan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Chapitre 4 Structures repetitives 25
12 Principes des structures repetitives 25
13 Boucle for 2513.1 Le compteur d’iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2513.2 Repetition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2513.3 Repetition en utilisant le compteur de boucle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2513.4 Valeur initiale du compteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2613.5 Increment du compteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
14 Boucle while 2814.1 La condition de boucle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2814.2 Repetition dependant d’une saisie utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
15 Equivalence boucles for/while 29
16 Boucles et structures alternatives 29
17 Boucle avec variable d’accumulation 3017.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3017.2 Accumulation additive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3017.3 Accumulation multiplicative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
18 Boucles imbriquees 31
Chapitre 5 Fonctions 32
2
19 Fonctions 3219.1 Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3219.2 Syntaxe de declaration d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
20 Exemples de fonctions 3320.1 Fonction a un parametre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3320.2 Fonction a deux parametres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3320.3 Fonction a plusieurs valeurs de retour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
21 Portee des variables dans une fonction 3421.1 Notion de portee locale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3421.2 Contexte local d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3421.3 Cas des parametres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
22 Chaınage de fonctions 35
23 Les prototypages classiques de fonctions 36
24 Ou declarer une fonction? 37 Tr. 1
3
Chapitre 1 — Introduction
Tr. 2
1 L’informatique en R&T
1.1 Les modules d’informatique
Sem. Modules IntituleS1 M1105 Unix
M1103 Architecture des equipements informatiquesM1106 Initiation au developpement WebM1207 Programmation 1
S2 M2104 SGBDM2105 Web dynamiqueM2109 Gestion de projets informatiquesM2207 Programmation 2
S3 M3206 POOS4 M4206C Programmation sur mobiles
M4207 Autres applications informatiquesTr. 3
1.2 Planning
Modalites— Cours/TD : 1h + 7 × 2h— TP : 2h + 6 × 2h— Evaluation (semaine 3) : DS papier 1h30 ; DS machine 1h30
Planning des seances
Semaine CM/TD TP46 Introduction, variable, expression46 Prise en main de l’IDE47 Bases de la programmation48 Structures alternatives Structures alternatives49 Structures repetitives Structures alternatives50 Structures repetitives imbriquees Structures repetitives51 Fonctions Structures repetitives imbriquees2 Fonctions Fonctions2 Revision DS Fonctions3 DS le 17/01/18 Examen sur machine le 15/01/18
Tr. 4
1.3 Outils a disposition
— Poly, slides, sujets de TD et de TP sur Chamilo :http://chamilo.univ-grenoble-alpes.fr/courses/IUT1RT1M1207/index.php
— IDE PyCharm Community Edition de JetBrainsTr. 5
4
2 Definition
2.1 L’informatique
Definition 1 (Informatique (data processing), algorithme). L’informatique est la science du traitementautomatique (software) de l’information (data), dont decoule des programmes qui implementent desalgorithmes a l’aide d’un langage de programmation.
DonneesProgramme(software) Resultats
Ordinateur
Tr. 6
Definition 2 (Algorithme). Un algorithme est la mise en œuvre d’une succession finie d’actions elementaires(instructions) pour resoudre un probleme ou obtenir une fonctionnalite.
Exemple 3 (Des algorithmes).— Recette de cuisine, notice de montage— Prise d’un medicament contre la toux— Resolution de ax2 + bx+ c = 0— Tri de donnees— Cryptographie— Recherche d’un plus court chemin— etc. Tr. 7
Exemple 4 (Prise d’un medicament contre la toux).
”En cas de toux, prendre, sauf avis contraire du medecin, un comprime toutes les 4 heures,jusqu’a disparition des symptomes. Pour les enfants, un comprime toutes les 8 heures suffit.”
SI toux ET PAS d’avis contraire du medecin ALORS| SI enfant ALORS| | delai d’attente VAUT 8 heures| SINON| | delai d’attente VAUT 4 heures| FIN DE SI| TANT QUE PAS disparition des symptomes FAIRE| | prendre un comprime| | attendre pendant le delai d’attente| FIN DE TANT QUEFIN DE SI
Tr. 8
2.2 Les langages de programmation
Definition 5 (Langage de programmation). Ensemble de caracteres, symboles, mots-cles et reglesd’assemblage (equivalents au vocabulaire et a la grammaire d’une langue), utilise pour donner desinstructions a l’ordinateur.
Evolution des langages
1. Langage machine de plus bas niveau puis assembleur (mnemonique, macros, variables)
2. Langage structure :— paradigmes de programmation : procedural, oriente objet, fonctionnel...— compile : C, C#, C++, ObjectiveC, Pascal, Java...— interprete : Shell, Tcl/Tk, Perl, Python, Ruby, JavaScript, Matlab...
3. Langage naturel SQL, Windev, 4D (BDD)
� https://fr.wikipedia.org/wiki/Langage de programmation
5
Tr. 9
2 approches
1. Compilation : traduction d’un code source vers un code cible executable— code executable directement par l’OS— Bytecode executable par machine virtuelle (cf. Java au S3)
2. Interpretation : langage converti en bytecode ”a la volee” soit— lecture et analyse d’une instruction (ou une expression)— si correcte, l’executer (ou evaluer l’expression)— passer a l’instruction suivante
Pour Python889— tout le code source est verifie syntaxiquement— un bytecode est produit automatiquement pour execution dans l’interpreteur Python (via une machine
virtuelle)— le code peut aussi etre interprete en mode interactif
Tr. 10
2.3 Le langage Python
2.3.1 Qu’est ce que Python?
— Cree par Guido van Rossum en 1990— 1er objectif : un nouveau shell— grande communaute, usages industrialises— en progression ces dernieres annees (voir tiobe-index)— Open source, large communaute, bonne portabilite— plutot haut niveau, plutot pragmatique— Caracteristiques :
— l’indentation comme syntaxe— tout est objet
Tr. 11
2.3.2 Python, c’est mieux?
— Bon langage pour la pedagogie— Tres bonne expressivite— Aspects modernes (iterateurs, comprehension, introspection...)— Tres bon langage pour l’administration systeme— bibliotheques tres diverses (systeme, calcul, imagerie, SGBD, Web etc...)
Tr. 12
Some Spam?� https://youtu.be/nZG6lQPQKlI
Tr. 13
2.4 Temoignage
Si un etudiant est comme moi, en difficulte, dans les matiere type � programmation �, il ne fautpas desesperer.
Nous pouvons comparer la progression d’un langage informatique a l’apprentissage d’unelangue etrangere. Les cours m’ont permis de comprendre les concepts generaux. Mais c’est le faitde pratiquer tous les jours qui m’a reellement permis de progresser.
– Nathan R. 2016Tr. 14
2.5 Pour aller plus loin ...
Qualites d’un logiciel
6
— Fiabilite— Robustesse— Lisibilite du code
— Portabilite— Maintenabilite— Performance
Concretement, il faut :— Utiliser des nommages pertinents dans le code— Structurer le code par des modules, des fonctions et aussi des classes— Documenter le code, le commenter— Tester unitairement le code— Limiter les dependances, chercher la simplicite et la clarte
Tr. 15
7
Chapitre 2 — Variables et expression
Tr. 16
3 Variables
3.1 Qu’est ce qu’une variable?
Definition 6 (Variable). Une variable designe un objet informatique dans une zone memoire. Elle :
1. est designee par un identificateur, appele aussi nom, et lie a une reference
2. memorise une valeur, evoluant avec le flot d’instructions mais unique a un instant donne
3. presente un type, precisant la nature de la valeur qu’elle memorise
Remarques : Une variable possede egalement :— une duree de vie qui debute a la declaration de la variable et s’acheve lorsque l’espace memoire
occupe par la variable est libere et une portee zone du programme dans laquelle la variable estaccessible
— des proprietes en tant qu’objet informatique decrit (dans les langages de programmation oriente objetcomme Python) par une classeTr. 17
Choix de l’identificateur— L’identificateur est un nom :
Í utilisant des lettres (sensibles a la casse), des chiffres ou _
ë interdisant les caracteres accentues et speciaux (comme #, @, etc.)ë interdisant les noms commencant par un nombreë interdisant les mots-cles de Python
— Mots-cles Python interdits (cf. table 1) :
and del from not while
as elif global or with
assert else if pass yield
break except import print
class exec in raise
continue finally is return
def for lambda try
TABLE 1 – Mots-cles du langage Python, interdits en tant que nom de variable
Allocation memoirePython offre un systeme de gestion automatique de la memoire, qui alloue la memoire aux objets referenceset la libere lorsqu’ils ne le sont plus (ramasse-miette ou garbage collector ).
Tr. 18
3.2 Type d’une variable
Definition 7 (Type d’une variable). Le type est la nature (la classe) de la valeur memorisee par la variable. Ilest :
— defini a la creation de la variable ;— dynamique, c’est-a-dire qu’il peut evoluer lors de l’execution du programme (contrairement a d’autres
langages comme Java ou le type est statique c’est-a-dire declare dans le code par le programmeur).
Quelques types (simples) de variables en PythonCf. table 2.
Tr. 19
Fonctions autour du typeConnaıtre le type d’une variable x : type(x)
— type( 0 ) indique <class ’int’>
— type( 0. ) indique <class ’float’>
— type( ’Spam’ ) indique <class ’str’>
8
Nom Type (class) Exemple Remarquebooleen bool (boolean) False ; Trueentier int (integer) -2 ; 10 exprime en base 10 (par defaut),
-0b10 ; 0b1010 en binaire avec prefixe 0b,-0x2 ; 0xA en hexa avec prefixe 0x (ou 0X),-0o2 ; 0o12 en octal avec prefixe 0o (ou 0O)
flottant float 1.34 ; -0.6 avec le separateur .chaıne de caracteres str (string) "Spam" en la delimitant par ’ ou "
TABLE 2 – Quelques types de variables
Types numeriques (attention aux problemes de precision !)889— Entiers signes : int de precision illimitee (tant que la memoire est disponible)— Decimaux : float de precision limitee (∈ [sys.float_info.min sys.float_info.max]) (cf.
https://fr.wikipedia.org/wiki/IEEE 754)— Complexe : complex base sur les float. Par exemple : c=1+3j avec c.real la partie reelle flottante et
c.imag la partie imaginaireTr. 20
3.3 Affectation d’une variable
Variables du contexte de nommage et memoireLes variables permettent d’acceder a des objets informatiques (une valeur d’un certain type). Pythons’appuie donc sur deux ensembles differents : le contexte (ou espace) de nommage et la memoire (vive).Ces deux ensembles sont liberes a la fin de l’execution d’un programme.
Declaration et affectation d’une variable : x=2La declaration et l’affection d’une variable se font avec l’instruction x=2. Lorsque Python execute cetteinstruction (cf. figure 1), il :
1. cree une zone memoire pour ranger l’objet de type entier 2 (class ’int’),
2. cherche si x existe dans le contexte de nommage. Ne le trouvant pas, une entree x est ajoutee a cecontexte,
3. finalise l’affectation en associant x a 2
Contexte
x
Memoire
2
FIGURE 1 – Le contexte de nommage et la memoire d’un programme Python
Attention au sens d’une affectationë Ecrire 2 = x n’a pas de sens !
Exemple 8 (D’autres exemples d’affectations (cf. figure 2)).I val = 3.14 cree la valeur flottante 3.14 (de type float) en memoire, declare la variable val dans le
contexte, les associeI chaine = "Eggs" cree la chaine de caracteres "Eggs" (de type str), declare la variable chaine dans le
contexte et les associe
Remarque : Bien distinguer le nombre 3.14 (de type float) de la chaıne de caractere "3.14" (de type str). Tr. 21
9
Contexte Memoire
x 2
val 3.14
chaine ”Eggs”
FIGURE 2 – Le contexte de nommage et la memoire d’un programme Python pour 3 variables
3.4 Conversion de type
Fonctions de conversion de typeLes fonctions suivantes convertissent (si cela est possible) la valeur passee en parametre dans le type dumeme nom (cf. table 3) :
Fonction Traitementint(valeur) troncature de la valeur a l’entier le plus proche de zerofloat(valeur) conversion de la valeur en flottantstr(valeur) conversion de la valeur numerique en chaine
TABLE 3 – Les fonctions de conversion de type
Exemple 9 (Conversion de type).— a = int(3.0) ou a = int("3") sont equivalents a a = 3 avec a de type int
— chaine = str(3.2) est equivalent a chaine="3.2" de type str
Remarques888 :— Les fonctions de transtypage servent aussi a obtenir des valeurs par defaut : int() donne 0 ; float()
donne 0.0 ; str() donne "".— int permet aussi des conversions de base avec son parametre base ainsi int(’FF’, base=16) donne la
valeur 255.Tr. 22
4 Expression
4.1 Definitions
Definition 10 (Expression, operateurs).— Une expression est une serie de calculs ayant pour resultat une valeur d’un certain type.— Elle utilise des operateurs (+, -, *, ...) et des operandes (valeurs, variables, expressions).— Les expressions exploitent l’espace memoire : la valeur de l’expression, si elle doit etre reutilisee dans
la suite du programme, devra etre stockee dans (affectee a) une variable.
Exemple 11 (Des expressions).— recuperation de la valeur de la variable x : x— expression arithmetique : 4/3 ou (x+2) % 5
Remarque : Python autorise des expressions melangeant des types lorsqu’ils sont homogenes uniquement(typage fort).Tr. 23
4.2 Operateurs
Principaux operateurs des expressionsCf. table 4.
Affectation composee
10
Symb. Signification Symb. Signification+ addition pour int, float ;
concatenation pour str* multiplication pour int, float ;
repetition pour str- soustraction pour int, float / division (decimale)% modulo (reste de la division) // division euclidienne** exposant : 3**2 vaut 9 not negation logiqueand intersection logique or union logique
TABLE 4 – Operateurs des expressions
C’est une operation permettant de realiser en une seule etape une operation normale et l’affectation de sonresultat dans la variable servant de premier operande. On suit la syntaxe : variable op= valeur .ou op est l’un des operateurs arithmetiques : +, -, *, /, \%, //, **. Cette syntaxe est strictement equivalente a :variable = variable op valeur .
Remarque : En Python 2.x, / est une division euclidienne lorsque ses operandes sont de type int, et unedivision decimale lorsque l’un des deux est de type float. Tr. 24
4.3 Priorite des operateurs
Priorite des operateurs, par ordre croissant, avec groupement de gauche a droite si priorites egalesCf. table 5.
Priorite Operateur DescriptionBasse or ou logique
and et logiquenot non logique<, <=, >, >=, <>, !=, == comparaison| ou bit a bitˆ et bit a bit& et bit a bit<<, >> decalage bit a bit+, - addition et soustraction*, /, //, % Multiplication, division, reste+x, -x, ˜x signe positif, signe negatif, non bit a bit** exposant
Haute (expression) expression delimitee par des parentheses
TABLE 5 – Les priorites des operateurs
Remarque : en cas de doute (cf. details surhttps://docs.python.org/3.6/reference/expressions.html#operator-precedence), utilisez des parentheses Tr. 25
5 Instructions
Definition 12 (Instructions). Une instruction est un ordre a executer par le programme; c’est une etape quidicte a la machine ce qu’elle doit effectuer avant de passer a l’instruction suivante. Par exemple :
— affecter une valeur a une variable— afficher une information a l’ecran— recuperer une saisie clavier faite par l’utilisateur
Executer une instruction implique d’evaluer des expressions.
Definition 13 (Programme). Un programme est une suite d’instructions, qui s’executent les unes apres lesautres - autrement dit sequentiellement.
Tr. 26
11
5.1 Instructions d’affectation
Exemple 14 (Des instructions d’affectation). Voici un programme (script) de 3 instructions. Les instructionsd’affectation et leurs effets sur l’espace des variables et des valeurs sont representees figure 3.
1 a = 32 b = a + 13 b += a4
Contexte Memoire
a 3
b 4
1
7
%
FIGURE 3 – Affectations dans le contexte et la memoire
Ligne 1 : a ne faisant pas partie du contexte, l’instruction declare la variable a dans le contexte et luiaffecte la valeur 3Ligne 2 : incrementation : evalue l’expression a + 1 et, puisque b ne fait pas partie du contexte,declare la variable b dans le contexte, et lui affecte le resultat (ici 4)Ligne 3 : affectation composee equivalente a b = b + a : evalue l’expression b + a pour obtenir 7 ;procede ensuite a l’affectation : comme b est deja declaree dans le contexte, sa valeur est modifieepour prendre celle du resultat 7. L’objet 4 n’est plus reference et est efface par le ramasse-miette.
Tr. 27
5.2 Instructions de sortie : affichage console
5.2.1 L’art du print
Ecriture vers l’ecran (ou affichage console) avec print
L’instruction qui demande au programme l’affichage (l’ecriture) d’une donnee sur la console (l’ecran) est :print( valeur ). Les donnees peuvent etre de tous types (int, float, str, etc.). Un retour chariot est ajoutepar defaut a la fin de chaque appel a print
Exemple 15 (Affichage de donnees (extrait de code)). Les instructions :
1 msg = "Bonjour"2 valeur = 3.143 print( msg )4 print( valeur )5 print( "fin" )
1 print( "Bonjour" )2 print( 3.14 )3 print( "fin" )
donnent a l’affichage console :
Bonjour3.14fin
Tr. 28
5.2.2 Variantes du print
1. print(donnee1, donnee2, ...) affiche, sur une meme ligne et separee (par defaut) par un espace,toutes les donnees passees en parametres.Exemple 16 (Affichage de donnees (extrait de code)). Les instructions :
12
1 msg = "Bonjour"2 valeur = 3.143 print( msg, valeur)4 print( "fin" )
1 print( "Bonjour", 3.14)2 print( "fin" )
donnent a l’affichage console :Bonjour 3.14fin
Tr. 29
2. print( donnee1, donnee2, ..., sep=chaine_sep, end=chaine_fin ) affiche les donnees :— en les separant par la chaine_sep fournie dans le parametre (optionnel) sep (par defaut sep=" ")— en terminant l’affichage par la chaine_fin precisee dans le parametre (optionnel) end (par defaut
end="\n")Exemple 17 (Affichage de donnees (extrait de code)). Le programme :
1 msg = "Bonjour"2 valeur = 3.143 print( msg, valeur, sep="--" )4 print( "et" )5 print( msg, valeur, end=">>" )6 print( "fin" )
donne a l’affichage console :Bonjour--3.14etBonjour 3.14>>fin
Remarque888 : L’usage de print avec sep et end est un appel a parametres nommes : les parametres(optionnels) peuvent etre en nombre et en ordre quelconques a condition de les indiquer apres lesparametres obligatoires. Tr. 30
3. print peut afficher la valeur d’expressions apres les avoir evalueesExemple 18 (Affichage de valeurs de variables). Les instructions :
1 nbre_art = 52 prix_unitaire = 19.693 print( "total=", nbre_art*prix_unitaire)4 print( "(-) "*3 )5 print( str(nbre_art) + "x" + str(prix_unitaire) + "=", "?")
donne a l’affichage console :total= 98.45(-) (-) (-)5x19.69= ?
Tr. 31
5.2.3 Formatage de chaine
Formatage de chaıneLe formatage permet de creer des chaınes de caracteres incorporant des donnees (de divers types). Il peutetre fait avec la syntaxe :
1. pour une donnee : "une chaine formatee avec {}".format( donnee )
2. pour plusieurs donnees :"une chaine formatee avec {} et {} ... et {}".format(donnee1, donnee2, ..., donneeN)"
Exemple 19 (Affichage de valeurs de variables). Les instructions :1 msg = "Hello"2 val = 3.143 chaine = "Say {}".format( msg )4 print( chaine )5 chaine = "{} Mr {}!".format( msg, val )6 print( chaine )
donne a l’affichage console :Say HelloHello Mr 3.14!
Tr. 32
13
5.2.4 Precision d’affichage
La combinaison de {} et format peut aussi (cf. https://pyformat.info/) :— controler la precision dans l’affichage des variables numeriques (float)— controler le nombre de caracteres de la console utilises pour l’affichage
Exemple 20 (Quelques exemples classiques). Cf. table 6
Variable Formatage Affichage dans la console
p=3.141592 "{}".format(p) 3 . 1 4 1 5 9 2
"{:.3f}".format(p) 3 . 1 4 1
"{:06.2f}".format(p) 0 0 3 . 1 4
s="test" "{}".format(s) t e s t
"{:>7}".format(s) t e s t
e=666 "{}".format(e) 6 6 6
"{:>5}".format(e) 6 6 6
"{:05d}".format(e) 0 0 6 6 6
TABLE 6 – Exemples de formatage avec {} et format
Tr. 33
5.2.5 Directives empruntees du C
Formatage de chaıne avec directives du CUne autre syntaxe pour creer des donnees formatees est celle empruntee du C :
I "une chaine formatee %format" % valeur pour une valeur a formaterI "une autre %format1 et %format2" % (valeur1, valeur2) pour deux valeurs a formater
Les valeurs (ou variables) placees apres l’operateur de conversion % seront inserees dans la chaıne al’emplacement balise par les specificateurs de conversion. Cf. table 7.
Tr. 34
Exemple 21 (Formatage de chaınes). Les instructions— avec un entier :
1 val = 102 print( "val vaut %d" % val )3 print( "val est affiche %04d" % val )
donnent a l’affichage console :
val vaut 10val est affiche 0010
— avec un flottant :
1 print( "%f" % 1. )2 print( "%.3f" % 123. )3 print( "Mais aussi %010.3f" % 123.567 )
donnent a l’affichage console :
1.000000123.000Mais aussi 000123.567
— avec deux donnees :
1 TC = 23.52 TF = TC*9./5+323 print( "%5.1f C" % TC, "= %5.1f F" % TF )4 print( "%5.1f C = %5.1f F" % (TC, TF) )
donnent a l’affichage console :
23.5 C = 74.3 F
Tr. 35
14
Specif. Specif. Format Specif. Specif. Formatavec format du C avec format du C{:d} %d Entier {:nd} %nd Entier sur n caracteres
min{:0nd} %0nd Entier sur n caracteres min et des 0 non significatifs{:f} %f Flottant avec 6 decimales {:.mf} %.mf Flottant avec m decimales
%nf Flottant dans un champde n caracteres (’.’ in-clus)
{:n.mf} %n.mf Flottant dans un champde n caracteres avec mdecimales (’.’ inclus)
{:b} %b Entier en binaire (Python> 3.0)
{:o} %o Entier en octal
{:x} %x Entier en Hexadecimal {:X} %X Entier en Hexadecimalavec lettres capitales
{:s} %s Une chaıne (a incluredans une chaıne)
{:ns} %ns Une chaıne sur n ca-racteres minimum
{:<ns} %s Une chaıne alignee agauche sur n caracteresminimum
{:>ns} %ns Une chaıne alignee adroite sur n caracteres mi-nimum
TABLE 7 – Les formats d’affichage soit avec les specificateurs de format, soit avec les specificateurs empruntesau C.
5.3 Instruction d’entrees : lecture d’une saisie clavier
5.3.1 La fonction input
Lecture de caracteres saisis au clavierL’instruction chaine = input("tapez une chaine : ") :
1. affiche sur la console le message tapez une chaine :
2. capture les caracteres saisis au clavier jusqu’a l’appui sur Enter
3. les renvoient dans la variable chaine de type str.
Exemple 22 (Saisie de donnees). Les instructions :1 chaine = input("Saisir une chaine : ")2 print( chaine, type(chaine) )3 chaine = input("Un entier : ")4 print( chaine, type(chaine) )5 chaine = input("Une valeur : ")6 print( chaine, type(chaine) )
donnent, pour les saisies de l’utilisateur indiquees en violet :Saisir une chaine : totototo <class ’str’>Un entier : 1212 <class ’str’>Une valeur : -3.5-3.5 <class ’str’>
Tr. 36
5.3.2 Typage des donnees saisies au clavier
Typer des donnees acquises avec input peut se faire :
1. en ajoutant un transtypage (int(), float(), ...) qui convertit les caracteres renvoyes par input dans letype attendu :Exemple 23 (Input avec transtypage). Les instructions :
1 chaine = input("Un entier : ")2 nbre = int(chaine)3 print( nbre, type(nbre))4 chaine = input("Une valeur : ")5 val = float(chaine)6 print( val, type(val) )
15
donnent, pour les saisies de l’utilisateur indiquees en violet :
Un entier : 1212 <type ’int’>Une valeur : -3.5-3.5 <type ’float’>
Tr. 37
2. avec la fonction eval qui laisse a Python le choix de decider du type de la variable le plus adequat enfonction de la saisie clavierExemple 24 (Input avec choix d’un type). Les instructions :
1 chaine = input("Un entier : ")2 nbre = eval(chaine)3 print( nbre, type(nbre))4 chaine = input("Une valeur : ")5 val = eval(chaine)6 print( val, type(val) )7 chaine = input("Une autre valeur: ")8 val = eval(chaine)9 print( val, type(val) )
donnent, pour les saisies de l’utilisateur indiquees en violet :
Un entier : 1212 <type ’int’>Une valeur : -3.5-3.5 <type ’float’>Un entier : 1212 <type ’int’>Une autre valeur: 12.12.0 <type ’float’>
Remarque : Si le transtypage ou l’evaluation de l’entree saisie est impossible, alors une exeption est levee.Tr. 38
5.4 Modules et fonctions
5.4.1 Modules et fonctions
Definition 25 (Modules et fonctions). Python propose un ensemble de fonctions servant a differentscalculs ou a differentes taches utiles et recurrentes dans un programme. Certaines de ces fonctions sontfournies (rangees, declarees) dans des bibliotheques (appelees modules).
Exemple 26 (Quelques modules (cf. https://docs.python.org/3/library/index.html)). Cf. table 8
Module Role Exemples de fonctionsBuilt-in int, float, absmath Calculs mathematiques cos, sin, exprandom Choix aleatoires rand, randomos, sys Interactions systemes chdir, getlogin, getpidturtle Fenetre graphique forward, goto
TABLE 8 – Quelques modules python
Tr. 39
5.4.2 Fonctions : caracteristiques et appels
Definition 27 (Caracteristiques d’une fonction). En plus d’un nom et d’un eventuel module, les fonctionspeuvent :
— etre dependantes de parametres— produire un resultat, appele valeur de retour (de l’anglais return)
Exemple 28 (Extrait de documentation de fonctions).
16
Tr. 40
Definition 29 (Appel d’une fonction). Pour appeler une fonction, c’est a dire evaluer son resultat pour desvaleurs de parametres donnees (appeles arguments), il faut :
— importer son module (si necessaire) avec l’instruction : import module
— appeler la fonction avec la synthaxe :I fonction si la fonction est declaree dans le contexte courantI module.fonction si la fonction appartient a un module importesuivi de parentheses
— indiquer dans les parentheses les arguments : chaque argument donne une valeur a chaqueparametre de la fonction, dans le meme ordre que celui de la declaration des parametres.
Cet appel se finit en renvoyant un resultat (une valeur), qui peut etre affecte a une variable.Tr. 41
Exemple 30 (Appel de fonction).— Pour sqrt( x ) dans le module math : l’instruction d’import est :
1 import math
permettant d’ecrire les instructions :
1 res = math.sqrt( 3 )2 print( res )
qui evaluent la fonction sqrt(x) lorsque son parametre x recoit l’argument 3, stockent le resultat dansres puis l’affichent sur la console :
1.7320508075688772
— Pour la fonction max( a, b ) (qui n’appartient a aucun module) : les instructions :
1 res = max( 1, 10 )2 print( res )
evaluent la fonction max(a, b) lorsque son parametre a recoit l’argument 1 et son parametre b recoitl’argument 10, stocke le resultat dans res puis l’affiche sur la console :
10
— Pour la fonction getlogin() du module os, qui n’a pas de parametres mais est appele obligatoirementavec des parentheses : l’instruction d’import :
1 import os
permet d’ecrire les instructions :
1 log = os.getlogin()2 print( log )
qui evaluent la fonction getlogin, stockent le resultat dans log puis l’affichent sur la console :
barasc
Tr. 42
6 Programme Python
Definition 31 (Programme Python). Un programme Python est un fichier d’extension .py contenant desseries d’instructions. Il possede un point d’entree, qui est par convention la fonction main.Ce point d’entree permet a Python de savoir ou trouver la premiere instruction a executer : c’est la premiereinstruction du main.
La structure d’un programme est :
17
1 #!/usr/bin/env python2 # -*- coding: UTF-8 -*-3 """4 Script: un_programme.py5 Auteur: pycharm6 Date: 01/09/20177 """8
9 # Programme principal10 def main():11 # Les instructions12 print("1er programme")13
14 # Fin du programme15
16 if __name__ == ’__main__’:17 main()
L’art de la tabulationAttention : pour faire partie du main, les instructions du programme doivent toutes etre tabulees (d’unetabulation ou 4 espaces d’apres le PEP8).
Tr. 43
18
Chapitre 3 — Structures alternatives (ou conditionnelles)
Tr. 44
7 Expressions booleennes
7.1 Le type booleen
Definition 32 (Le type booleen). Une variable de type booleen (bool) peut prendre uniquement deux valeurs :— True (correspondant a vrai ou a la valeur binaire 1)— False (correspondant a faux ou a la valeur binaire 0)
Remarque888Toute variable peut etre transtypee en booleen avec la fonction bool(valeur) :
— toute valeur egale a 0 ou vide (ou None) est consideree comme False
— tout le reste est vu comme True.Par defaut, b=bool() donne b=False
Tr. 45
7.2 Expressions booleennes
7.2.1 Operateurs de comparaison
Operateurs de comparaisonLes expressions booleennes mettent en œuvre des operateurs de comparaison qui comparent deuxdonnees du meme type (numerique, chaıne) et s’evaluent en un booleen.
Les principaux operateurs de comparaisonCf. table 9
Op. Signification Op. Signification== egal (meme valeur) != different> strictement superieur < strictement inferieur>= superieur ou egal <= inferieur ou egalb<x<B x est compris entre b et Bin appartenance a une liste
d’elementsnot in non appartenance a une
liste d’elementsisinstance(x, t) x est du type t? is egal (meme objet en
memoire)
TABLE 9 – Les principaux operateurs de comparaison
Tr. 46
Exemple 33 (Des expressions booleennes avec operateurs de comparaison). Cf. table 10
Condition Expression PythonLa variable prog1 est-elle egale a 10? prog1 == 10
La variable prog2 est-elle comprise entre 10 et 20? 10 < prog2 < 20
La moyenne des notes prog1 et prog2 est-elle superieure a 10? (prog1+prog2)/2 > 10
La note prog1 est-elle divisible par 3? prog1 % 3 == 0
Le jour est-il "lundi", "mardi" ou "mercredi"? jour in ["lundi", "mardi", "mercredi"]
x est-il different de 2.2, 3.3 et de 4.4? x not in [2.2, 3.3, 4.4]
x est-il du type int? isinstance(x, int)
TABLE 10 – Des exemples d’expressions booleennes
Remarque : Les expressions booleennes peuvent bien sur servir a affecter une variable. Par exemple,l’instruction reponse = (x == 5) affecte reponse au resultat de la comparaison ”x est-il egal a 5?” Tr. 47
19
7.2.2 Operateurs booleens
Operateurs booleensLes expressions booleennes peuvent egalement mettre en oeuvre des operateurs booleens entreexpressions booleennes (souvent obtenues comme resultat d’une comparaison entre deux valeurs).
Principaux operateurs booleensCf. table 11.
Symb. Signification Symb. Significationor union logique pour les boolean and intersection logique pour les
boolean
not negation logique pour lesboolean
TABLE 11 – Operateurs des expressions booleennes
Remarque : Attention aux priorites des operateurs (cf. table 5). Dans le doute, abuser des parentheses quiameliorent souvent la lisibilite !Tr. 48
Rappel : Table de verite des operateurs (cf. table 12)
and True False
True True False
False False False
or True False
True True True
False True False
not True False
False True
TABLE 12 – Les tables de verite du and, or, not
Exemple 34 (Des conditions booleennes). Cf. table 13
Condition Expression PythonLa variable jour est-elle egale a ”lundi” et la variable annee (jour == "lundi") and (annee > 2000)
est-elle superieure a 2000?Le jour est-il dans le WE? (jour == "samedi") or (jour == "dimanche")
jour in ["samedi", "dimanche"]
La variable x est-elle differente de 0? x != 0
(x > 0) or (x < 0)
La variable x est-elle comprise entre 0.5 inclu et 1.5? (x >= 0.5) and (x < 1.5)
0.5 <= x < 1.5
TABLE 13 – Des exemples d’expressions booleennes
Remarque889 : L’evaluation de la condition booleenne s’arrete des que le resultat est sur : par ex., dansX and Y, si X est evalue a False, alors l’expression est False et Y n’est pas evalue. Sinon, l’expression estevaluee a la valeur booleenne de Y. Pour X or Y, si X est evalue a True, alors l’expression est True et Y n’estpas evalue.Tr. 49
8 Structure alternative elementaire : Si sinon
8.1 Principe et syntaxe
20
Structure alternative ”Si ... sinon”La structure alternative :
# Debut du si/sinonif condition_booleenne:# Instructions si la condition est vraieinstructioninstruction
else:# Instructions si la condition est fausseinstructioninstruction
# Fin du si/sinonsuite_du_programme
uniquement si la condition est True
uniquement si la condition est False
suite du deroulement sequentiel
teste la condition_booleenne en evaluant si elle est True ou False.— Si elle est True, alors le bloc d’instructions qui suit le if est execute(mais pas le bloc qui suit le else) ;— Sinon (si la condition est False), alors le bloc d’instruction qui suit le else est execute (mais pas le
bloc qui suit le if).Une fois les instructions de la structure if/else executee, le programme continue ensuite son deroulementavec la premiere instruction suivante.
Tr. 50
La tabulation comme identifiant des blocs d’instructionsC’est l’indentation (tabulation avec la touche −−→−−→ ) qui definit les blocs d’instructions en Python :vue d’une structure alternative seule :
if condition_booleenne:# Instructions si# la condition est vraie# ...
else:# Instructions si# la condition est fausse# ...
# suite_du_programme
−−→−−→
vue du programme principal :
def main():#...if condition_booleenne:
# Instructions si# la condition est vraie# ...
else:# Instructions si# la condition est fausse# ...
# suite_du_programme
−−→−−→
−−→−−→
Il y a donc :— une tabulation pour separer la ligne du if et les instructions du if
— une tabulation pour separer la ligne du else et les instructions du else
— aucune tabulation entre les lignes du if et du else et les instructions qui marquent la reprise duprogramme apres la structure alternative.
Tr. 51
8.2 Exemple
Exemple 35 (Alternative 1, si sinon). Les instructions :
21
1 chaine_var = input("Saisir un entier: ")2 var = int(chaine_var)3 if var > 4:4 # Instructions si la condition est vraie5 print("oui: {} est superieur a 4".format(var))6 else:7 # Instructions si la condition est fausse8 print("non: {} est inferieur ou egal a 4".format(var))9 # Fin du si/sinon et suite du programme
10 print("fin")
donnent a l’execution :Cas 1 :
Saisir un entier: 5oui: 5 est superieur a 4fin
Cas 2 :
Saisir un entier: 3non: 3 est inferieur ou egal a 4fin
Tr. 52
9 Structure conditionnelle elementaire : Si
9.1 Principe et syntaxe
La structure conditionnelle ”si” peut etre vue comme un cas particulier de l’alternative si ... sinon lorsqu’iln’y a pas d’instructions dans le cas sinon.
Structure conditionnelle ”Si”
if condition_booleenne:# Instructions si la condition est vraiinstruction...instruction
# Fin de la condition et suite du programmesuite_du_programme
uniquement si la condition est vraie
”omis” sila conditionest fausse
suite du deroulement sequentiel
La structure precedente teste la condition_booleenne en evaluant si elle est True ou False.Si elle est True alors le bloc d’instructions qui suit le if est execute.Sinon (si la condition est False) le bloc d’instructions qui suit le if n’est pas execute.Dans les deux cas, le programme se poursuit avec la premiere instruction de la suite_du_programme.
Tr. 53
9.2 Exemple
Exemple 36 (Alternative 2, si). Les instructions :
1 chaine_var = input("Saisir un nombre: ")2 var = float(chaine_var)3 if var < 0:4 # Instructions si la condition est vrai5 var = -var6 # Fin de la condition et suite du programme7 print("Sa valeur absolue est {}".format(var))8 print("fin")
donnent a l’execution :Cas 1 :
Saisir un nombre: 5Sa valeur absolue est 5fin
Cas 2 :
22
Saisir un nombre: -2Sa valeur absolue est 2fin
Tr. 54
10 Structure alternative multiple : si ... ou si ... sinon
10.1 Principe et syntaxe
Structure alternative Si ... ou si ... sinon
if condition_booleenne_1:instructioninstruction
elif condition_booleenne_2:instructioninstruction
else:instructioninstruction
suite_du_programme
s’execute si la condition 1 est True
s’execute si la condition 1 est Falseet la condition 2 est True
s’execute si les conditions 1 et 2sont False
Remarques :— Le bloc elif peut apparaıtre autant de fois que l’on souhaite tester de conditions alternatives— Des que l’une des conditions booleennes est True alors les conditions testees dans les elif qui
suivent ne sont plus evaluees et le programme passe a la suite du programme— Le bloc else est optionnel Tr. 55
10.2 Exemple
Exemple 37 (Alternative 3, si ... ou si ... sinon). Les instructions :
1 chaine_nombre = input("Un nombre: ")2 nombre = float(chaine_nombre)3 if nombre < 0:4 print(nombre, "est negatif")5 elif nombre > 0:6 print(nombre, "est positif")7 else:8 print(nombre, "est nul")9 print("fin")
donnent a l’execution :Cas 1 :
Un nombre: 22 est positiffin
Cas 2 :
Un nombre: -3-3 est negatiffin
Cas 3 :
Un nombre: 00 est nulfin
Tr. 56
23
11 Structures alternatives imbriquees
Les structures alternatives peuvent etre imbriquees les unes dans les autres autant de fois qu’on le souhaite.
Exemple 38 (Alternative 4, le meme test du signe avec des structures alternatives imbriquees).
1 chaine_nombre = input("Un nombre: ")2 nombre = float(chaine_nombre)3 if nombre >= 0:4 if nombre > 0:5 print(nombre, "est positif")6 else:7 print(nombre, "est_nul")8 # fin du test nombre >09 else: # nombre <0
10 print(nombre, "est negatif")11 # fin du test nombre >= 0:12 print("fin")
Remarque : La encore, c’est l’indentation qui permet d’interpreter les blocs d’instructions.Tr. 57
11.1 Bilan
Exemple 39 (Algo). Une UE contient 2 modules : M1 et M2.— L’UE est valide si les notes aux deux modules sont superieures a 10— Il y a rattrapage si un seul des modules a une note superieure a 10— Si les deux notes sont inferieures a 10, l’UE n’est pas validee
Ici, les variables m1 et m2 representent la note obtenue a chaque moduleTr. 58
Les trois implementations suivantes sont equivalentes :
1. Avec 2 structures si sinon imbriquees :
1 if m1 >= 10 and m2 >= 10:2 print("valide")3 else: # Donc si (m1<10 or m2<10)4 if m1 >= 10 or m2 >= 10:5 print("rattrapage")6 else: # Donc si (m1<10 and m2<10)7 print("refuse")
2. Avec une structure si ou si sinon :
1 if m1 >= 10 and m2 >= 10:2 print("valide")3 elif m1 >= 10 or m2 >= 10: # et si (m1<10 or m2<10)4 print("rattrapage")5 else: # donc si (m1<10 and m2<10)6 print("refuse")
Tr. 59
3. Avec des conditions simples :
1 if m1 >= 10:2 if m2 >= 10: # et m1>=103 print("valide")4 else: # donc si m1>=10 et m2<105 print("rattrapage")6 else: # donc si m1<107 if m2 >= 10: # et m1<108 print("rattrapage")9 else: # donc si m1<10 et m2<10
10 print("refuse")
Tr. 60
24
Chapitre 4 — Structures repetitives
Tr. 61
12 Principes des structures repetitives
Definition 40 (Structure repetitive). Une structure repetitive est un bloc d’instructions parcouru un certainnombre de fois (de 0 a une infinite).
Boucle whileLes boucles while/tant que repetent une serie d’instructions tant qu’une condition est verifiee ; lacondition est une expression booleenne qui s’ecrit de la meme facon que dans les structures alternatives.
Boucle forEn pratique, le nombre de repetitions est tres souvent connu par le programmeur (parcours des elementsd’une liste, repetition d’une meme action, ...) ; on leur prefere une syntaxe plus simple appelee boucle for.
Tr. 62
13 Boucle for
13.1 Le compteur d’iteration
Definition 41 (Boucle for). Pour repeter un bloc d’instructions N fois, une boucle for utilise un compteurd’iteration :
for compteur in range( N ) :instruction # Debut du bloc a repeter...instruction
# Fin du forsuite_du_programme
— Une iteration est une execution (ou une repetition) du bloc d’instructions— Le compteur s’initialise a 0 ; apres chaque iteration, il augmente de 1.— Lorsqu’il atteint N , le bloc d’instructions a ete execute N fois - il n’est plus execute et le programme
passe aux instructions qui suivent le blocRemarque : les compteurs sont couramment appeles i, j ou k... pour des raisons historiques liees aulangage Fortran.
Tr. 63
13.2 Repetition
Exemple 42 (Boucle 1, iterant le meme affichage 3 fois). Les instructions suivantes :
1 for i in range(3):2 print("*", end=" ")3 print("fin")
iterent 3 fois l’affichage de * et donnent :
* * * fin
Le trace du code est donne table 14.Remarque : ce code est equivalent a print "*"*3 + "fin".
Tr. 64
13.3 Repetition en utilisant le compteur de boucle
Le compteur de boucle, une variable comme une autre ...Le compteur peut etre utilise dans les instructions de la boucle pour faire varier leurs resultats d’une iterationa une autre
Exemple 43 (Boucle 2, affichage des nombres de 2 jusqu’a 6 (exclu)). Les instructions suivantes :
25
Ligne i Affichage Commentaire1 0 Initialisation du compteur a 02 0 * Fin de la 1ere iter. de boucle1 1 *
2 1 * * Fin de la 2eme iter. de boucle1 2 * *
2 2 * * * Fin de la 3eme iter. de boucle1 3 * * * Le compteur atteint le nbre d’iter. voulu3 3 * * * fin
TABLE 14 – Trace de la boucle affichant * * * fin
1 for i in range(4):2 print(i + 2, end=" ")3 print("fin")
affichent les nombres de 2 a 5 et donnent :
2 3 4 5 fin
Le trace du code est donne table 15.
Ligne i i+2 Affichage Commentaire1 0 Initialisation du compteur a 02 0 2 2 Fin de la 1ere iter. de boucle1 1 2
2 1 3 2 3 Fin de la 2eme iter. de boucle1 2 2 3
2 2 4 2 3 4 Fin de la 3eme iter. de boucle1 3 2 3
2 3 5 2 3 4 5 Fin de la 4eme iter. de boucle1 4 2 3 4 5 Le compteur a atteint le nbre d’iter. voulu3 4 2 3 4 5 fin
TABLE 15 – Trace de la boucle affichant 2 3 4 5 fin
Tr. 65
... mais ë attention : le compteur de boucle ne doit en general pas etre modifie par les instructions dela boucleLes valeurs du compteur sont pre-calculees au 1ere passage dans la boucle pour aller de 0 a N. Quelquesoient les modifications faites sur le compteur dans le bloc d’instruction, chaque nouvelle iteration donne aucompteur la prochaine valeur pre-calculee.
Tr. 66
Exemple 44 (Boucle 3, ne pas modifier le compteur dans la boucle).Les instructions :
1 for i in range(2):2 print(i, end=" ") # affichage3 i = 0 # raz du compteur4 print("fin")
donnent :
0 1 fin
Le trace du programme est donne table 16.Tr. 67
13.4 Valeur initiale du compteur
Definition 45 (Boucle for avec valeur initiale non nulle). La syntaxe d’une boucle for repetant un blocd’instructions sur la base d’un compteur allant d’une valeur initiale a une valeur finale (exclue) est :
1 for compteur in range(val_ini, val_fin_exclue) :2 instructions
26
Ligne i Affichage1 0 Initialisation du compteur a 02 0 0
3 0 0 Fin de la 1ere iter. de boucle1 1 0
2 1 0 1
3 0 0 1 Fin de la 2eme iter. de boucle1 2 0 1 Le compteur atteint le nbre d’iter. voulu3 3 0 1 fin
TABLE 16 – Trace de la boucle affichant 0 1 fin
Le nombre d’iterations est alors de val_fin_exclue - val_ini ; la boucle s’arrete lorsque le compteur atteintla valeur val_fin_exclue.
Exemple 46 (Boucle 4, affichage des nombres de 2 jusqu’a 5 (exclu)). Les instructions pour afficher lesnombres de 2 a 4 :
1 for i in range(2, 5):2 print(i, end=" ")3 print("fin")
donnent en 3 iterations :
2 3 4 fin
Le trace du code est donne table 17.
Ligne i Affichage Commentaire1 2 Initialisation du compteur a 22 2 2 Fin de la 1ere iter. de boucle1 3 2
2 3 2 3 Fin de la 2eme iter. de boucle1 4 2 3
2 4 2 3 4 Fin de la 3eme iter. de boucle1 5 2 3 4 Le compteur a atteint sa valeur finale3 5 2 3 4 fin
TABLE 17 – Trace de la boucle affichant 2 3 4 fin
Tr. 68
13.5 Increment du compteur
Definition 47 (Boucle for avec un increment du compteur different de 1). La syntaxe suivante :
1 for compteur in range(val_ini, val_fin_exclue, increment) :2 instructions
initialise le compteur a la val_ini et a chaque iteration augmente la valeur du compteur de increment jusqu’ace qu’il egale ou depasse val_fin_exclue
Exemple 48 (Boucle 5, affichage des nombres pairs de 2 jusqu’a 8 (exclu)).
1 for i in range(2, 8, 2):2 print(i, end=" ")3 print("fin")
donne :
2 4 6 fin
Le trace du code est donne table 18.Tr. 69
27
Ligne i Affichage Commentaire1 2 Initialisation du compteur a 22 2 2 Fin de la 1ere iter. de boucle1 4 2
2 4 2 4 Fin de la 2eme iter. de boucle1 6 2 4
2 6 2 4 6 Fin de la 3eme iter. de boucle1 8 2 4 6 Le compteur atteint sa valeur max.3 8 2 4 6 fin
TABLE 18 – Trace de la boucle affichant * ** *** fin
14 Boucle while
14.1 La condition de boucle
Definition 49 (Boucle while). Une boucle while repete un bloc d’instructions tant qu’une conditionbooleenne est verifiee :
1 initialisation_condition2 while condition [== True] :3 instruction4 ...5 modification_condition6 suite_du_programme
Y 3 etapes fondamentales la constituent :1. Initialisation de la condition2. Test de la condition a chaque iteration de la boucle3. Modification du contexte (de la condition) a chaque iteration— Des que la condition n’est plus vraie, le programme se poursuit avec les instructions qui suivent le
bloc repetitif— Pour ne pas se repeter sans fin, le bloc d’instructions doit obligatoirement reaffecter la condition
booleenne.
Ces boucles sont particulierement utiles lorsque le nombre d’iterations n’est pas connu a l’avance comme parexemple lorsqu’elles dependent d’une action de l’utilisateur ou du resultat d’un calcul fait par les instructionsde boucle.Tr. 70
14.2 Repetition dependant d’une saisie utilisateur
Exemple 50 (Verification d’une saisie clavier). Les programmes suivants imposent a un utilisateur une saisieclavier valant ’O’ ou ’N’ 1.Ils utilisent pour condition de boucle la variable rep, donnant le resultat de la saisie utilisateur, comparee auxvaleurs attendues.Deux types d’initialisation peuvent etre envisagees :
1. rep = input("Tapez O/N ") qui realise une premiere saisie avant test2. rep = "" qui affecte une valeur garantissant l’entree dans la boucle.
Tr. 71
Exemple 51 (Boucle 1&2, verification d’une saisie clavier).Variante 1 :
1 rep = input("Tapez O/N ? ") # Initialisation2 while not (rep == "O" or rep == "N"): # Condition de boucle3 rep = input("O/N svp; recommencez : ") # Modif. de la variable4 print("fin")
Variante 2 :1 rep = "" # Autre initialisation2 while not (rep == "O" or rep == "N"): # Meme condition3 rep = input("Tapez O/N ? ") # Modif. de la variable4 print("fin")
1. Rappel : Python est sensible a la casse ; ’O’ n’est donc pas le meme caractere que ’o’
28
donnent a l’execution pour les meme saisies de l’utilisateur :pour la variante 1 (2 passages dans la boucle) :
Tapez O/N iO/N svp; recommencez : pO/N svp; recommencez : Ofin
pour la variante 2 (3 passages dans la boucle) :
Tapez O/N ? iTapez O/N ? pTapez O/N ? Ofin
Tr. 72
15 Equivalence boucles for/while
L’art du compteur d’iterationLorsque le nombre d’iterations est connu et qu’on peut le denombrer avec un compteur d’iteration allantd’une valeur ini a une valeur fin en s’incrementant a chaque iteration de inc, les structures repetitivespeuvent finalement s’ecrire indifferemment avec une boucle for ou une boucle while :
for compteur in range(ini, fin, inc) :instruction...
suite_du_programme
compteur = iniwhile compteur < fin :instruction...compteur += inc
suite_du_programme
Tr. 73
Exemple 52 (Boucle 6&3, affichage des nombres impairs de 0 a 20). Avec une boucle for :1 for i in range(1, 20, 2):2 print(i, end=" ")3 print("fin")
Avec une boucle while :1 i = 12 while i < 20:3 print(i, end=" ")4 i = i + 25 print("fin")
Ils donnent tous les deux a l’execution :
1 3 5 7 9 11 13 15 17 19 fin
avec 10 iterations pour chaque boucle
Tr. 74
16 Boucles et structures alternatives
Y Les instructions d’une boucle peuvent contenir des structures alternatives... C’est toujours l’indentationqui permet d’identifier les blocs d’instructions : ici les instructions du if sont indentees 1 fois par rapport au if
qui lui-meme est indente 1 fois par rapport au for.
Exemple 53 (Boucle 7, affichage des nombres impairs de 0 a 10).1 for i in range(20):2 if (i % 2) != 0:3 print(i, end=" ")4 else:5 print("-", end=" ")6 print("fin")
donne a l’execution :- 1 - 3 - 5 - 7 - 9 fin
avec 20 iterations
Tr. 75
29
17 Boucle avec variable d’accumulation
17.1 Principe
Principe de la variable d’accumulation— Les boucles s’utilisent couramment avec une variable d’accumulation, dont la valeur s’actualise a
chaque iteration dans le bloc d’instruction de la boucle.— L’actualisation peut etre : l’ajout a la variable d’une valeur (nombre ou chaine de caracteres), la
multiplication de la variable par une valeur, ...— Le choix du type de boucle (for ou while) depend de l’application visee toujours dans l’idee qu’elle
conduit (ou non) a un nombre d’iterations connuTr. 76
17.2 Accumulation additive
Exemple 54 (Boucle 1, solde d’un compte bancaire apres un nombre fixe de mois). Application : afficher lesolde d’un compte bancaire initialement egal a 0, sur lequel est verse un montant fixe de 50 euros tous lesmois, apres 4 ans de fonctionnement :
— Variable d’accumulation : le solde— Boucle : for car le nombre de mois (ici 4*12) est connu
1 solde = 0 # Initialisation2 for mois in range(1, 4 * 12):3 solde = solde + 504 print("solde final :", solde)5 print("fin")
donne a l’execution :
solde final : 2350
Y Il n’y a pas trace des valeurs intermediaires du solde (cf. listes en Prog2)Tr. 77
Exemple 55 (Boucle 2, quand pourrais-je avoir un iPhone?). Application : partant d’un livret de 50 euros, surlequel est vire 200 euros chaque annee et avec 0.75% d’interet, combien d’annee faut-il a son titulaire pouracheter un iPhone?
— Variable d’accumulation : le solde avec ajout des interets et du versement a chaque iteration— La boucle : while avec un compteur d’annees
1 solde = 502 annee = 03 while solde < 700:4 solde = solde*(1+0.75/100)+2005 annee = annee + 16 print("Nombre d’annees :", annee)7 print("Solde :", solde)
donne a l’execution :
Nbre d’annees : 4Solde : 860.5620439082031
Le nombre d’annees est d’ailleurs le nombre d’iterations de la boucle while.Tr. 78
Exemple 56 (Boucle 3, calcul de la somme de tous les entiers de 1 jusqu’a 36 (inclus)).1 somme = 0 # Initialisation2 for i in range(1, 36 + 1):3 somme = somme + i4 print("somme finale :", somme)
donne :
somme finale : 666
Conclusion : structure des programmes avec une variable d’accumulationUn programme utilisant une variable d’accumulation doit toujours :
1. initialiser la variable d’accumulation,2. programmer une structure repetitive qui actualise la valeur de la variable d’accumulation.
La valeur finale de la variable est obtenue en sortie de boucle.Tr. 79
30
17.3 Accumulation multiplicative
Exemple 57 (Boucle 4, calcul iteratif d’une puissance). Le programme suivant calcule 24 dans res en utilisantle fait que 24 = 2× 2× 2× 2 ; res etant modifiee par accumulation de multiplication, sa valeur initiale seradonc 1.
1 res = 12 i = 13 while i <= 4:4 res = res * 25 i = i + 16 print("2ˆ4 vaut", res)
Le trace des variables est donne table 19.
Ligne i i<=4? res calcul commentaire1-2 1 13 1 True 1 1er iteration
4-5 2 True 2 1*23 2 True 2 1*2 2eme iteration
4-5 3 True 4 1*2*23 3 True 4 1*2*2 3eme iteration
4-5 4 True 8 1*2*2*23 4 True 8 1*2*2*2 4eme iteration
4-5 5 True 16 1*2*2*2*23 5 False 16 1*2*2*2*26 5 False 16 1*2*2*2*2
TABLE 19 – Trace de la boucle calculant 2ˆ4
Tr. 80
18 Boucles imbriquees
Exemple 58 (Trace d’un triangle d’etoiles).1 for i in range(2, 4):2 for j in range(1, i):3 print("*", end=" ")4 print("")
donne :
** *
Le trace des variables est donne table 20.
Ligne i j Aff. Commentaire1 2 i initialise a 22 2 1 j initialise a 13 2 1 * Fin de la 1ere iter. de la boucle sur j2 2 2 * j atteint sa valeur max.4 2 2 \n Fin de la 1ere iter. de la boucle sur i1 3 22 3 1 j initialise a 13 3 1 * Fin de la 1ere iter. de la boucle sur j2 3 2 *3 3 2 * * Fin de la 2eme iter. de la boucle sur j3 3 3 * * j atteint sa valeur maximale4 3 3 \n Fin de la 2eme iter. de la boucle sur i1 4 3 i atteint sa valeur max.
TABLE 20 – Trace d’une boucle imbriquee
Tr. 81
31
Chapitre 5 — Fonctions
Tr. 82
19 Fonctions
19.1 Definition
Definition 59 (Fonction). Une fonction est un bloc/une suite d’instructions autonome qui decrit un calcul ouune tache dans le but de structurer le programme en taches simples.Elle :
1. possede un nom pour etre appelee plusieurs fois,
2. des parametres d’entree 2 servant a faire varier les calculs ; ses parametres sont identifies par un nomet un ordre,
3. renvoie une unique valeur (dependante ou non des parametres) servant de resultat a la fonction.
Elle se decrit par une signature de la forme nom_de_fonction(param1, param2, ..., paramN)
Exemple 60 (Des fonctions).— cos(x) est la fonction dont le nom est cos ; elle a un parametre x et retourne la valeur de cos(x).— max(a,b) est la fonction dont le nom est max ; elle a deux parametres a et b et retourne la valeur la plus
grande parmi a et b.Tr. 83
19.2 Syntaxe de declaration d’une fonction
Elements pour la declaration d’une fonction
1. Nom de la fonction : identificateur explicite
2. Parametres : liste de parametres d’entree-sortie de l’algorithme
3. Preconditions (optionnel) : des expressions booleennes qui precisent les conditions d’application del’algorithme (888)
4. Description (optionnel mais d’usage obligatoire) : une documentation de l’algorithme
5. Code : sequence d’instruction necessaire a la resolution du probleme
6. Retour (ou renvoi) : la valeur renvoyee
Tr. 84
Syntaxe de declaration
def nom(param1, param2, ..., paramN ) :["[""] commentaires [""]"] # documentation[assert type(param) is ...] # pre-conditions
instruction # codeinstruction...return [valeur] # renvoie de la valeur de retour
# avec sortie de la fonction# fin de la fonction
Remarques :— l’indentation definit le bloc d’instructions de la fonction— l’execution de return stoppe le flux d’instructions dans une fonction et force la sortie de la fonction— si return n’est suivi d’aucune valeur, alors la fonction renvoie NoneTr. 85
2. Python gere des parametres optionnels (hors du cadre de ce cours)
32
20 Exemples de fonctions
20.1 Fonction a un parametre
Exemple 61 (Declaration de la fonction factorielle).La fonction factorielle (avec son unique parametre) est declaree par :
1 def factorielle(n):2 """Calcule et renvoie la factorielle du parametre entier positif n, valant n!"""3 res = 14 for i in range(1, n+1):5 res *= i6 return res # Valeur de retour
et peut etre appellee avec :1 res = factorielle(4)2 print("4! vaut :", res)3 res = factorielle(3)4 print("3! vaut :", res)
ce qui donne :
4! vaut : 243! vaut : 6
Tr. 86
20.2 Fonction a deux parametres
Exemple 62 (La fonction somme2). La fonction somme2 (avec ses deux parametres a et b) est declaree par :1 def somme2(a, b):2 """Calcule et renvoie la somme de deux nombres (ou de deux chaines) a et b"""3 total = a + b4 return total
Elle peut etre appelee avec :1 res = somme2(10, 2)2 print("10+2 vaut :", res)3 res = somme2(’a’, ’b’)4 print("a+b vaut :", res)
ce qui donne :
10+2 vaut : 12a+b vaut : ab
Remarque FFF : cette fonction est un exemple de polymorphisme puisqu’elle peut etre utilisee avecn’importe quel type d’objets tant que l’addition + est definie. Tr. 87
20.3 Fonction a plusieurs valeurs de retour
Une fonction a obligatoirement (au moins) une instruction return, qui declenche la fin de la fonction et leretour a l’instruction appelante avec pour valeur de retour, celle indiquee par le return. L’instruction return
peut apparaıtre plusieurs fois, mais une seule sera evaluee.La fonction est declaree avec :
1 def strctmax(a, b):2 """Retourne le parametre strictement le plus grand, None sinon"""3 if a > b:4 return a5 elif b > a:6 return b7 else: # si a == b8 return
Elle peut etre appelee avec :1 res = strctmax(1, 2)2 print("strctmax de 1 et 2 :", res)3 res = strctmax(3, 1)4 print("strctmax de 3 et 1 :", res)5 res = strctmax(4, 4)6 print("strctmax de 4 et 4 :", res)
33
ce qui donne :
strctmax de 1 et 2 : 2strctmax de 3 et 1 : 3strctmax de 4 et 4 : None
Tr. 88
21 Portee des variables dans une fonction
21.1 Notion de portee locale
1. L’execution d’un programme s’appuie sur un contexte (de nommage) des variables et sur la memoire(vive) qui stocke leur valeur.
2. Le programme principal utilise le contexte principal
3. Un appel a une fonction cree un contexte local (qui lui est propre), dans lequel sont declares lesparametres et les variables de la fonction :— Ce contexte local est efface (n’existe plus) au retour (return) de la fonction— Il est recree (”a neuf”) a chaque nouvel appel de la fonction— Les parametres recoivent une copie de la reference des arguments
4. Les contextes principal et local sont completement separes, de sorte qu’il n’y a pas d’interferencesentre eux : on dit alors que la portee des variables d’une fonction est locale a la fonction (c’est adire les variables n’existent que lors de l’appel a la fonction - elles peuvent donc avoir le meme nom quedes variables du programme principal sans conflit)
5. La memoire est partagee par le programme principal et la (les) fonction(s)Tr. 89
21.2 Contexte local d’une fonction
Exemple 64. Soit la fonction :
1 def puissance() :2 nbr = 33 puiss = 24 res = nbr ** puiss5 return res
appellee dans le programme principal avec :
1 nbr = 12 res = puissance()
Contexteprincipal Memoire
nbr 1
Contextelocal
Appel : puissance()
nbr3
puiss2
res6res
return res
FIGURE 4 – Contexte local de l’appel a une fonction sans parametre
— Le contexte de la fonction (cf. figure 4) n’existe qu’au moment de son evaluation : la variable localenbr differe de nbr, au meme titre que res differe de res.
— L’objet en memoire, renvoye par la fonction, est celui recupere dans le programme principal (et doncici affecte a res)Tr. 90
34
21.3 Cas des parametres
Exemple 65. Soit :
1 def somme( a, b ) :2 a = 33 res = a + b4 return res
appelee avec :
1 a = 12 b = 23 res = somme( a, b )4 mais = a + b
Contexteprincipal Memoire
Contextelocal
3
a 1 a
b 2 b
res5res
3mais
%
Appel : somme()
return res
FIGURE 5 – Contexte local de l’appel a une fonction avec parametres
— Lors de l’appel a la fonction somme (cf. figure 5), les parametres a et b (n’existant que dans le contextelocal) referencent les meme objets que a et b
— Toute modification des parametres (ou plus precisement, toute reaffectation des objets designes parles parametres) dans la fonction n’aura d’impact que dans la fonction, et pas dans le programmeprincipal puisque a et a ne designent plus les meme objets a la fin de la fonction. Tr. 91
22 Chaınage de fonctions
Une fonction peut en appeler une autre : toutes deux auront leur propre return.
Exemple 66 (La fonction somme4). La fonction somme4 utilise somme2 pour sommer ses 4 parametres :
1 def somme4(a, b, c, d):2 """Calcule la somme des 4 parametres en utilisant somme2"""3 res1 = somme2(a, b)4 res2 = somme2(c, d)5 res = somme2(res1, res2)6 return res
1 def somme2(a, b):2 """Calcule et renvoie la somme de deux nombres (ou de deux chaines) a et b"""3 total = a + b4 return total
Elle peut etre appelee pour differents calculs avec :
1 res = somme4(1, 2, 3, 4)2 print("1+2+3+4 :", res)3 res = somme4(’a’, ’b’, ’c’, ’d’)4 print("a+b+c+d :", res)
ce qui donne :
1+2+3+4 : 10a+b+c+d : abcd
Tr. 92
35
23 Les prototypages classiques de fonctions
Les fonctions forment trois grandes categories (prototypages) :
1. Les fonctions dediees aux saisies clavier de l’utilisateur, qui :— n’ont en general pas de parametre— renvoient la valeur saisie
2. Les fonctions dediees a l’affichage, qui :— peuvent avoir en parametres des donnees a afficher,— s’occupent de l’affichage console avec print,— ont pour valeur de retour None
3. Les fonctions dediees aux calculs/traitements, qui :— ont des parametres,— ont une valeur de retour, renvoyee par return et dependante du traitement,— n’ont pas de saisie-clavier avec input car ce sont les arguments d’appel qui dirigent l’evaluation de
la fonction— ne font pas d’affichage avec print (sauf pour aider au deboggage du programme)L’affichage du resultat est alors faite, soit par le programme principal, soit par une fonction dediee al’affichage.
Tr. 93
Exemple 67 (Termes d’une suite). Pour un programme qui calcule les termes de la suite un+1 = 2un + 1 avecu0 = 1 et affiche la valeur du terme de rang N , N etant choisi par l’utilisateur, on peut trouver :
1. la fonction dediee a la saisie clavier de N :
1 def saisie():2 """Demande un rang et le renvoie en verifiant la saisie"""3 nbre = eval(input("Un nbre: "))4 while not(isinstance(nbre, int) and nbre >= 0):5 nbre = eval(input("Un nbre svp; recommencez: "))6 return nbre
2. la fonction dediee a l’affichage du terme un :
1 def affichage(u, n):2 """Affichage du terme u et de son rang n"""3 print("u_{} vaut {}".format(n, u))4 return
Tr. 94
Exemple 68 (Termes d’une suite (suite)).
3. la fonction dediee au calcul du terme un de la suite :
1 def terme_np1(n):2 """Calcule le terme de rang n de la suite"""3 u = 1 # Terme initial u04 for i in range(1, n+1):5 u = 2*u + 1 # Calcul du terme un+1 en fonction de un6 return u
4. les instructions du programme principal :
1 n = saisie() # Rang souhaite par l’utilisateur ?2 u = terme_np1(n) # Calcul du terme de rang N3 affichage(u, n) # Affichage
L’execution donne par exemple :
Un nbre: 5u_5 vaut 63
Tr. 95
36
24 Ou declarer une fonction?
Python etant un langage interprete, il est imperatif, dans un script, de definir une fonction avant de l’utiliser.
Exemple 69 (Script demoTriangle.py).
1 # -*- coding: UTF-8 -*-2 """3 Script: td_sphinx/demoTriangle4 Auteur: pycharm5 Date: 01/09/20176 """7
8 # Fonctions9 def ligne(nb):
10 """Renvoie une ligne de nb etoiles (type str)"""11 chaine = ’*’*nb12 return chaine13
14 def triangle(nb):15 """Renvoie un triangle d’etoiles dont la derniere ligne contient nb etoiles (type str)"""16 res = ""17 for n in range(1, nb+1):18 res += ligne(n) + ’\n’19 return res20
21
22 # Programme principal23 def main():24 tr = triangle(5)25 print(tr)26
27 if __name__ == ’__main__’:28 main()
Tr. 96
37