Méthodologie de la programmation

Sylvia Chalençon Licence Informatique 1re année

1

Déroulement du cours

• Mon mail : chalencon@ai.univ-paris8.fr

• Le support de cours et les sujets de TD/TP sont disponibles sur ma page : www.ai.univ-paris8.fr/~chalencon

• Évaluations

2

Chapitre 1 : Introduction

3

L’informatique ?

• Informatique : traitement automatique de l’information par un programme exécuté sur un ordinateur, un système embarqué, un robot, un automate…

• Exemples d’informations : nombres, textes, images, sons, vidéos.

• Les informations circulent sous forme d’une suite de bits (chiffres en base 2).

4

Ordinateur ?• Unité d’entrée : permet de faire entrer les informations

dans le système.

• Unité de stockage : permet de conserver les informations.

• Unité de traitement (processeur) : traite les informations en suivant scrupuleusement les instructions d’un programme informatique.

• Unité de sortie : permet de faire sortir les résultats des traitements.

5

Programme informatique ?• Séquence d’opérations destinées à être exécutées

par l’ordinateur pour réaliser une tâche.

• Un programme est soit : • un code source écrit par un informaticien dans un

langage de programmation. Il peut être compilé vers une forme binaire, ou directement interprété.

• un code binaire : suite de bits interprétée par le processeur d'un ordinateur exécutant un programme informatique. C'est le langage natif du processeur (langage machine).

6

Intérêt du langage de programmation ?

• L’ordinateur ne comprend que le langage machine : • Opérations élémentaires sur des données

binaires. • Spécifique à chaque processeur. • Difficile et pénible à utiliser.

• Langage de programmation : • Facilite la programmation. • Interface homme-machine.

7

Langage de programmation• Notation conventionnelle destinée à formuler des

algorithmes et produire des programmes informatiques qui les appliquent.

• Composé d'un alphabet, d'un vocabulaire, de règles de grammaire et de significations.

• Permet de décrire les structures des données qui seront manipulées par l'appareil informatique, et d'indiquer comment sont effectuées les manipulations.

8

Vocabulaire• Instruction : ordre donné à l’ordinateur.

• Variable : nom utilisé dans un programme pour faire référence à une donnée manipulée par le programme.

• Constante : nom utilisé pour faire référence à une valeur permanente.

• Type : chaque donnée a une classification qui influe sur la plage de valeurs possibles, les opérations qui peuvent être effectuées, et la représentation de la donnée sous forme de bits.

• Procédures, fonctions, méthodes : fragment de programme transformée en opération générale, paramétrable, susceptible d'être utilisée de façon répétée. Ces fragments sont appelés procédures, fonctions ou méthodes.

• Déclaration : phrase du programme qui sert à renseigner au traducteur (compilateur, interpréteur...) les noms et les caractéristiques des éléments du programme tels que des variables, des procédures, des types…

9

Paradigmes de programmation 1/2

• Impératif : • Basé sur l'idée d'une exécution étape par étape. • Abstraction réalisée à l'aide de procédures auxquelles sont transmises des

données. • Une procédure principale, la première à être exécutée, et qui peut faire appel

à d'autres procédures. • C, Pascal, Fortran ou encore COBOL sont en paradigme impératif.

• Fonctionnel : • Basé sur l'idée d'évaluer une formule, et d'utiliser le résultat pour autre chose. • Tous les traitements sont faits en évaluant des expressions et en faisant appel

à des fonctions. • 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. • Introduit par le langage Lisp à la fin des années 1960.

10

Paradigmes de programmation 2/2

• Logique : • Basé sur l'idée de répondre à une question par des recherches sur un ensemble, en utilisant

des axiomes, des demandes et des règles de déduction. • Cascade de recherches de données dans un ensemble, en faisant usage de règles de

déduction. Les données obtenues, et associées à un autre ensemble de règles peuvent alors être utilisées dans le cadre d'une autre recherche.

• L'exécution du programme se fait par évaluation : le système effectue une recherche de toutes les affirmations qui, par déduction, correspondent à au moins un élément de l’ensemble.

• Introduit par le langage Prolog en 1970.

• Objet :• Destiné à faciliter le découpage d'un grand programme en plusieurs modules isolés les uns

des autres. • Un objet représente un concept, une idée ou toute entité du monde physique. • Les objets ont une structure interne et un comportement. • Introduit les notions d'objet et d’héritage : un objet contient implicitement les variables et les

fonctions de ses ancêtres, et cet héritage aide à réutiliser du code.

11

Chapitre 2 : Linux & Shell

12

Présentation• Linux est un système d’exploitation permettant de

contrôler un PC et ses différents périphériques.

• Multi-utilisateurs = utilisable par plusieurs personnes simultanément

• Multi-tâches = peut exécuter plusieurs programmes en même temps

• Repose sur un noyau (kernel) utilisant 4 concepts principaux : fichiers, droits d’accès, processus et communication interprocessus (IPC).

13

Histoire• 1965 : Multics (laboratoires Bell - AT&T, MIT, General Electric)

• 1969 : Unics (Kenneth Thompson, laboratoires Bell, développé en langage d’assemblage)

• 1971 : réécriture de Unix en langage C (Dennis Ritchie, Brian Kernighan)

• 1973 : Premier article sur Unix au Symposium on Operating System à l’université de Purdue

• fin des années 70: reprise par le monde académique (Université de Californie, Berkeley)

14

Histoire

15

Image issue de wikipedia (https://fr.wikipedia.org/wiki/Unix)

Le système de fichiers 1/3Arborescence que l’on parcourt de la racine (root), notée /, vers les feuilles.

16

Le système de fichier 2/3• /bin : exécutables essentiels au système, employés par tous les utilisateurs.

• /boot : fichiers permettant à Linux de démarrer.

• /etc : fichiers de configuration nécessaires à l'administration du système (fichiers passwd, group, inittab, ld.so.conf, lilo.conf, …).

• /dev : points d'entrée des périphériques.

• /home : répertoires personnels des utilisateurs.

• /mnt : points de montage des partitions temporaires (cd-rom, usb, …).

• /opt : contient des packages d’applications supplémentaires

• /proc : fichiers permettant d’accéder aux informations sur le matériel, la configuration du noyau et sur les processus en cours d’exécution.

17

Le système de fichier 3/3• /root : répertoire personnel de l'administrateur root.

• /sbin : exécutables système essentiels.

• /usr/bin : majorité des fichiers binaires et commandes utilisateur.

• /usr/lib : la plupart des bibliothèques partagées du système.

• /usr/local : données relatives aux programmes installés sur la machine locale par le root.

• /usr/sbin : fichiers binaires non essentiels au système réservés à l'administrateur système.

• /usr/src : sources des diverses applications installées sur le système.

18

Shell 1/2

• Interpréteur de commandes qui permet d’accéder aux fonctionnalités internes du système d’exploitation

• Ne fait pas partie du noyau mais peut être vu comme une enveloppe externe (d’où shell) permettant d’interagir avec.

• Interface en ligne de commande accessible depuis un terminal

19

Shell 2/2Voici les noms de quelques-uns des principaux shells qui existent :

• sh : Bourne Shell. L'ancêtre de tous les shells.

• bash : Bourne Again Shell. Une amélioration du Bourne Shell, disponible par défaut sous Linux et Mac OS X.

• ksh : Korn Shell. Un shell puissant assez présent sur les Unix propriétaires, mais aussi disponible en version libre, compatible avec bash.

• csh : C Shell. Un shell utilisant une syntaxe proche du langage C.

• tcsh : Tenex C Shell. Amélioration du C Shell.

• zsh : Z Shell. Shell assez récent reprenant les meilleures idées de bash, ksh et tcsh.

Il y en a quelques autres, mais vous avez là les principaux.

20

Le terminal et l’invite de commande shell

• Le terminal correspond à une fenêtre présentant un prompt, encore appelé invite de commande. Celle-ci est paramétrable et par défaut en bash se compose comme suit : login@machine$

• suffixe $ pour l’utilisateur normal, suffixe # pour le super-utilisateur encore appelé root ou administrateur

• On saisit les commandes à la suite du prompt

• Pour stopper la commande en cours : Ctrl-C

• Pour mettre en attente la commande en cours : Ctrl-Z

• Pour terminer l’entrée standard (les éventuelles paramètres saisis par l’utilisateur via le clavier) : Ctrl-D

21

Entrée et sortie standards

• stdin : l’entrée standard, par défaut le clavier, identifiée par l’entier 0.

• stdout : la sortie standard, par défaut l’écran, identifiée par l’entier 1

• stderr : la sortie d’erreur standard, par défaut l’écran, identifée par l’entier 2

22

Redirection des flux d’entrée-sortie

• > : redirection de la sortie standard

• < : redirection de l’entrée standard

• >> : redirection de la sortie standard avec concaténation

• >& : redirection des sorties standard et d’erreur

• | : redirection de la sortie standard sur l’entrée standard

23

Quelques commandes• man comme manuel ;-)

• man [n] commande : visualisation à l'écran des informations concernant la commande spécifiée.

• Affichage réalisé par la commande more donc : • la touche ‘entrée’ pour afficher la ligne suivante, • la touche ‘espace’ pour afficher la page

suivante, • la touche ‘q’ pour quitter

24

Quelques commandes

• pwd : affiche le chemin absolu du répertoire courant.

• cd [chemin] : change le répertoire courant pour celui spécifié par le chemin.

• cd - : change le répertoire courant pour le répertoire précédent

• cd : change le répertoire courant pour le home directory.

25

Absolu vs relatif• Alias :

• . désigne le répertoire courant • .. désigne le répertoire parent

• Si pwd nous retourne /home/login/methodo alors cd .. nous amène dans le répertoire /home/login/

• cd methodo/shell nous amène dans le répertoire/home/login/methodo/shell

• cd /home/login/prog_fonctionnelle nous amène dans le répertoire /home/login/prog_fonctionnelle

26

Visualiser le contenu d’un répertoire

La commande ls [-options] liste le contenu d'un répertoire. Voici quelques options :

• -F : positionne à la fin des noms un / pour les répertoires et un * pour les fichiers exécutables

• -a : affiche tous les fichiers, y compris les fichiers cachés (ceux qui commencent par . )

• -l : description complète du contenu d'un répertoire (une ligne par fichier). Le premier caractère de la ligne indique le type du fichier :

• - : standard • d : répertoire

• -d : évite de lister le contenu d'un répertoire : si rep est un repertoire, ls -l rep listera le contenu du répertoire rep, alors que ls -ld rep listera la description du répertoire

27

Permission sur les fichiers• Pour chaque fichier, il y a trois classes d’utilisateurs

• utilisateur (u) : le propriétaire du fichier • groupe (g) : le groupe d’utilisateurs auquel appartient le fichier • autre (a) : tous les autres

• Les permissions accordées à ces trois classes sont : • r : lecture • w : écriture • x : exécution (pour un fichier, peut être exécuté, pour un répertoire, peut être

parcouru)• chmod [options] droits fichier1, fichier2, … : change les droits d’un ou plusieurs

fichiers • chmod a+r toto.txt : ajoute l’accès en lecture du fichier toto.txt à tout le monde • chmod 444 toto.txt : donne les droits en lecture (et uniquement en lecture) à

tous les utilisateurs

28

Manipuler les fichiers• cat [option] [fichier1, fichier 2, etc] : affiche le contenu

d’un ou plusieurs fichiers.

• more [fichier] pour visualiser le contenu d’un fichier page par page.

• find [options] : effectue une recherche à partir des informations données en option

• find rep -name fichier : cherche, dans rep et ses sous-répertoires, un fichier nommé fichier

• find rep -type d : cherche tous les sous-répertoires de rep

29

Manipuler les fichiers• cp [option] [fichier_source] [fichier_destination] : copie

le fichier source dans le fichier destination. • Si le fichier destination n'existe pas, il est créé. • Sinon son contenu est écrasé sans avertissement. • Si la destination est un répertoire, alors la source

peut être une liste de fichiers. • mv [option] [fichier_source] [fichier_destination] :

déplace un fichier source en le renommant si le chemin du fichier destination contient un nom de fichier.

30

Manipuler les fichiers• rm [option] [fichier] : supprime un fichier.

• -i : demande confirmation à l’utilisateur • -f : supprime sans demander confirmation à l’utilisateur • -r : efface récursivement le contenu du répertoire

• wc [option] [fichier] : obtenir des statistiques sur un fichier. Exemples :

• wc -l toto affiche le nombre de lignes du fichier toto • ls | wc -l affiche le nombre de fichiers dans le répertoire

courant • wc -c toto affiche le nombre de caractères du fichier toto

31

Répertoires

• mkdir [répertoire] : crée un répertoire

• rmdir [répertoire] : supprime un répertoire vide

• du [option] chemin : donne la taille en octets d’un fichier ou d’un répertoire

32

Les variables d’environnement

• Variables permettant de paramétrer le fonctionnement du système (langue utilisée, chemins vers les fichiers exécutables, chemin vers les bibliothèques, etc)

• HOME : Chemin d'accès de votre répertoire d’accueil.

• PATH : liste des répertoires a parcourir pour trouver un programme. Par exemple, PATH=.:/usr/bin:/usr/sbin:/bin:/sbin Les différents répertoires sont séparés par :.

• SHELL : chemin d'accès du programme shell (souvent /bin/bash).

• USER : identifiant de l'utilisateur connecté.

33

Les variables d’environnement

• Lire une variable d’environnement : echo $HOME

• Redéfinir une variable d’environnement :export PATH=$PATH:/home/login/monbin Mais attention, la modification de la valeur de PATH ne vaut que dans ce terminal

• Pour définir une variable d’environnement de manière à ce qu’elle affecte l’ensemble de la session il suffit de placer une commande la définissant dans un des fichiers cachés dans le répertoire personnel par exemple $HOME/.bash_profile (bash).

34

Les variables• Pour affecter une valeur à une variable :

nom_variable=valeur

• Pour accéder au contenu de la variable : $nom_variable

• Il existe des variables un peu spéciales : • $* : contient tous les arguments passés à la fonction • $# : contient le nombre d’arguments • $? : contient le code de retour de la dernière opération • $0 : contient le nom du script • $n : contient l'argument n, n étant un nombre • $! : contient le PID de la dernière commande lancée

35

Test• Opération dont le but est d’évaluer la valeur d’une

expression

• 2 façons équivalentes de réaliser un test : • test expression • [ expression ]

• Renvoie un code de retour : un nombre qui correspond à une réponse de type « vrai » ou « faux ». 0 pour vrai, n’importe quel autre pour faux.

36

Instruction if• Syntaxe 1 :

• Syntaxe 2 :

37

if [ condition ] then action1fi

if [ condition ] then action1elseaction2fi

Opérateurs arithmétiques• -eq (equal) : « égal à » (=)

• -ne (not equal) : « différent de » (≠)

• -gt (greater than) : « strictement supérieur à » (>)

• -lt (lesser than) : « strictement inférieur à » (<)

• -ge (greater or equal) : « supérieur ou égal à » (≥)

• -le (lesser or equal) : « inférieur ou égal à » (≤) ;

38

Exemple

L’exécution de ce script donne l’affichage suivant :

39

#!/bin/bash if test 2 -lt 3then echo "C'est normal."fi

if test 2 -gt 3then echo "C'est absurde."fi

petit=2grand=3

if test $petit -ne 3then echo "C'est normal."fi

if test 2 -eq $grandthen echo "C'est absurde."fi

C'est normal.C'est normal.

Opérateurs sur les fichiers• nature du fichier

• -e (exists) : vérifie l'existence d'un fichier • -f (file) : vérifie l'existence d'un fichier, et le fait qu'il s'agisse bien d'un fichier au sens

strict • -d (directory) : vérifie l'existence d'un répertoire • -L (link) : vérifie si le fichier est un lien symbolique ;

• attributs du fichier • -s (size) : vérifie qu'un fichier n'est pas vide ;

• droits sur le fichier • - r (readable) : vérifie si un fichier peut être lu • -w (writable) : vérifie si un fichier peut être écrit ou modifié • -x : vérifie si un fichier peut être exécuté

• comparaison de fichiers • -nt (newer than) : vérifie si un fichier est plus récent qu'un autre • -ot (older than) : vérifie si un fichier est plus ancien qu'un autre

40

Exemple

41

#!/bin/bash if test -e ~/premier then echo "~/premier existe." else echo "~/premier n'existe pas."fi

if test -d ~/td1 then echo "~/td1 est un répertoire." else echo "~/td1 n'est pas un répertoire."fi

if test -f ~/premier then echo "~/premier est un fichier." else echo "~/premier n'est pas un fichier."fi

if test ~/premier -nt ~/copie then "~/premier est plus récent que ~/copie."fi

Expression arithmétique• Le shell peut évaluer des expressions arithmétiques délimitées

par $(( ))

• Affiche

42

#!/bin/bashn=2echo $(( $n * 2 + 3 ))p=$(( $n + 1 ))echo $p

73

Boucle for• Syntaxe 1 :

• Exemple :

43

for variable in liste_valeurs do instruction(s)done

#!/bin/bashfor i in "$@"do echo "$i"done

Boucle for• Syntaxe 2 :

• e1, e2 et e3 sont des expressions arithmétiques.

• Commence par exécuter l'expression e1, puis tant que l'expression e2 est différente de zéro le bloc d'instructions est exécuté et l'expression e3 évaluée.

44

for ((e1;e2;e3)) do instruction(s)done

Exemple

Affiche :

45

#!/bin/bash for ((i=0 ; 10 - $i ; i=$(( i + 1 )) )) do echo $idone

0123456789

Boucle while• Syntaxe :

• Exécute un bloc d'instructions tant qu'une certaine condition est satisfaite.

• Lorsque cette condition devient fausse la boucle se termine.

• Cette boucle permet donc de faire un nombre indéterminé de tours de boucle, voire infini si la condition ne devient jamais fausse.

46

while condition do instruction(s)done

Exemple

Affiche la même chose que le script précédent.

47

#!/bin/bash while [ $j -lt 10 ]do echo $j j=$(( j + 1 ))done

Fonctions • Intérêt :

• éviter les répétitions de code; • diminuer les risques de bogues ; • augmenter la lisibilité du script.

• Définition d’une fonction — Syntaxe :

• Appel de la fonction — Syntaxe :

48

nom_fonction () { instruction1 instruction2 ...}

nom_fonction argument1 argument2 …

Chapitre 3 : Scheme

49

Fonction• Une fonction prend des arguments et retourne un résultat

• Arguments et résultat peuvent être de n’importe quel type :

• Nombre • Booléen • Caractère • Chaîne de caractères • Liste • Fonction

50

Appel à une fonction• Parenthèse ouvrante

• Nom de la fonction

• Espace

• Premier argument

• Espace

• Deuxième argument

• …

• Parenthèse fermante

• Il faut donner à la fonction le bon nombre d’arguments, et du bon type

51

(nom_fonction Arg1 Arg2 ... Argn)

Exemples

-> retourne 8

-> retourne la différence entre 15 et x si x a une valeur numérique, une erreur sinon

-> retourne 18

-> ne sont pas corrects

-> n’est pas correct non plus

52

(* 5) ou (+ 3)

(+ (* 3 4) (+ 5 1))

(- 15 x)

(+ 3 5)

(* 5 "toto")

Évaluation d’une fonction• Lorsqu’on lui fournit un appel de fonction, Scheme :

• Évalue chacun des arguments • Regarde s’il connaît la fonction, sinon affiche

un message d’erreur • Applique la fonction aux résultats de

l’évaluation des arguments • Affiche le résultat

• C’est un processus récursif

53

Les variables• L’affectation revient à attribuer une valeur à un

symbole. On utilise pour cela la forme spéciale define

• Exemples :

-> retourne 9

54

(define a 5)(define b 4)(+ a b)

Les fonctions• Une fonction en Scheme est un objet qui, à partir

de données, retourne un seul et unique résultat.

• Les données sont appelées paramètres ou arguments.

• Le nombre de paramètres est l'arité de la fonction.

• Une fonction à résultat booléen est appelée un prédicat. Par convention, le nom d'un prédicat se terminera par ? (integer?, real?, ...)

55

Exemples

• retourne 8

• retourne 16

56

(define (double x) (* 2 x))(define (carre x) (* x x))

(double 4)

(carre 4)

Les tests

• Deux constantes : #t (vrai) et #f (faux)

• test est une expression booléenne

• si sa valeur est vraie (#t), seule si_vrai est évaluée et retournée

• si sa valeur est fausse (#f), seule si_faux est évaluée et retournée

57

(if test expr_si_vrai expr_si_faux)

Exemple

• retourne 8

• retourne 8 également

58

(define (valeur_absolue x) (if (> x 0) x (- x)))

(valeur_absolue 8)

(valeur_absolue -8)

Conditions• L’expression cond :

• Les conditions sont évaluées séquentiellement.

• Dès qu'une condition est vraie (#t), les expressions associées sont successivement évaluées et la valeur de la dernière expression est retournée.

• Si toutes les conditions sont fausses (#f), les expressions du else sont évaluées et sa valeur (celle de la dernière expression) est retournée

59

(cond (condition1 expr11 expr12 ... expr1N) (condition2 expr21 expr22 ... expr2N) ...... (conditionN exprN1 exprN2 ... exprNN) (else expr1 expr2 ... exprN))

Récursivité• Une fonction est dite récursive si sa définition contient un

appel à elle-même (en réalité c'est l'algorithme qui est récursif)

• Il faut s'assurer de l'arrêt de l’algorithme :

• il faut toujours mettre une condition d'arrêt (sinon le programme tourne à l'infini) grâce à une expression conditionnelle dont au moins l'une des alternatives ne contient pas d'appel récursif

• la condition d’arrêt doit devenir vraie après un nombre fini d'appels récursifs

60

Exemple

61

(define (factorielle n) (if (= 0 n) 1 (* n (factorielle (- n 1)))))

(factorielle 5)(* 5 (factorielle 4))(* 5 (* 4 (factorielle 3)))(* 5 (* 4 (* 3 (factorielle 2))))(* 5 (* 4 (* 3 (* 2 (factorielle 1)))))(* 5 (* 4 (* 3 (* 2 (* 1 (factorielle 0))))))(* 5 (* 4 (* 3 (* 2 (* 1 1)))))(* 5 (* 4 (* 3 (* 2 1))))(* 5 (* 4 (* 3 2))) (* 5 (* 4 6))(* 5 24)120

Processus d’évaluation :

Chapitre 4 : Python

62

Les variables• Stockage en mémoire manipulé grâce à un nom

symbolique

• En Python, tout accès à la mémoire se fait par l’intermédiaire de variables (pas d’adresses, ni pointeurs)

• Un nom de variable doit commencer par une lettre ou par le caractère souligné _ suivi d’un nombre quelconque de lettres, chiffres ou caractères soulignés.

63

Les variables• Création de la variable au moment de sa première utilisation qui est

toujours une initialisation réalisée grâce à l’opérateur d’affectation =

• Cette affectation crée une variable a et lui affecte la valeur entière 5.

• Pour afficher le contenu de a :

• On peut utiliser a dans une expression

64

a = 5

print a

b = 5 + a

Type des variables• Notion très importante en programmation : aux valeurs contenues

en mémoire sont associés des types.

• Permet de savoir ce qu’on peut faire avec les valeurs et comment les manipuler.

• En Python, pas de déclaration de type lors de la création d’une variable.

• Les variables ne sont donc pas associées à un type mais les valeurs qu’elles contiennent le sont !

• C’est au programmeur de connaître le type de la valeur contenue dans une variable pour ne pas faire d’opération incompatible

65

Opérateurs arithmétiques• + : addition

• - : soustraction

• * : multiplication

• / : division

• % : modulo (reste de la division entière)

• += : ajout d’une valeur à une variable

• -= : retrait d’une valeur à une variable

66

b = 5 + a #affecte à b la valeur 5 + a

b = 5 / 2 #affecte 2 à b car ici la division est entière car les deux opérandes le sont.b = 5.0 / 2 #affecte 2.5 à b. Division décimale.

b += 5 #on ajoute 5 à la valeur contenue dans b

Les structures de contrôle

• Si l'expression est vraie alors le bloc d'instructions 1 est exécuté.

• Si l'expression est fausse alors c'est le bloc d'instructions 2 qui est exécuté.

67

if expression: # ne pas oublier les : bloc d’instructions1 # attention à l'indentation else: # else au même niveau que if bloc d'instructions2 # suite du programme

Les structures de contrôle

68

if expression1: bloc d'instructions1 elif expression2: bloc d'instructions2 elif expression3: # autant de elif que nécessaire bloc d'instructions3 else: #optionnel bloc d'instructions4 # suite du programme

Boucle while

• Si l'expression est vraie le bloc d'instructions est exécuté

• L'expression est à nouveau évaluée.

• Le cycle continue jusqu'à ce que l'expression soit fausse : on passe alors à la suite du programme.

69

while expression: bloc d'instructions # suite du programme

Boucle for

• Les éléments de la séquence sont issus d'une chaîne de caractères ou bien d'une liste.

• Exemple avec une chaîne de caractères :

70

for élément in séquence: bloc d'instructions # suite du programme

chaine = 'Salut' for l in chaine: # l est la variable d'itération print(l) print("Fin de la boucle")

Fonctions• On utlise le mot-clé réservé def pour créer une fonction.

• On indique entre parenthèses les arguments avec lesquels la fonction va travailler.

• Le mot-clé return permet le renvoi d’une valeur au programme appelant. L’utilisation est facultative.

•

71

def nom_de_la_fonction (argument1, argument2, …) : instruction1 instruction2 … return valeur # suite du programme

Les listes• Une liste est une collection ordonnée et modifiable d’éléments

éventuellement hétérogènes.

• Les éléments séparés par des virgules, et entourés de crochets.

• Pour indexer une liste, on utilise l’opérateur [ ] dans lequel l’index, un entier signé qui commence à 0 indique la position d’un élément :

72

couleurs = [’trèfle’, ’carreau’, ’coeur’, ’pique’] print(couleurs) # [’trèfle’, ’carreau’, ’coeur’, ’pique’] couleurs[1] = 14 print(couleurs) # [’trèfle’, 14, ’coeur’, ’pique’] list2 = [4, 2.718] print (list2[1]) #2.178