INFO 2 Éléments de programmation · PDF filedédié (par exemple Java et Java Virtual Machine). ... une avancée majeure : alors que la programmation avec GOTO condamnait à raisonner

INFO 2 Éléments de programmation

On poursuit le cours par un exposé sur les langages de programmation, leurs prin-cipes généraux et en particulier le noyau impératif. Le langage Python sert d’illus-tration tout au long du cours.

2 Éléments de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Les langages de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

1.1 Qu’est-ce qu’un langage de programmation ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.2 Niveau d’un langage, compilateur, interpréteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3 Les différents paradigmes de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.4 Le langage Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2 Les environnements de développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 La notion de type en programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

3.1 Nécessité du typage, catégories de typage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53.2 Entiers de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63.3 Flottants de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63.4 Booléens de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73.5 La fonction type et le transtypage sous Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

4 Les variables informatiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 Le noyau impératif d’un langage de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

5.1 Les instructions d’entrée et de sortie sous Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125.2 La séquence sous Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135.3 Le test sous Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135.4 La boucle sous Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155.5 Annexe : réponses aux tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

PCSI 2 \ 2017-2018 Laurent Kaczmarek

1. Les langages de programmation

1.1. Qu’est-ce qu’un langage de programmation ?

Un langage de programmation est un langage formel dans lequel on peut exprimer des algorithmes.Tous les langages informatiques sont formels mais tous ne sont pas des langages de programmation,par exemple HTML, qui est un langage de description.

Comme une langue humaine, un langage de programmation est constitué :

. d’un alphabet ;

. d’un ensemble de mots-clés ;

. d’une syntaxe explicitant les règles de construction des phrases du langage ;

. d’une sémantique explicitant le sens des expressions du langage.

Il existait des langages formels avant l’informatique, la notation musicale par exemple. Un autreexemple est le langage des opticiens OD : −1,25(−0,50)180◦ OG : −1,00(−0,25)180◦.

Les langages de programmation permettent de :

. décrire les structures de données qui seront traitées par l’ordinateur ;

. indiquer comment est effectué ce traitement (ie selon quels algorithmes).

Les langages de programmation offrent différentes possibilités d’abstraction, et une notation prochede l’algèbre, permettant de décrire de manière concise et facile à saisir les opérations de manipula-tion de données et l’évolution du déroulement du programme en fonction des situations. La possibi-lité d’écriture abstraite libère l’esprit du programmeur d’un travail superflu, notamment de prise encompte des spécificités du matériel informatique, et lui permet ainsi de se concentrer sur des pro-blèmes plus avancés.

1.2. Niveau d’un langage, compilateur, interpréteur

Les langages de programmation peuvent être distingués selon leur niveau, ie leur distance au langagecompris par le processeur, le langage machine. Nous commencerons par les langages de plus basniveau :

. Le langage machine.Suite de 0 et de 1 compréhensible par le processeur. Ce langage est spécifique au processeur etdépend des opérations que ce dernier permet d’effectuer. L’ensemble des instructions disponiblessur le processeur est appelé jeu d’instructions.

. Le langage assembleur.Langage codant le langage machine (donc dépendant du processeur utilisé) en termes pouvant êtrecompris par un programmeur. Le programme qui transforme l’assembleur en langage machine estégalement appelé assembleur.

. Les langages évolués, dit de haut-niveau.L’utilisateur code en utilisant des instructions définies par la syntaxe du programme mais l’exé-cution du programme passe par une phase de traduction automatique : une compilation ou uneinterprétation, selon le langage utilisé.

† Si le langage est compilé , le compilateur produit soit du langage machine (par exemple C), soitdu langage intermédiaire qui est ensuite traduit dans du langage machine par un programmedédié (par exemple Java et Java Virtual Machine).

LLG \ PCSI 2 INFO 2 \ 2


† Soit le langage est interprété (par exemple Python) et l’interpréteur lit le programme et le traduiten direct en langage assembleur pour que les instructions soient exécutées par la machine. Leslangages interprétés sont plus lents que les langages compilés.

1.3. Les différents paradigmes de programmation

Les premiers langages de programmation

Les premiers langages de programmation comme Fortran (créé en 1955), offraient une syntaxe pluscompréhensible que l’assembleur et permettaient l’utilisation d’expressions arithmétiques, ce quiconstituait un réel progrès. Le modèle de programmation d’une séquence d’instructions numérotées,avec éventuellement indication explicite du numéro de la prochaine instruction – la fameuse ins-truction de branchement GOTO, a été rapidement abandonné : il est apparu dans les années 60 quel’utilisation des GOTO est une source de complications et que, sans perte de généralité, il est possiblede limiter l’usage du GOTO à un tout petit nombre de schémas bien définis : l’alternative, la boucletant-que et, dans un registre un peu différent, l’appel de procédure ou de fonction. Cela constituaitune avancée majeure : alors que la programmation avec GOTO condamnait à raisonner d’emblée surla totalité du programme, l’utilisation de schémas élémentaires s’emboîtant les uns dans les autresfournissait un moyen de découper et structurer la conception, la mise au point et la maintenanced’un programme.

Quatre paradigmes de programmation

Chaque langage de programmation reflète un paradigme, un ensemble de notions qui orientent letravail de réflexion du programmeur et sa technique de programmation.

. La programmation impérative.Le paradigme impératif (dit aussi procédural) est basé sur l’idée d’une exécution étape par étape.Un ensemble de structures permet de contrôler l’ordre dans lequel sont exécutées les commandesqui décrivent les étapes. Les langages de programmation C, Pascal, Fortran et COBOL sont en para-digme impératif.

. La programmation fonctionnelle.Le paradigme fonctionnel est basé sur l’idée d’évaluer une formule, et d’utiliser le résultat pourautre chose, selon le modèle du lambda-calcul. Tous les traitements sont faits en évaluant des ex-pressions et en faisant appel à des fonctions, et l’exécution étape par étape n’est pas possible dansle paradigme fonctionnel. Le résultat d’un calcul sert de matière première pour le calcul suivant,et ainsi de suite, jusqu’à ce que toutes les fonctions aient produit un résultat. ML et Lisp sont deslangages de programmation en paradigme fonctionnel.

. La programmation logique.Le paradigme logique est basé sur l’idée de répondre à une question par des recherches sur unensemble, en utilisant des axiomes, des demandes et des règles de déduction. L’exécution d’unprogramme est une cascade de recherches de données dans un ensemble, en faisant usage de règlesde déduction. Prolog est un langage de programmation en paradigme logique.

. La programmation orientée objet.L’autre grande approche fournissant une structuration de haut niveau pour les données se trouvedans la programmation par objets. Elle trouve son origine dans les types abstraits, notion quiconsiste à réunir au sein d’une même entité données et fonctions constituant l’interface obligéepour y accéder ou les modifier. Dans les langages à objets, les types abstraits sont étendus par unmécanisme d’héritage et prennent le nom de classes, les objets sont précisément des exemplairesd’éléments d’une classe. L’héritage consiste à définir une sous-classe à partir d’une classe existante



en complétant les données et/ou les fonctions d’accès. Par exemple, dans une application logiciellegraphique, on pourra avoir une classe de figures géométriques comportant des fonctions de trans-lation et de rotation, une sous-classe des figures colorées comportant des opérations supplémen-taires (on peut par exemple les repeindre). Dans une sous-classe, on a la possibilité de redéfinir lesfonctions de la classe d’origine ; par exemple, on ne réalise pas de la même manière la translationdans la sous-classe des cercles que dans la sous-classe des polygones.

1.4. Le langage Python

Python a été créé en 1990 par Guido van Rossum, grandfan des Monty Python. C’est un langage orienté objet, im-pératif et interprété. Sa syntaxe, éloignée de celle des lan-gages de plus bas niveau, permet une initiation aisée auxconcepts de base de la programmation.

Python est très largement utilisé : Youtube, Google 1, la Nasa, Industrial light & Magic, etc. Il est deplus en plus utilisé dans les cours d’informatique.

2. Les environnements de développement

Un environnement de développement est un logiciel permettant de rationaliser la création et le dé-veloppement de programmes.

Il comporte un éditeur de texte permettant d’écrire et de sauvegarder des programmes longs et mo-dulaires, des raccourcis pour les compiler ou les déboguer et un interpréteur.

Les environnements de développemnt suivants sont gratuits et compatibles avec Python : Eclipse,Idle, Spyder, pyzo. Cette liste n’est pas exhaustive. Le lycée Louis-Le-Grand a choisi d’installer l’envi-ronnement de développement pyzo dans les salles de TP.

Pyzo est composé de trois fe-nêtres (qui peuvent se fermer etêtre redimensionnées) :

. en haut, l’interpréteur Python ;

. en bas à gauche, l’éditeur detexte ;

. en bas à droite, l’explorateurde fichiers.

Les programmes sont écrits dansl’interpréteur ou dans l’éditeur ;leur mode d’exécution en dépen-dera.

L’interpréteur s’utilise comme une calculatrice et, en cela, n’est adapté qu’à des vérifications, des pro-grammes ou des calculs courts qui n’ont pas besoin d’être sauvegardés. Les programmes plus longs

1. Rossum a travaillé pour Google jusqu’au milieu des années 2000.



ou destinés à être sauvegardés sont écrits dans l’éditeur et exécutés dans l’interpréteur (cf. le menuExécuter dans la barre outil tout en haut de la fenêtre principale).

L’affichage d’un résultat est automatique pour un programme écrit dans l’interpréteur ; pour un pro-gramme écrit dans l’éditeur, il faudra utiliser l’instruction de sortie print pour obtenir l’affichagedans l’interpréteur.

3. La notion de type en programmation

La notion de type est une réponse à l’un des problèmes soulevés par le stockage des données dans lamémoire d’un ordinateur.

3.1. Nécessité du typage, catégories de typage

Dans un ordinateur, l’information est manipulée sous forme binaire quelque soit sa nature (nombreentier relatif, décimal, chaîne de caractères, etc). Par exemple, selon l’interprétation qu’on en fait,la séquence binaire 00111010 peut désigner le caractère de ponctuation « : » (selon le code ASCII,American Standard Code for Information Interchange) ou l’entier 58 écrit 2 en base 2. Pour lever touteambiguité sur l’interprétation d’une donnée sous forme binaire, il est nécessaire de lui associer untype, ie une interprétation.

Il existe deux grands paradigmes de typage :

. Le typage statique.Le type est associé à l’emplacement de la mémoire contenant la donnée. Dans ce cas, il faudradéclarer le type de la variable contenant la donnée.

. Le typage dynamique.Le type est associé à la donnée. Dans ce cas, pas de déclaration à faire, le typage se fait « à la volée »en quelque sorte.

Les types se décomposent en types primitifs (entiers, flottants et booléens 3) et types composés(chaînes de caractères, listes, etc). Nous exposerons dans un premier temps les types primitifs dePython. Python est dynamiquement typé.

2. On a 58 = 25 +24 +23 +2.3. Dans certains langages, il y aussi un type pour les caractères.



3.2. Entiers de Python

Constantes

Python utilise le type int pour les entiers relatifs. Les constantes entières sont écrites dans les pro-grammes en base 10, avec un signe − pour les éléments deZ\N. Le nombre de chiffres est théorique-ment illimité 4.

Opérateurs sur les entiers

Opérateur Opération

+ Addition

- Soustraction

* Multiplication

/ Quotient usuel

a%b Reste dans la divisioneuclidienne de a par b

a//b Quotient dans la divisioneuclidienne de a par b

a**n a puissance n

Attention à ne pas confondre a//b (quotient dans divi-sion euclidienne) et a/b (quotient dansQ).

Il suffit d’écrire l’opération souhaitée dans une ligne ac-tive de l’interpéteur Python et d’appuyer sur la toucheENTRÉE pour obtenir le résultat :

>>> 45-441>>> 45+3479

>>> 45*4180>>> 45**22025

>>> 45//411>>> 45%41

�La notion d’expression entière.Plus généralement, en combinant des constantes et des opérateurs, on obtient ce qu’on appelleune expression entière. La syntaxe est celle des mathématiques (utilisation de parenthèses, on

ne divise par zéro, etc), nous ne l’expliciterons pas. Par exemple, 34, 47-65*3 et 32-3165 sont desexpressions entières. Pour obtenir la valeur de l’expression, autrement dit pour évaluer l’expression,on l’écrit directement dans l’interpréteur et on appuie sur la touche ENTRÉE.

Signalons que Python applique également des règles de précédence 5, mais il est préférable de paren-théser correctement ses calculs :

>>> 2**2+5//35

>>> 2**(3+5//3)16

>>> 2**2+5//3*26

>>> 2**2+5//(3*2)4

3.3. Flottants de Python

Constantes

Les nombres à virgule flottante, appelés aussi flottants, forment un sous-ensemble de l’ensemble desnombres décimaux. Ils permettent la représentation informatique des nombres réels. Nous les étu-dierons plus en détail dans le cours sur la représentation informatique des nombres. Contrairementau cas des entiers, la précision est ici limitée. Pour écrire un flottant, on utilise le symbole . au lieu dela virgule. On peut aussi utiliser la notation m e n pour m10n (m est la mantisse et n est l’exposant).

4. Python manipule ce qu’on appelle des entiers longs depuis la version 3. En fait, il y a évidemment une limite, la taille de la mémoire de l’ordinateur.5. C’est-à-dire de priorité. Par exemple, 3+5*4 sera compris comme 3+ (5×4) par un interpréteur Python, et non pas comme (3+5)×4 : on dit que

la multiplication est prioritaire sur l’addition.



>>> 0.0004578954330.000457895433

>>> 4.57895433e-40.000457895433

Opérateurs sur les flottants

Les opérateurs +, -, /, * et ** sont valables pour les nombres flottants. Voici quelques exemples depuisun interpéteur Python :

>>> 7.6*4.735.72

>>> 4.3**5.42634.69083146

>>> 7/41.75

>>> 6.6-4.52.09999999999

>>> 6.5+9.516.0

On définit comme au paragraphe précédent la notion d’expression flottante (cf. page 6).

La précision étant limitée, les calculs sur les flottants, contrairement aux calculs sur les entiers, nesont approchés et les propriétés usuelles de + et × (commutativité et associativité par exemple) nesont plus vérifiées en général :

>>> 1-1/3-1/3-1/31.1102230246251565e-16

>>> 1-(1/3+1/3+1/3)0.0

�Choix d’un type de données.Avant de programmer, il faut choisir avec soin un type des données approprié aux traitementsque l’on va effectuer : la précision est infinie pour les entiers ce qui n’est pas le cas pour les

flottants. Par exemple, pour faire des calculs sur des montants en euros, il sera préférable de travailleravec l’unité centime afin de ne manipuler que des entiers.

On remarque que la présence d’un flottant dans une expression numérique impliquera que la valeuraprès évaluation sera un flottant même si le nombre est, au sens mathématique, un entier relatif. C’estune des conséquences du typage dynamique de Python.

>>> 1+23456789902345678991

>>> 1.0+23456789902345678991.0

3.4. Booléens de Python

Constantes

Le type bool (pour booléens) n’admet que deux constantes : False et True. Ce type correspond auxvaleurs de vérité Vrai et Faux de la logique.

Opérateurs logiques

Pour combiner des booléens booléennes, on dispose des trois opérateurs logiques, la disjonction,la conjonction et la négation : or (ou), and (et), not (non). Ils sont définis par les tables de véritésuivantes :



b1 b2 b1 or b2 b1 and b2 not(b1)True True True True FalseTrue False True False FalseFalse True True False TrueFalse False False False True

On étend naturellement la notion d’expression aux booléens (cf. page 6) au moyen de ces opérateurs.Voici une illustration dans un interpréteur Python :

>>> not(False or True)False

>>> (False or True) and (not(True))False

Construction de booléens par opérateurs de comparaison

On appelle expression de type numérique toute suite de caractères du langage définissant une constanted’un des types numériques (int et float pour Python).

Les opérateurs de comparaison permettent de construire des valeurs booléennes à partir d’autresexpressions. On peut appliquer à des couples d’expressions les opérateurs de comparaison suivants :

Opérateur Sens

== = (égalité)

!= 6=>, < >, <>=, <= Ê, É

Voici quelques exemples de comparaison obtenues depuis un interpré-teur Python :

>>> 1<2True

>>> 2>=2True

>>> 15==45-3*10True

>>> 15!=45-3*10False

Ces opérateurs sont paresseux. Par exemple, dans x and y, si la valeur de l’expression x après éva-luation est False, la deuxième expression y n’est pas évaluée.

Tests

2.1. Soient x, y et z des constantes entières. Écrire des expressions booléennes traduisant :

a) x est divisible par 7 ;

b) L’un des nombres x et y est multiple del’autre ;

c) Les nombres x, y et z sont de même signe ;

d) Les nombres x, y et z sont deux à deuxdistincts ;

e) x est le plus petit multiple de 7 supérieur à10100.

3.5. La fonction type et le transtypage sous Python

La fonction type permet d’identifier le type d’une expression.

>>> type(3-4)<type ’int’>

>>> type(False)<type ’bool’>

>>> type(5.6)<type ’float’>

>>> type(3-4.0)<type ’float’>



Les fonctions int et float permettent des changements de type. On peut en particulier transformerun nombre donné par la chaîne de caractères de ses chiffres en base 10 en l’entier correspondant :

>>> float(355565)355565.0

>>> int(355565.0)355565

>>> int("355")355

4. Les variables informatiques

La mémoire d’un ordinateur peut être vue comme un très grand espace découpé en cases. Pour s’yretrouver, les différentes cases de cet espace ont été numérotées, chaque case porte ainsi une adresse.Lorsque l’on connaît l’adresse d’une case, on peut demander d’aller consulter le contenu de la caseen question. On peut également bien entendu modifier le contenu de cette case. Dans un langage telque l’assembleur, cela doit être fait en détail par le programmeur, qui doit donc, en plus du traitementdes données, gérer lui-même la mémoire.

Dans les langages de plus haut niveau, ce mécanisme très lourd à programmer a été remplacé parl’utilisation de variables.

Une variable est un espace mémoire dans lequel il est possible de mettre une valeur, cette opérationétant appelée affectation. L’utilisateur manipule cette variable par l’intémédaire d’un nom qu’il choi-sit :

>>> x=2 >>> 2*x4

>>> id(x)148684964

Dans ce qui précède, la fonction id de Python permet d’accéder à la référence 6 148684964 qui per-met au système de trouver l’adresse-mémoire correspondant à la variable x. On retiendra la syntaxed’une affectation et les noms de variables admissibles :

Symbole d’affectation =

Noms de variableFormés de lettres sans accent, de chiffres, du caractère tiret bas _ etcommencent toujours par une lettre

Remarque 2.1. Typage statique et typage dynamiqueLa manière de définir une variable dépend du typage du langage :

. Dans le cas d’un typage statique (par exemple sous Java), le programmeur doit d’abord déclarerla variable, ie associer un nom valable nomvar à un type existant typevar. Ensuite, il effectue uneaffection, ie il associe le nom valeurvar à une valeur.

. Dans le cas d’un typage dynamique (par exemple sous Python), le programmeur n’a pas besoin dedéclarer la variable et se contente de l’affecter.

6. Les mécanismes d’allocation de mémoire ne sont pas un attendu du programme et varient beaucoup selon les langages. Sous Python, les variablescontiennent en fait les références, pas les valeurs. La référence d’une variable est générée lors de l’interprétation du programme et associée à l’adressede la mémoire où est effectivement stockée la valeur de la variable.



On étend la notion d’expression au cas des variables (cf. page 6). Pour évaluer une expression, il suffitde l’écrire dans un interpréteur et d’appuyer sur la touche Entrée : l’ordinateur substitue les valeursstockées dans la mémoire aux noms de variable correspondants puis évalue l’expression numériqueainsi trouvée. Un petit exemple dans un interpréteur Python :

>>> x=0>>> x=17

>>> 12*x+17217

�Affection Vs. égalité.Une des erreurs les plus courantes chez le pythonneux débutant est de confondre le symboled’affectation = et le comparateur logique ==.

>>> x=0 >>> x0

>>> x==1False

>>> x0

Il est souvent commode, plus efficace et plus lisible de n’utiliser qu’une seule variable dans un pro-gramme. La variable prend des valeurs successives au cours de l’algorithme, seule la valeur finale étantd’intérêt. Pour mettre à jour une variable x au moyen d’une expression exp, on utilisera la syntaxe quisuit.

Code Action

x=exp l’expression exp est évaluée puis le résultat est stocké dans lavariable x

x+=expa le même effet que x=x+exp : l’expression exp est évaluée, puissa valeur est ajoutée à celle de x et finalement le résultat finalest enregistré dans x

x-=exp a le même effet que x=x-exp

Quelques exemples dans un interpréteur Python :

>>> x=3>>> y=x>>> x=1000>>> z=y**2+1

>>> x,y,z(1000,3,10)>>> x*y3000

>>> type(z)<type ’int’>>>> y==(y//x)*x+y%xTrue

>>> x=3>>> x+=2>>> x5

Moralité : les modifications de la variable x sont sans impact 7 sur la variable y.

Continuons avec les affectations multiples. Elles sont très spécifiques au langage Python et ne pour-ront pas être utilisées dans d’autres langages.

Code Action

x1,x2=exp1,exp2 les expressions exp1 et exp2 sont évaluées puis les résultatssont respectivement affectés aux variables x1 et x2

7. Attention, ce ne sera plus le cas pour des variables du type list. Cela vient essentiellement du fait que, en Python, l’affectation se fait par adressageet que les listes, contrairement aux entiers et aux flottants, est un type mutable.



Le procédé se généralise à un nombre fini quelconque de variables. Voici quelques exemples d’affec-tations multiples dans un interpréteur Python :

>>> x=2>>> y=3

>>> x,y=2*x+3*y,4*x >>> x,y(13,8)

Il est souvent intéressant de comprendre comment évolue les variables au cours d’un programme.

Remarque 2.2. État d’un système de variablesOn appelle état des variables à un instant t la donnée de tous les couples (nomvar,valeurvar) de lamémoire occupée par l’exécution du programme. On peut représenter schématiquement un état pardes boîtes étiquetées. Reprenons par exemple le cas des affectations multiples étudié ci-dessus :

2x

3

y

13x

8

y

à l’étatLes variables x et y passent de l’état

Tests

2.2. Soient x et y dans l’état décrit ci-dessous. Calculer à la main les valeurs des expressionssuivantes puis vérifier les résultats dans un interpréteur Python :

−2x

5

y a) x*y-2 ;

b) y**2 ;

c) x<=y ;

d) y<x andy**2>x**2 ;

e) x*y>1 ;

f ) x**(-2).

2.3. Expliquer pourquoi les programmes suivants renvoient des messages d’erreur :

a=4b=22=ab=3

b=2b=a

2.4. Pour chacun des programmes suivants, prédire puis vérifier dans un interpréteur :

a) On tape successivement : x=0 ; y=x ; x=1. Que valent x et y à la fin ?

b) On tape successivement : x=14 ; y=5 ; z=x+y ; x=y ; y=z ; print(x+y+z). Que s’affiche-t-il ?

c) Quelles sont les valeurs de x et y après les instructions suivantes : x=4 ; y=3 ; z=x ; x=y ; y=z ?

d) Quelles sont les valeurs de x et y après les instructions suivantes : x=4 ; y=3 ; x,y=y,x ?

e) Quelles sont les valeurs des différentes variables après les instructions suivantes : a1=1 ; i=1 ;ai=3 ; i=3 ; ai=6 ?

2.5. Soient x et y initialisées respectivement à 2 et 6. Décrire l’évolution du système (x,y) aprèschacune des instructions successives suivantes : x=-2, y=y*x+4, x=y%2 et y=x-y.



2.6. On considère les trois programmes suivants :

x=1y=2x=yy=x

x=1y=2x=x+yy=x-yx=x-y

x=1y=2z=xx=yy=z

a) Que valent les variables x et y à la fin de chacun de ces trois programmes ?

b) Obtenir le même résultat par une double affectation en une seule ligne.

5. Le noyau impératif d’un langage de programmation

En 2014, on recense près de 2000 langages de programmation. On peut dégager, dans la plupart deslangages, qu’ils soient impératifs ou non, un groupe de cinq constructions élémentaires qui consti-tuent ce qu’on appelle le noyau impératif du langage :

• LA DÉCLARATION et L’AFFECTATION : nous les avons déjà étudiées ci-dessus ;

• LA SÉQUENCE : exécution d’une première instruction p1 puis d’une seconde p2 ;

• LE TEST : selon l’état des variables, on exécute une instruction p1 ou une autre instruction p2 ;

• LA BOUCLE : répéter une instruction p un nombre de fois dépendant de l’état des variables.

À ces constructions fondamentales s’ajoutent les instructions d’entrée-sortie qui existent dans presquetous les langages et qui permettent de « dialoguer » avec l’utilisateur.

5.1. Les instructions d’entrée et de sortie sous Python

Elles servent respectivement à :

• demander à l’utilisateur d’entrer une donnée au clavier au cours d’un programme et de l’enregistrerdans une variable pour la traiter.

• afficher la valeur d’une expression à l’écran au cours d’un programme.

Code Action

x=input("message")

affiche à l’écran message, attend que l’utilisateur saisisse dansl’interpréteur une donnée au clavier, dès que la touche entréeest pressée par l’utilisateur après avoir saisit sa donnée, ladonnée est enregistrée dans la variable x sous la formed’une chaîne de caractères

print("message") affiche message

print(exp) affiche la valeur de l’expression exp

Remarque 2.3. De la bonne utilisation de input et printAttention, input enregistre toujours une chaîne de caractères. Pour enregistrer la donnée comme un



entier ou un flottant, il faudra utiliser les fonctions de transtypage de Python (int et float, cf. leparagraphe 3.5 à la page 8). On peut remplacer les guillemets "" par les côtes ” (cf. les exemples quisuivent). On peut également « panacher » du texte et des valeurs d’expressions avec une syntaxe dutype print("message1",exp1,"message2",exp2,...)

Quelques exemples pour l’instruction d’entrée input dans un interpréteur Python 8 :

>>> x=input("Entrer x : ")Entrer x : 4>>> x+x44

>>> y=int(input("Entrer y : "))Entrer y : 4>>> y+y8

Quelques illustrations pour l’instruction de sortie print dans un interpréteur Python :

>>> print("Salut les gars")Salut les gars>>> print(’Ça marche aussi’)Ça marche aussi>>> print(’"Ça" aussi’)"Ça" aussi

>>> print("’Idem’")’Idem’>>> a=3>>> print("a vaut",a)a vaut 3>>> print("a*a vaut",a**2)a*a vaut 9

Pour afficher des variables dans un message, on alterne les « bouts » de messages et les variables :

>>> a,b=2,7>>> print("Il est clair que",b,"est plus grand que",a)Il est clair que 7 est plus grand que 2

5.2. La séquence sous Python

Plusieurs syntaxes sont possibles pour créer une séquence de deux ins-tructions p1 et p2. On peut les juxtaposer en les séparant par un point-virgule, ou les séparer par un passage à la ligne.

p1;p2 p1p2

5.3. Le test sous Python

C’est l’instruction if...then qui permet de réaliser un test. En voici la syntaxe.

Soient b une expression booléenne , p1 et p2 deux instructions. Le sens de l’instructionci-contre est le suivant : si, après évaluation b vaut True, alors p1 est exécutée ; sinon,Python exécute p2.

if b:p1

else:p2

8. L’opérateur + appliqué aux chaînes de caractères a pour effet de les concaténer, ie de les mettre bout à bout. C’est ce qui explique le 44 du premieressai.



if b:p1

L’alternative else dans le programme précédent est optionnelle. Le sens de l’instru-cion ci-contre est le suivant : si, après évaluation, b vaut True, alors l’instruction p1 estexécutée ; sinon, il ne se passe rien.

�Syntaxe d’un test sous Python.On respectera scrupuleusement cette syntaxe qui est en par-tie spatiale ; les deux points « : » marquent la fin de la condi-

tion du test et l’indentation 9de p1 est obligatoire, car elle délimitela portée de l’instruction if.

if b :p1

fin de la condition

indentation

passage à la ligne

Voici un exemple.

Le programme ci-contre demandedeux nombres à l’utilisateur, lessauvegarde dans des variables a etb, puis affiche le double du plusgrand des deux avec un message adhoc.

a=int( input(" Entrer a : "))b=int( input(" Entrer b : "))if a<b:

print ("Le double de max(a,b) est" ,2*b)else:

print ("Le double de max(a,b) est" ,2*a)

On peut généraliser cette syntaxe. On utilise alors le mot-clé elif (qui est la contraction de else if).L’instruction else permet de déterminer les autres cas.

if b1:p1

elif b2:p2

etc.elif bN:

pNelse:

p’

Dans ce cas, le déroulement de la suite d’instructions est la suivante :

. L’expression booléenne b1 est évaluée. Si elle est vraie, l’instruction p1 est exécutée.

. Si b1 est fausse et b2 est vraie, l’instruction p2 est exécutée.

. etc.

. Si les bk pour k ∈ �1,N� sont fausses, l’instruction p’ est exécutée.

. À noter que dès qu’une condition est satisfaite, les instructions associées sont effec-tuées et le programme sort du test. Dans un test, on peut utiliser plusieurs instruc-tions elif. Cependant, il y a au plus une instruction else.

Tests

2.7. Écrire un programme demandant à l’utilisateur un entier relatif x et affichant sa valeur absolue.

2.8.

Le typage dynamique autorise Python à intepréter 0 et 1comme False et True dans des expressions booléennes. Ainsi,0 and 1 est une expression booléenne et vaut 0.

a) Avec cette convention, donner des formules pour calculera and b, a or b et not(a) en fonction des expressions boo-lénnes a et b ?

b) Quelle est la valeur de la variable y après la suite d’instruc-tions ci-contre ? Prédire et vérifier dans un interpréteur.

p,d,r,h,z=1,0,0,1,0f=p and (d or r)g=not(r)m=not(p) and not(z)g=g and (d or h or m)if f or g:

y=1else:

y=0

2.9. Ce qui suit est à faire sur feuille et à vérifier sous pyzo.

a) Écrire un programme calculant le maximum de deux nombres saisis par l’utilisateur au clavier.

9. Elle s’effectue automatiquement dans l’éditeur d’un environnement de développement, par exemple pyzo.9. On notera l’utilisation de la fonction de transtypage int (voir page 8), nécessaire car input n’enregistre qu’une chaîne de caractères.



b) Idem pour trois nombres.

5.4. La boucle sous Python

Il existe deux types de boucles : la boucle conditionnelle, dite boucle while, et la boucle incondition-nelle, dite boucle for.

La boucle while

Si on souhaite répéter une séquence d’instructions un nombre de fois qui n’est pas connu à l’avancecar dépendant de l’état des variables, on utilise une boucle while.

Soient b une expression boolénne et p une instruction. Voici la syntaxe d’une bouclewhile. Comme dans le cas d’un test, notez les deux points et l’indentation.

while b:p

if b:pif b:

pif b:

pif b:

petc.

Son sens est le suivant : si b 10est True, on exécute l’instruction pet on revient au début de la boucle, on évalue à nouveau b ; sinon,on sort de la boucle.

Nous avons ici un premier exemple de programme poten-tiellement infini. La boucle while peut être vue comme uneformalisation de l’instruction infinie ci-contre. Une boucle whilepeut en effet être infinie, c’est ce qui se passe lorsque l’expressionbooléenne b est toujours vraie. Il s’agit bien-sûr d’une erreur deprogrammation car, concrètement, le programme ne s’arrête pas.

Voici un exemple. On trouvera ci-contre un petit programme calculant puis af-fichant le plus petit entier n naturel tel que 1+2+ ·· ·+n Ê 24. On trouve 7. Pourcomprendre comment s’exécute pas à pas ce programme, il est intéressant d’écrireles états successifs des variables k et s après les deux affectations k=... et s=...On conseille aux débutants de faire de même lorsqu’il concevront leurs premiersprogrammes.

s,k=0,0while s <24:

k=k+1s=s+k

print(k)

0k

0s

4k

10s

1k

1s

5k

15s

2k

3s

6k

21s

3k

6s

7k

28s

Tests

2.10. On considère le programme ci-dessous.

a) Pour n = 5, écrire l’évolution de l’état du système de variables (i,f) (ini-tialement et à la fin de chaque itération).

b) Que vaut f de manière générale en fin de boucle ?

i,f=1,0while i<n+1:

f=f+ii=i+1

9. Expression appelée condition comme dans le cas des tests.



2.11. Écrire un programme demandant à l’utilisateur d’entrer un entier naturel n et qui calcule lafactorielle de n en utilisant une boucle while.

La boucle for

Quand une instruction est itérée un nombre de fois connu à l’avance,on utilise une boucle for. Soient n une variable ou une constante à va-leur dans N et p une instruction. L’instruction ci-contre exécute n foisl’instruction p.

for i in range(n):p

for i in range (4):print ("LoL")

print (i)

Explication : cette instruction crée une variable i qu’elle affectesuccessivement aux valeurs 0, 1, . . . , n. Par exemple, le programmeci-contre affiche 4 fois LoL puis renvoie 3 : en fin de boucle, la variabled’indice existe encore et sa dernière valeur vaut 3.

L’utilisateur peut choisir n’importe quel nom valable de variable à la place de i. Comme dans le casdes tests et de la boucle while, l’indentation du bloc d’instructions est obligatoire, car elle délimite laportée de l’instruction for. Toute boucle for peut s’écrire au moyen d’une boucle while 11 (cf. le test2.12. à la page 17).

On peut généraliser cette syntaxe : on peut remplacer range(n) par range(debut,fin,pas) et dansce cas la variable i décrit dans l’ordre croissant l’ensemble des entiers de la forme deb+k*pas com-pris entre deb et fin-1 où k ∈ N. Par exemple, pour range(3,17,2), la variable d’indice prendresuccessivement les valeurs 3, 5, 7, 9, 11, 13, et 15.

�Gestion de l’indice dans une boucle for.Les indices sont à valeurs dans � deb,fin�, c’est une erreur classique chez le pythonneux débu-tant. On prendra garde aux indices de début et de fin ! L’argument fin est par défaut égal à 0 et

l’argument pas est par défaut égal à 1. En fin de boucle, la variable d’indice existe toujours et contientla dernière valeur générée par range.

for i in range(debut ,fin ,pas ):p

L’instruction p est executée pour chacunedes valeurs ind de la séquence générée parrange.

Dans certains cas, l’indice i ne joue aucun rôle dans l’instruction p, il n’est qu’un artifice pour comp-ter les itérations de la boucle : on utilise alors plus simplement 12 range(n). C’était le cas ci-dessusdans le programme affichant 4 fois LoL.

s=0for i in range (0 ,7 ,2):

s=s+iprint (s)

Dans d’autres cas, il est commode d’avoir un indicejouant un rôle dans p. Calculons par la somme desentiers pairs compris entre 0 et 6. Ici, l’indice intervientdans le calcul de la somme. On trouve bien sûr 12.

Pour comprendre le fonctionnement d’une boucle for, il est recommandé aux débutants d’écrirel’évolution de l’état des variables. Par exemple, pour le dernier exemple, on trace l’évolution du couple(i , s) à la fin de chacune des itérations :

11. L’intérêt d’une boucle for par rapport à une boucle while est que le programmeur n’a pas besoin de gérer l’indice de boucle.12. Mais on pourrait aussi utiliser range(0,2*n+1,2) ou range(1,2*n+2,2), etc.



0i

0s

2i

2s

4i

6s

6i

12s

Tests

2.12. Montrer que toute boucle for peut s’écrire au moyen d’une boucle while.

2.13. Écrire un programme affichant la valeur de100∑

k=10(7k +5)2.

On donnera deux versions avec boucle for mais des « range » différents.

2.14. On considère le programme ci-dessous.

a) Décrire ce que fait ce programme.

b) Vérifier en utilisant l’éditeur de pyzo.

n=9for k in range(n):

print(n,"fois",k,"=",n*k)

2.15. Écrire un programme demandant à l’utilisateur d’entrer un entier naturel n et qui affiche lafactorielle de n en utilisant une boucle for.

2.16. Écrire un programme qui demande à l’utilisateur d’entrer un entier naturel M et affiche leplus petit entier n tel que 1+2+·· ·+n Ê M.



5.5. Annexe : réponses aux tests

2.1.

a) x%7==0 ;

b) Attention, n% m provoque une erreur si mest nul. En utilisant la paresse des opérateurslogiques, on peut donc choisir : y==0 or x%y==0 or y % x==0 ;

c) x*y>=0 and y*z>=0 ;

d) x!=y and y!=z and z!=x ;

e) x%7==0 and 10**100<=x<10**100+7.

2.2. On trouve :

a) -12 ;

b) 25 ;

c) True ;

d) False ;

e) False ;

f ) .25.

2.3.

a) L’instruction 2=a est incorrecte comme plusgénéralement exp1=exp2 si exp1 est uneexpression qui n’est pas une variable.

b) L’instruction b=a est incorrecte car a n’estpas une expression (cette variables n’a jamaisété définie).

2.4.

a) (x,y) est dans l’état (1,0).

b) 43.

c) (x,y) est dans l’état (3,4).

d) (x,y) est dans l’état (3,4).

e) (a1,i,ai) est dans l’état (1,3,6).

2.5. (x,y) prend les états successifs (2,6),(-2,6), (-2,-8), (0,-8) et (0,8).

2.6.

a) On trouve respectivement les états (2,2),(2,1), (2,1).

b) x,y=y,x.

2.7.

x=int(input (" Entrez x:"))if x >0:

print(x)else:

print(-x)

2.8.

a) On trouve a*b pour a and b, a+b-a*b poura or b et1-a pour not(a).

b) En utilisant, par exemple le (a), on trouvey = 1.

2.9.

a)

x=float (input (" Entrer x:"))y=float (input (" Entrer y:"))if x>y:

print("Le max vaut",x)else:

print("Le maw vaut",y)

b)

x=float (input (" Entrer x:"))y=float (input (" Entrer y:"))z=float (input (" Entrer z:"))if x<=y:

m=yif y<z:

m=zelse:

m=xif x<z:

m=zprint ("Le max vaut",m)



2.10.

a)

1i

0f

2i

1f

3i

3f

4i

6f

5i

10f

6i

15f

b) La valeur de f au sortir de la boucle whileest

n∑k=0

k

2.11.

n=int( input(" Entrer n : "))i,f=1,1while i<n+1:

f=f*ii=i+1

print(f)

2.12. La boucle

for i in range (d,f,pas ):p

peut s’écrire de manière équivalente :

i=dwhile i<f:

p:i=i+pas

2.13. Par exemple :

s=0for k in range (10 ,101):

s=s+(7*k +5)**2print(s)

et

s=0for m in range (75 ,706 ,7):

s=s+m**2print(s)

2.14. Ce programme affiche la table demultiplication de 9 :

9 fois 0 = 09 fois 1 = 99 fois 2 = 189 fois 3 = 279 fois 4 = 369 fois 5 = 459 fois 6 = 549 fois 7 = 639 fois 8 = 72

2.15.

n=int(input (" Entrer n:"))f=1for i in range (2,n+1):

f=f*iprint (f)

2.16.

M=int(input (" Entrez n:"))s,k=0,0while s<M:

k+=1s+=k

print (k)


Documents

INFO 2 Éléments de programmation · PDF filedédié (par exemple Java et Java Virtual Machine). ... une avancée majeure : alors que la programmation avec GOTO condamnait à raisonner