Algorithmique_et_programmation_part2

166 vues

Publié le

0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
166
Sur SlideShare
0
Issues des intégrations
0
Intégrations
8
Actions
Partages
0
Téléchargements
10
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Algorithmique_et_programmation_part2

  1. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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…]

×