SlideShare une entreprise Scribd logo
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
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
2 | P a g e E m e r i c T a p a c h è s
Exercice 4 :......................................................................................................................................... 24
Exercice 5 :......................................................................................................................................... 24
Exercice 6 :......................................................................................................................................... 24
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
3 | P a g e E m e r i c T a p a c h è s
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 ;
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
4 | P a g e E m e r i c T a p a c h è s
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 ».
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
5 | P a g e E m e r i c T a p a c h è s
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 :
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
6 | P a g e E m e r i c T a p a c h è s
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.
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
7 | P a g e E m e r i c T a p a c h è s
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 :
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
8 | P a g e E m e r i c T a p a c h è s
>>> 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 (…).
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
9 | P a g e E m e r i c T a p a c h è s
>>> 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.
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
10 | P a g e E m e r i c T a p a c h è s
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
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
11 | P a g e E m e r i c T a p a c h è s
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]
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
12 | P a g e E m e r i c T a p a c h è s
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)
>>>
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
13 | P a g e E m e r i c T a p a c h è s
>>> 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.
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
14 | P a g e E m e r i c T a p a c h è s
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
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
15 | P a g e E m e r i c T a p a c h è s
« 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
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
16 | P a g e E m e r i c T a p a c h è s
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 :
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
17 | P a g e E m e r i c T a p a c h è s
>>> 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)
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
18 | P a g e E m e r i c T a p a c h è s
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
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
19 | P a g e E m e r i c T a p a c h è s
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 :
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
20 | P a g e E m e r i c T a p a c h è s
>>> 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))
Cette valeur vaut : 3.00
Cela est utile pour contrôler la précision des nombres à virgule.
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
21 | P a g e E m e r i c T a p a c h è s
Il est également possible d’utiliser cette notation :
>>> print('Cette valeur vaut: %.2f' %3)
Cette valeur vaut : 3.00
>>>
>>> print("Cette valeur vaut : %.2f n et cette valeur vaut : %d "
%(3.57886, 3)
Cette valeur vaut : 3.58
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()
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
22 | P a g e E m e r i c T a p a c h è s
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
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
23 | P a g e E m e r i c T a p a c h è s
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 :
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
24 | P a g e E m e r i c T a p a c h è s
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…]

Contenu connexe

Tendances

Python
PythonPython
TP4 Atelier C++ /GL2 INSAT / Tunisie
TP4 Atelier C++ /GL2 INSAT / TunisieTP4 Atelier C++ /GL2 INSAT / Tunisie
TP4 Atelier C++ /GL2 INSAT / Tunisie
Mariem ZAOUALI
 
Algo vol.2 sujets
Algo vol.2   sujetsAlgo vol.2   sujets
Algo vol.2 sujets
chrisdilane
 
Cours python avancé
Cours python avancéCours python avancé
Cours python avancé
pierrepo
 
Chap3 programmation modulaire en python
Chap3 programmation modulaire en pythonChap3 programmation modulaire en python
Chap3 programmation modulaire en python
Mariem ZAOUALI
 
Patterns and OOP in PHP
Patterns and OOP in PHPPatterns and OOP in PHP
Patterns and OOP in PHP
julien pauli
 
Usage des expressions régulières dans Openrefine
Usage des expressions régulières dans OpenrefineUsage des expressions régulières dans Openrefine
Usage des expressions régulières dans Openrefine
Mathieu Saby
 
Programmer dans Openrefine avec GREL
Programmer dans Openrefine avec GRELProgrammer dans Openrefine avec GREL
Programmer dans Openrefine avec GREL
Mathieu Saby
 
Chap XIV : Calcul parallèle (Fondements & Principe d'utilisation)
Chap XIV : Calcul parallèle (Fondements & Principe d'utilisation)Chap XIV : Calcul parallèle (Fondements & Principe d'utilisation)
Chap XIV : Calcul parallèle (Fondements & Principe d'utilisation)
Mohammed TAMALI
 
Tp1 design patternappliques
Tp1 design patternappliquesTp1 design patternappliques
Tp1 design patternappliques
Mariem ZAOUALI
 
Introduction à l'objet - Deuxième année ISIMA
Introduction à l'objet - Deuxième année ISIMAIntroduction à l'objet - Deuxième année ISIMA
Introduction à l'objet - Deuxième année ISIMA
Loic Yon
 
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
Loic Yon
 
Développer des codes de simulation numérique avec une équipe "non geek" à l'ULg
Développer des codes de simulation numérique avec une équipe "non geek" à l'ULgDévelopper des codes de simulation numérique avec une équipe "non geek" à l'ULg
Développer des codes de simulation numérique avec une équipe "non geek" à l'ULg
Romain Boman
 
StHack 2014 - Ninon Eyrolles Obfuscation 101
StHack 2014 - Ninon Eyrolles Obfuscation 101StHack 2014 - Ninon Eyrolles Obfuscation 101
StHack 2014 - Ninon Eyrolles Obfuscation 101
StHack
 
Go
GoGo
TP2 Atelier C++/ GL2 INSAT / Tunisie
TP2 Atelier C++/ GL2 INSAT / TunisieTP2 Atelier C++/ GL2 INSAT / Tunisie
TP2 Atelier C++/ GL2 INSAT / Tunisie
Mariem ZAOUALI
 
TP2 RMI
TP2 RMITP2 RMI
12 03 19_n7_openfoam_presentation_generale
12 03 19_n7_openfoam_presentation_generale12 03 19_n7_openfoam_presentation_generale
12 03 19_n7_openfoam_presentation_generale
Cyprien Soulaine
 
Correction TP4 Atelier C++ /GL2 INSAT / Tunisie
Correction TP4 Atelier C++ /GL2 INSAT / TunisieCorrection TP4 Atelier C++ /GL2 INSAT / Tunisie
Correction TP4 Atelier C++ /GL2 INSAT / Tunisie
Mariem ZAOUALI
 
C3 - Langage C - ISIMA 1 - Troisieme partie
C3 - Langage C - ISIMA 1 - Troisieme partieC3 - Langage C - ISIMA 1 - Troisieme partie
C3 - Langage C - ISIMA 1 - Troisieme partie
Loic Yon
 

Tendances (20)

Python
PythonPython
Python
 
TP4 Atelier C++ /GL2 INSAT / Tunisie
TP4 Atelier C++ /GL2 INSAT / TunisieTP4 Atelier C++ /GL2 INSAT / Tunisie
TP4 Atelier C++ /GL2 INSAT / Tunisie
 
Algo vol.2 sujets
Algo vol.2   sujetsAlgo vol.2   sujets
Algo vol.2 sujets
 
Cours python avancé
Cours python avancéCours python avancé
Cours python avancé
 
Chap3 programmation modulaire en python
Chap3 programmation modulaire en pythonChap3 programmation modulaire en python
Chap3 programmation modulaire en python
 
Patterns and OOP in PHP
Patterns and OOP in PHPPatterns and OOP in PHP
Patterns and OOP in PHP
 
Usage des expressions régulières dans Openrefine
Usage des expressions régulières dans OpenrefineUsage des expressions régulières dans Openrefine
Usage des expressions régulières dans Openrefine
 
Programmer dans Openrefine avec GREL
Programmer dans Openrefine avec GRELProgrammer dans Openrefine avec GREL
Programmer dans Openrefine avec GREL
 
Chap XIV : Calcul parallèle (Fondements & Principe d'utilisation)
Chap XIV : Calcul parallèle (Fondements & Principe d'utilisation)Chap XIV : Calcul parallèle (Fondements & Principe d'utilisation)
Chap XIV : Calcul parallèle (Fondements & Principe d'utilisation)
 
Tp1 design patternappliques
Tp1 design patternappliquesTp1 design patternappliques
Tp1 design patternappliques
 
Introduction à l'objet - Deuxième année ISIMA
Introduction à l'objet - Deuxième année ISIMAIntroduction à l'objet - Deuxième année ISIMA
Introduction à l'objet - Deuxième année ISIMA
 
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
 
Développer des codes de simulation numérique avec une équipe "non geek" à l'ULg
Développer des codes de simulation numérique avec une équipe "non geek" à l'ULgDévelopper des codes de simulation numérique avec une équipe "non geek" à l'ULg
Développer des codes de simulation numérique avec une équipe "non geek" à l'ULg
 
StHack 2014 - Ninon Eyrolles Obfuscation 101
StHack 2014 - Ninon Eyrolles Obfuscation 101StHack 2014 - Ninon Eyrolles Obfuscation 101
StHack 2014 - Ninon Eyrolles Obfuscation 101
 
Go
GoGo
Go
 
TP2 Atelier C++/ GL2 INSAT / Tunisie
TP2 Atelier C++/ GL2 INSAT / TunisieTP2 Atelier C++/ GL2 INSAT / Tunisie
TP2 Atelier C++/ GL2 INSAT / Tunisie
 
TP2 RMI
TP2 RMITP2 RMI
TP2 RMI
 
12 03 19_n7_openfoam_presentation_generale
12 03 19_n7_openfoam_presentation_generale12 03 19_n7_openfoam_presentation_generale
12 03 19_n7_openfoam_presentation_generale
 
Correction TP4 Atelier C++ /GL2 INSAT / Tunisie
Correction TP4 Atelier C++ /GL2 INSAT / TunisieCorrection TP4 Atelier C++ /GL2 INSAT / Tunisie
Correction TP4 Atelier C++ /GL2 INSAT / Tunisie
 
C3 - Langage C - ISIMA 1 - Troisieme partie
C3 - Langage C - ISIMA 1 - Troisieme partieC3 - Langage C - ISIMA 1 - Troisieme partie
C3 - Langage C - ISIMA 1 - Troisieme partie
 

En vedette

Python et les bases de données non sql
Python et les bases de données non sqlPython et les bases de données non sql
Python et les bases de données non sql
bchesneau
 
Formation python
Formation pythonFormation python
Formation python
j_lipaz
 
Cours python
Cours pythonCours python
Cours python
salmazen
 
Rendez votre code Python plus beau !
Rendez votre code Python plus beau !Rendez votre code Python plus beau !
Rendez votre code Python plus beau !
Ronan Amicel
 
Python packaging
Python packagingPython packaging
Python packaging
Axel Haustant
 
Base NoSql et Python
Base NoSql et PythonBase NoSql et Python
Base NoSql et Python
yboussard
 
Python et son intégration avec Odoo
Python et son intégration avec OdooPython et son intégration avec Odoo
Python et son intégration avec Odoo
Hassan WAHSISS
 
Introduction à Python - Achraf Kacimi El Hassani
Introduction à Python - Achraf Kacimi El HassaniIntroduction à Python - Achraf Kacimi El Hassani
Introduction à Python - Achraf Kacimi El Hassani
Shellmates
 
Présentation python
Présentation pythonPrésentation python
Présentation python
Sarah
 
Aiguille dans botte de foin: scikit-learn et joblib
Aiguille dans botte de foin: scikit-learn et joblibAiguille dans botte de foin: scikit-learn et joblib
Aiguille dans botte de foin: scikit-learn et joblib
Gael Varoquaux
 
Sondage aléatoire simple ou a probabilité égal
Sondage aléatoire simple ou a probabilité égal Sondage aléatoire simple ou a probabilité égal
Sondage aléatoire simple ou a probabilité égal
hammamiahlem1
 
Je configure mes serveurs avec fabric et fabtools
Je configure mes serveurs avec fabric et fabtoolsJe configure mes serveurs avec fabric et fabtools
Je configure mes serveurs avec fabric et fabtools
Ronan Amicel
 
Scikit learn: apprentissage statistique en Python
Scikit learn: apprentissage statistique en PythonScikit learn: apprentissage statistique en Python
Scikit learn: apprentissage statistique en Python
Gael Varoquaux
 
Code Week 2014 - atelier d'initiation à la programmation avec python
Code Week 2014 - atelier d'initiation à la programmation avec pythonCode Week 2014 - atelier d'initiation à la programmation avec python
Code Week 2014 - atelier d'initiation à la programmation avec python
bbourgois
 
Scikit-learn: the state of the union 2016
Scikit-learn: the state of the union 2016Scikit-learn: the state of the union 2016
Scikit-learn: the state of the union 2016
Gael Varoquaux
 
Accessibilite ERP - points importants
Accessibilite ERP - points importantsAccessibilite ERP - points importants
Accessibilite ERP - points importants
Corentin Le Faucheur
 
Biopython
BiopythonBiopython
Biopython
Antoine Taly
 
Programmation objet
Programmation objetProgrammation objet
Programmation objet
Antoine Taly
 

En vedette (20)

Python et les bases de données non sql
Python et les bases de données non sqlPython et les bases de données non sql
Python et les bases de données non sql
 
Formation python
Formation pythonFormation python
Formation python
 
Cours python
Cours pythonCours python
Cours python
 
Rendez votre code Python plus beau !
Rendez votre code Python plus beau !Rendez votre code Python plus beau !
Rendez votre code Python plus beau !
 
Python packaging
Python packagingPython packaging
Python packaging
 
Base NoSql et Python
Base NoSql et PythonBase NoSql et Python
Base NoSql et Python
 
Python et son intégration avec Odoo
Python et son intégration avec OdooPython et son intégration avec Odoo
Python et son intégration avec Odoo
 
Introduction à Python - Achraf Kacimi El Hassani
Introduction à Python - Achraf Kacimi El HassaniIntroduction à Python - Achraf Kacimi El Hassani
Introduction à Python - Achraf Kacimi El Hassani
 
Présentation python
Présentation pythonPrésentation python
Présentation python
 
Aiguille dans botte de foin: scikit-learn et joblib
Aiguille dans botte de foin: scikit-learn et joblibAiguille dans botte de foin: scikit-learn et joblib
Aiguille dans botte de foin: scikit-learn et joblib
 
python
pythonpython
python
 
Sondage aléatoire simple ou a probabilité égal
Sondage aléatoire simple ou a probabilité égal Sondage aléatoire simple ou a probabilité égal
Sondage aléatoire simple ou a probabilité égal
 
Je configure mes serveurs avec fabric et fabtools
Je configure mes serveurs avec fabric et fabtoolsJe configure mes serveurs avec fabric et fabtools
Je configure mes serveurs avec fabric et fabtools
 
Python et NoSQL
Python et NoSQLPython et NoSQL
Python et NoSQL
 
Scikit learn: apprentissage statistique en Python
Scikit learn: apprentissage statistique en PythonScikit learn: apprentissage statistique en Python
Scikit learn: apprentissage statistique en Python
 
Code Week 2014 - atelier d'initiation à la programmation avec python
Code Week 2014 - atelier d'initiation à la programmation avec pythonCode Week 2014 - atelier d'initiation à la programmation avec python
Code Week 2014 - atelier d'initiation à la programmation avec python
 
Scikit-learn: the state of the union 2016
Scikit-learn: the state of the union 2016Scikit-learn: the state of the union 2016
Scikit-learn: the state of the union 2016
 
Accessibilite ERP - points importants
Accessibilite ERP - points importantsAccessibilite ERP - points importants
Accessibilite ERP - points importants
 
Biopython
BiopythonBiopython
Biopython
 
Programmation objet
Programmation objetProgrammation objet
Programmation objet
 

Similaire à Algorithmique_et_programmation_part2

apprendre-a-programmer-avec-python-3.pdf
apprendre-a-programmer-avec-python-3.pdfapprendre-a-programmer-avec-python-3.pdf
apprendre-a-programmer-avec-python-3.pdf
kamouzou878
 
Tp python
Tp pythonTp python
Tp python
Slim Moalla
 
Tp python dauphine
Tp python dauphineTp python dauphine
Tp python dauphine
noussa krid
 
Cours python
Cours pythonCours python
Cours python
mohamednacim
 
découverte du langage python dans tous ses aspects
découverte du langage python dans tous ses aspectsdécouverte du langage python dans tous ses aspects
découverte du langage python dans tous ses aspects
Thierry Gayet
 
Programmation des pic_en_c_part1
Programmation des pic_en_c_part1Programmation des pic_en_c_part1
Programmation des pic_en_c_part1
oussamada
 
Support Formation Samsung - Python - Session 1 - 2022.pptx
Support Formation Samsung - Python - Session 1 - 2022.pptxSupport Formation Samsung - Python - Session 1 - 2022.pptx
Support Formation Samsung - Python - Session 1 - 2022.pptx
bpmana
 
Configuration des services web sous CentOS
Configuration des services web sous CentOSConfiguration des services web sous CentOS
Configuration des services web sous CentOS
Sarah
 
Manuel ns1.3
Manuel ns1.3Manuel ns1.3
Manuel ns1.3
thiedia
 
Machine-learning-FR.pdf
Machine-learning-FR.pdfMachine-learning-FR.pdf
Machine-learning-FR.pdf
MBarakOUROAKONDO
 
« LabVIEW : programmation et applications » ou comment apprendre à utiliser L...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser L...« LabVIEW : programmation et applications » ou comment apprendre à utiliser L...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser L...
Luc Desruelle
 
Rapport de projet shell
Rapport de projet shellRapport de projet shell
Rapport de projet shell
Bilal ZIANE
 
Skan it 6.0 user manual french
Skan it 6.0 user manual frenchSkan it 6.0 user manual french
Skan it 6.0 user manual french
Lenin TaMe
 
Standards ouverts et logiciels libres
Standards ouverts et logiciels libresStandards ouverts et logiciels libres
Standards ouverts et logiciels libres
Genève Lab
 
IoT.Lab.5.SMTR.pdf
IoT.Lab.5.SMTR.pdfIoT.Lab.5.SMTR.pdf
IoT.Lab.5.SMTR.pdf
NizarTOUJENI3
 
Rapport de projet de fin d"études
Rapport de projet de fin d"étudesRapport de projet de fin d"études
Rapport de projet de fin d"études
Mohamed Boubaya
 
Présentation de Django @ Orange Labs (FR)
Présentation de Django @ Orange Labs (FR)Présentation de Django @ Orange Labs (FR)
Présentation de Django @ Orange Labs (FR)
Martin Latrille
 

Similaire à Algorithmique_et_programmation_part2 (20)

apprendre-a-programmer-avec-python-3.pdf
apprendre-a-programmer-avec-python-3.pdfapprendre-a-programmer-avec-python-3.pdf
apprendre-a-programmer-avec-python-3.pdf
 
Tp python
Tp pythonTp python
Tp python
 
Tp python dauphine
Tp python dauphineTp python dauphine
Tp python dauphine
 
Cours python
Cours pythonCours python
Cours python
 
découverte du langage python dans tous ses aspects
découverte du langage python dans tous ses aspectsdécouverte du langage python dans tous ses aspects
découverte du langage python dans tous ses aspects
 
Programmation des pic_en_c_part1
Programmation des pic_en_c_part1Programmation des pic_en_c_part1
Programmation des pic_en_c_part1
 
Support Formation Samsung - Python - Session 1 - 2022.pptx
Support Formation Samsung - Python - Session 1 - 2022.pptxSupport Formation Samsung - Python - Session 1 - 2022.pptx
Support Formation Samsung - Python - Session 1 - 2022.pptx
 
Configuration des services web sous CentOS
Configuration des services web sous CentOSConfiguration des services web sous CentOS
Configuration des services web sous CentOS
 
Manuel ns1.3
Manuel ns1.3Manuel ns1.3
Manuel ns1.3
 
Machine-learning-FR.pdf
Machine-learning-FR.pdfMachine-learning-FR.pdf
Machine-learning-FR.pdf
 
47750479 cours-c
47750479 cours-c47750479 cours-c
47750479 cours-c
 
« LabVIEW : programmation et applications » ou comment apprendre à utiliser L...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser L...« LabVIEW : programmation et applications » ou comment apprendre à utiliser L...
« LabVIEW : programmation et applications » ou comment apprendre à utiliser L...
 
vanderpypendaniel_msc
vanderpypendaniel_mscvanderpypendaniel_msc
vanderpypendaniel_msc
 
Rapport de projet shell
Rapport de projet shellRapport de projet shell
Rapport de projet shell
 
Skan it 6.0 user manual french
Skan it 6.0 user manual frenchSkan it 6.0 user manual french
Skan it 6.0 user manual french
 
Standards ouverts et logiciels libres
Standards ouverts et logiciels libresStandards ouverts et logiciels libres
Standards ouverts et logiciels libres
 
IoT.Lab.5.SMTR.pdf
IoT.Lab.5.SMTR.pdfIoT.Lab.5.SMTR.pdf
IoT.Lab.5.SMTR.pdf
 
B1
B1B1
B1
 
Rapport de projet de fin d"études
Rapport de projet de fin d"étudesRapport de projet de fin d"études
Rapport de projet de fin d"études
 
Présentation de Django @ Orange Labs (FR)
Présentation de Django @ Orange Labs (FR)Présentation de Django @ Orange Labs (FR)
Présentation de Django @ Orange Labs (FR)
 

Algorithmique_et_programmation_part2

  • 1. 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
  • 2. 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
  • 3. 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 2 | P a g e E m e r i c T a p a c h è s Exercice 4 :......................................................................................................................................... 24 Exercice 5 :......................................................................................................................................... 24 Exercice 6 :......................................................................................................................................... 24
  • 4. 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 3 | P a g e E m e r i c T a p a c h è s 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 ;
  • 5. 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 4 | P a g e E m e r i c T a p a c h è s 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 ».
  • 6. 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 5 | P a g e E m e r i c T a p a c h è s 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 :
  • 7. 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 6 | P a g e E m e r i c T a p a c h è s 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.
  • 8. 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 7 | P a g e E m e r i c T a p a c h è s 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 :
  • 9. 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 8 | P a g e E m e r i c T a p a c h è s >>> 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 (…).
  • 10. 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 9 | P a g e E m e r i c T a p a c h è s >>> 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.
  • 11. 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 10 | P a g e E m e r i c T a p a c h è s 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
  • 12. 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 11 | P a g e E m e r i c T a p a c h è s 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]
  • 13. 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 12 | P a g e E m e r i c T a p a c h è s 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) >>>
  • 14. 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 13 | P a g e E m e r i c T a p a c h è s >>> 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.
  • 15. 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 14 | P a g e E m e r i c T a p a c h è s 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
  • 16. 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 15 | P a g e E m e r i c T a p a c h è s « 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
  • 17. 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 16 | P a g e E m e r i c T a p a c h è s 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 :
  • 18. 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 17 | P a g e E m e r i c T a p a c h è s >>> 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)
  • 19. 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 18 | P a g e E m e r i c T a p a c h è s 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
  • 20. 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 19 | P a g e E m e r i c T a p a c h è s 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 :
  • 21. 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 20 | P a g e E m e r i c T a p a c h è s >>> 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)) Cette valeur vaut : 3.00 Cela est utile pour contrôler la précision des nombres à virgule.
  • 22. 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 21 | P a g e E m e r i c T a p a c h è s Il est également possible d’utiliser cette notation : >>> print('Cette valeur vaut: %.2f' %3) Cette valeur vaut : 3.00 >>> >>> print("Cette valeur vaut : %.2f n et cette valeur vaut : %d " %(3.57886, 3) Cette valeur vaut : 3.58 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()
  • 23. 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 22 | P a g e E m e r i c T a p a c h è s 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
  • 24. 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 23 | P a g e E m e r i c T a p a c h è s 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 :
  • 25. 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 24 | P a g e E m e r i c T a p a c h è s 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…]