Algorithmique_et_programmation_part2

LES BASES DE LA PROGRAMMATION AVEC PYTHON 3
Python Pur avec l’invite commande
Support de cours est rédigé par Dr. Emeric Tapachès. C’est une compilation de tutoriels disponibles
sur https://www.python.org et https://openclassrooms.com/
Algorithmique et
Programmation
Partie II

A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
1 | P a g e E m e r i c T a p a c h è s
CONTENU
Préambule ............................................................................................................................................... 3
1 Brève présentation de Python......................................................................................................... 3
1.1 À quoi peut servir Python ?..................................................................................................... 3
1.2 Un langage de programmation interprété.............................................................................. 4
1.3 Différentes versions de Python............................................................................................... 4
2 Installation....................................................................................................................................... 4
3 Base de la programmation avec l’invite commande....................................................................... 6
3.1 Les nombres ............................................................................................................................ 7
3.2 Les caractères et les chaines caractères.................................................................................. 9
3.3 Les listes................................................................................................................................. 11
3.4 Les structures conditionnelles............................................................................................... 13
3.4.1 Les conditions et les opérateurs de comparaison......................................................... 13
3.4.2 Conditions combinées ................................................................................................... 13
3.4.3 La structure d’instructions if…elif…else :....................................................................... 13
3.5 Les boucles ............................................................................................................................ 14
3.5.1 La boucle for.................................................................................................................. 14
3.5.2 Les list comprehensions................................................................................................. 16
3.5.3 Les boucles while........................................................................................................... 16
3.6 Les fonctions.......................................................................................................................... 17
4 Programmation modulaire............................................................................................................ 18
5 Gestion entrée/sortie.................................................................................................................... 19
5.1 Ecran...................................................................................................................................... 19
5.1.1 Lecture........................................................................................................................... 19
5.1.2 Écriture .......................................................................................................................... 20
5.2 Fichier.................................................................................................................................... 21
5.2.1 Lecture........................................................................................................................... 22
5.2.2 Écriture .......................................................................................................................... 23
6 Exercices........................................................................................................................................ 23
Exercice 1 :......................................................................................................................................... 23
Exercice 2 :......................................................................................................................................... 23
Exercice 3 :......................................................................................................................................... 24

Exercice 4 :......................................................................................................................................... 24
Exercice 5 :......................................................................................................................................... 24
Exercice 6 :......................................................................................................................................... 24

PREAMBULE
Dans la première partie du cours, l’histoire de l’informatique, l’architecture d’un ordinateur, la
représentation de l’information et l’abstraction du langage machine ont été abordées. Dans cette 2e
partie du cours, nous nous intéressons à un langage permettant de faire abstraction du langage
machine, le langage Python. Ce cours est dédié à la programmation en Python « pur » à partie de
l’invite commande de l’ordinateur. Les notions de base de la programmation seront abordées dans
l’optique du calcul scientifique.
1 BREVE PRESENTATION DE PYTHON
D’après https://openclassrooms.com/courses/apprenez-a-programmer-en-python/qu-est-ce-que-
python.
Python est un langage de programmation, dont la première version est sortie en 1991. Créé
par Guido van Rossum, il a voyagé du Macintosh de son créateur, qui travaillait à cette époque au
Centrum voor Wiskunde en Informatica aux Pays-Bas, jusqu'à se voir associer une organisation à but
non lucratif particulièrement dévouée, la Python Software Foundation, créée en 2001. Ce langage a
été baptisé ainsi en hommage à la troupe de comiques les « Monty Python ».
1.1 À QUOI PEUT SERVIR PYTHON ?
Python est un langage puissant, à la fois facile à apprendre et riche en possibilités. Dès
l'instant où vous l'installez sur votre ordinateur, vous disposez de nombreuses fonctionnalités
intégrées au langage.
Il est, en outre, très facile d'étendre les fonctionnalités existantes. Il existe ce qu'on appelle
des bibliothèques qui aident le développeur à travailler sur des projets particuliers. Plusieurs
bibliothèques peuvent ainsi être installées pour, par exemple, développer des interfaces graphiques
en Python.
Concrètement, voilà ce qu'on peut faire avec Python :
 de petits programmes très simples, appelés scripts, chargés d'une mission très précise sur
votre ordinateur ;
 des programmes complets, comme des jeux, des suites bureautiques, des logiciels
multimédias, des clients de messagerie…
 des projets très complexes, comme des progiciels (ensemble de plusieurs logiciels pouvant
fonctionner ensemble, principalement utilisés dans le monde professionnel).
Voici quelques-unes des fonctionnalités offertes par Python et ses bibliothèques :
 créer des interfaces graphiques ;
 faire circuler des informations au travers d'un réseau ;
 dialoguer d'une façon avancée avec votre système d'exploitation ;

1.2 UN LANGAGE DE PROGRAMMATION INTERPRETE
Python est un langage de programmation interprété, c'est-à-dire que les instructions que vous lui
envoyez sont « transcrites » en langage machine au fur et à mesure de leur lecture. D'autres langages
(comme le C/C++) sont appelés « langages compilés », car, avant de pouvoir les exécuter, un logiciel
spécialisé se charge de transformer le code du programme en langage machine. On appelle cette
étape la « compilation ». À chaque modification du code, il faut rappeler une étape de compilation.
Les avantages d'un langage interprété sont la simplicité (on ne passe pas par une étape de
compilation avant d'exécuter son programme) et la portabilité (un langage tel que Python est censé
fonctionner aussi bien sous Windows que sous Linux ou Mac OS, et on ne devrait avoir à effectuer
aucun changement dans le code pour le passer d'un système à l'autre). Cela ne veut pas dire que les
langages compilés ne sont pas portables, loin de là ! Mais on doit utiliser des compilateurs différents
et, d'un système à l'autre, certaines instructions ne sont pas compatibles, voire se comportent
différemment.
En contrepartie, un langage compilé se révèlera bien plus rapide qu'un langage interprété (la
traduction à la volée de votre programme ralentit l'exécution), bien que cette différence tende à se
faire de moins en moins sentir au fil des améliorations. De plus, il faudra installer Python sur le
système d'exploitation que vous utilisez pour que l'ordinateur puisse comprendre votre code.
1.3 DIFFERENTES VERSIONS DE PYTHON
Lors de la création de la Python Software Foundation, en 2001, et durant les années qui ont
suivi, le langage Python est passé par une suite de versions que l'on a englobées dans l'appellation
Python 2.x (2.3, 2.5, 2.6…). Depuis le 13 février 2009, la version 3.0.1 est disponible.
Quand un langage de programmation est mis à jour, les développeurs se gardent bien de
supprimer ou de trop modifier d'anciennes fonctionnalités. L'intérêt est qu'un programme qui
fonctionne sous une certaine version marchera toujours avec la nouvelle version en date. Cependant,
la Python Software Foundation observant un bon nombre de fonctionnalités obsolètes, mises en
œuvre plusieurs fois… a décidé de nettoyer tout le projet. Un programme qui tourne à la perfection
sous Python 2.x devra donc être mis à jour pour fonctionner de nouveau sous Python 3. C'est
pourquoi je vais vous conseiller ultérieurement de télécharger et d'installer la dernière version en
date de Python. Je m'attarderai en effet sur les fonctionnalités de Python 3 et certaines d'entre elles
ne seront pas accessibles (ou pas sous le même nom) dans les anciennes versions.
2 INSTALLATION
Python est multiplateforme, c’est-à-dire qu’il peut être installé sur différent système
d’exploitation, comme Windows, Mac OS, Linux et bien autre encore (moins connu il est vrai).
Première solution :
D’après https://openclassrooms.com/courses/apprenez-a-programmer-en-python/qu-est-ce-que-
python.
À partir du site officiel : https://www.python.org/ dans l’onglet « Download ».

Sous Windows :
1. https://www.python.org/downloads/windows/
2. Sélectionnez la version de Python que vous souhaitez utiliser. Dans notre cas, choisissez la
dernière version stable.
3. Enregistrez puis exécutez le fichier d'installation et suivez les étapes.
4. Une fois l'installation terminée, vous pouvez vous rendre dans le menu Démarrer > Tous les
programmes. Python devrait apparaitre dans cette liste (figure suivante).
Sous Linux :
Python est préinstallé sur la plupart des distributions Linux. Cependant, il est possible que
vous n'ayez pas la dernière version en date. Pour le vérifier, tapez dans un terminal la commande
python -V. Cette commande vous renvoie la version de Python actuellement installée sur votre
système. Il est très probable que ce soit une version 2.x, comme 2.6 ou 2.7, pour des raisons de
compatibilité. Dans tous les cas, je vous conseille d'installer Python 3.x, la syntaxe est très proche de
Python 2.x, mais diffère quand même…
Cliquez sur https://www.python.org/downloads/source/ et téléchargez la dernière version
de Python (actuellement « Python 3.5.1 gzipped source tarball »). Ouvrez un terminal, puis rendez-
vous dans le dossier où se trouve l'archive :
 Décompressez l'archive en tapant : tar -xzf Python-3.5.1.tar.bz2 (cette commande est bien
entendu à adapter suivant la version et le type de compression).
 Attendez quelques instants que la décompression se termine, puis rendez-vous dans le
dossier qui vient d'être créé dans le répertoire courant (Python-3.5.1 dans mon cas).
 Exécutez le script configure en tapant ./configure dans la console.
 Une fois que la configuration s'est déroulée, il n'y a plus qu'à compiler en tapant make puis
make install en tant que super-utilisateur.
Sous Mac OS X :

Téléchargez la dernière version de Python : https://www.python.org/downloads/mac-osx/.
Ouvrez le fichier .dmg et faites un double-clic sur le paquet d'installation Python.mpkg. Un assistant
d'installation s'ouvre, laissez-vous guider : Python est maintenant installé !
Deuxième solution :
Celle que nous allons utiliser. Plusieurs distributeurs proposent des « package » d’installation
Python. Ces « package » regroupent bien évidemment le noyau Python (comme précédemment), des
bibliothèques spécifiques pour étendre les fonctionnalités de Python et généralement un
Environnement de Développement Intégré (EDI) qui inclut quasi systématiquement un débogueur
(identification des erreurs de syntaxe).
Dans notre cas, nous allons utiliser le package ANACONDA dédié aux calculs scientifiques d’une
part et à la gestion, l’analyse et la visualisation de très grandes quantités de données d’autre part.
Ce package est distribué par CONTINUUM ANALYTICS.
Les procédures d’installation de ce package pour Windons, Max OS et Linux sont décrite pour
sur ce lien : https://www.continuum.io/downloads
3 BASE DE LA PROGRAMMATION AVEC L’INVITE COMMANDE
Dans cette partie II du module Algorithmique et Programmation nous allons nous intéresser
uniquement à l’utilisation de Python 3 « pur » à partir de l’invite de commandes de votre ordinateur.
L’utilisation de Python « pur » signifie que nous n’allons pas utiliser de bibliothèques afin d’élargir les
fonctionnalités de Python. Cet élargissement sera abordé dans la troisième partie de ce module et
dans les deux projets qui suivront, notamment avec les bibliothèques Scipy, initialement intégrées
dans le package ANACONDA.
Pour accéder à l’invite commande de Windows, faites Démarrer > Tous les programmes >
Accessoires > Invite de commandes. Une fenêtre s’ouvre, tapez Python pour accéder aux
fonctionnalités de Python. Cela permet d’indiquer à l’ordinateur que vous allez parler un autre
langage et qu’il doit utiliser les traducteurs appropriés (l’interprète et le compilateur, voir partie I du
cours).
À partir de là, nous pouvons commencer à programmer.

Certains des exemples qui suivent sont extraits de :
https://docs.python.org/3/tutorial/introduction.html et de
https://openclassrooms.com/courses/apprenez-a-programmer-en-python
3.1 LES NOMBRES
Python formate automatiquement les nombres saisis par supposition. Tapez successivement les
instructions suivantes :
>>> 7
>>> 7.
>>> type(7)
>>> type(7.)
Que se passe-t-il ? La fonction type() permet de connaitre le format (ou le type) de n’importe objet.
Ces deux objets ne sont pas traduits de la même façon en mémoires (voir cours partie I).
Pour effectuer ces opérations, on utilise respectivement les symboles +, -, * et/.
>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # la division retourne toujours un nombre à virgule
1.6
Notez que le symbole # permet d’introduire des commentaires dans votre code. Ces commentaires
ne sont pas évalués par l’ordinateur, mais ils permettent d’améliorer la compréhension du code pour
vous et pour les autres personnes amené à lire votre code. Nous reviendrons sur les commentaires
plus tard.
>>> 17 / 3 # la division classique retourne un nombre à virgule
5.666666666666667
>>>
>>> 17 // 3 # l’opérateur // retourne le quotient de la division
5
>>> 17 % 3 # l’opérateur % (modulo) retourne le reste de la division
2
>>> 5 * 3 + 2 # quotient * diviseur + reste
17
L’opérateur pour le calcul des puissances : **
>>> 5 ** 2 # 5 au carré
25
>>> 2 ** 7 # 2 à la puissance 7
128
>>> 2 ** 0.5 # 2 à une puissance décimale
1.4142135623730951
>>> 2 ** -1 # 2 à une puissance négative
0.5
Python permet d’assigner des valeurs à des variables en utilisant le signe =, et de manipuler ces
variables. Tapez :

>>> mon_age = 21
Puis tapez :
>>> mon_age
Que se passe-t-il ? Maintenant, tapez :
>>> Mon_age
Que se passe-t-il ?
Le langage Python est sensible à la casse, ce qui signifie que des lettres majuscules et minuscules ne
constituent pas la même variable (la variable AGE est différente de aGe, elle-même différente de
age).
Attention :
 Le nom de la variable ne peut être composé que de lettres, majuscules ou minuscules, de
chiffres et du symbole souligné « _ » (appelé underscore en anglais).
 Le nom de la variable ne peut pas commencer par un chiffre.
Effectuez des calculs à partir des variables :
>>> width = 20
>>> height = 5 * 9
>>> width * height
Petite astuce, la dernière expression affichée à l’écran est automatique et systématiquement
assignée à la variable _.
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
Notez que la fonction round() permet de fixer le nombre de chiffres significatifs d’un nombre à
virgule.
Vous serez amenés par la suite, et assez régulièrement, à incrémenter des variables.
L'incrémentation désigne l'augmentation de la valeur d'une variable d'un certain nombre. Jusqu'ici,
nous procédions comme ci-dessous pour augmenter une variable de 1 :
variable = variable + 1
Cette syntaxe est claire et intuitive, mais assez longue, et les programmeurs, tout le monde le sait,
sont des fainéants nés. Ils ont donc trouvé plus court.
variable += 1
L'opérateur += revient à ajouter à la variable la valeur qui suit l'opérateur. Les opérateurs -=, *= et/=
existent également, bien qu'ils soient moins utilisés.
Il possible d’écrire une instruction sur plusieurs lignes en utilisant les (…).

>>> 1 + 4 - 3 * 19 + 33 - 45 * 2 + (8 - 3)
... -6 + 23.5
-86.5
3.2 LES CARACTERES ET LES CHAINES CARACTERES
Python permet de manipuler les chaines de caractères. Ces chaines sont transmises entre
simple quote '...'ou double quote "..." sans distinction.
>>> 'spam eggs' # chaine passée en simple quote
'spam eggs'
>>>
>>> 'doesn't' # le symbole permet de ne pas évaluer la quote en
tant qu’indicateur de fin de caractère, mais en tant que caractère
"doesn't"
>>> "doesn't" # ... chaine passée en double quote
"doesn't"
>>>
>>> '"Yes," he said.'
'"Yes," he said.'
>>>
>>> ""Yes," he said."
'"Yes," he said.'
>>>
>>> '"Isn't," she said.'
'"Isn't," she said.'
La fonction print() permet l’affichage sur une sortie à l’écran en prenant en compte les caractères
spéciaux de déplacement.
>>> '"Isn't," she said.'
'"Isn't," she said.'
>>>
>>> print('"Isn't," she said.')
"Isn't," she said.
Avec cette fonction les quotes de délimitation de chaine de caractères ne s’affichent pas à l’écran.
>>> s = 'First line.nSecond line.' # n signifie nouvelle ligne
>>> s
'First line.nSecond line.'
>>> # sans print(), n est inclu dans la sortie affichée
>>> print(s)
First line.
Second line.
>>> # avec print(), n produit une nouvelle ligne
Les caractères spéciaux de déplacement sont appelés séquences d’échappement POSIX. Ils
permettent de :
Séquence POSIX Description
b Caractère de contrôle retour arrière (correction).
t Caractère de contrôle de tabulation horizontale.
n Caractère de contrôle de saut de ligne.
v Caractère de contrôle de tabulation verticale.

f Caractère de contrôle de saut de page.
r Caractère de contrôle de retour charriot.
Cependant, ces caractères peuvent poser problème :
>>> print('C:somename') # ici n est considéré comme une nouvelle
C:some # ligne
ame
>>> print(r'C:somename') # r devant la première quote permet
C:somename # de ne pas évaluer les séquences POSIX
Les chaines de caractères peuvent être écrites sur plusieurs lignes en les incluant entre triples quotes
"""...""" ou '''...'''.
>>> print("""
Usage : thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
""")
Usage : thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
Il est possible de concaténer des chaines de caractères :
>>> 'Py' 'thon'
'Python'
>>>
>>> prefix = 'Py'
>>> prefix + 'thon'
'Python'
Les chaines de caractères sont des caractères stockés consécutivement en mémoire et la mémoire
peut être vue comme un tableau. Ainsi, il est possible accéder à chacun des caractères d’une chaine à
l’aide d’un indice qui indique sa position :
>>> word = 'Python'
>>> word[0] # caractére à la position 0
'P'
>>> word[5] # caractére à la position 5
'n'
Notez que 0 correspond à la première position du mot. Des indices négatifs peuvent être utilisés :
>>> word[-1] # dernier caractère
'n'
>>> word[-2] # avant-dernier caractère
>>> word[-6]
'P'
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1

L’on peut aussi accéder à des séquences de chaine de caractères :
>>> word[0:2] # caractères entre la position 0 (inclus) et 2 (exclus)
'Py'
>>> word[2:5] # caractères entre la position 2 (inclus) et 5 (exclus)
'tho'
>>> word[:2] # caractères entre le début et position 2 (exclus)
'Py'
>>> word[4:] # caractères entre la position 4 (inclus) et la fin
'on'
La fonction len() permet de déterminer la taille de la chaine de caractère. Cette fonction est très
utile.
>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34
Quel est le type (ou format) de la variable ‘s’ ?
3.3 LES LISTES
Les listes permettent de regrouper plusieurs objets dans un même objet, la liste. Ces objets peuvent
de types (ou formats) différents, mais généralement les objets sont de même type. Voici la syntaxe :
nom_variable = [ Obj1 , Obj2, … ].
>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]
Quel est le type de « squares » ?
De la même façon que les listes de caractères, il est possible d’accéder à des éléments ou à des
séquences de la liste de la façon suivante :
>>> squares[0] # élément à la position 0
1
>>> squares[-1]
25
>>> squares[-3:] # sequence de la troisième position en partant de la
fin jusqu’à la fin
[9, 16, 25]
>>> squares[:] # tous les éléments de la liste
[1, 4, 9, 16, 25]
Il est possible de changer le contenu d’une liste :
>>> cubes = [1, 8, 27, 65, 125] # le cube de 4 est 64 et non 65
>>> 4 ** 3
64
>>> cubes[3] = 64 # on replace la valeur fausse
>>> cubes
[1, 8, 27, 64, 125]

Les listes supportent la concaténation :
>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25]
>>> squares = squares + [36, 49, 64, 81, 100] # l’ancien contenu est
>>> squares # écrasé par le nouveau
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Il est également possible de modifier des séquences dans une liste, de modifier leur taille en ajoutant
ou en supprimant des éléments :
>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>>
>>> letters[2:5] = ['C', 'D', 'E'] # remplace des éléments
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>>
>>> letters[2:5] = [] # supprime des éléments
>>> letters
['a', 'b', 'f', 'g']
>>>
>>> letters[:] = [] # vide la liste de son contenu
>>> letters
[]
>>> letters = ['a', 'b', 'c', 'd']
Quelle est la taille de la liste « letters » ? Quel est le type de « letters » ?
Il est possible de construire des listes imbriquées, par exemple :
>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1] # accès aux éléments des listes imbriquées
'b'
Il existe plusieurs fonctions, appelées méthode, qui sont associées aux listes, voici quelques une
d’entre elles :
>>> list.append(x) # ajout d’éléments (x) à la fin de la liste
>>>
>>> list.insert(i, x) # insertion d’éléments (x)à une position (i)
>>>
>>> list.remove(x) # suppression du premier élèment de la liste
>>> # correspondant (x)
>>>
>>> list.clear() # vide la liste de son contenu
>>>
>>> list.index(x) # retourne la position du premier élément de la
>>>v # liste correspondant à (x)
>>>

>>> list.count(x) # retourne le nombre de fois où (x) apparait dans
>>> # la liste
>>>
>>> list.sort() # tri les éléments d’une liste
>>>
>>> list.reverse() # Inverse la position des éléments de la
>>> # liste
3.4 LES STRUCTURES CONDITIONNELLES
3.4.1 LES CONDITIONS ET LES OPERATEURS DE COMPARAISON
Une condition est soit vraie, soit fausse. Les conditions ont donc un comportement binaire. Elles
résultent bien souvent d’un test de comparaison. Ces tests emploient les opérateurs suivants :
Opérateur Signification littérale
< Strictement inférieur à
> Strictement supérieur à
<= Inférieur ou égal à
>= Supérieur ou égal à
== Égal à
!= Différent de
Par exemple :
>>> a = 0
>>> a == 5
False
>>> a > -8
True
>>> a != 33.19
True
>>>
Les tests de comparaison retournent soit « False » soit « True ». Quel est le type de l’expression
(appelé prédicat) « a == 5 » ?
3.4.2 CONDITIONS COMBINEES
En première partie du cours nous avons vu que tout raisonnement logique peuvent traduit avec
l’algèbre de Boole et notamment en utilisant les opérateurs logiques ET, OU et NON. Python propose
également ces opérateurs : and, or et not. Par exemple :
>>> a = 8
>>> a >= 5 and a < 10
True
>>> a >= 5 and a < 7
False
>>> a >= 5 or a < 7
True
>>> not( a >= 5 and a < 10 )
False
3.4.3 LA STRUCTURE D’INSTRUCTIONS IF…ELIF…ELSE :
Tout l’intérêt de l’algorithmique et de la programmation est de pouvoir exécuter des instructions
sous certaines conditions. La structure d’instruction ( if…elif…else : ) permet cela.

Exemple avec if… :
>>> a = 5
>>> if a > 0: # Si a est supérieur à 0
... print("a est supérieur à 0.")
...
a est supérieur à 0.
>>> a = 5
>>> if a > 0: # Si a est positif
... print("a est positif.")
... if a < 0 : # a est négatif
... print("a est négatif.")
...
a est positif.
Testez de code avec a égale à 0.
Exemple avec if…else :
>>> a = 0
>>> if a > 0:
... print("a est supérieur à 0.")
... else :
... print("a est inférieur ou égal à 0.")
Exemple avec if…elif…else :
>>> x = int(input("Entrez un nombre entier: "))
Entrez un nombre entier : 42
>>> if x < 0:
... x = 0
... print('Les nombres négatifs sont mis à zéro’)
... elif x == 0 :
... print('Zéro')
... elif x == 1 :
... print('Single')
... else :
... print('More')
...
More
Que permettent de faire les fonctions int() et input() ?
Exercice : Écrire un programme permettant de valider ou non un mot de passe saisi à dans l’invite
commande.
3.5 LES BOUCLES
Les boucles permettent de répéter une certaine opération autant de fois que nécessaire.
3.5.1 LA BOUCLE FOR
La boucle « for » permet de répéter une instruction en parcourant chaque élément d’une séquence.
L’instruction est exécutée autant de fois qu’il y a d’élément dans la séquence. À chaque répétition la

« variable d’itération » prend, la valeur de l’élément considère. La syntaxe est la suivante : for
variable_itération in séquence :
>>> chaine = "Bonjour les ZER0S" # ceci est une séquence
>>> for lettre in chaine: # lettre est la variable d’itération
... print(lettre) # ceci est l’instruction à exécuter
...
Autre exemple :
... words = ['cat', 'window', 'defenestrate']
>>> for w in words:
... print(w, len(w))
...
Autre exemple :
>>> for i in range(5):
... print(i)
...
0
1
2
3
4
Très pratique, la fonction range() permet de générer une progression arithmétique.
>>> # a, b et c sont des entiers positifs
>>> range(a) # génère une suite d’entiers de 0 à a-1 avec un pas de 1
>>> range(a,b) # génère une suite d’entiers de a à b-1 avec un pas de 1
>>> range(a,b,c) # génère une suite d’entiers de a à b avec un pas de c
L’utilisation de range() ne génère pas de listes manipulables. En effet :
>>> print(range(10))
range(0, 10)
Pour générer une liste manipulable, il faut procéder de la façon suivante :
>>> list(range(5))
[0, 1, 2, 3, 4]
Un exemple utile :
>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
... print(i, a[i])
...
0 Mary
1 had

2 a
3 little
4 lamb
3.5.2 LES LIST COMPREHENSIONS
Elles permettent de récupérer une nouvelle liste avec tous les éléments de l'ancienne liste filtrés et
sur lesquels on a effectué (ou non) un traitement.
Une list comprehension a la syntaxe suivante :
>>> [expression for element in liste if predicat]
Le prédicat est facultatif.
Exemples :
>>> liste = range(10) # On prend une liste contenant les 10 premiers
>>> # entiers naturels
>>> liste
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
>>> [element + 1 for element in liste] # La même liste en ajoutant 1 à
>>> # chaque élément
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>>
>>> [element ** 2 for element in liste] # On élève les éléments au
>>> # carré
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>>
>>> liste # La liste n'est pas modifiée
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
>>> liste = [element for element in liste if element % 2 == 0]
>>> # On prend tous les éléments pairs de notre liste
>>> liste
[0, 2, 4, 6, 8]
>>>
>>> [element ** 4 for element in liste if element < 7] # On met à la
puissance 4 les éléments inférieurs à 7
[0, 16, 256, 1296]
>>>
>>> squares = [x**2 for x in range(10)]
3.5.3 LES BOUCLES WHILE
Cette boucle permet de répéter un bloc d'instructions tant qu'une condition est vraie (while signifie
« tant que » en anglais).
La syntaxe de while est :
>>>while condition:
# instruction 1
# instruction 2
# ...
# instruction N
Exemple :

>>> nb = 7
>>> i = 0 # variable d’itération
>>>
>>> while i < 10: # Tant que i est strictement inférieure à 10 on
exécute les instructions
... print(i + 1, "*", nb, "=", (i + 1) * nb)
... i += 1 # On incrémente i de 1 à chaque tour de boucle
3.6 LES FONCTIONS
Nous avons déjà utilisé quelques fonctions : print(), len(), input(),…. Les fonctions permettent de
regrouper des instructions dans un bloc qui sera appelé grâce à un nom. Dans la plupart des cas, mais
pas toujours, les fonctions regroupent des instructions pour manipuler des objets, appelés
arguments, et retournent d’autres objets, appelés résultats.
La création d’une fonction adopte la syntaxe suivante :
>>> def nom_de_la_fonction(arg_1, arg_2, arg_3, …,arg_N):
... # Bloc d'instructions
... return résultats
def est le mot-clé qui est l'abréviation de « define » (définir, en anglais) et qui constitue le prélude à
toute construction de fonction. Attention, le bloc d’instruction doit être indenté pour la fonction soit
valable.
Exemple :
>>> def carre(valeur):
... return valeur * valeur
>>>
>>> alfred = carre(5)
Les valeurs des arguments peuvent être affectées par défaut :
>>> def aire_rect(long, larg = 1):
... return long * larg
...
>>>
>>> aire_rect(10,5)
50
>>> aire_rect(10)
10
Comme expliqués précédemment, les arguments et les résultats à retourner ne sont pas obligatoires.
Par exemple :
>>> def table_par_7():
... nb = 7
... i = 0 # variable d’itération
... while i < 10 : # Tant que i est strictement inférieure à 10
faire :
... print(i + 1, "*", nb, "=", (i + 1) * nb)
... i += 1 # On incrémente i de 1 à chaque tour de boucle.
...
Exécutez la fonction table_par_7, puis tapez :
>>> print(i)
>>> print(nb)

Que se passe-t-il ?
Les fonctions permettent d’utiliser des blocs d’instruction autant de fois qu’on le souhaite par simple
appel de leur nom, sans besoin de réécrire les blocs d’instructions.
4 PROGRAMMATION MODULAIRE
Jusque-là, nous avons codé uniquement dans l’invite de commande. Quittez l’interprète Python en
tapant l’instruction exit(), ouvrez-le à nouveau en tapant Python et appeler la fonction carre() avec
par exemple carre(5) :
>>> exit()
C:UsersEmeric> Python
Python 3.5.1 |Anaconda 2.4.1 (64-bit)| (default, Dec 7 2015, 15:00:12)
[MSC v.1
900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> carre(5)
Vous remarquez que la fonction de vous avez définie tout à l’heure n’est plus disponible. Lorsque
vous quittez l’interprète, vous perdez toutes les informations tapées.
De plus, lorsque l’on travaille sur de longs programmes il est préférable de rédiger celui-ci dans un ou
plusieurs fichiers texte, à partir d’un éditeur, et les appeler dans l’interpréteur au moment où vous
en avez besoin. Les fichiers texte qui reçoivent le ou une partie du programme sont appelés script.
Les scripts peuvent contenir des groupements fonctions que vous codez une seule fois et que vous
pouvez utiliser dans n’importe quel de vos projets par importation. Ces scripts que vous pouvez
importer sont appelés modules. Ils doivent être sauvegardés en .py dans le répertoire courant.
Pour déterminer votre répertoire courant, tapez :
>>> import os
>>> os.getcwd()
L’adresse du répertoire courant apparait entre quote. Copier l’adresse (sans les quotes) et la barre de
recherche de Windows. La fenêtre du répertoire courant s’ouvre.
Ouvrez le logiciel bloc-notes, copiez/collez ce programme :
# Fibonacci numbers module
def fib(n) : # write Fibonacci series up to n
a, b = 0, 1
while b < n:
print(b, end=' ')
a, b = b, a+b
print()
def fib2(n) : # return Fibonacci series up to n
result = []
a, b = 0, 1
while b < n :
result.append(b)
a, b = b, a+b
return result

Et enregistrez-le sous : fibo.py. Faites attention à l’extension. Vous venez de créer un module
accessible depuis votre répertoire courant. Ce module regroupe deux fonctions fib et fib2. Pour
utiliser ces fonctions à partir de l’invite de commande, il faut importer le module de la façon
suivante :
>>> import fibo
Ensuite, pour utiliser les fonctions contenues dans ce module il faut procéder de la façon suivante :
nom_du_module.nom_de_la_fonction()
>>> fibo.fib(9)
1 1 2 3 5 8
>>> fibo.fib2(9)
[1, 1, 2, 3, 5, 8]
Il est également possible import du module et de l’associé à un alias.
>>> import fibo as fb
>>> fb.fib(9)
1 1 2 3 5 8
Des modules tels que nous venons d’en créer existent déjà lors de l’installation de Python. Par
exemple, il existe un module appelé math qui regroupe les fonctions mathématiques usuelles. En
tapant :
>>> import math
Vous avez accès à ces fonctions :
>>> math.sqrt(16)
4
>>> math.cos(3)
-0.9899924966004454
>>> math.exp(4)
54.598150033144236
>>> math.sqrt(9)
3.0
Pour connaitre toutes les fonctions disponibles dans ce module, tapez :
>>> help("math")
5 GESTION ENTREE/SORTIE
L’ordinateur reçoit et/ou transmet des informations à des utilisateurs ou à d’autres ordinateurs.
Entre ordinateurs, l’information peut-être véhiculée en binaire. Pour des utilisateurs humains,
l’information doit être compréhensible. Il y a deux possibilités pour échanger de l’information avec
l’ordinateur : l’écran ou un fichier.
5.1 ECRAN
5.1.1 LECTURE
Transmettre une information à l’ordinateur, c’est faire lire à l’ordinateur une information à l’écran.
Pour cela, il peut utiliser la fonction input() comme vu précédemment :

>>> age = input("Quel age avez-vous ?")
Quel âge avez-vous ?29
>>> age
'29 '
>>> type(age)
<class 'str'>
Par défaut, l’information que vous tapez à l’écran est stockée systématiquement en tant que
« string », c’est-à-dire une chaine de caractères. Pour forcer le type de l’information saisi à l’écran il
faut utiliser les fonctions telles que : int(), float(), str(), bool(),…
>>> T_ext = int(input("Quel est la temperature extérieur ?"))
Quelle est la température extérieure ? 34
>>> T_ext
34
>>> type(T_ext)
<class 'int'>
>>>
>>> T_ext = float(input("Quel est la temperature extérieur ?"))
Quelle est la température extérieure ? 34
>>> T_ext
34.0
>>> type(T_ext)
<class 'float'>
5.1.2 ÉCRITURE
La fonction print() permet d’afficher des informations à l’écran :
>>> prénoms = "Barack"
>>> nom = "Obama"
>>> age = 54
>>>
>>> print("Je m'appelle " + prénoms + " " + nom + " et j'ai " +
str(age) + " ans.")
Je m'appelle Barack Obama et j'ai 54 ans.
Ou
>>> print("Je m'appelle {} {} et j'ai {} ans.".format(prénoms, nom,
age))
Je m'appelle Barack Obama et j'ai 54 ans.
Il est possible de formater la sortie, par exemple :
>>> print('Cette valeur vaut: {}'.format(3))
Cette valeur vaut : 3
>>>
>>> print('Cette valeur vaut: {:d}'.format(3))
Cette valeur vaut : 3
>>>
>>> print('Cette valeur vaut: {:f}'.format(3))
Cette valeur vaut : 3.000000
>>>
>>> print('Cette valeur vaut: {:.2f}'.format(3))
Cela est utile pour contrôler la précision des nombres à virgule.

Il est également possible d’utiliser cette notation :
>>> print('Cette valeur vaut: %.2f' %3)
>>>
>>> print("Cette valeur vaut : %.2f n et cette valeur vaut : %d "
%(3.57886, 3)
et cette valeur vaut : 3
Voici les types possibles :
Type Lettre
int %d
long %ld
float/double %f/%lf
char %c
string (char*) %s
pointeur (void*) %p
short %hd
entier hexadécimal %x
5.2 FICHIER
Il est possible d’ouvrir, lire et fermer un fichier à partir de l’invite commande. L’on peut également
écrire dans un fichier. Les fichiers permettent de stocker des données et/ou des instructions (p. ex.
des programmes) pour être utilisé plus tard quand on le souhaite. Les fichiers sont enregistrés dans
un espace (sur un emplacement, c’est-à-dire un dossier ou répertoire) de l’ordinateur. Créer, ouvrir
et enregistrer un fichier nécessite de gérer les emplacements.
Comme vu précédemment, pour connaitre « où vous êtes » dans Python (dans quel répertoire
courant vous êtes), il faut taper :
>>> import os
>>> os.getcwd()
'C:UsersEmeric'
L’adresse qui s’affiche correspond au répertoire courant où vous êtes.
Pour travailler dans un autre répertoire, il faut se déplacer. Pour cela, créez dans votre espace
utilisateur de votre ordinateur un dossier « Test_python ». Copiez l’adresse de ce dossier et collez-le
dans instruction suivante :
>>> os.chdir("adresse")
Attention : il est possible que votre adresse contienne des antislashs simples () ou des antislash
double () , remplacer ces symboles par le symbole slash (/).
En exécutant l’instruction précédente, vous vous êtes déplacé dans le dossier (ou répertoire)
correspondant à l’adresse indiquée. Pour le vérifier, tapez :
>>> os.getcwd()

C’est dans ce dossier que nous allons travailler.
Nous allons commencer par ouvrir, lire et fermer un fichier texte se trouvant dans le dossier
« Test_python ». Avec « Bloc-note », créer un fichier contenant le poème « La voix » d’Ondine
Valmore disponible sur le lien suivant : http://www.poetica.fr/poeme-2800/ondine-valmore-la-voix/
Enregistrez-le dans le dossier « Test_python » sous le nom de « La_voix ».
L’ouverture d’un fichier se fait à l’aide de la fonction open(). Cette fonction admet deux arguments :
open( non_fichier , mode ). Vous l’avez compris « non_fichier » correspond au nom du fichier que
vous souhaitez ouvrir. Il est possible de précéder le nom du fichier par une adresse. Cela permet de
travailler à un autre endroit que celui du dossier courant. L’argument « mode » précise le mode
d’ouverture du fichier :
 'r' : ouverture en lecture (Read).
 'w' : ouverture en écriture (Write). Le contenu du fichier est écrasé. Si le fichier n'existe pas,
il est créé.
 'a' : ouverture en écriture en mode ajout (Append). On écrit à la fin du fichier sans écraser
l'ancien contenu du fichier. Si le fichier n'existe pas, il est créé.
 'r+' : ouverture en lecture et en écriture.
5.2.1 LECTURE
Lisons le fichier « La_voix » qui se trouve dans le dossier courant. Pour cela, ouvrons le fichier en
mode lecture :
>>> f = open( "La_voix.txt", "r")
>>> f
<_io.TextIOWrapper name='La_voix.txt' mode='r' encoding='cp1252'>
>>> type(f)
<class '_io.TextIOWrapper'>
>>>
f = open() créer un objet qui est affecté à la variable f. Ainsi, manipuler le contenu du fichier revient à
manipuler la variable f. L’on manipule f à l’aide de fonctions :
>>> contenu = f.read() #read() permet de lire tout le contenue du
ficher
>>> contenu
>>> ligne = f.readline() #readline() permet de lire le fichier ligne
par ligne
>>> ligne

Que se passe-t-il lors de l’affichage de « contenu » et de « ligne » ?
Après ouverture et éventuellement utilisation d’un fichier, il faut systématiquement et
impérativement le fermer. Pour cela il faut utiliser la fonction close() :
>>> f.close()
5.2.2 ÉCRITURE
Il y a deux solutions, l’écriture par écrasement 'w' ou l’écriture par ajout 'a'.
Commençons par l’ajout. Lorsque l’on ouvre un fichier existant avec ce mode, l’on pourra écrire à
partir de la fin du fichier :
>>> f = open( "La_voix.txt", "a")
>>> f.write("Ajout d’une nouvelle ligne !!!")
30
>>> f.close()
Ouvrez le fichier « La_voix » à partir du bloc-note. Que constatez-vous ?
Maintenant, faites la même chose, mais en mode 'w' :
>>> f = open( "La_voix.txt", "w")
>>> f.write("Ajout d’une nouvelle ligne !!!")
30
>>> f.close()
Ouvrez le fichier « La_voix » à partir du bloc-note. Que constatez-vous ?
Pour finir, demander l’ouverture en mode écriture 'w' ou 'a' d’un fichier qui n’existe pas dans votre
dossier courant :
>>> f = open( "New_file.txt", "w")
>>> f.write("Bonjour !!");
10
>>> f.close()
Que se passe-t-il ?
6 EXERCICES
EXERCICE 1 :
Réalisez un programme python qui convertisse une température des degrés Celsius en degrés
Fahrenheit et inversement.
Formules de conversion :
9
32
5
f cT T   où fT en degré Fahrenheit et cT en degré Celsuis.
EXERCICE 2 :

Réalisez un programme pour calculer l’approximation de la fonction exponentielle à l’aide d’une série
entière.
Formule à connaitre : pour N grand,
2 3 4
0
exp(x) 1 ...
! 1! 2! 3! 4!
nn N
n
x x x x x
n


      
EXERCICE 3 :
Réalisez un programme qui retourne le plus grand élément d’une liste de nombres réels.
EXERCICE 4 :
Réalisez un programme qui compte le nombre d’occurrences du caractère « e » dans une chaine de
caractères.
EXERCICE 5 :
Réaliser un programme permettant de vérifier un mot de passe saisi à l’écran.
EXERCICE 6 :
Soient les listes suivantes :
L1 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
L2 = [‘Janvier’, ‘Février’, ‘Mars’, ‘Avril’, ‘Mai’, ‘Juin’, ‘Juillet’, ‘Aout’, ‘Septembre’, ‘Octobre’,
‘Novembre’, ‘Décembre’]
Réalisez un programme permettant de créer une nouvelle liste L3. Celle-ci devra contenir tous les
éléments des deux listes en les alternant, de telle manière que chaque nom de mois soit suivi de
nombre de jours correspondant :
L3 = [‘Janvier’, 31, ‘Février’, 28, ‘Mars’, 31, etc…]

Algorithmique_et_programmation_part2

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a Algorithmique_et_programmation_part2

Semelhante a Algorithmique_et_programmation_part2 (20)

Algorithmique_et_programmation_part2