cours détaillé python premier annee OFPPT.pptx

Formateur : ELYOUSSOUFI Mohamed Année scolaire: 2022/ 2023

2
Introduction:
Python présente de nombreuses caractéristiques intéressantes :
— Il est multiplateforme. C’est-à-dire qu’il fonctionne sur de nombreux systèmes d’exploitation : Windows, Mac OS..
— Il est gratuit. Vous pouvez l’installer sur autant d’ordinateurs que vous voulez (même sur votre téléphone !).
— C’est un langage de haut niveau.
— C’est un langage interprété. n’a pas besoin d’être compilé pour être exécuté, contrairement à des langages comme
le C ou le C++.
— Il est orienté objet.
— Il est relativement simple à prendre en main 2.
— Enfin, il est très utilisé..

3
Les Variables:
Définition:
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 affectation se font en même temps.
>>> x = 2
>>> x
2

4
Les Variables:
Les types de variables:
Le type d’une variable correspond à la nature de celle-ci.
Les trois principaux types dont nous aurons besoin dans un premier temps sont:
• les entiers (integer ou int),
• les nombres décimaux que nous appellerons floats
• les chaînes de caractères (string ou str).
Bien sûr, il existe de nombreux autres types (par exemple, les booléens, les nombres complexes, etc.).

6
Les Variables:
Opérations sur les types numériques
Les quatre opérations arithmétiques de base se font de manière simple sur les types numériques (entiers et
floats) :
>>> x = 45
>>> x + 2
47
>>> x - 2
43
>>> x * 3
135
>>> y = 2.5
>>> x - y
42.5
>>> ( x * 10) + y
452.5

7
Les Variables:
Remarquez toutefois que si vous mélangez les types entiers et floats, le résultat est renvoyé comme un float
(car ce type est plus général).
Par ailleurs, l’utilisation de parenthèses permet de gérer les priorités.
L’opérateur / effectue une division. Contrairement aux opérateurs +, - et *, celui-ci renvoie systématiquement
un float :
>>> 3 / 4
0.75
>>> 2.5 / 2
1.25
L’opérateur puissance utilise les symboles ** :
>>> 2**3
8
>>> 2**4
16

8
Les Variables:
Pour obtenir le quotient et le reste d’une division entière, on utilise respectivement les symboles //
et modulo % :
>>> 5 // 4
1
>>> 5 % 4
1
>>> 8 // 4
2
>>> 8 % 4
0
Les symboles +, -, *, /, **, // et % sont appelés opérateurs, car ils réalisent des opérations sur
les variables.

9
Les Variables:
Enfin, il existe des opérateurs « combinés » qui effectue une opération et une affectation en une seule
étape :
>>> i = 0
>>> i = i + 1
>>> i
1
>>> i += 1
>>> i
2
>>> i += 2
>>> i
4
L’opérateur += effectue une addition puis affecte le résultat à la même variable. Cette opération
s’appelle une « incrémentation ».
Les opérateurs -=, *= et /= se comportent de manière similaire pour la soustraction, la multiplication
et la division.

10
Les Variables:
Opérations sur les chaînes de caractères
Pour les chaînes de caractères, deux opérations sont possibles, l’addition et la multiplication :
>>> chaine = " Salut "
>>> chaine
' Salut '
>>> chaine + " Python "
' Salut Python '
>>> chaine * 3
' SalutSalutSalut '
L’opérateur d’addition + concatène (assemble) deux chaînes de caractères.
L’opérateur de multiplication * entre un nombre entier et une chaîne de caractères duplique (répète) plusieurs fois une
chaîne de caractères.

11
Les Variables:
Opérations sur les chaînes de caractères
Attention .!!
Vous observez que les opérateurs + et * se comportent différemment s’il s’agit d’entiers ou
de chaînes de caractères : 2+ 2 est une addition alors que "2" + "2" est une concaténation.
On appelle ce comportement redéfinition des opérateurs.

12
Les Variables:
La fonction type()
Si vous ne vous souvenez plus du type d’une variable, utilisez la fonction type() qui vous le rappellera.
>>> x = 2
>>> type ( x )
< class 'int ' >
>>> y = 2.0
>>> type ( y )
< class ' float ' >
>>> z = '2 '
>>> type ( z )
< class 'str ' >
Attention !!
Pour Python, la valeur 2 (nombre entier) est différente de 2.0 (float) et est aussi différente de '2' (chaîne de caractères).

13
Les Variables:
Conversion de types: casting
En programmation, on est souvent amené à convertir les types, c’est-à-dire passer d’un type numérique à une chaîne
de caractères ou vice-versa. En Python, rien de plus simple avec les fonctions int(), float() et str():
>>> i = 3
>>> str ( i )
'3 '
>>> i = '456 '
>>> int ( i )
456
>>> float ( i )
456.0
>>> i = '3.1416 '
>>> float ( i )
3.1416
En effet, lorsqu’on lit des entrée en claviers, ils sont considérés comme du texte, donc des chaînes de caractères.
Toute conversion d’une variable d’un type en un autre est appelé casting en anglais

14
L’Affichage:
La fonction print()
la fonction print() affiche l’argument qu’on lui passe entre parenthèses et un retour à ligne.
Ce retour à ligne supplémentaire est ajouté par défaut. Si toutefois, on ne veut pas afficher ce retour à la ligne, on
peut utiliser l’argument par « mot-clé » end :
>>> print (" Hello world !")
Hello world !
>>> print (" Hello world !" , end ="")
Hello world ! > > >

15
L’AFFICHAGE:
La fonction print()
La fonction print() peut également afficher le contenu d’une variable quel que soit son type. Par exemple, pour un
entier :
>>> var = 3
>>> print ( var )
3
Il est également possible d’afficher le contenu de plusieurs variables (quel que soit leur type) en les séparant par
des virgules :
>>> x = 32
>>> nom = " John "
>>> print ( nom , " a " , x , " ans ")
John a 32 ans
Python a écrit une phrase complète en remplaçant les variables x et nom par leur contenu. Vous remarquerez que
pour afficher plusieurs éléments de texte sur une seule ligne, nous avons utilisé le séparateur « , » entre les
différents éléments.

16
L’AFFICHAGE:
Commentaires:
Les commentaires débutent toujours par le symbole # suivi d’un espace. Ils donnent des explications claires sur
l’utilité du code et doivent être synchronisés avec le code, c’est-à-dire que si le code est modifié, les commentaires
doivent l’être aussi.
Dans un script, tout ce qui suit le caractère # est ignoré par Python jusqu’à la fin de la ligne et est considéré
comme un commentaire.
Les commentaires doivent expliquer votre code dans un langage humain. Voici un exemple :
1 # Votre premier commentaire en Python .
2 print (" Hello world !")
3
4 # D ' autres commandes plus utiles pourraient suivre .
Pour un commentaire en plusieurs ligne on utilise le trois guillemets:
"""
cela est un commentaire
Sur plusieurs lignes …
"""

17
LECTURE:
La fonction input()
La fonction input() prend en argument un message (sous la forme d’une chaîne de caractères), demande à
l’utilisateur d’entrer une valeur et renvoie celle-ci sous forme d’une chaîne de caractères.
Il faut ensuite convertir cette dernière en type correspondant (avec les fonctions int() ou float()).
Voici un exemple dans lequel on demande à l’utilisateur d’entrer un nombre entier, puis on affiche ce nombre.
>>> nb = int ( input (" Entrez un nombre entier : "))
Entrez un nombre entier : 23
>>> print ( nb )
23
Voici le cas ou on demande à l’utilisateur d’entrer un nombre reel, puis on affiche ce nombre.
>>> nb = float ( input (" Entrez un nombre reel: "))
Entrez un nombre entier : 23
>>> print ( nb )
23.00

18
LES TESTS:
Les tests sont un élément essentiel à tout langage informatique car ils permettent à l’ordinateur de
prendre des décisions.
Pour cela, Python utilise l’instruction if ainsi qu’une comparaison .
Voici un premier exemple :
>>> x = 2
>>> if x == 2:
... print (" Le test est vrai !")
...
Le test est vrai !
et un second :
>>> x = " souris "
>>> if x == " tigre ":
...

19
LES TESTS:
Tests à plusieurs cas
Parfois, il est pratique de tester si la condition est vraie ou si elle est fausse dans une même instruction if.
Plutôt que d’utiliser deux instructions if, on peut se servir des instructions if et else :
>>> x = 2
>>> if x == 2:
... else :
... print (" Le test est faux !")
...
Le test est vrai !
>>> x = 3
>>> if x == 2:
... else :
... print (" Le test est faux !")
...
Le test est faux !

20
LES TESTS:
Tests à plusieurs cas
On peut utiliser une série de tests dans la même instruction if, notamment pour tester plusieurs valeurs d’une
même variable. Par exemple :
>>> import random
>>> base = random . choice ([" a " , " t " , " c " , " g "])
>>> if base == " a ":
... print (" choix d ' une ad é nine ")
... elif base == " t ":
... print (" choix d ' une thymine ")
... elif base == " c ":
... print (" choix d ' une cytosine ")
... elif base == " g ":
... print (" choix d ' une guanine ")
Dans cet exemple, Python teste la première condition, puis, si et seulement si elle est fausse, teste la deuxième et
ainsi de
suite

21
LES TESTS:
Importance de l’indentation:
faites bien attention à l’indentation ! Vous devez être très rigoureux sur ce point. Pour vous en convaincre,
exécutez ces deux exemples de code :

23
Boucles et comparaisons:
Boucles for:
En programmation, on est souvent amené à répéter plusieurs fois une instruction. Incontournables
à tout langage de programmation, les boucles vont nous aider à réaliser cette tâche de manière
compacte et efficace
Exemple:
for animal in animaux :
print ( animal )
print ( animal *2)
print (" C ' est fini " )
Faite attention à l’ indentation qui définit le corps de la boucle!!

24
Fonction range()
Python possède la fonction range() pour faire une boucle sur une liste d’entiers de manière automatique :
>>> for i in range (4):
... print ( i )
...
0
1
2
3
on peut spécifier en argument une borne de début, une borne de fin:
range (4,10)
[ 4 , 5 , 6 , 7 , 8 , 9]
Comme avec range(), on peut spécifier en argument une borne de début, une borne de fin et un pas :
range (10 , 0 , -1)
[10 , 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1]

25
Les comparaisons:
Avant de passer à une autre sorte de boucles (les boucles while), nous abordons tout de suite les
comparaisons.
Python est capable d’effectuer toute une série de comparaisons entre le contenu de deux variables,
telles que :
Syntaxe Python Signification
== égal à
!= différent de
> supérieur à
>= supérieur ou égal à
< inférieur à
<= inférieur ou égal à

26
Les comparaisons:
Observez les exemples suivants avec des nombres entiers.
>>> x = 5
>>> x == 5
True
>>> x > 10
False
>>> x < 10
True
Python renvoie la valeur True si la comparaison est vraie et False si elle est fausse. True et False sont des
booléens (un nouveau type de variable).
Faites bien attention à ne pas confondre l’opérateur d’affectation = qui affecte une valeur à une variable et
l’opérateur de comparaison == qui compare les valeurs de deux variables.

27
Les comparaisons:
Vous pouvez également effectuer des comparaisons sur des chaînes de caractères.
>>> animal = " tigre "
>>> animal == " tig "
False
>>> animal != " tig "
True
>>> animal == " tigre "
True
Dans le cas des chaînes de caractères, a priori seuls les tests == et != ont un sens. En fait, on peut aussi
utiliser les opérateurs <, >, <= et >=. Dans ce cas, l’ordre alphabétique est pris en compte, par exemple :
>>> " a " < " b "
True

28
Boucles while:
Une autre alternative à l’instruction for couramment utilisée en informatique est la boucle while.
Le principe est simple:
Une série d’instructions est exécutée tant qu’une condition est vraie. Par exemple :
>>> i = 1
>>> while i <= 4:
... print ( i )
... i = i + 1
...
1
2
3
4
Remarquez qu’il est encore une fois nécessaire d’indenter le bloc d’instructions correspondant au corps de
la boucle (ici, les instructions lignes 3 et 4).

29
Boucles while:
Une boucle while nécessite généralement trois éléments pour fonctionner correctement :
1. Initialisation de la variable d’itération avant la boucle (ligne 1).
2. Test de la variable d’itération associée à l’instruction while (ligne 2).
3. Mise à jour de la variable d’itération dans le corps de la boucle (ligne 4).
Faites bien attention aux tests et à l’incrémentation que vous utilisez car une erreur mène souvent à des «
boucles infinies» qui ne s’arrêtent jamais.
Vous pouvez néanmoins toujours stopper l’exécution d’un script Python à l’aide de la combinaison de
touches Ctrl-C (c’est-à-dire en pressant simultanément les touches Ctrl et C). Par exemple :
i = 0
while i < 10:
print (" Le python c ' est cool !")
Ici, nous avons omis de mettre à jour la variable i dans le corps de la boucle. Par conséquent, la boucle ne
s’arrêtera jamais (sauf en pressant Ctrl-C) puisque la condition i < 10 sera toujours vraie.

30
Boucles while:
La boucle while combinée à la fonction input() peut s’avérer commode lorsqu’on souhaite demander à
l’utilisateur une valeur numérique. Par exemple :
>>> i = 0
>>> while i < 10:
... reponse = input (" Entrez un entier sup é rieur à 10 : ")
... i = int ( reponse )
...
Entrez un entier sup é rieur à 10 : 4
Entrez un entier sup é rieur à 10 : -3
Entrez un entier sup é rieur à 10 : 15
>>> i
15

31
Instructions break et continue
Ces deux instructions permettent de modifier le comportement d’une boucle (for ou while) avec un test.
L’instruction break stoppe la boucle.
... if i > 2:
... break
... print (i)
...
0
1
2

32
Instructions break et continue
L’instruction continue saute à l’itération suivante, sans exécuter la suite du bloc d’instructions de la boucle.
... if i == 2:
... continue
... print (i)
...
0
1
3
4

33
Les Fonction:
I - Principe et généralités:
En programmation, les fonctions sont très utiles pour réaliser plusieurs fois la même opération au
sein d’un programme.
Elles rendent également le code plus lisible et plus clair en le fractionnant en blocs logiques.
Vous connaissez déjà certaines fonctions internes à Python comme range() ou print().
Pour l’instant, une fonction est à vos yeux une sorte de « boîte noire » :
• À laquelle vous passez aucune, une ou plusieurs variable(s) entre parenthèses.
Ces variables sont appelées arguments. Il peut s’agir de n’importe quel type.
• Qui effectue une action.
• Et qui renvoie un objet Python ou rien du tout.

34
Les Fonction:
I I - Définition :
Pour définir une fonction, Python utilise le mot-clé def.
Si on souhaite que la fonction renvoie quelque chose, il faut utiliser le mot-clé return. Par exemple :
>>> def carre ( x):
return x **2
>>> print ( carre (2))
4
Notez que la syntaxe de def utilise les deux-points comme les boucles for et while ainsi que les tests
if, un bloc d’instructions est donc attendu.
De même que pour les boucles et les tests, l’indentation de ce bloc d’instructions (qu’on appelle le corps de
la fonction) est obligatoire.

35
Les Fonction:
I I - Dé f i n i t i o n :
Dans l’exemple précédent, nous avons passé un argument à la fonction carre() qui nous a renvoyé
(ou retourné) une valeur que nous avons immédiatement affichée à l’écran avec l’instruction print().
Que veut dire valeur renvoyée ? Et bien cela signifie que cette dernière est récupérable dans une variable :
>>> res = carre (2)
>>> print ( res)
4
Ici, le résultat renvoyé par la fonction est stocké dans la variable res.
Notez qu’une fonction ne prend pas forcément un argument et ne renvoie pas forcément une valeur, par
exemple :
>>> def hello ():
print (" bonjour ")
>>> hello ()
bonjour

36
Les Fonction:
I I I – Passage d ’arguments :
Le nombre d’arguments que l’on peut passer à une fonction est variable.
Nous avons vu ci-dessus des fonctions auxquelles on passait 0 ou 1 argument. Dans les chapitres précédents, vous
avez rencontré des fonctions internes à Python qui prenaient au moins 2 arguments.
Souvenez vous par exemple de range(1, 10) ou encore range(1, 10, 2).
Le nombre d’argument est donc laissé libre à l’initiative du programmeur qui développe une nouvelle fonction.

37
Les Fonction:
I I I - Passage d ’arguments :
Une particularité des fonctions en Python est que vous n’êtes pas obligé de préciser le type des arguments que vous
lui passez, dès lors que les opérations que vous effectuez avec ces arguments sont valides. Python est en effet connu
comme étant un langage au « typage dynamique », c’està-dire qu’il reconnaît pour vous le type des variables au
moment de l’exécution. Par exemple :
>>> def fois (x, y):
return x* y
>>> fois(2 , 3)
6
>>> fois (3.1415 , 5.23)
16 .430045000000003
>>> fois(’ to ’, 2)
’ toto ’
L’opérateur * reconnaît plusieurs types (entiers, floats, chaînes de caractères, listes). Notre fonction fois() est donc
capable d’effectuer des tâches différentes ! Même si Python autorise cela, méfiez-vous tout de même de cette grande
flexibilité qui pourrait conduire à des surprises dans vos futurs programmes. En général, il est plus judicieux que
chaque argument ait un type précis (entiers, floats, chaînes de caractères, etc) et pas l’un ou l’autre.

38
Les Fonction:
I I I - arguments par defaut:
En python, il est possible de définir des valeurs par défaut pour les arguments d’une fonction.
On obtient ainsi une fonction qui peut être appelée avec une partie seulement des arguments.
Exemple :
>>> def fois (x= 1, y=2):
return x* y
>>> fois(2 , 3)
6
>>> fois()
2
>>> fois(4)
8

39
Les Fonction:
I I I - arguments par defaut:
Dans la plupart des langages de programmation les arguments fournis lors de l’appel d’une fonction (paramètres
réels) doivent être dans le même ordre que celui des paramètres formels correspondant à la définition de la fonction.
En python lorsque les paramètres ont reçu des valeurs par défaut (selon la syntaxe indiquée
ci-dessus), ils ont chacun une étiquette qui va permettre de fournir les paramètres réels dans
n’importe quel ordre lors de l’appel de la fonction (ce qui est bien pratique en pratique…).
Exemple :
>>> def fois (x= 1, y=2):
return x* y
>>> fois(y=2 , x=3)
6

40
Les Fonction:
I I I - Fonctions à nombre variable de paramètres:
Le langage Python permet de définir des fonctions à nombre variable d'arguments.
De telles fonctions permettent la manipulation des paramètres via une liste qui doit être déclarer via un caractère *.
Par exemple :
def add( *params ). Vous pouvez mixer de paramètres nommés ainsi qu'une liste à nombre variable de paramètres,
comme le montre l'exemple ci-dessous:
# Cette première fonction permet d'ajouter tous les
# paramètres numériques passés à la fonction.
def add( *arguments ):
accumulator = 0
for value in arguments:
accumulator += value
return accumulator
print( add( 1, 2, 3 ) ) # Affiche 6
print( add( 1, 2, 3, 4, 5 ) ) # Affiche 15
print( add( 1, 2, 3, 100 ) ) # Affiche 106

41
Les Fonction:
IV - Renvoi de résultats :
Un énorme avantage en Python est que les fonctions sont capables de renvoyer plusieurs objets à la fois, comme dans
cette fraction de code :
>>> def carre_ cube ( x):
return x**2 , x **3
>>> carre_ cube (2)
(4 , 8)
En réalité Python ne renvoie qu’un seul objet, mais celui-ci peut être séquentiel, c’est-à-dire contenir lui même
d’autres objets. Dans notre exemple Python renvoie un objet de type tuple, type que nous verrons par la suite (grosso
modo, il s’agit d’une sorte de liste avec des propriétés différentes).
Renvoyer un tuple ou une liste de deux éléments (ou plus) est très pratique en conjonction avec l’affectation multiple,
par exemple :
1 >>> z1 , z2 = carre_ cube2 (3)
>>> z1 # affiche 9
>>> z2 # affiche 27
Cela permet de récupérer plusieurs valeurs renvoyées par une fonction et de les affecter à la volée à des variables
différentes.

42
Les Fonction:
V - Variables locales et variables globales :
Lorsqu’on manipule des fonctions, il est essentiel de bien comprendre comment se comportent les variables.
Une variable est dite locale lorsqu’elle est créée dans une fonction.
Elle n’existera et ne sera visible que lors de l’exécution de ladite fonction.
Une variable est dite globale lorsqu’elle est créée dans le programme principal. Elle sera visible partout dans le
programme.

43
Les Fonction:
Variables locales:
Exemple :
>>> def table(base, deb, fin):
for n in range(deb,fin+1):
print ( base,’*’,n,’=’,base*n)
Les variables n,deb,fin et base sont des variables locales.
Chaque fois que python appelle la fonction table() il réserve pour elle dans la mémoire de l’ordinateur un
nouvel espace des noms. Les contenus des variables n,deb,fin et base sont stockés dans cet espace des noms
qui est inaccessible depuis l’extérieur de la fonction.
Si on essaie par exemple d’afficher la valeur de base à l’extérieur de la fonction, l’interpréteur génère un
message d’erreur.
>>> base
Traceback (most recent call last): File "<stdin>", line 1, in ?
NameError: name 'base' is not defined

44
Les Fonction:
Variables globales:
Les variables définies à l’extérieur d’une fonction sont des variables globales. En cas de conflit entre une
variable locale et une variable globale (même nom pour les 2 variables) c’est la variable locale qui a la priorité et
qui masque donc la variable globale.
Exemple :
>>> a = 10
>>> def function(a,b):
a = b*b
print a,b
>>> function(2,3)
>>> print a
9 3 # a vaut 9 en local à la fonction function()
10 # a vaut 10 en global après la fonction function()

45
Les Fonction:
Il y a possibilité de déclarer comme globale une variable définie à l’intérieur d’une fonction,
pour cela il faut utiliser le mot clé global avant le nom de la variable lors de l’affectation.
Exemple :
>>> def compte_appels():
global cpt
cpt += 1
print cpt
>>> cpt = 0
>>> for i in range(0,5):
compte_appels()
1
2
3
4
5
>>> def compte_appels():
cpt += 1
print cpt
>>> cpt = 0
>>> for i in range(0,5):
compte_appels()
UnboundLocalError: local variable 'cpt' referenced
before assignment

46
Les structures de données:
A- Les structures de données :
Sont des moyens de stocker et d'organiser des données dans un programme informatique.
Elles permettent aux développeurs de stocker, manipuler et récupérer efficacement des données en fonction de
leurs besoins.
En Python, il existe plusieurs structures de données intégrées, Voici quelques-unes les plus courantes:
• Les listes
• Les Tuples
• Les dictionnaires
• Les ensembles
• Les chaines de caractères
• …

47
B- Listes :
Les listes sont des collections ordonnées d'éléments, qui peuvent être de n'importe quel type de données.
Les éléments de la liste sont indexés à partir de zéro et peuvent être accédés, modifiés ou supprimés en
utilisant leur indice.
Les listes sont définies en utilisant des crochets [ ] et les éléments sont séparés par des virgules.
Création de liste
Pour créer une liste contenant des éléments définis, il est possible d’utiliser la syntaxe suivante :
liste = [1, 5, 7]
De la même façon, on peut créer une liste vide (ne contenant aucun élément) :
liste = []
Print (len(liste))
0

48
B- Listes :
Toutefois, lorsque l’on souhaite créer des listes longues (par exemple la liste des 1000 premiers entiers), cette
méthode est peu pratique.
Heureusement, il existe des fonctions qui permettent de créer de telles listes.
Par exemple, la fonction range(a, b) retourne un itérable contenant les entiers de a (inclus) à b (exclu) :
maList= list(range(1,1000)) : la fonction list est utilisée pour convertir un itérable en liste

49
C- Accès aux éléments d’une liste :
Pour accéder au i-ème élément d’une liste, on utilise la syntaxe :
liste[i]
Attention, toutefois, le premier indice d’une liste est 0, on a donc :
liste = [1, 5, 7]
print(liste[1])  5
print(liste[0])  1
On peut également accéder au dernier élément d’une liste en demandant l’élément d’indice -1 :
print(liste[-1])  7
De la même façon, on peut accéder au deuxième élément en partant de la fin via l’indice -2, etc.
Ainsi, pour une liste de taille n, les valeurs d’indice valides sont les entiers compris entre –n et n-1 (inclus).

50
C- Accès aux éléments d’une liste :
Il est également à noter que l’accès aux éléments d’une liste peut se faire en lecture (lire l’élément stocké à
l’indice i) comme en écriture (modifier l’élément stocké à l’indice i) :
liste[1] = 2
print(liste) ->->[1, 2, 7]
Enfin, on peut accéder à une sous-partie d’une liste à l’aide de la syntaxe liste[d:f] où d est l’indice de début et f
est l’indice de fin (exclu). Ainsi, on a :
liste = [1, 5, 7, 8, 0, 9, 8]
print(liste[2:4]) ->-> [7, 8]
Lorsque l’on utilise cette syntaxe, si l’on omet l’indice de début, la sélection commence au début de la liste et si
l’on omet l’indice de fin, elle s’étend jusqu’à la fin de la liste :
liste = [1, 5, 7, 8, 0, 9, 8]
print(liste[:3]) ->-> [1, 5, 7]
print(liste[5:]) -> ->[9, 8]

51
D- Parcours d’une liste:
Lorsque l’on parcourt une liste, on peut vouloir accéder :
• aux éléments stockés dans la liste uniquement ;
• aux indices de la liste uniquement (même si c’est rare) ;
• aux indices de la listes et aux éléments associés.
Ces trois cas de figure impliquent trois parcours de liste différents, décrits dans ce qui suit.
Attention. Quel que soit le parcours de liste utilisé, il est fortement déconseillé de supprimer ou d’insérer des
éléments dans une liste pendant le parcours de celle-ci.

52
Parcours des éléments:
Pour parcourir les éléments d’une liste, on utilise une boucle for :
liste = [1, 5, 7]
for elem in liste:
print(elem)
1
5
7
Dans cet exemple, la variable elem va prendre successivement pour valeur chacun des éléments de la liste.

53
Parcours par indices :
Pour avoir accès aux indices (N° de la positions) de la liste, on devra utiliser un intermédiaire. On sait que les
indices d’une liste sont les entiers compris entre 0 (inclus) et la taille de la liste (exclu). On va donc utiliser la
fonction range pour cela :
liste = [1, 5, 7]
n = len(liste) # la fonction len() renvois la taille de la liste , n = 3 ici
for i in range(n):
print(i, liste[i])
0 1
1 5
2 7
.

54
Parcours par éléments et indices :
Dans certains cas, enfin, on a besoin de manipuler simultanément les indices d’une liste et les éléments
associés. Cela se fait à l’aide de la fonction enumerate :
liste = [1, 5, 7]
for i, elem in enumerate(liste):
print(i, elem)
0 1
1 5
2 7
On a donc ici une boucle for pour laquelle, à chaque itération, on met à jour les variables i (qui contient l’indice
courant) et elem (qui contient l’élément se trouvant à l’indice i dans la liste liste).

55
Pour tous ces parcours de listes, il est conseillé d’utiliser des noms de variables pertinents, afin de
limiter les confusions dans la nature des éléments manipulés.
Par exemple, on pourra utiliser i ou j pour noter des indices, mais on préfèrera elem ou val pour
désigner les éléments de la liste.

56
II - EXERCICE:
Écrivez une fonction en Python qui permette de calculer
l’Elemax d’une liste, c’est-à-dire l’indice auquel est
stockée la valeur maximale de la liste. Si cette valeur
maximale est présente plusieurs fois dans la liste, on
retournera l’indice de sa première occurrence..

57
E- Manipulations de listes:
Méthodes Description
append(elt) Ajoute elt à la liste
count() Compte les éléments de la liste
extend(seq) Etend la liste avec les éléments de la sequence
index(elt) Renvoie l’index de l’élément elt
insert(pos,elt) Insére elt immédiatement avant l’index pos
pop() Supprime le dernier objet après l’avoir retourné
pop(index) Retourne l’élément à la position index et le supprime

58
E- Manipulations de listes:
Méthodes Description
remove(elt) Supprime l’élément ayant la valeur elt
reverse() *** Renverse la liste – modifie l’objet sur lequel elle est appelée
sort() *** Ordonne la liste - modifie l’objet sur lequel elle est appelée
del nombre[1:3] Enlève les éléments d’index 1 à 3 (3 non inclus)

59
II – Exercice 1 : Intersection de listes:
Écrivez une fonction qui prenne deux listes en entrée et retourne l’intersection des
deux listes (c’est-à-dire une liste contenant tous les éléments présents dans les deux
listes).

60
II – Exercice 1 : Intersection de listes:
Écrivez une fonction qui prenne deux listes en entrée et retourne l’intersection des
deux listes (c’est-à-dire une liste contenant tous les éléments présents dans les deux
listes).
Solution:
def intersection(liste1, liste2):
liste_intersection = []
for elem in liste1:
if elem in liste2 and not elem in liste_intersection:
liste_intersection.append(elem)
return liste_intersection
l1=[2,1,10]
l2=[2,1,33,"b",2,10]
print(intersection(l1,l2))

61
II – Exercice 2 : union de listes:
Écrivez une fonction qui prenne deux listes en entrée et retourne l’union des deux
listes (c’est-à-dire une liste contenant tous les éléments présents dans au moins une
des deux listes) sans doublon.

62
III –LES DICTIONNAIRES:
En Python, un dictionnaire est une structure de données qui permet de stocker des éléments de manière
associée à des clés.
Contrairement aux listes qui sont indexées par des entiers, les dictionnaires sont indexés par des clés qui
peuvent être de tout type immuable, tels que les chaînes de caractères, les nombres entiers, les tuples ou
même les objets.
Chaque entrée dans un dictionnaire est une association entre une clé (équivalente à un indice pour une liste) et
une valeur

63
Pour créer un dictionnaire en Python, on utilise des accolades {} ou la fonction dict().
Les clés et les valeurs sont séparées par des deux-points : et chaque paire clé-valeur est séparée par des
virgules;
Par exemple : mon_dictionnaire = {'prenom': 'Jean', 'nom': 'Dupont', 'age': 30}
On peut également créer un dictionnaire vide en utilisant {} ou dict().
Par exemple : mon_dictionnaire_vide = {}

64
Modification du contenu d’un dictionnaire:
Pour modifier la valeur associée à une clé d’un dictionnaire, la syntaxe est similaire à celle utilisée pour les listes,
en remplaçant les indices par les clés :
Exemple:
mon_dic = {"a" : 123, "z" : 7, "bbb" : None}
mon_dic["a"] = 1000
print(mon_dic)  {'a': 1000, 'z': 7, 'bbb': None}

65
Modification du contenu d’un dictionnaire:
De même, on peut créer une nouvelle paire clé-valeur en utilisant la même syntaxe :
mon_dic["c"] = -1
print(mon_dic) {'a': 123, 'z': 7, 'bbb': None, 'c': -1}
Enfin, pour supprimer une paire clé-valeur d’un dictionnaire, on utilise le mot-clé del :
mon_dico = {"a" : 123, "z" : 7, "bbb" : None}
del mon_dic["a"]
print(mon_dic)  {'z': 7, 'bbb': None}

66
Lecture du contenu d’un dictionnaire:
Pour lire la valeur associée à une clé du dictionnaire, on peut utiliser la même syntaxe que pour les listes :
print(mon_dic["a"]) 123
Par contre, si la clé demandée n’existe pas, cela génèrera une erreur.
Pour éviter cela, on peut utiliser la méthode get qui permet de définir une valeur par défaut à retourner si la clé
n’existe pas :
print(mon_dic.get("a", 0)) 123
print(mon_dic.get("b", 0))  0

67
Parcours d’un dictionnaire:
Pour parcourir le contenu d’un dictionnaire, il existe, comme pour les listes, trois possibilités:
Parcours par valeurs:
Si l’on souhaite uniquement accéder aux valeurs stockées dans le dictionnaire, on utilisera la méthode values :
for val in mon_dic.values():
print(val)  123
7
None

68
Parcours par Clés:
Si l’on souhaite uniquement accéder aux clés stockées dans le dictionnaire, on utilisera la méthode keys :
for cle in mon_dic.keys():
print(cle)  a
z
bbb

69
Parcours par couples clés/valeurs:
Si l’on souhaite accéder simultanément aux clés stockées dans le dictionnaire et aux valeurs associées, on
utilisera la méthode items :
for cle, valeur in mon_dic.items():
print(cle, valeur)  a 123
z 7
bbb None

70
III –Exercices 1:
Écrivez une fonction qui compte le nombre d’occurrences de chacun des mots d’une
chaîne de caractères et retourne le résultat sous forme de dictionnaire :
# [In] print(compte_occurrences("la vie est belle c'est la vie"))
# [Sortie] {"c'est": 1, 'la': 2, 'belle': 1, 'est': 1, 'vie': 2}

71
III –Exercices 1:
Écrivez une fonction qui compte le nombre d’occurrences de chacun des mots d’une
chaîne de caractères et retourne le résultat sous forme de dictionnaire :
# [In] print(compte_occurrences("la vie est belle c'est la vie"))
# [Sortie] {"c'est": 1, 'la': 2, 'belle': 1, 'est': 1, 'vie': 2}
Solution:
def compte_occurrences(s):
d = {}
for mot in s.split():
d[mot] = d.get(mot, 0) + 1
return d
print(compte_occurrences("la vie est belle c'est la vie"))

72
III –Exercices 2:
Écrivez une fonction qui retourne la somme des valeurs d’un dictionnaire fourni en
argument, en supposant que toutes les valeurs stockées dans ce dictionnaire soient
numériques.

73
III –Exercices 2:
Écrivez une fonction qui retourne la somme des valeurs d’un dictionnaire fourni en
argument, en supposant que toutes les valeurs stockées dans ce dictionnaire soient
numériques.
Solution:
def somme_valeurs(d):
s = 0
for v in d.values():
s += v
return s
print(somme_valeurs({"a": 12, "zz": 1.5, "AAA": 0}))

74
III –Les méthodes des dictionnaires:
Les dictionnaires en Python disposent d'un certain nombre de méthodes pour effectuer différentes opérations.
Voici quelques-unes des méthodes les plus couramment utilisées :
clear() : supprime toutes les paires clé-valeur du dictionnaire
copy() : retourne une copie du dictionnaire
get(cle, valeur_par_defaut) : retourne la valeur correspondant à la clé spécifiée, ou la valeur par défaut si la clé n'existe pas
items() : retourne une vue sur les paires clé-valeur du dictionnaire sous la forme d'un objet itérable
keys() : retourne une vue sur les clés du dictionnaire sous la forme d'un objet itérable
values() : retourne une vue sur les valeurs du dictionnaire sous la forme d'un objet itérable
pop(cle, valeur_par_defaut) : supprime la paire clé-valeur correspondant à la clé spécifiée et retourne la valeur correspondante,
ou la valeur par défaut si la clé n'existe pas
popitem() : supprime et retourne une paire clé-valeur arbitraire du dictionnaire
setdefault(cle, valeur_par_defaut) : retourne la valeur correspondant à la clé spécifiée, ou la valeur par défaut si la clé n'existe
pas, et ajoute cette paire clé-valeur au dictionnaire si elle n'existe pas
update(dictionnaire) : fusionne le dictionnaire actuel avec un autre dictionnaire

75
VI –Tuples :
un tuple est une collection ordonnée et immuable d'éléments, similaire à une liste,
mais avec la différence clé que les tuples ne peuvent pas être modifiés une fois créés.
Les tuples sont souvent utilisés pour stocker des données qui ne doivent pas être modifiées, telles que des
coordonnées géographiques, des noms de jours de la semaine ...
Pour créer un tuple on utilise la syntaxes suivante: (les parenthèses et des virgules pour séparer les valeur)
mon_tuple = (1, 2, 3, 4, 5)
Les éléments d'un tuple peuvent être de différents types, y compris des chaînes de caractères, des nombres, des listes,
des dictionnaires et même d'autres tuples.

76
VI –les Sets ( les ensembles):
un set (ou ensemble) est une collection non ordonnée et non indexée d'éléments uniques.
Les sets sont souvent utilisés pour éliminer les doublons d'une séquence ou pour effectuer des opérations
mathématiques telles que l'intersection, l'union et la différence entre ensembles.
Les sets sont créés en utilisant des accolades ou la fonction set() :
c = {1, 2, 3}
d= set(["truc", "machin", "chose"])  set(liste) :prend en argument un iterable
print(c) {1, 2, 3}
print(d) {'truc', 'chose', 'machin'}

77
Pour créer un set vide en utilise la fonction set:
vi= set()  un set vide
vi = {}  un dictionnaire vide
Puisque les sets ne peuvent pas stocker de valeurs répétées, lorsqu’on convertit une liste en set, on obtient une liste
sans doublon (mais on perd la notion d’ordre) :
ma_liste = ["truc", "machin", "truc", "chose", "machin", "machin"]
mon_set = set(ma_liste) # Convertit la liste en set
print(mon_set) {'truc', 'chose', 'machin'}

78
Une fois un set défini, on ne peut plus modifier les valeurs qu’il contient, mais on peut lui supprimer / ajouter des
valeurs :
mon_set = {"truc", "machin", "chose"}
# Ajouter un élément
mon_set.add(« autre")
# Supprimer un élément
mon_set.remove("truc")
print(mon_set) {‘autre‘, 'chose', 'machin'}

79
Les ensembles possèdent les méthode suivantes:
add() : ajoute un élément à un set.
clear() : supprime tous les éléments d'un set.
copy() : renvoie une copie d'un set.
difference() : renvoie un set contenant les éléments qui ne sont présents que dans le set appelant et pas dans
l'ensemble passé en argument (ou bien on utilise le symbole - ).
difference_update() : supprime les éléments de l'ensemble appelant qui sont également présents dans l'ensemble
passé en argument.
discard() : supprime un élément spécifié d'un set.

80
intersection() : renvoie un set contenant les éléments qui sont présents à la fois dans le set appelant et dans
l'ensemble passé en argument (ou bien on utilise le symbole &).
intersection_update() : supprime les éléments de l'ensemble appelant qui ne sont pas également présents dans
l'ensemble passé en argument.
isdisjoint() : renvoie True si deux sets n'ont pas d'éléments en commun, sinon renvoie False.
issubset() : renvoie True si tous les éléments d'un set sont présents dans l'ensemble appelant, sinon renvoie False.
issuperset() : renvoie True si tous les éléments de l'ensemble appelant sont présents dans le set spécifié, sinon
renvoie False.
pop() : supprime et renvoie un élément arbitraire d'un set.
remove() : supprime un élément spécifié d'un set. Si l'élément n'est pas présent, une exception KeyError est levée.

81
symmetric_difference() : renvoie un set contenant les éléments qui sont présents soit dans l'ensemble appelant, soit
dans l'ensemble spécifié, mais pas dans les deux (ou bien on utilise le symbole ^).
symmetric_difference_update() : met à jour l'ensemble appelant en supprimant les éléments qui sont présents à la
fois dans l'ensemble appelant et dans l'ensemble spécifié, et en ajoutant les éléments qui sont présents soit dans
l'ensemble appelant, soit dans l'ensemble spécifié, mais pas dans les deux.
union() : renvoie un set contenant tous les éléments des deux sets spécifiés (ou bien on utilise le symbole |).
update() : met à jour l'ensemble appelant en ajoutant les éléments de l'ensemble spécifié.

cours détaillé python premier annee OFPPT.pptx

Contenu connexe

Tendances

Similaire à cours détaillé python premier annee OFPPT.pptx

Dernier

cours détaillé python premier annee OFPPT.pptx