Vous êtes sur la page 1sur 63

Algorithmique et Programmation

Introduction à la programmation en
Python

Dame Samb, Université de Thiès


Licence MIO

Année académique: 2019-2020

Dame Samb – Algorithmique et programmation - MIO 1


Plan de la séance

• Des différents niveaux de langages à Python

• Les types de bases

• Variables et affectation

• Affichage et saisie

• Les structures de contrôle

• Les sequences

• Les fonctions et modules


Dame Samb – Algorithmique et programmation - MIO 2
Des différents niveaux de langage à Python
• L’ordinateur
– un ensemble de circuits électroniques (le courant passe ou le
courant ne passe pas).
– Traite donc des signaux assimilables à 0 ou 1.

• Pour que les opérations à effectuer soient compréhensibles par


l’ordinateur, il faut effectuer un codage binaire.

• Les différentes opérations pour l’essentiel consistent à:


– lire dans la mémoire;
– écrire dans la mémoire;
– effectuer des calculs;
– afficher le résultat

Dame Samb – Algorithmique et programmation - MIO 3


Des différents niveaux de langage à Python
• Code binaire (langage machine)
– Constitué de 0 et de 1;
– Directement exécutable par la machine;
– Non portable (chaque famille de processeur possède son propre
langage);
– Manipule uniquement des registres de taille fixée (64 bits en
général);
– Permet simplement d’effectuer des opérations élémentaires (accès
mémoire, additions, soustractions, etc.);
• Exemple en langage binaire x86 d'un programme calculant 4+5

01010101 10001001 11100101 10000011 11101100 00010000 11000111 01000101 11110100 00000100
00000000 00000000 00000000 11000111 01000101 11111000 00000101 00000000 00000000 00000000
10001011 01000101 11111000 10001011 01010101 11110100 10001101 00000100 00000010 10001001
01000101 11111100 10001011 01000101 11111100 11001001 11000011

Dame Samb – Algorithmique et programmation - MIO 4


Des différents niveaux de langage à Python
• Langage assembleur
– Langage symbolique textuel d’un peu plus haut niveau;
– Lisible par un humain!
– Non portable;
– La traduction en langage machine se fait via un assembleur;

• Exemple: programme assembleur affichant "Hello World!" sous


Windows :

ORG 100h
MOV AH, 09h
MOV DX, message
INT 21h
RET
message db "Hello World !", '$'

Dame Samb – Algorithmique et programmation - MIO 5


Des différents niveaux de langage à Python
• Langages de haut niveau
– Permettent de comprendre plus facilement le code écrit;
– Portables (abstraction des caractéristiques du matériel);
– Manipulent des concepts plus élaborés (variables, tableaux,
fonctions).

• Plusieurs paradigmes (logique de fonctionnement):


– La programmation impérative: décrit les opérations en séquences
d'instructions exécutées par l'ordinateur pour modifier l'état du
programme (la plupart des langages sont impératifs).
– La programmation objet: consiste en la définition et l'interaction de
briques logicielles appelées objets regroupant les données et les
traitements qui sont liés.
– La programmation fonctionnelle déclarative: considère le calcul
en tant qu'évaluation de fonctions mathématiques.
Dame Samb – Algorithmique et programmation - MIO 6
Des différents niveaux de langage à Python
• Langages de haut niveau
– Exemple: programme affichant "Hello World!" en Langage C

#include <stdio.h>
int main() {
printf("Hello World!\n");
return 0; }

– Exemple: programme affichant "Hello World!" en Python 3.x

print("Hello World!")

Dame Samb – Algorithmique et programmation - MIO 7


Des différents niveaux de langage à Python
• Techniques de production de programmes: La compilation
– Traduction du source en langage objet.

– Elle comprend au moins quatre phases (trois phases d’analyse —


lexicale, syntaxique et sémantique — et une phase de production de
code objet).

– Pour générer le langage machine il faut encore une phase


particulière: l’édition de liens.

– Elle est contraignante mais offre au final une grande vitesse


d’exécution.

Dame Samb – Algorithmique et programmation - MIO 8


Des différents niveaux de langage à Python
• Techniques de production de programmes: L’interprétation
– Chaque ligne du source analysé est traduite au fur et à mesure en
instructions directement exécutées.
– Technique très souple mais les codes générés sont peu performants.

• Technique de production de programmes: Interprétation


du bytecode compilé (Mixte)
– Compromis entre facilité de développement et rapidité d’exécution;
– le bytecode (forme intermédiaire) est portable sur tout ordinateur
muni de la machine virtuelle du langage.

Dame Samb – Algorithmique et programmation - MIO 9


Des différents niveaux de langage à Python
• Langage Python
– Crée en 1989 aux Pays-Bas par Guido Van Rossum;
– Syntaxe simple (Typage Dynamique, Indentation significative,
gestion automatique de la mémoire) permettant de passer de
l’algorithme au programme;
– Portable sur tous les systèmes d’exploitation: Win, Lin, Mac;
– Langage open source;
– Disponibilité de plusieurs milliers de bibliothèques;
– Deux modes d’utilisation: script (écriture du programme dans
un fichier) et interactif (similaire à une calculatrice);
– Langage interprété rapide;
– Permet de mettre en œuvre les trois paradigmes (impérative,
objet et fonctionnel);

Dame Samb – Algorithmique et programmation - MIO 10


Les types de base
• Python permet de manipuler toutes sortes de données:
– Entiers : 0, -12, 3569
– Flottants : 0.232, 3.1415, -12.0
– Booléens : True, False (vrai, faux)
– Chaines de caractères : ”Bonjour le monde”

• On parle en programmation du type d’une donnée. On peut


connaitre le type d’une donnée en utilisant la fonction type().
Pour afficher une donnée on utilise la fonction print().

Dame Samb – Algorithmique et programmation - MIO 11


Les types de base: les entiers (int)
• Permet de représenter n’importe quel entier positif ou négatif
• On utilise l’écriture en base du 10 du nombre avec un signe optionnel
>>> 1
1
>>> 144
144
>>> -321
-321
>>> +51
+51
• La fonction standard int() permet de convertir n’importe quelle valeur
compatible vers l’entier correspondant (transtypage).
>>> int('0')
0
>>> int('-12')
-12
>>> int('48')
48
>>> int(3.712) # Conversion d'un nombre réel en nombre entier
3
Dame Samb – Algorithmique et programmation - MIO 12
Les types de base: les réels (float)
• Permet de représenter une partie des nombres à virgule;
• La séparation entre partie entière et partie décimale se fait avec un point
• On peut également utiliser l’écriture scientifique avec un E ou un e suivi
d’une puissance de 10
>>> 12.765
12.765
>>> .32
0.32
>>> -45.84
-45.84
• La fonction standard float() permet de convertir n’importe quelle valeur
compatible vers le nombre réel correspondant.
>>> float('0')
0.0
>>> float('0.425')
0.425
>>> float('-23E-10')
-2.3e-09

Dame Samb – Algorithmique et programmation - MIO 13


Les types de base: les booléens (bool)
• Permet de représenter les valeurs logiques VRAI et FAUX
• Deux mots réserves en python : True et False
• N’importe quelle donnée en Python possède une valeur logique :
– les valeurs non nulles valent True
– les valeurs vides ou nulles valent False
>>> True # Constante booléenne vrai
True
>>> False # Constante booléenne faux
False
>>> type(True)
<class 'bool'>
• Trois opérateurs
– not : négation
– and : et
– or : ou inclusif

Dame Samb – Algorithmique et programmation - MIO 14


Les types de base: opérations sur les nombres
• Les opérateurs arithmétiques
– - : moins unaire
– +, -, *, /, () : opérations usuelles
– // : division entière
– % : reste de la division (modulo)
– **: puissance

• Les opérateurs de comparaison


– == : égalité
– <, >, != : inégalités strictes
– <=, >= : inégalités larges

Dame Samb – Algorithmique et programmation - MIO 15


Les types de base: opérations sur les nombres
• Priorité des opérateurs (par ordre descendante)
– ()
– - (unaire)
– ** ! ! associatif à droite ! !
– *, /, //, %
– +, -
– <, >, <=, >=, ==, !=
– not
– and
– or
– Exemple: Quelle est la valeur de cette expression

not 16/2**2+10 != 15 % 8*2 and 0.5**-2/2*5 >= 10**2**(1/2)

Dame Samb – Algorithmique et programmation - MIO 16


Les types de base: opérations sur les nombres
• Exemple pour les opérateurs arithmétiques
>>> 28 + 2 # Addition, opérateur +
30
>>> 28 + 2.0 # Résultat flottant dès qu'il y a un flottant dans l'opération!
30.0
>>> 18 - 9 # Soustraction, opérateur -
9
>>> 45 * 3 # Multiplication, opérateur *
135
>>> 20 / 3 # Division flottante (même avec des entiers!)
6.666666666666667
>>> 20 // 3 # Division entière (dite euclidienne), opérateur //
6
>>> 20 % 3 # Reste de la division entière, opérateur %
2
>>> 5 ** 3 # Élévation à la puissance, opérateur **
125
>>> 2 ** 0.5
1.4142135623730951

Dame Samb – Algorithmique et programmation - MIO 17


Les types de base: opérations sur les nombres
• Exemple pour les opérateurs de comparaison

>>> 34 == 2 * 17 # Opérateur test d'égalité ==


True
>>> 27 != 3 * 9 # Opérateur test de différence !=
False
>>> 56 < 12 # Opérateur test strictement inférieur <
False
>>> 56 <= 2 * 28 # Opérateur test inférieur ou égal <=
True
>>> 45 > 4 * 5 # Opérateur test strictement supérieur >
True
>>> 23 >= 25 # Opérateur test supérieur ou égal >=
False

Dame Samb – Algorithmique et programmation - MIO 18


Les types de base: les chaines de caractère (str)
• Permet de représenter les textes. Les valeurs littérales sont
entourées par des apostrophes (’), des guillemets (”) ou bien des
triples quottes (’’’ ou ”””)
• Exemple:

>>> print("A") # Chaîne d'un seul caractère


A
>>> print("Un texte simple")
Un texte simple
>>> print('Un autre')
Un autre
>>> print("Avec l'inclusion de \"guillemets\" et de \\ dans le texte")
Avec l'inclusion de "guillemets" et de \ dans le texte

Dame Samb – Algorithmique et programmation - MIO 19


Les types de base: les chaines de caractère (str)
• La fonction standard str() permet de convertir la plupart des
valeurs dans leur représentation sous forme de texte.

• Exemple:

>>> str(184) # Conversion nombre entier en chaîne


'184'
>>> str(3.14) # Conversion nombre flottant en chaîne
'3.14'
>>> str(True) # Conversion booléen en chaîne
'True'

Dame Samb – Algorithmique et programmation - MIO 20


Les types de base: les chaines de caractère (str)
• Le caractère backslash (\), est appelé caractère d’échappement. Il
permet de spécifier des notations particulières dans une chaîne (voir
tableau).

Séquence Usage

\\ Insère un simple \

\" Insère un " (utile dans une chaîne entre ")

\' Insère un ' (utile dans une chaîne entre ')

\n Insère un retour à la ligne (line feed, code 10)

\r Insère un retour chariot (carriage return, code 13)

\t Insère une tabulation horizontale (code 9)

\f Insère un saut de page (form feed, code 12)

Dame Samb – Algorithmique et programmation - MIO 21


Les types de base: opérations sur les chaines (str)
• Les operateurs
– + : concaténation
– * : répétition
– len() : fonction retournant la longueur d’une chaine
– <, >, == : comparaison

• En Python, les chaines de caractères sont dits immutables (une fois


constituée en mémoire, elles ne sont plus modifiables). Les opérations
de modification sur les chaînes produisent donc de nouvelles chaînes.

>>> "Je programme" + " en Python" # Concaténation


'Je programme en Python'
>>> "Répéter " * 6 # Répétition
'Répéter Répéter Répéter Répéter Répéter Répéter '
>>> len("Le langage Python") # Longueur
17

Dame Samb – Algorithmique et programmation - MIO 22


Les types de base: opérations sur les chaines (str)
• Indexation et sous chaines
– En Python les chaines peuvent être considérées comme des
tableaux de caractères indicés par leur position.
– L’opérateur [ ] permet d’extraire un caractère particulier (syntaxe
[indice]) ou bien d’extraire une sous chaine (syntaxe [début:fn]).
>>> s = "la chaine, Du texte" # Chaîne de départ
>>> s[0] # Extraction premier caractère
'l'
>>> s[1] # Extraction second caractère
'a'
>>> len(s) # Longueur de la chaîne
19
>>> s[18] # Extraction dernier caractère
'e'
>>> s[19] # Extraction impossible (erreur) après le dernier caractère
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range

Dame Samb – Algorithmique et programmation - MIO 23


Les types de base: opérations sur les chaines (str)
• Indexation et sous chaines
– L’opérateur [ ] permet d’extraire un caractère particulier (syntaxe
[indice]) ou bien d’extraire une sous chaine (syntaxe [début:fn]).

>>> s[-1] # Extraction du dernier caractère en parcours inversé (← index négatif)


'e'
>>> s[0:len(s)] # Extraction sous-chaîne indice du début à indice de la fin
'la chaine, Du texte'
>>> s[11:13] # Extraction sous-chaîne indices 11 compris à 13 non compris
'Du'
>>> s[14:] # Extraction sous-chaîne indices 14 jusqu'à la fin
'texte'
>>> s[:3] # Extraction sous-chaîne du début jusqu'à l'indice 3 non compris
'la '
>>> s[14:-2] # Extraction sous-chaîne indice 14 compris à -2 (←) non compris
'tex'
>>> s[:] # Extraction sous-chaîne du début à la fin
'la chaine, Du texte'

Dame Samb – Algorithmique et programmation - MIO 24


Variables et affectation
• Une variable est une zone de la mémoire de l’ordinateur dans laquelle
une valeur est stockée.
En Python, la déclaration d’une variable et son initialisation se font en
même temps.
• Le nom d’une variable est une suite de caractères ne contenant que des
caractères alphanumériques (0 → 9, a→z , A→Z) ou le caractère _
(appelé “souligné” ou “barre du bas” ou underscore)
• Le nom d’une variable commence forcement par une lettre ou un
caractère souligné
• Le nom d’une variable ne doit pas être un mot réservé du langage : if,
elif, else, while, not, and, or ...
• La casse (distinction majuscule et minuscule) est prise en compte

• Exemples valides: x2, hauteur, calculer_maxi, bDebut, HAUTEUR,


_mini, Pt_X, distance_cm, xStartT0.

Dame Samb – Algorithmique et programmation - MIO 25


Variables et affectation
• Python étant dynamiquement typé, une variable prend le type de la
valeur qu’on lui a affecté́ .

>>> x = 23
>>> x = 2 * x - 10
>>> x
36
>>> x = x + 1 # Incrémentation
>>> x
37
>>> x = x - 1 # Décrémentation
>>> x
36

• L’opérateur d’affectation
– Il n’est pas symétrique (3 = a ne marche pas)
– Il est associatif à droite! (a = b = c veut dire a = (b = c))
– Il peut servir pour des affectations multiples (a, b = 2,3)
Dame Samb – Algorithmique et programmation - MIO 26
Variables et affectation
• Conventions pour le cours
– Limitation des noms de variables aux caractères alphabétiques
latins sans accent et sans commencer un nom par le caractère _
(sauf quelques cas spécifiés).

– Utilisation de la convention d’écrire les constantes toutes en


majuscules (ex. TAUX_TVA, MAX_X) et interdiction de les modifier.

– Définition des noms des fonctions tout en minuscules avec les


mots séparés par des _.

– Interdiction d’utiliser une variable avec des données de type différent


en cours d’exécution.
– Utilisation de la notation mixed case (mélangeant minuscules et
majuscules) et d’un préfixe indiquant le type de donnée afin de
mieux identifier la partie sémantique dans le nom de la variable.
Dame Samb – Algorithmique et programmation - MIO 27
Variables et affectation
• Conventions pour le cours
Préfixe de type Pour le type
i entier (int)
f nombre réel (nombre à virgule flottante — float)
b booléen (valeur logique True/False — bool)
s chaîne de caractère (str)
l liste de valeurs (tableau indicé — list)
fic objet fichier résultant d’un appel à open()
o objet d’une classe définie par nous en programmation objet

• Exemple
– iCompteur: valeur entière (comptant quelque chose)
– fCoef: valeur flottante (un coefficient)
– iAge: valeur entière (âge d’une personne)
– sDateDebut: chaîne de caractères (représentant une date de démarrage)
– ficDataLect: fichier (contenant des données a lire)
– oPtDepart: objet point (pour des coordonnées de départ)
Dame Samb – Algorithmique et programmation - MIO 28
Affichage et saisie: Fonction d’affichage (print)
• Elle est directement accessible (builtin).
• Elle prend un nombre variable d’arguments, séparés par des virgules,
qu’elle affiche sous forme de texte lisible, en les séparant par des
espaces et en terminant par un retour à la ligne.
• Les arguments de la fonction peuvent être des valeurs littérales, des
variables, ou toute expression permettant de calculer un résultat.
• Interprète les caractères spéciaux (saut de ligne, tabulation, etc.)

sLang = "Python"
iNais = 1991
iAge = 2019 - iNais
print("Le langage", sLang, "a", iAge, "ans.")
print("En 2030 il aura", 2030 - iNais, "ans.")
# Affichage Le langage Python a 28 ans.
En 2030 il aura 39 ans.

Dame Samb – Algorithmique et programmation - MIO 29


Affichage et saisie: Fonction d’affichage (print)
• Les chaînes littérales formatées ou f-string:
– simplification syntaxique introduite dans Python 3.6 pour le
formatage de chaînes.
– chaînes de caractères dont la déclaration est préfixée par un f
(f"..."), et qui peuvent comporter des champs indiqués entre
accolades { }.
– Les champs contiennent des variables ou des expressions dont la
valeur est évaluée lors de la construction de la chaine à l’exécution
du programme.

sLang = "Python"
iNais = 1991
iAge = 2019 - iNais
print(f"Le langage" {sLang} "a" {iAge} "ans.")
print(f"En 2030 il aura" { 2030 - iNais} "ans.")
# Affichage Le langage Python a 28 ans.
En 2030 il aura 39 ans.
Dame Samb – Algorithmique et programmation - MIO 30
Affichage et saisie: Fonction de saisie (input)
• Elle est directement accessible (builtin).
• Elle peut prendre en argument une chaîne de caractères qui est affichée
afin de donner des indications à l’utilisateur.
• Elle stoppe l’exécution du programme jusqu’a ce que l’utilisateur ait saisi
une valeur validée par l’appui sur la touche Entrée.
• Elle retourne une donnée de type str (qui demande parfois une
conversion de type) contenant la saisie.
sNom = input("Votre nom ? ")
print(f"Bonjour, {sNom}")
sMois = input("N° du mois en cours :") # Saisie mois dans variable chaîne intermédiaire
iMois = int(sMois) # Conversion chaîne mois en entier
iAnnee = int(input("Année en cours :")) # Saisie année et conversion directe en entier
print(f"XX/{iMois}/{iAnnee}")

Votre nom ? Laurent # Affichage


Bonjour, Laurent
N° du mois en cours :1
Année en cours :2019
XX/1/2019
Dame Samb – Algorithmique et programmation - MIO 31
Structures de contrôle: instructions composées
• En Python une instruction composée contient :
– la ligne d’entête, terminée par le caractère:
– le bloc d’instructions associé, constitué de toutes les lignes
suivantes qui sont indentées par rapport à la ligne d’entête
– le bloc se termine quand l’indentation devient égale ou plus faible
que celle de la ligne d’entête associée.

Dame Samb – Algorithmique et programmation - MIO 32


Structures de contrôle: Conditionnelle (if…else)
• Bloc if: Lorsque la condition logique est vérifiée, le bloc d’instructions
(instruction1 et instruction2) est exécuté. Si la condition n’est pas
vérifiée le bloc n’est pas exécuté et on passe aux instructions après le if.
#avant
if condition:
instruction1
instruction2
#après
• Bloc if…else: permet de spécifier un second bloc d’instructions qui est
exécuté lorsque la condition du if n’est pas vérifiée.
if condition:
instruction1
instruction2
else:
instructionA
instructionB
Dame Samb – Algorithmique et programmation - MIO 33
Structures de contrôle: Conditionnelle (if…elif…else)

• Permet de spécifier des alternatives ou des choix multiples avec


une batterie de tests.
#avant. # Classification canadienne par tranche d'age:
if condition1: iAge = int(input("Age (ans): "))
instruction1 if iAge <= 14:
instruction2 sClassification = "enfant"
elif condition2: elif iAge <= 24:
instructionA. sClassification = "adolescent"
instructionB. elif iAge <= 64:
elif condition3: sClassification = "adulte"
instructionα. else:
instructionβ sClassification = "aîné"
else: print(f"Classifié en {sClassification.title()}")
instructionψ
instructionω
#après
• RQ: Les instructions conditionnelles peuvent être imbriquées.
Dame Samb – Algorithmique et programmation - MIO 34
Structures de contrôle: les répétitions (while)
• condition, appelé critère de continuation est une donnée de type
booléen
• si condition est vraie, instruction1 et instruction2 sont exécutées,
• une fois instruction2 terminée, si condition est toujours vraie,
instruction1 et instruction2 sont à nouveau exécutées.
• les variables composant la condition doivent toutes avoir une valeur
avant le début de la boucle.
• Il faut s’assurer que la boucle se termine ! ! !
#avant
while condition:
instruction1
instruction2
#après
• Python contrairement à d’autres langages ne propose pas d’autre
instruction de boucle conditionnelle

Dame Samb – Algorithmique et programmation - MIO 35


Les séquences: boucle for
• Les instructions du bloc secondaire (aussi appelé corps de la
boucle) sont répétées pour chaque valeur dans la séquence.
• À chaque passage la variable itérateur prend la valeur suivante
dans la séquence.
• L’affectation de la valeur de la séquence à la variable itérateur
est réalisée automatiquement.

• RQ: il est INTERDIT de modifier la variable itérateur dans le


corps d'une boucle for.

Dame Samb – Algorithmique et programmation - MIO 36


Les séquences: boucle for
• Séquences ou types itérables: Un type "itérable" est un type de
donnée sur lequel on peut faire une itération, c'est à dire que l’on
peut énumérer les données qu’il contient les unes après les
autres, en séquence.

• Python dispose de plusieurs types prédéfinis de séquences:


– Les chaînes de caractères (vues précédemment);
– Les suites (avec le générateur range);
– Les listes;
– Les tuples;
– Les dictionnaires;
– Les ensembles (set)

Dame Samb – Algorithmique et programmation - MIO 37


Les séquences: les suites
• Le générateur range():

# Exemple avec for: # Exemple avec for:


for i in range(10): for i in range(3,8):
print(i, end = ",") print(i, end = ",")

# Affichage à l’exécution # Affichage à l’exécution


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

# Exemple:
– range(-2,2) génère la suite -2,-1,0,1
– range(4,2) génère une suite vide
Dame Samb – Algorithmique et programmation - MIO 38
Les séquences: les suites
• Le générateur range():

# Exemple avec for:


for i in range(-7, 8, 3):
print(i, end = ",")

# Affichage à l’exécution
-7,-4,-1,2,3,

# Exemples:
– range(2,12,2) génère la suite 2,4,6,8,10
– range(15,10,-1) génère la suite 15,14,13,12,11

Dame Samb – Algorithmique et programmation - MIO 39


Les séquences: les listes
• Liste: Suite ordonnée et modifiable d’éléments éventuellement
hétérogènes (de type différent).
• Les éléments d'une liste python sont entre deux crochets, et
séparés par des virgules (on peut définir une liste vide par [ ]).
• Le nombre d’éléments d'une liste est renvoyé par la fonction
len()

– Exemple :
>>> maliste = ['a','b',1,2,3,"toto",9.5]
>>> type(maliste)
<class 'list’>
>>> len(maliste)
7

Dame Samb – Algorithmique et programmation - MIO 40


Les séquences: les listes
• Les éléments d'une liste sont repères par leur indice.
• Les indices d'une liste commencent à 0 et se terminent à (n-1) ou
n est la valeur retournée par la fonction len ().
• Python détecte automatiquement l'utilisation d'index invalides et
génère une erreur (exception).

>>> maliste[0] # maliste = ['a','b',1,2,3,"toto",9.5]


‘a’
>>> maliste[1]
'b’
>>> maliste[6]
9.5
>>> maliste[7] # index invalide
IndexError: list index out of range

Dame Samb – Algorithmique et programmation - MIO 41


Les séquences: les listes
• Opérateur d’appartenance (in): renvoie True si l’élément est
dans la liste, False sinon
>>> "toto" in maliste ) # maliste = ['a','b',1,2,3,"toto",9.5]
True
>>> "robert" in maliste
False

• Opérateur de concaténation (+).


>>> liste2 = [10,'a’]
>>> maliste + liste2 # maliste = [1,2,3]
[1, 2, 3, 10, 'a’]

• Opérateur de répétition (*): permet de dupliquer le contenu


>>> liste2 * 3 # liste2 = [10,'a’]
[10, 'a', 10, 'a', 10, 'a']
Dame Samb – Algorithmique et programmation - MIO 42
Les séquences: les listes
• Parcours (sur les éléments) d’une liste avec une boucle for:
for element in maliste :
print(element, end = ",")

# Affichage à l’exécution
a,b,1,2,3,toto,9.5,

• Parcours (sur les indices) d’une liste avec une boucle for:
for k in range (len(maliste)) :
print(k, maliste[k], end = ",")

# Affichage à l’exécution
0 a,1 b,2 1,3 2,4 3,5 toto,6 9.5,

Dame Samb – Algorithmique et programmation - MIO 43


Les séquences: les listes
• Ajouter un élément avec la méthode append():
>>> maliste.append("fleur")
>>> maliste ['a',15,1,2,3,"toto",9.5,"fleur"] # ajout en fin de liste
>>> len(maliste)
8
• Supprimer un élément avec les méthodes pop () et remove():
>>> maliste.pop() # supprime le dernier élément et renvoi sa valeur
'fleur'
>>> maliste
['a',15,1,2,3,"toto",9.5]
>>> maliste.pop(5) # supprime l’élément à la position indiquée
'toto'
>>> maliste
['a’, 15, 1, 2, 3, 9.5]
>>> maliste.remove(15) # supprime l’élément avec la valeur indiquée
>>> maliste
['a', 1, 2, 3, 9.5]
Dame Samb – Algorithmique et programmation - MIO 44
Les séquences: les listes
• Liste contenant plusieurs listes: permet de définir des tableaux
à deux dimensions ou plus

• Extraction de sous listes:

# maliste = ['a','b',10,20,30,"toto",9.5]
– maliste[2:5] génère la liste [10, 20, 30]
– maliste[2:7:2] génère la liste [10, 30, 9.5]
– maliste[::-1] génère la liste [9.5, 'toto', 30, 20, 10, 'b', 'a']

Dame Samb – Algorithmique et programmation - MIO 45


Les séquences: les tuples
• Tuples: séquence ordonnée et non modifiable d’éléments
éventuellement hétérogènes.
• Les éléments du tuple sont séparés par des virgules, et entourés
de parenthèses ou non (on peut définir un tuple vide par ())
• Les éléments sont indices de 0 à n − 1

>>> t1 = (1,4,"toto")
>>> t2 = 42,"pi",11.78,"Python"
>>> len (t2)
4
>>> t2[0]
42
>>> t3 = ()
>>> t4 = ("un seul élément",)

Dame Samb – Algorithmique et programmation - MIO 46


Les séquences: les dictionnaires
• Dictionnaires: permet de stocker des collections d'associations
cle→valeur, et fournissant un accès très rapide à la valeur à
partir de la clé́ . L'itération sur un dictionnaire travaille sur les clés.

>>> d = { "Ain": 1, "Ardèche": 7, "Calvados": 14, "Lozère": 48, "Orne": 61,


"Paris": 75, "Essonne": 91}
>>> d["Paris"]
75
>>> list(d.keys())
['Ardèche', 'Orne', 'Essonne', 'Ain', 'Lozère', 'Paris', 'Calvados']
>>> list(d.values())
[7, 61, 91, 1, 48, 75, 14]
>>> list(d.items())
[('Ardèche', 7), ('Orne', 61), ('Essonne', 91), ('Ain', 1), ('Lozère', 48), ('Paris', 75),
('Calvados', 14)]
>>> for dept in d:
print("Département", dept, "code", d[dept])

Dame Samb – Algorithmique et programmation - MIO 47


Les séquences: les sets
• Set: permet de stocker des collections de valeurs en offrant des
opérations ensemblistes (appartient, inclus, intersection, union,
différence...).
>>> s1 = {'A','B','C','D','E','F’}
>>> s2 = {'E','F','G','H'}
>>> 'C' in s1 # appartenance
True
>>> 'X' in s1 # appartenance
False
>>> s1 & s2. # intersection
{'F', 'E'}
>>> s1 | s2
{'G', 'F', 'A', 'C', 'D', 'B', 'E', 'H’} # union
>>> s1 - s2 # différence
{'A', 'D', 'B', 'C’}
>>> s1 ^ s2 # différence symétrique
{'D', 'C', 'G', 'B', 'A', 'H'}
Dame Samb – Algorithmique et programmation - MIO 48
Les modules et fonctions
• Fonction: blocs d’instructions regroupés sous un nom
utilisée pour:
– Rendre le programme plus lisible
– Éviter de dupliquer le même code à plusieurs endroits du
programme.
– Faciliter la maintenance et le débogage du programme
– Être éventuellement réutilisés dans un autre programme

• Fonctions Python déjà rencontrées:


– print() : affiche des données
– input() : récupère une saisie au clavier
– len() : retourne le nombre d’éléments d’une séquence
• Les fonctions regroupées dans des fichiers séparés appelés
modules.
Dame Samb – Algorithmique et programmation - MIO 49
Les modules et fonctions
• Il y a trois façons pour pouvoir utiliser les fonctions contenues
dans un module Python :
1. from math import sin, cos // les fonctions sin et cos sont importées
du module math et sont disponibles dans la suite du programme

2. from math import * //La totalité des fonctions du module est


importée et disponible dans la suite du programme.

3. import math // Le nom du module est importé, on


accède à chaque fonction en faisant précéder son nom du nom du
module et d’un point (ex. math.sin(), math.cos()).
• Il y a deux types de fonctions
– Fonctions prédéfinies: fonctions de la bibliothèque standard
– Fonctions définies: fonctions imaginées par le concepteur du
programme.
Dame Samb – Algorithmique et programmation - MIO 50
Les modules et fonctions: définition d’une fonction

• La définition d’une fonction se compose:


– De la ligne déclarative: le mot clé def suivi de l’identificateur de la
fonction, de parenthèses entourant les paramètres de la fonction
séparés par des virgules, et du caractère ":" ;
– D’une chaîne de documentation indentée comme le corps de la
fonction ;
– Du corps de la fonction: bloc d’instructions indenté par rapport à la
ligne déclarative.

• Le bloc d’instructions est obligatoire. S’il est vide, on emploie


l’instruction pass. La documentation, bien que facultative, est
fortement conseillée.
• L’instruction return est utilisée dans le corps de la fonction pour
indiquer une sortie de la fonction en spécifiant si nécessaire la
valeur qui doit être retournée.
Dame Samb – Algorithmique et programmation - MIO 51
Les modules et fonctions: définition d’une fonction

• Exemple: fonction en python permettant de calculer la valeur


absolue d’un nombre passé en paramètre.

# Définition de la fonction
def val_absolue(fx_p):
"""Retourne |x|.
Si x est positif, retourne sa valeur.
Si x est négatif, retourne son opposé.
"""
fVabs = fx_p
if fx_p < 0:
fVabs = -fx_p
return fVabs

Dame Samb – Algorithmique et programmation - MIO 52


Les modules et fonctions: Appel d’une fonction

• L’appel d’une fonction provoque:


1. L’affectation des valeurs d’arguments éventuellement fournis
(paramètres effectifs) aux paramètres formels.
2. L’exécution du bloc d’instructions constituant le corps de la
fonction.

• Il doit y avoir un argument fourni pour chaque paramètre déclaré


de la fonction. Les arguments (positionnels) doivent être placés
dans le même ordre et du type attendu pour les paramètres.

• En Python la définition de la fonction doit être réalisée avant que


les instructions qui y font appel ne soient exécutées.
– On définit donc les fonctions au début du fichier source et on place
à la fin le code dit programme principal (main) qui fait appel à ces
fonctions.
Dame Samb – Algorithmique et programmation - MIO 53
Les modules et fonctions: Appel d’une fonction

Dame Samb – Algorithmique et programmation - MIO 54


Les modules et fonctions: Appel de fonctions
• Appel entre fonctions: Une fonction peut en appeler une autre. Tant
que les fonctions ne sont pas appelées, leur ordre de définition n’a
pas d’importance. # Imports de librairies outils
from math import sin

# Définition des fonctions (ordre de définition sans importance)


def moy_inv_sin(fx1_p, fx2_p):
"Retourne la moyenne des inverses des sinus de x1 et x2"
return (inv_sin(fx1_p) + inv_sin(fx2_p)) / 2

def inv_sin(fx_p):
"Retourne l'inverse du sinus de x."
return 1 / sin(fx_p)

# Programme principal
fx1 = float(input("Première valeur: "))
fx2 = float(input("Seconde valeur: "))
fRes = moy_inv_sin(fx1, fx2)
print(f"Moyenne des inverses des sinus: {fRes}")

Dame Samb – Algorithmique et programmation - MIO 55


Les modules et fonctions: Appel de fonctions

• Liste extensible d’arguments avec des tuples: ils doivent


être placés derrière les arguments prédéfinis.

def somme(*args):
print(args)
if len(args) == 3:
a, b, c = args[0], args[1], args[2]
return a+b+c. # retourne la somme des paramètres
else:
return None

# Exemple d’appel
somme(1,2,3)
somme(3)
Dame Samb – Algorithmique et programmation - MIO 56
Les modules et fonctions: Appel de fonctions

• Liste extensible d’arguments avec un dictionnaire: ils


doivent être placés derrière les arguments prédéfinis.

def dico(**args):
return args. # retourne les éléments d’un dictionnaire

# Exemples d’appels possible

## par des paramètres nommés :


print(dico(a=23, b=42)) # {’a’: 23, ’b’: 42}

## en fournissant un dictionnaire :
mots = {’d’: 85, ’e’: 14, ’f’:9}
print(dico(**mots)) # {’e’: 14, ’d’: 85, ’f’: 9}

Dame Samb – Algorithmique et programmation - MIO 57


Les modules et fonctions: Appel de fonctions

• Paramètres avec valeur par défaut: ils doivent être placés


derrière les arguments prédéfinis

def initPort(speed=9600, parity="paire", data=8, stops=1):


print("Init. à", speed, "bits/s", "parité :", parity)
print(data, "bits de données", stops, "bits d’arrêt")

# Exemples d’appels possibles :


initPort() initPort(parity="nulle")
# Init. à 9600 bits/s parité : paire # Init. à 9600 bits/s parité : nulle
# 8 bits de données 1 bits d’arrêt # 8 bits de données 1 bits d’arrêt

Dame Samb – Algorithmique et programmation - MIO 58


Les modules et fonctions: portée des variables

• La portée d’une variable définit les endroits dans le code du


programme où celle-ci est visible, c’est a dire qu’il est possible
de l’utiliser dans une expression ou bien de la modifier. On définit
en Python deux grandes catégories de variables:
– les variables globales qui sont déclarées hors de toutes fonctions et
sont accessibles n’importe ou dans le programme.
– les variables locales qui sont déclarées à l’intérieur d’une fonction et
ne sont accessible que depuis l’intérieur de cette fonction.

• Pour pouvoir manipuler une donnée globale et la modifier depuis


l’intérieur d’une fonction il faut la déclarer au début du corps de la
fonction avec la directive global
• Une variable locale à une fonction portant le même nom qu’une
variable globale masquera celle-ci et la rendra inaccessible à
partir de cette fonction.
Dame Samb – Algorithmique et programmation - MIO 59
Les modules et fonctions: portée des variables

• Exemple de portée

# x et fonc sont affectes dans le module : globaux


def fonc(y): # y et z sont affectes dans fonc : locaux
global x # permet de modifier x ligne suivante
x += 2
z=x+y
return z

x = 99
print(fonc(1)) # 102

Dame Samb – Algorithmique et programmation - MIO 60


Les modules et fonctions: portée des variables

• Exemple de portée

# x et fonc sont affectes dans le module : globaux


def fonc(y): # y et z sont affectes dans fonc : locaux
z=x+y
return z

x = 99
print(fonc(1)) # 100

Dame Samb – Algorithmique et programmation - MIO 61


Les modules et fonctions: portée des variables

• Exemple de portée

# x et fonc sont affectes dans le module : globaux


def fonc(y): # x, y et z sont affectés dans fonc : locaux
x=3 # ce nouvel x est local et masque le x global
z=x+y
return z

x = 99
print(fonc(1)) #4

Dame Samb – Algorithmique et programmation - MIO 62


Références et outils
• POINTAL, Laurent, algorithmique programmation (principale)
– https://perso.limsi.fr/pointal/python:cours_prog

• Sabine MARDUEL, révisions Laurent POINTAL, Informatique et


Algorithmique avec le langage Python (complémentaire)

• CORDEAU, Robert, Introduction à Python 3 (complémentaire)

• http://www.pythontutor.com/ excellent outil pour la visualisation


de programmes Python

• http://www.pyzo.org/start.html environnement de développement


Python fonctionnant avec Miniconda3 (ou Anaconda).

Dame Samb – Algorithmique et programmation - MIO 63

Vous aimerez peut-être aussi