Download - Algorithmique_et_programmation_part2

LES BASES DE LA PROGRAMMATION AVEC PYTHON 3

Python Pur avec l’invite commande

Support de cours est rédigé par Dr. Emeric Tapachès. C’est une compilation de tutoriels disponibles

sur https://www.python.org et https://openclassrooms.com/

Algorithmique et

Programmation

Partie II

A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I

1 | P a g e E m e r i c T a p a c h è s

CONTENU Préambule ............................................................................................................................................... 3

1 Brève présentation de Python......................................................................................................... 3

1.1 À quoi peut servir Python ? ..................................................................................................... 3

1.2 Un langage de programmation interprété .............................................................................. 4

1.3 Différentes versions de Python ............................................................................................... 4

2 Installation ....................................................................................................................................... 4

3 Base de la programmation avec l’invite commande ....................................................................... 6

3.1 Les nombres ............................................................................................................................ 7

3.2 Les caractères et les chaines caractères.................................................................................. 9

3.3 Les listes................................................................................................................................. 11

3.4 Les structures conditionnelles ............................................................................................... 13

3.4.1 Les conditions et les opérateurs de comparaison ......................................................... 13

3.4.2 Conditions combinées ................................................................................................... 13

3.4.3 La structure d’instructions if…elif…else : ....................................................................... 13

3.5 Les boucles ............................................................................................................................ 14

3.5.1 La boucle for .................................................................................................................. 14

3.5.2 Les list comprehensions ................................................................................................. 16

3.5.3 Les boucles while ........................................................................................................... 16

3.6 Les fonctions .......................................................................................................................... 17

4 Programmation modulaire ............................................................................................................ 18

5 Gestion entrée/sortie .................................................................................................................... 19

5.1 Ecran ...................................................................................................................................... 19

5.1.1 Lecture ........................................................................................................................... 19

5.1.2 Écriture .......................................................................................................................... 20

5.2 Fichier .................................................................................................................................... 21

5.2.1 Lecture ........................................................................................................................... 22

5.2.2 Écriture .......................................................................................................................... 23

6 Exercices ........................................................................................................................................ 23

Exercice 1 : ......................................................................................................................................... 23

Exercice 2 : ......................................................................................................................................... 23

Exercice 3 : ......................................................................................................................................... 24



Exercice 4 : ......................................................................................................................................... 24

Exercice 5 : ......................................................................................................................................... 24

Exercice 6 : ......................................................................................................................................... 24



PREAMBULE Dans la première partie du cours, l’histoire de l’informatique, l’architecture d’un ordinateur, la

représentation de l’information et l’abstraction du langage machine ont été abordées. Dans cette 2e

partie du cours, nous nous intéressons à un langage permettant de faire abstraction du langage

machine, le langage Python. Ce cours est dédié à la programmation en Python « pur » à partie de

l’invite commande de l’ordinateur. Les notions de base de la programmation seront abordées dans

l’optique du calcul scientifique.

1 BREVE PRESENTATION DE PYTHON D’après https://openclassrooms.com/courses/apprenez-a-programmer-en-python/qu-est-ce-que-

python.

Python est un langage de programmation, dont la première version est sortie en 1991. Créé

par Guido van Rossum, il a voyagé du Macintosh de son créateur, qui travaillait à cette époque au

Centrum voor Wiskunde en Informatica aux Pays-Bas, jusqu'à se voir associer une organisation à but

non lucratif particulièrement dévouée, la Python Software Foundation, créée en 2001. Ce langage a

été baptisé ainsi en hommage à la troupe de comiques les « Monty Python ».

1.1 À QUOI PEUT SERVIR PYTHON ?

Python est un langage puissant, à la fois facile à apprendre et riche en possibilités. Dès

l'instant où vous l'installez sur votre ordinateur, vous disposez de nombreuses fonctionnalités

intégrées au langage.

Il est, en outre, très facile d'étendre les fonctionnalités existantes. Il existe ce qu'on appelle

des bibliothèques qui aident le développeur à travailler sur des projets particuliers. Plusieurs

bibliothèques peuvent ainsi être installées pour, par exemple, développer des interfaces graphiques

en Python.

Concrètement, voilà ce qu'on peut faire avec Python :

de petits programmes très simples, appelés scripts, chargés d'une mission très précise sur

votre ordinateur ;

des programmes complets, comme des jeux, des suites bureautiques, des logiciels

multimédias, des clients de messagerie…

des projets très complexes, comme des progiciels (ensemble de plusieurs logiciels pouvant

fonctionner ensemble, principalement utilisés dans le monde professionnel).

Voici quelques-unes des fonctionnalités offertes par Python et ses bibliothèques :

créer des interfaces graphiques ;

faire circuler des informations au travers d'un réseau ;

dialoguer d'une façon avancée avec votre système d'exploitation ;

https://openclassrooms.com/courses/apprenez-a-programmer-en-python/qu-est-ce-que-python




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 ».



https://www.python.org/



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 :

https://www.python.org/downloads/windows/

https://www.python.org/downloads/source/



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.

https://www.python.org/downloads/mac-osx/

https://www.continuum.io/downloads



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 :

https://docs.python.org/3/tutorial/introduction.html



>>> mon_age = 21

Puis tapez :

>>> mon_age

Que se passe-t-il ? Maintenant, tapez :

>>> Mon_age

Que se passe-t-il ?

Le langage Python est sensible à la casse, ce qui signifie que des lettres majuscules et minuscules ne

constituent pas la même variable (la variable AGE est différente de aGe, elle-même différente de

age).

Attention :

Le nom de la variable ne peut être composé que de lettres, majuscules ou minuscules, de

chiffres et du symbole souligné « _ » (appelé underscore en anglais).

Le nom de la variable ne peut pas commencer par un chiffre.

Effectuez des calculs à partir des variables :

>>> width = 20

>>> height = 5 * 9

>>> width * height

Petite astuce, la dernière expression affichée à l’écran est automatique et systématiquement

assignée à la variable _.

>>> tax = 12.5 / 100

>>> price = 100.50

>>> price * tax

12.5625

>>> price + _

113.0625

>>> round(_, 2)

113.06

Notez que la fonction round() permet de fixer le nombre de chiffres significatifs d’un nombre à

virgule.

Vous serez amenés par la suite, et assez régulièrement, à incrémenter des variables.

L'incrémentation désigne l'augmentation de la valeur d'une variable d'un certain nombre. Jusqu'ici,

nous procédions comme ci-dessous pour augmenter une variable de 1 :

variable = variable + 1

Cette syntaxe est claire et intuitive, mais assez longue, et les programmeurs, tout le monde le sait,

sont des fainéants nés. Ils ont donc trouvé plus court.

variable += 1

L'opérateur += revient à ajouter à la variable la valeur qui suit l'opérateur. Les opérateurs -=, *= et/=

existent également, bien qu'ils soient moins utilisés.

Il possible d’écrire une instruction sur plusieurs lignes en utilisant les (…).



>>> 1 + 4 - 3 * 19 + 33 - 45 * 2 + (8 - 3) \

... -6 + 23.5

-86.5

3.2 LES CARACTERES ET LES CHAINES CARACTERES

Python permet de manipuler les chaines de caractères. Ces chaines sont transmises entre

simple quote '...'ou double quote "..." sans distinction.

>>> 'spam eggs' # chaine passée en simple quote

'spam eggs'

>>>

>>> 'doesn\'t' # le symbole \ permet de ne pas évaluer la quote en

tant qu’indicateur de fin de caractère, mais en tant que caractère

"doesn't"

>>> "doesn't" # ... chaine passée en double quote

"doesn't"

>>>

>>> '"Yes," he said.'

'"Yes," he said.'

>>>

>>> "\"Yes,\" he said."

'"Yes," he said.'

>>>

>>> '"Isn\'t," she said.'

'"Isn\'t," she said.'

La fonction print() permet l’affichage sur une sortie à l’écran en prenant en compte les caractères

spéciaux de déplacement.

>>> '"Isn\'t," she said.'

'"Isn\'t," she said.'

>>>

>>> print('"Isn\'t," she said.')

"Isn't," she said.

Avec cette fonction les quotes de délimitation de chaine de caractères ne s’affichent pas à l’écran.

>>> s = 'First line.\nSecond line.' # \n signifie nouvelle ligne

>>> s

'First line.\nSecond line.'

>>> # sans print(), \n est inclu dans la sortie affichée

>>> print(s)

First line.

Second line.

>>> # avec print(), \n produit une nouvelle ligne

Les caractères spéciaux de déplacement sont appelés séquences d’échappement POSIX. Ils

permettent de :

Séquence POSIX Description

\b Caractère de contrôle retour arrière (correction). \t Caractère de contrôle de tabulation horizontale. \n Caractère de contrôle de saut de ligne. \v Caractère de contrôle de tabulation verticale.



\f Caractère de contrôle de saut de page. \r Caractère de contrôle de retour charriot.

Cependant, ces caractères peuvent poser problème :

>>> print('C:\some\name') # ici \n est considéré comme une nouvelle

C:\some # ligne

ame

>>> print(r'C:\some\name') # r devant la première quote permet

C:\some\name # de ne pas évaluer les séquences POSIX

Les chaines de caractères peuvent être écrites sur plusieurs lignes en les incluant entre triples quotes

"""...""" ou '''...'''.

>>> print("""\

Usage : thingy [OPTIONS]

-h Display this usage message

-H hostname Hostname to connect to

""")

Usage : thingy [OPTIONS]

-h Display this usage message

-H hostname Hostname to connect to

Il est possible de concaténer des chaines de caractères :

>>> 'Py' 'thon'

'Python'

>>>

>>> prefix = 'Py'

>>> prefix + 'thon'

'Python'

Les chaines de caractères sont des caractères stockés consécutivement en mémoire et la mémoire

peut être vue comme un tableau. Ainsi, il est possible accéder à chacun des caractères d’une chaine à

l’aide d’un indice qui indique sa position :

>>> word = 'Python'

>>> word[0] # caractére à la position 0

'P'

>>> word[5] # caractére à la position 5

'n'

Notez que 0 correspond à la première position du mot. Des indices négatifs peuvent être utilisés :

>>> word[-1] # dernier caractère

'n'

>>> word[-2] # avant-dernier caractère

>>> word[-6]

'P'

+---+---+---+---+---+---+

| P | y | t | h | o | n |

+---+---+---+---+---+---+

0 1 2 3 4 5 6

-6 -5 -4 -3 -2 -1



L’on peut aussi accéder à des séquences de chaine de caractères :

>>> word[0:2] # caractères entre la position 0 (inclus) et 2 (exclus)

'Py'

>>> word[2:5] # caractères entre la position 2 (inclus) et 5 (exclus)

'tho'

>>> word[:2] # caractères entre le début et position 2 (exclus)

'Py'

>>> word[4:] # caractères entre la position 4 (inclus) et la fin

'on'

La fonction len() permet de déterminer la taille de la chaine de caractère. Cette fonction est très

utile.

>>> s = 'supercalifragilisticexpialidocious'

>>> len(s)

34

Quel est le type (ou format) de la variable ‘s’ ?

3.3 LES LISTES

Les listes permettent de regrouper plusieurs objets dans un même objet, la liste. Ces objets peuvent

de types (ou formats) différents, mais généralement les objets sont de même type. Voici la syntaxe :

nom_variable = [ Obj1 , Obj2, … ].

>>> squares = [1, 4, 9, 16, 25]

>>> squares

[1, 4, 9, 16, 25]

Quel est le type de « squares » ?

De la même façon que les listes de caractères, il est possible d’accéder à des éléments ou à des

séquences de la liste de la façon suivante :

>>> squares[0] # élément à la position 0

1

>>> squares[-1]

25

>>> squares[-3:] # sequence de la troisième position en partant de la

fin jusqu’à la fin

[9, 16, 25]

>>> squares[:] # tous les éléments de la liste

[1, 4, 9, 16, 25]

Il est possible de changer le contenu d’une liste :

>>> cubes = [1, 8, 27, 65, 125] # le cube de 4 est 64 et non 65

>>> 4 ** 3

64

>>> cubes[3] = 64 # on replace la valeur fausse

>>> cubes

[1, 8, 27, 64, 125]



Les listes supportent la concaténation :

>>> squares + [36, 49, 64, 81, 100]

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

>>> squares

[1, 4, 9, 16, 25]

>>> squares = squares + [36, 49, 64, 81, 100] # l’ancien contenu est

>>> squares # écrasé par le nouveau

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Il est également possible de modifier des séquences dans une liste, de modifier leur taille en ajoutant

ou en supprimant des éléments :

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

>>> letters

['a', 'b', 'c', 'd', 'e', 'f', 'g']

>>>

>>> letters[2:5] = ['C', 'D', 'E'] # remplace des éléments

>>> letters

['a', 'b', 'C', 'D', 'E', 'f', 'g']

>>>

>>> letters[2:5] = [] # supprime des éléments

>>> letters

['a', 'b', 'f', 'g']

>>>

>>> letters[:] = [] # vide la liste de son contenu

>>> letters

[]

>>> letters = ['a', 'b', 'c', 'd']

Quelle est la taille de la liste « letters » ? Quel est le type de « letters » ?

Il est possible de construire des listes imbriquées, par exemple :

>>> a = ['a', 'b', 'c']

>>> n = [1, 2, 3]

>>> x = [a, n]

>>> x

[['a', 'b', 'c'], [1, 2, 3]]

>>> x[0]

['a', 'b', 'c']

>>> x[0][1] # accès aux éléments des listes imbriquées

'b'

Il existe plusieurs fonctions, appelées méthode, qui sont associées aux listes, voici quelques une

d’entre elles :

>>> list.append(x) # ajout d’éléments (x) à la fin de la liste

>>>

>>> list.insert(i, x) # insertion d’éléments (x)à une position (i)

>>>

>>> list.remove(x) # suppression du premier élèment de la liste

>>> # correspondant (x)

>>>

>>> list.clear() # vide la liste de son contenu

>>>

>>> list.index(x) # retourne la position du premier élément de la

>>>v # liste correspondant à (x)

>>>



>>> list.count(x) # retourne le nombre de fois où (x) apparait dans

>>> # la liste

>>>

>>> list.sort() # tri les éléments d’une liste

>>>

>>> list.reverse() # Inverse la position des éléments de la

>>> # liste

3.4 LES STRUCTURES CONDITIONNELLES

3.4.1 LES CONDITIONS ET LES OPERATEURS DE COMPARAISON

Une condition est soit vraie, soit fausse. Les conditions ont donc un comportement binaire. Elles

résultent bien souvent d’un test de comparaison. Ces tests emploient les opérateurs suivants :

Opérateur Signification littérale

< Strictement inférieur à > Strictement supérieur à <= Inférieur ou égal à >= Supérieur ou égal à == Égal à != Différent de

Par exemple :

>>> a = 0

>>> a == 5

False

>>> a > -8

True

>>> a != 33.19

True

>>>

Les tests de comparaison retournent soit « False » soit « True ». Quel est le type de l’expression

(appelé prédicat) « a == 5 » ?

3.4.2 CONDITIONS COMBINEES

En première partie du cours nous avons vu que tout raisonnement logique peuvent traduit avec

l’algèbre de Boole et notamment en utilisant les opérateurs logiques ET, OU et NON. Python propose

également ces opérateurs : and, or et not. Par exemple :

>>> a = 8

>>> a >= 5 and a < 10

True

>>> a >= 5 and a < 7

False

>>> a >= 5 or a < 7

True

>>> not( a >= 5 and a < 10 )

False

3.4.3 LA STRUCTURE D’INSTRUCTIONS IF…ELIF…ELSE :

Tout l’intérêt de l’algorithmique et de la programmation est de pouvoir exécuter des instructions

sous certaines conditions. La structure d’instruction ( if…elif…else : ) permet cela.



Exemple avec if… :

>>> a = 5

>>> if a > 0: # Si a est supérieur à 0

... print("a est supérieur à 0.")

...

a est supérieur à 0.

>>> a = 5

>>> if a > 0: # Si a est positif

... print("a est positif.")

... if a < 0 : # a est négatif

... print("a est négatif.")

...

a est positif.

Testez de code avec a égale à 0.

Exemple avec if…else :

>>> a = 0

>>> if a > 0:

... print("a est supérieur à 0.")

... else :

... print("a est inférieur ou égal à 0.")

Exemple avec if…elif…else :

>>> x = int(input("Entrez un nombre entier: "))

Entrez un nombre entier : 42

>>> if x < 0:

... x = 0

... print('Les nombres négatifs sont mis à zéro’)

... elif x == 0 :

... print('Zéro')

... elif x == 1 :

... print('Single')

... else :

... print('More')

...

More

Que permettent de faire les fonctions int() et input() ?

Exercice : Écrire un programme permettant de valider ou non un mot de passe saisi à dans l’invite

commande.

3.5 LES BOUCLES

Les boucles permettent de répéter une certaine opération autant de fois que nécessaire.

3.5.1 LA BOUCLE FOR

La boucle « for » permet de répéter une instruction en parcourant chaque élément d’une séquence.

L’instruction est exécutée autant de fois qu’il y a d’élément dans la séquence. À chaque répétition la



« variable d’itération » prend, la valeur de l’élément considère. La syntaxe est la suivante : for

variable_itération in séquence :

>>> chaine = "Bonjour les ZER0S" # ceci est une séquence

>>> for lettre in chaine: # lettre est la variable d’itération

... print(lettre) # ceci est l’instruction à exécuter

...

Autre exemple :

... words = ['cat', 'window', 'defenestrate']

>>> for w in words:

... print(w, len(w))

...

Autre exemple :

>>> for i in range(5):

... print(i)

...

0

1

2

3

4

Très pratique, la fonction range() permet de générer une progression arithmétique.

>>> # a, b et c sont des entiers positifs

>>> range(a) # génère une suite d’entiers de 0 à a-1 avec un pas de 1

>>> range(a,b) # génère une suite d’entiers de a à b-1 avec un pas de 1

>>> range(a,b,c) # génère une suite d’entiers de a à b avec un pas de c

L’utilisation de range() ne génère pas de listes manipulables. En effet :

>>> print(range(10))

range(0, 10)

Pour générer une liste manipulable, il faut procéder de la façon suivante :

>>> list(range(5))

[0, 1, 2, 3, 4]

Un exemple utile :

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']

>>> for i in range(len(a)):

... print(i, a[i])

...

0 Mary

1 had



2 a

3 little

4 lamb

3.5.2 LES LIST COMPREHENSIONS

Elles permettent de récupérer une nouvelle liste avec tous les éléments de l'ancienne liste filtrés et

sur lesquels on a effectué (ou non) un traitement.

Une list comprehension a la syntaxe suivante :

>>> [expression for element in liste if predicat]

Le prédicat est facultatif.

Exemples :

>>> liste = range(10) # On prend une liste contenant les 10 premiers

>>> # entiers naturels

>>> liste

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>>

>>> [element + 1 for element in liste] # La même liste en ajoutant 1 à

>>> # chaque élément

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>>

>>> [element ** 2 for element in liste] # On élève les éléments au

>>> # carré

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>>

>>> liste # La liste n'est pas modifiée

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>>

>>> liste = [element for element in liste if element % 2 == 0]

>>> # On prend tous les éléments pairs de notre liste

>>> liste

[0, 2, 4, 6, 8]

>>>

>>> [element ** 4 for element in liste if element < 7] # On met à la

puissance 4 les éléments inférieurs à 7

[0, 16, 256, 1296]

>>>

>>> squares = [x**2 for x in range(10)]

3.5.3 LES BOUCLES WHILE

Cette boucle permet de répéter un bloc d'instructions tant qu'une condition est vraie (while signifie

« tant que » en anglais).

La syntaxe de while est :

>>>while condition:

# instruction 1

# instruction 2

# ...

# instruction N

Exemple :



>>> nb = 7

>>> i = 0 # variable d’itération

>>>

>>> while i < 10: # Tant que i est strictement inférieure à 10 on

exécute les instructions

... print(i + 1, "*", nb, "=", (i + 1) * nb)

... i += 1 # On incrémente i de 1 à chaque tour de boucle

3.6 LES FONCTIONS

Nous avons déjà utilisé quelques fonctions : print(), len(), input(),…. Les fonctions permettent de

regrouper des instructions dans un bloc qui sera appelé grâce à un nom. Dans la plupart des cas, mais

pas toujours, les fonctions regroupent des instructions pour manipuler des objets, appelés

arguments, et retournent d’autres objets, appelés résultats.

La création d’une fonction adopte la syntaxe suivante :

>>> def nom_de_la_fonction(arg_1, arg_2, arg_3, …,arg_N):

... # Bloc d'instructions

... return résultats

def est le mot-clé qui est l'abréviation de « define » (définir, en anglais) et qui constitue le prélude à

toute construction de fonction. Attention, le bloc d’instruction doit être indenté pour la fonction soit

valable.

Exemple :

>>> def carre(valeur):

... return valeur * valeur

>>>

>>> alfred = carre(5)

Les valeurs des arguments peuvent être affectées par défaut :

>>> def aire_rect(long, larg = 1):

... return long * larg

...

>>>

>>> aire_rect(10,5)

50

>>> aire_rect(10)

10

Comme expliqués précédemment, les arguments et les résultats à retourner ne sont pas obligatoires.

Par exemple :

>>> def table_par_7():

... nb = 7

... i = 0 # variable d’itération

... while i < 10 : # Tant que i est strictement inférieure à 10

faire :

... print(i + 1, "*", nb, "=", (i + 1) * nb)

... i += 1 # On incrémente i de 1 à chaque tour de boucle.

...

Exécutez la fonction table_par_7, puis tapez :

>>> print(i)

>>> print(nb)



Que se passe-t-il ?

Les fonctions permettent d’utiliser des blocs d’instruction autant de fois qu’on le souhaite par simple

appel de leur nom, sans besoin de réécrire les blocs d’instructions.

4 PROGRAMMATION MODULAIRE Jusque-là, nous avons codé uniquement dans l’invite de commande. Quittez l’interprète Python en

tapant l’instruction exit(), ouvrez-le à nouveau en tapant Python et appeler la fonction carre() avec

par exemple carre(5) :

>>> exit()

C:\Users\Emeric> Python

Python 3.5.1 |Anaconda 2.4.1 (64-bit)| (default, Dec 7 2015, 15:00:12)

[MSC v.1

900 64 bit (AMD64)] on win32

Type "help", "copyright", "credits" or "license" for more information.

>>> carre(5)

Vous remarquez que la fonction de vous avez définie tout à l’heure n’est plus disponible. Lorsque

vous quittez l’interprète, vous perdez toutes les informations tapées.

De plus, lorsque l’on travaille sur de longs programmes il est préférable de rédiger celui-ci dans un ou

plusieurs fichiers texte, à partir d’un éditeur, et les appeler dans l’interpréteur au moment où vous

en avez besoin. Les fichiers texte qui reçoivent le ou une partie du programme sont appelés script.

Les scripts peuvent contenir des groupements fonctions que vous codez une seule fois et que vous

pouvez utiliser dans n’importe quel de vos projets par importation. Ces scripts que vous pouvez

importer sont appelés modules. Ils doivent être sauvegardés en .py dans le répertoire courant.

Pour déterminer votre répertoire courant, tapez :

>>> import os

>>> os.getcwd()

L’adresse du répertoire courant apparait entre quote. Copier l’adresse (sans les quotes) et la barre de

recherche de Windows. La fenêtre du répertoire courant s’ouvre.

Ouvrez le logiciel bloc-notes, copiez/collez ce programme :

# Fibonacci numbers module

def fib(n) : # write Fibonacci series up to n

a, b = 0, 1

while b < n:

print(b, end=' ')

a, b = b, a+b

print()

def fib2(n) : # return Fibonacci series up to n

result = []

a, b = 0, 1

while b < n :

result.append(b)

a, b = b, a+b

return result



Et enregistrez-le sous : fibo.py. Faites attention à l’extension. Vous venez de créer un module

accessible depuis votre répertoire courant. Ce module regroupe deux fonctions fib et fib2. Pour

utiliser ces fonctions à partir de l’invite de commande, il faut importer le module de la façon

suivante :

>>> import fibo

Ensuite, pour utiliser les fonctions contenues dans ce module il faut procéder de la façon suivante :

nom_du_module.nom_de_la_fonction()

>>> fibo.fib(9)

1 1 2 3 5 8

>>> fibo.fib2(9)

[1, 1, 2, 3, 5, 8]

Il est également possible import du module et de l’associé à un alias.

>>> import fibo as fb

>>> fb.fib(9)

1 1 2 3 5 8

Des modules tels que nous venons d’en créer existent déjà lors de l’installation de Python. Par

exemple, il existe un module appelé math qui regroupe les fonctions mathématiques usuelles. En

tapant :

>>> import math

Vous avez accès à ces fonctions :

>>> math.sqrt(16)

4

>>> math.cos(3)

-0.9899924966004454

>>> math.exp(4)

54.598150033144236

>>> math.sqrt(9)

3.0

Pour connaitre toutes les fonctions disponibles dans ce module, tapez :

>>> help("math")

5 GESTION ENTREE/SORTIE L’ordinateur reçoit et/ou transmet des informations à des utilisateurs ou à d’autres ordinateurs.

Entre ordinateurs, l’information peut-être véhiculée en binaire. Pour des utilisateurs humains,

l’information doit être compréhensible. Il y a deux possibilités pour échanger de l’information avec

l’ordinateur : l’écran ou un fichier.

5.1 ECRAN

5.1.1 LECTURE

Transmettre une information à l’ordinateur, c’est faire lire à l’ordinateur une information à l’écran.

Pour cela, il peut utiliser la fonction input() comme vu précédemment :



>>> age = input("Quel age avez-vous ?")

Quel âge avez-vous ?29

>>> age

'29 '

>>> type(age)

<class 'str'>

Par défaut, l’information que vous tapez à l’écran est stockée systématiquement en tant que

« string », c’est-à-dire une chaine de caractères. Pour forcer le type de l’information saisi à l’écran il

faut utiliser les fonctions telles que : int(), float(), str(), bool(),…

>>> T_ext = int(input("Quel est la temperature extérieur ?"))

Quelle est la température extérieure ? 34

>>> T_ext

34

>>> type(T_ext)

<class 'int'>

>>>

>>> T_ext = float(input("Quel est la temperature extérieur ?"))

Quelle est la température extérieure ? 34

>>> T_ext

34.0

>>> type(T_ext)

<class 'float'>

5.1.2 ÉCRITURE

La fonction print() permet d’afficher des informations à l’écran :

>>> prénoms = "Barack"

>>> nom = "Obama"

>>> age = 54

>>>

>>> print("Je m'appelle " + prénoms + " " + nom + " et j'ai " +

str(age) + " ans.")

Je m'appelle Barack Obama et j'ai 54 ans.

Ou

>>> print("Je m'appelle {} {} et j'ai {} ans.".format(prénoms, nom,

age))

Je m'appelle Barack Obama et j'ai 54 ans.

Il est possible de formater la sortie, par exemple :

>>> print('Cette valeur vaut: {}'.format(3))

Cette valeur vaut : 3

>>>

>>> print('Cette valeur vaut: {:d}'.format(3))

Cette valeur vaut : 3

>>>

>>> print('Cette valeur vaut: {:f}'.format(3))

Cette valeur vaut : 3.000000

>>>

>>> print('Cette valeur vaut: {:.2f}'.format(3))


Cela est utile pour contrôler la précision des nombres à virgule.



Il est également possible d’utiliser cette notation :

>>> print('Cette valeur vaut: %.2f' %3)


>>>

>>> print("Cette valeur vaut : %.2f \n et cette valeur vaut : %d "

%(3.57886, 3)


et cette valeur vaut : 3

Voici les types possibles :

Type Lettre

int %d

long %ld

float/double %f/%lf

char %c

string (char*) %s

pointeur (void*) %p

short %hd

entier hexadécimal %x

5.2 FICHIER

Il est possible d’ouvrir, lire et fermer un fichier à partir de l’invite commande. L’on peut également

écrire dans un fichier. Les fichiers permettent de stocker des données et/ou des instructions (p. ex.

des programmes) pour être utilisé plus tard quand on le souhaite. Les fichiers sont enregistrés dans

un espace (sur un emplacement, c’est-à-dire un dossier ou répertoire) de l’ordinateur. Créer, ouvrir

et enregistrer un fichier nécessite de gérer les emplacements.

Comme vu précédemment, pour connaitre « où vous êtes » dans Python (dans quel répertoire

courant vous êtes), il faut taper :

>>> import os

>>> os.getcwd()

'C:\\Users\\Emeric'

L’adresse qui s’affiche correspond au répertoire courant où vous êtes.

Pour travailler dans un autre répertoire, il faut se déplacer. Pour cela, créez dans votre espace

utilisateur de votre ordinateur un dossier « Test_python ». Copiez l’adresse de ce dossier et collez-le

dans instruction suivante :

>>> os.chdir("adresse")

Attention : il est possible que votre adresse contienne des antislashs simples (\) ou des antislash

double (\\) , remplacer ces symboles par le symbole slash (/).

En exécutant l’instruction précédente, vous vous êtes déplacé dans le dossier (ou répertoire)

correspondant à l’adresse indiquée. Pour le vérifier, tapez :

>>> os.getcwd()



C’est dans ce dossier que nous allons travailler.

Nous allons commencer par ouvrir, lire et fermer un fichier texte se trouvant dans le dossier

« Test_python ». Avec « Bloc-note », créer un fichier contenant le poème « La voix » d’Ondine

Valmore disponible sur le lien suivant : http://www.poetica.fr/poeme-2800/ondine-valmore-la-voix/

Enregistrez-le dans le dossier « Test_python » sous le nom de « La_voix ».

L’ouverture d’un fichier se fait à l’aide de la fonction open(). Cette fonction admet deux arguments :

open( non_fichier , mode ). Vous l’avez compris « non_fichier » correspond au nom du fichier que

vous souhaitez ouvrir. Il est possible de précéder le nom du fichier par une adresse. Cela permet de

travailler à un autre endroit que celui du dossier courant. L’argument « mode » précise le mode

d’ouverture du fichier :

'r' : ouverture en lecture (Read).

'w' : ouverture en écriture (Write). Le contenu du fichier est écrasé. Si le fichier n'existe pas,

il est créé.

'a' : ouverture en écriture en mode ajout (Append). On écrit à la fin du fichier sans écraser

l'ancien contenu du fichier. Si le fichier n'existe pas, il est créé.

'r+' : ouverture en lecture et en écriture.

5.2.1 LECTURE

Lisons le fichier « La_voix » qui se trouve dans le dossier courant. Pour cela, ouvrons le fichier en

mode lecture :

>>> f = open( "La_voix.txt", "r")

>>> f

<_io.TextIOWrapper name='La_voix.txt' mode='r' encoding='cp1252'>

>>> type(f)

<class '_io.TextIOWrapper'>

>>>

f = open() créer un objet qui est affecté à la variable f. Ainsi, manipuler le contenu du fichier revient à

manipuler la variable f. L’on manipule f à l’aide de fonctions :

>>> contenu = f.read() #read() permet de lire tout le contenue du

ficher

>>> contenu

>>> ligne = f.readline() #readline() permet de lire le fichier ligne

par ligne

>>> ligne

http://www.poetica.fr/poeme-2800/ondine-valmore-la-voix/



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

325

f cT T où fT en degré Fahrenheit et cT en degré Celsuis.

EXERCICE 2 :



Réalisez un programme pour calculer l’approximation de la fonction exponentielle à l’aide d’une série

entière.

Formule à connaitre : pour N grand, 2 3 4

0

exp(x) 1 ...! 1! 2! 3! 4!

nn N

n

x x x x x

n

EXERCICE 3 :

Réalisez un programme qui retourne le plus grand élément d’une liste de nombres réels.

EXERCICE 4 :

Réalisez un programme qui compte le nombre d’occurrences du caractère « e » dans une chaine de

caractères.

EXERCICE 5 :

Réaliser un programme permettant de vérifier un mot de passe saisi à l’écran.

EXERCICE 6 :

Soient les listes suivantes :

L1 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

L2 = [‘Janvier’, ‘Février’, ‘Mars’, ‘Avril’, ‘Mai’, ‘Juin’, ‘Juillet’, ‘Aout’, ‘Septembre’, ‘Octobre’,

‘Novembre’, ‘Décembre’]

Réalisez un programme permettant de créer une nouvelle liste L3. Celle-ci devra contenir tous les

éléments des deux listes en les alternant, de telle manière que chaque nom de mois soit suivi de

nombre de jours correspondant :

L3 = [‘Janvier’, 31, ‘Février’, 28, ‘Mars’, 31, etc…]