12/30/202

Cours Python
[Link] CHIHAB

Année universitaire 2024-2025

Un peu d’historique du Python

 Le langage Python a été développée par Guido VAN ROSSUM en 1991.

 Il utilise une syntaxe très légère, inspirée d’ABC.
 Il est riche en structures de données dynamiques, bien intégrées à la
syntaxe.
 Le Python est distribué en 2001 sur une licence libre compatible avec la
GPL.
 En 2001 : naissance de la PSF (Python Software Fundation)
 Les versions se succèdent… Un grand choix de modules est disponible, des
colloques annuels sont organisés, Python est enseigné dans plusieurs
universités et est utilisé en entreprise…
 En 2006 : première sortie de IPython
 Fin 2008 : sorties simultanées de Python 2.6 et de Python 3.0
 12/30/202

Caractéristiques du langage Python

 Python est un langage à typage dynamique. Le développeur n’a pas à déclarer les
variables avant de leur affecter une valeur : la création de la variable se fait au
moment où elle est utile. Il n’a pas non plus à déclarer son type : lors de son
utilisation, les opérateurs (qui sont en fait des méthodes des opérandes) en testent le
type pour vérifier s’ils sont dans leurs conditions d’utilisation.
 Python est un puissant langage de programmation portable, orienté objet et dynamique, avec une
bibliothèque standard très importante.
 Python a des similarités avec des langages de script comme Perl ainsi qu’avec d’autres langages comme
Java et C.
 Python est un langage à typage fort : lorsqu’un opérateur reçoit deux opérandes
incompatibles, une exception est levée et l’opération n’est pas exécutée. Un langage à
typage faible aurait tenté une conversion de l’un des opérandes vers un type
compatible et effectué l’opération, au risque d’avoir un résultat inattendu : 4+"2"
doit-il fournir la chaîne "42", l’entier 6 ou une erreur ?

Le Python

 Production des programmes:

 La compilation est la 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. La compilation est contraignante mais offre au final
une grande vitesse d’exécution.

source compilateur objet

exécuteur résultat
 12/30/202

Le Python

 Dans la technique de l’interprétation chaque ligne du source analysé est

traduite au fur et à mesure en instructions directement exécutées.
Aucun programme objet n’est généré. Cette technique est très souple
mais les codes générés sont peu performants : l’interpréteur doit être
utilisé à chaque nouvelle exécution…

source interpréteur résultat

Caractéristiques de base de python

 Logiciel libre.
 Python gère lui-même l’espace mémoire disponible.
 Il n'y a pas de pointeurs explicite en Python
 Il existe des interpréteurs en Python.
 Il a une importantes documentations en ligne.
 Il permet:
 un développement rapide et incrémentiel.
 Tests et débogage outillés.
 Analyse interactive de données

 Il offre des possibilités pour la programmation orientée objet

 il est ouvert au monde : Excellente portabilité
 12/30/202

Utilisation du Python

où on peut utiliser python ?

 Web : Flask, Django, TurboGears, Zope, Plone, ...
 Bases de données : MySQL, PostgrSQL, Oracle, MongoDb...
 Réseaux : TwistedMatrix, PyRO, ...
 Gui : Gtk, Qt, Tcl/Tk, WxWidgets
 Représentation graphique : gnuplot, matplotlib, VTK, ...
 Calcul scientifique : numpy, scipy, sage, ...

Installation de python

 On peut télécharger la version la plus récente du langage sur le site web officiel de Python :
Sous Windows: [Link]
Sous Linux: [Link]

 Dans ce site, vous trouverez dans la section Download des logiciels d’installation automatique pour les différentes versions

de Python. Vous pouvez choisir la dernière version mais attention certains modules ne sont alors pas forcément disponibles.

 Vous pouvez alors utiliser Python à partir de l’environnement de programmation IDLE.

 12/30/202

Installation via anaconda

Installation via anaconda

 Anaconda est une distribution libre et open source des langages de programmation Python et R

appliqué au développement d'applications dédiées à la science des données et à l'apprentissage

automatique (traitement de données à grande échelle, analyse prédictive, calcul scientifique), qui vise

à simplifier la gestion des paquets et de déploiement. Les versions de paquetages sont gérés par le

système de gestion de paquets conda. La Distribution Anaconda est utilisée par plus de 6 millions

d'utilisateurs, et il comprend plus de 250 paquets populaires en science des données adaptés pour

Windows, Linux et MacOS.

[Link]

Installation via anaconda

 12/30/202

Variables
Définition :

- Une variable est une zone de la mémoire dans laquelle on stocke une valeur; cette variable est définie par un nom. Pour la
machine, elle s’agit en fait d’une adresse :une zone de la mémoire).

- Les noms de variables sont des suites de lettres (non accentuées) ou de chiffres. Le premier caractère est obligatoirement une

lettre.

Attention: Python distingue les minuscules des majuscules.

Exemple:
x=4
y=5
z=x+y
Print(z)

Les mots réservés de Python 3

 Les mots réservés de Python 3

and del from None True as elif global nonlocal try

assert else if not while break except import or with

class False in pass yield continue finally is raise def

for lambda return

 12/30/202

Les mots réservés de Python

3 Mot Utilisation

Les mots réservés de Python

3

Mot Utilisation
 12/30/202

Les variables

 Type de variable
- Les 3 types principaux dont nous aurons besoin sont : les entiers, les flottants et les chaines de caractères.
- Il existe de nombreux autres types (e.g. complex pour les nombres complexes), c’est d’ailleurs un des gros
avantages de Python.
Déclaration et assignation
x=2 # entier
y=2,3 # flottant
z= " bonjour " # chaines de caractères
print(x)
print(y)
print(z)

Les variables

 Le type complexe
- Les complexes sont écrits en notation cartésienne formée de deux
flottants.
- La partie imaginaire est suffixée par j :
Exemple:
 print(3j) # 3j
 print((2+3j) + (5-7j)) # (7-4j)
 print((3+5j).real) # 3.0
 print((3+5j).imag) # 5.0
 print((abs(3+4j))) # 5.0 : module
 12/30/202

Objet Python

TYPE D'UN OBJET PYTHON

La fonction type permet de retourner le type d’une variable
Syntaxe : type(nom_de_lavariable)

Casting en python

 int() : convertir en un int.

 x = int(3) # x = 3
 y = int(2.1) # y = 2
 z = int("5") # z =5
 float() : convertir en float.
 x = float(2) # x =2.0
 y = float(3.8) # y =3.8
 z = float("3") # z = 3.0
 w = float("4.2") # w=4.2
 str() : convertir en chaîne de caractères.
 x = str("s1") # x ='s1’
 y = str(2) # y = '2’
 z = str(3.0) # z = '3.0'
 12/30/202

Opérations de base
Opérateurs arithmétiques
 Le langage Python ne possède que très peu d’opérations arithmétiques pour
manipuler les nombres. Il se résume à une calculatrice élémentaire :

Opération Signification Exemple Résultat

+ Addition x=2+3 5
- Soustraction X=2-3 -1
* Multiplication x=2*3 6
** Puissance x=2**3 8
/ Division x=2/3 0,666666
// Quotient de division x=2//3 0
entière
% Modulo x=2%3 2

Opérations de base

Raccourcis pour les opérateurs arithmétiques

a+=2 a=a+2
a*=2 a=a*2
a/=2 a=a/2
a//=2 a=a//2
a**=2 a=a**2
a%=2 a=a%2
 12/30/202

Opérations de base

 Opérateurs de comparaison
< plus petit
<= plus petit ou égal
> plus grand
=> plus grand ou égal égal
!= Différent
is est
 Quelques fonctions supplémentaires
Abs(a) Valeur absolue de a
max(...) Plus grande valeur d’une suite de nombres
min(...) Plus petite valeur d’une suite de nombres
round(a,n) Arrondi de la variable a au niveau de la nième décimale

Opérations de base

Opérateurs logiques
Opérateur Description Exemple
And Retourne True si les a<2 and a>10
deux conditions sont
vraies
Or Returns True si au a<2 or a>10
moins une condition
est vraie
not Retourne le contraire not(a<2 and a>10)
du résultat
 12/30/202

Opérations de base

Opérateurs d'appartenance

Opérateur Description Exemple

in Returns True si la séquence x in y
x est présente dans l'objet y

not in Returns True if a sequence x not in y

with the specified value is
not present in the object

 c= 2+2j
 d=5+3j
 Effectuer les opérations suivantes entre ces deux nombres complexes :
 Addition
 Soustraction
 Multiplication
 Division
 Calculer et afficher le module de chacun des nombres complexes
 12/30/202

Chaînes de caractères

 Le type chaîne de caractères est nommé str en Python.

 Un caractère en Python est une chaîne d’un caractère. Les chaînes de
caractères sont des séquences non modifiables : elle répondent aux
opérations habituelles mais elle ne peuvent pas être modifiées, elles sont
non mutables.
 Une chaîne de caractères est délimitée par des apostrophes ou des
guillemets.. Les deux sont possibles, mais le double guillemet permet d’avoir
une apostrophe sans avoir recours au backslash : "\".
 Exemple
- Des guillemets simples : chaine1=’Bonjour’ #chaine sur une seule ligne
- Des guillemets simples : chaine1=’’Bonjour’’ #chaine sur une seule ligne
- Des guillemets simples : chaine1=’’’’’’Bonjour
- Tout le monde ‘’ ‘’ ‘’ #chaine sur plusieurs lignes

Chaînes de caractères

 Les chaînes de caractères : opérations

- Longueur :
s = ”Master”
len(s) # 6
- Concaténation :
s1 = ”master”
s2 = ”cloud”
s3 = s1 + s2 # ’mastercloud’
print(s3)
-Répétition :
s4 = ”master! ”
s5 = s4 * 3 # ’master! master! master! ’
print(s5)
 12/30/202

Chaînes de caractères

 Les chaînes de caractères : fonctions vs méthodes

 On peut agir sur une chaîne (et plus généralement sur une séquence) en
utilisant des fonctions (notion procédurale) ou des méthodes (notion objet).
Pour appliquer une fonction, on utilise l’opérateur () appliqué à la fonction :
chaine = ”master”
long = len(chaine) # 6
On applique une méthode à un objet en utilisant la notation pointée entre la
donnée/- variable à laquelle on applique la méthode, et le nom de la méthode
suivi de l’opérateur () appliqué à la méthode :
 ch2 = ”master”
 ch3 = [Link]() # ”MASTER”

Chaînes de caractères

 Autres fonctions utiles

 12/30/202

Chaînes de caractères

 Autres fonctions utiles

Chaînes de caractères

 Les chaînes de caractères : indexation simple

- Pour indexer une chaîne, on utilise l’opérateur [ ] dans lequel l’index, un
entier signé qui commence à 0 indique la position d’un caractère :
 12/30/202

Chaînes de caractères

 Extraction de sous-chaînes
- L’opérateur [ ] avec 2 ou 3 index séparés par le caractère : permet
d’extraire des souschaînes (ou tranches) d’une chaîne :
s = "master1"
print(s[1:4])
print(s[-2:]) [Link]@[Link]
print(s[:4])
print(s[4:])
print(s[::2])

Les entrées-sorties

- Les entrées
La fonction de saisie: input() effectue toujours une saisie en mode texte
Exemple:
a = input("Entrez votre nom : ")
print(type(a))
b = input("\nEntrez un flottant : ")
b = float(b) # transtypage en flottant
# ou plus simplement :
b = float(input("Entrez un autre flottant : "))
print(type(b))
 12/30/202

Les entrées-sorties
 Les sorties
 La fonction d'affichage: print() est une fonction indispensable aux affichages dans
les scripts. import sys
Exemple: a, b = 2, 5
print(a, b) # 2 5
print("Somme :", a + b) # Somme : 7
print(a - b, "est la différence") # -3 est la différence
print("Le produit de", a, "par", b, "vaut :", a * b)
# Le produit de 2 par 5 vaut : 10
print() # affiche une nouvelle ligne
# pour afficher un espace à la place de la nouvelle ligne:
print(a, end=" " ) # 2 (et ne va pas à la ligne)
print("\nErreur fatale !", file=[Link]) # dans un fichier
print("On a <", 2**32, "> cas !", sep="###")
# On a <###4294967296###> cas !

Liste, Tuple, ensemble, Dictionnaire

Collections Python:
Il existe quatre types de données de collection dans le langage de programmation Python:

 List est une collection ordonnée et modifiable. Permet de doubler les données.

 Le tuple est une collection ordonnée et immuable. Permet de doubler les données.

 Set est une collection non ordonnée et non indexée. Aucune donnée membre en double.

 Dictionary est une collection non ordonnée, modifiable et indexée. Aucune donnée en double.
 12/30/202

Liste

Liste:
 Une liste est une structure de données qui contient une série de valeurs.
Le langage Python autorise la construction de liste contenant des
valeurs de types différents.
Syntaxe:
Éléments séparés par des virgules, et entourés de crochets.
Exemple:
couleurs = [‘blanc’, ’noir’, ’marron’, ’vert’]

Liste

Exemple:
couleurs = [’blanc’, ’noir’, ’marron’, ’vert’]
print(couleurs)
couleurs[1] = 8 # Accéder à un élément de la liste pour changer sa valeur
print(couleurs)
list1 = [’z’, ’y’]
list2 = [2, 5,’a’,7]
list3 = [list1, list2] # liste de listes
 12/30/202

Liste

A. Ajouter un élément à la fin d'une liste:

couleurs = [’blanc’, ’noir’, ’marron’, ’vert’]
[Link]("rouge")
print(couleurs)
B. Insérer un élément à une position dans une liste:
couleurs = [’blanc’, ’noir’, ’marron’, ’vert’]
[Link](3,"gris")
print(couleurs)

Liste
C. Supprimer un élément de la liste : remove(), pop(), clear(), del

couleurs = [’blanc’, ’noir’, ’marron’, ’vert’]

[Link]("noir")
print(couleurs)
couleurs = [’blanc’, ’noir’, ’marron’, ’vert’]
[Link]() # supprime le dernier élément
print(couleurs)
[Link](1) # supprime le deuxième élément
[Link]() # vide la liste
print(couleurs)
 12/30/202

Liste

D. Quelques opérations sur les listes

couleurs = ['blanc', 'noir', 'marron', 'vert']
couleurs1 = ['rose', 'bleu']
a=couleurs+couleurs1 # concaténation des deux listes
print(a)
b=couleurs*2 # duplication de la liste
print(b)

Les listes : Création de liste avec range

• La fonction range() génère une liste de nombres entiers de valeurs
croissantes avec un pas égal à 1 (par défaut)
• range() attend toujours trois arguments: range(from,to,step=1)
• FROM est la première valeur à générer,
• TO est la dernière (ou plutôt la dernière + un),
• STEP le « pas » à sauter pour passer d'une valeur à la suivante.
S'ils ne sont pas fournis, les paramètres FROM et STEP
prennent leurs valeurs par défaut, qui sont respectivement 0 et 1.
 12/30/202

Liste

E. Tranches
L’avantage des listes est la possibilité de sélectionner une partie d’une liste en utilisant un indiçage
construit sur le modèle [n:m] pour récupérer tous les éléments ou une tranche de la liste.
Exemple:
couleurs = ['blanc', 'noir', 'marron', 'vert’]
print(couleurs[0:2])
nombre=[0,1,2,3,4,5,6,7,8,9]
print(nombre[ : :2]) # pas +2
print(nombre[ : :3]) #pas +3

Liste

E. Minimum, maximum et somme d’une liste

Les fonctions min(), max() et sum() renvoient respectivement le minimum, le
maximum et la somme d’une liste passée en argument.
liste = list ( range (10))
sum ( liste )
45
min ( liste )
0
max ( liste )
9
 12/30/202

Liste

Liste
len():
animaux = ["chat", "chien", "oiseau"] insert():
nombres = [1, 3, 4]
print(len(animaux)) # 3 [Link](1, 2)
append(): Ajoute un élément (chaîne ou entier) print(nombres) # [1, 2, 3, 4]
à la fin de la liste. remove():
nombres = [1, 2, 3] animaux = ["chat", "chien", "oiseau", "chat"]
[Link]("chat")
[Link](4) print(animaux) # ['chien', 'oiseau', 'chat']
print(nombres) # [1, 2, 3, 4] pop():
extend(): Ajoute plusieurs éléments à la fin de la nombres = [1, 2, 3]
liste. dernier = [Link]()
print(dernier) # 3
animaux = ["chat", "chien"] print(nombres) # [1, 2]
[Link](["oiseau", "souris"])
print(animaux) # ['chat', 'chien', 'oiseau', 'souris']
 12/30/202

Liste
remove(): index():
animaux = ["chat", "chien", "oiseau", "chat"] nombres = [1, 2, 3, 2]
index = [Link](2)
[Link]("chat")
print(index) # 1
print(animaux) # ['chien', 'oiseau', 'chat']
count():
animaux = ["chat", "chien", "oiseau"]
animaux = ["chat", "chien", "oiseau", "chat"]
pop(): nombre_chats = [Link]("chat")
dernier = [Link]() print(nombre_chats) # 2
print(dernier) # 'oiseau' sort():
print(animaux) # ['chat', 'chien'] nombres = [3, 1, 4, 1, 5]
[Link]()
clear():
print(nombres) # [1, 1, 3, 4, 5]
animaux = ["chat", "chien", "oiseau"] reverse():
[Link]() nombres = [1, 2, 3]
print(animaux) # [] [Link]()
print(nombres) # [3, 2, 1]

Liste

copy():
animaux = ["chat", "chien", "oiseau"]
copie_animaux = [Link]()
print(copie_animaux) # ['chat', 'chien', 'oiseau']
 12/30/202

Exercice 1 :
Créez une liste vide appelée couleurs.
Ajoutez trois couleurs à cette liste (par exemple, "rouge", "bleu", "vert").
Supprimez la première couleur de la liste.
Affichez la liste mise à jour.
Exercice 2 :
Créez une liste de nombres appelée nombres contenant les éléments suivants :
[3, 5, 7, 9, 5, 3, 5, 3].
Comptez le nombre de fois que le nombre 3 apparaît dans la liste.
Affichez le résultat.

Exercice 3 :
Créez une liste de fruits appelée fruits avec les éléments suivants : ["pomme", "banane",
"orange", "kiwi"].
Trouvez l'indice du fruit "orange".
Exercice 4 :
Créez une liste de nombres appelée scores contenant les éléments suivants : [15, 42, 23, 8, 34].
Triez cette liste dans l'ordre croissant.
Inversez l'ordre des éléments de la liste triée.
Calculez la somme des éléments de la liste.
Calculez la moyenne des éléments de la liste
 12/30/202

Les tuples
Un tuple est une collection ordonnée et non modifiable . En Python, les n-uplets sont écrits avec
des parenthèses ().
Exemple:
tuple1= (85, 3, [‘a’, 11])
print(tuple1)

 Remarque
q Les tuples s'utilisent comme les listes mais leur parcours est plus rapide.
q Ils sont utiles pour définir des constantes.

Les tuples

Modifier un élément d'un tuple:

tuple1= (9, 'z', [7, 11])
print(tuple1)
 12/30/202

Les tuples

Parcourir un tuple:
tuple2=(‘noir’,’blanc’,’vert’)
for x in my_tuple:
print(x)

Test d'appartenance à un tuple:

tuple2=(‘noir’,’blanc’,’vert’)
if ‘blanc' in my_tuple:
print(“le blanc appartient à my_tuple")

Les tuples

v Nombre d'éléments d'un tuple

tuple2=(‘noir’,’blanc’,’vert’)
print(len(tuple2))
v Supprimer le tulpe entier
tuple2=(‘noir’,’blanc’,’vert’)
del tuple2
print(tuple2)
v Nombre d'occurrence d'une valeur dans un tuple
t=(1,5,8,4,87,4,3,4)
print([Link](4))
 12/30/202

Les tuples

v Première occurrence d'une valeur dans un tuple

t=(1,5,8,4,87,4,3,4)
print([Link](4))

Exercice 1 :
Créez un tuple appelé mois contenant les noms des 12 mois de l'année : "Janvier", "Février", "Mars",
"Avril", "Mai", "Juin", "Juillet", "Août", "Septembre", "Octobre", "Novembre", "Décembre".
Affichez le premier et le dernier mois de l'année en utilisant l'indexation des tuples.
Utilisez le slicing pour afficher les trois premiers mois.
 12/30/202

Les ensembles : la classe set

q Un ensemble est une collection non ordonnée et non indexée. En Python, les ensembles sont écrits avec
des accolades.
q Les éléments d'un ensemble apparaîtront dans un ordre aléatoire.
my_set={'5','45','5','noir'}
type(my_set)
print(my_set)
- Parcourir un ensemble :
my_set={'5','45','5','noir'}
for x in my_set:
print(x)

Les ensembles : la classe set

- Tester si un élément appartient à un ensemble:

my_set={'5','45',’15','noir'}
'noir' in my_set
- Ajouter un élément à un ensemble :
my_set ={'5','45',’52','noir'}
my_set.add(‘bleu')
print(my_set)
- Ajouter plusieurs éléments à l'ensemble
my_set ={'5','45',’52','noir'}
my_set.update(('bleu','gris'))
print(my_set)
 12/30/202

Les ensembles : la classe set

Supprimer un élément
my_set ={'5','45','15','noir'}
my_set.remove("5")
print(my_set)

Autres méthodes de la classe set

 12/30/202

Exercice:
- Créez un ensemble appelé etudiant1 contenant les compétences suivantes :
"Python","Java","SQL",JavaScript","HTML"
- Créez un autre ensemble appelé etudiant2 contenant les compétences suivantes :
"JavaScript", "HTML", "CSS", "React"
Écrivez un programme pour :
Afficher les compétences de l’étudiant1.
Trouver et afficher les compétences communes entre les deux ensembles.
Ajouter une nouvelle compétence, "Django", à l'ensemble etudiant2.
Afficher l'ensemble mis à jour des compétences du développeur.

Les dictionnaires

q Les dictionnaires sont des collections non ordonnées d’objets.

q Les dictionnaires se révèlent très pratiques lorsque vous devez

manipuler des structures complexes à décrire et que les listes
présentent leurs limites.

q Un dictionnaire est une collection non ordonnée, modifiable et indexée de couples cle :
valeur entourée d’accolades.

q Les couples de cle : valeur n’occupent pas un ordre immuable, leur emplacement est géré
par un algorithme utilisant les fonctions de hachage.
 12/30/202

Les dictionnaires

- Une clé pourra être alphabétique, numérique ou tout type hachable. Les valeurs
pourront être des valeurs numériques, des séquences, des dictionnaires, mais aussi des
fonctions, des classes ou des instances.
- Exemple:
etat = {}
etat [" nom "] = " xxxx "
etat [" prenom "] = "yyyy"
etat [" age "] = 22
print(etat)
Exécution : {' nom ': ' xxxx ', ' prenom ': 'yyyy', ' age ': 22}

Les dictionnaires

- Accès aux éléments d'un dictionnaire en utilisant le nom de la clé:

dictionnaire={"nom": 'xxxx', "age": 27}
print(dictionnaire['nom'])
print(dictionnaire['age’])
- Accès aux éléments d'un dictionnaire par la méthode get:
dictionnaire={"nom": 'xxxx', "age": 27}
print([Link]('nom'))
print([Link]('age'))
 12/30/202

Les dictionnaires

- Ajout d'un élément au dictionnaire:

dictionnaire={"nom": 'xxxx', "age": 27}
dictionnaire['sexe']='homme’
print(dictionnaire)
- Suppression d'un élément du dictionnaire: del
dictionnaire={"nom": 'xxxx', "age": 27}
dictionnaire['sexe']='homme'
print(dictionnaire)
del dictionnaire['sexe']
print(dictionnaire)

Les dictionnaires

- Suppression d'un élément du dictionnaire par: popitem()

dictionnaire={"nom": 'xxxx', "age": 27}
dictionnaire['sexe']='homme'
print(dictionnaire)
[Link]()
print(dictionnaire)
- Vidage du dictionnaire: clear()
dictionnaire={"nom": 'xxxx', "age": 27}
[Link]()
print(dictionnaire)
 12/30/202

- Création d'un dictionnaire par le constructeur dict () :

dictionnaire=dict(nom='xxxxc',prenon= 'xxxxb', age= 27)
print(dictionnaire)

- Suppression du dictionnaire par del:

dictionnaire=dict(nom='xxxxc',prenon= 'xxxxb', age= 27)
del dictionnaire
print(dictionnaire)

Les dictionnaires

- Modifier un élément d'un dictionnaire :

dictionnaire={"nom": 'xxxx', "age": 27}
print(dictionnaire)
dictionnaire['nom']="hicham"
dictionnaire['age']=21
print(dictionnaire)
- Parcourir un dictionnaire pour afficher ses clés :
dictionnaire={"nom": 'xxxx', "age": 27}
for x in dictionnaire:
print(x)
 12/30/202

- Parcourir un dictionnaire pour afficher ses valeurs :

dictionnaire={"nom": 'xxxx', "age": 27}
for x in dictionnaire:
print(dictionnaire[x])
- Afficher les valeurs d'un dictionnaire en utilisant la méthode values():
dictionnaire={"nom": 'xxxx', "age": 27}
for x in [Link]():
print(x)
- Parcourir les clés et les valeurs d'un dictionnaire en utilisant la méthode items():
dictionnaire={"nom": 'xxxx', "age": 27}
for x,y in [Link]():
print(x,y)

Les dictionnaires

dictionnaire={"nom": 'xxxx', "age": 27}

for x in dictionnaire:
print(x,dictionnaire[x])

- Vérifier si une clé existe dans le dictionnaire:

dictionnaire={"nom": 'xxxx', "age": 27}
if 'nom' in dictionnaire:
print("existe")
 12/30/202

Exercice 1 :
Créez un dictionnaire appelé carnet_adresses qui contient les informations suivantes pour trois
contacts :
Nom : "amine", "hicham", "Nora"
Téléphone : "06123456789", "06987654321", "066147258369"
Email : "amine@[Link]", "hich@[Link]", "nora@[Link]"
Écrivez un programme pour :
Afficher les informations de chaque contact.
Ajouter un nouveau contact : "yassine", "06771234567", "yas@[Link]".
Modifier le numéro de téléphone de "Nora" en "0655555555".
Supprimer le contact "hicham".
Afficher le carnet d'adresses mis à jour

Test if - [elif] - [else]

 Exemple: note<10 : ajournée

x = 10 10<=note<12 : passable
12<=note<14 : A.B
if x < 0:
print("x est négatif") 14<=note<16: B
16<=note<18: T.B
elif x % 2 != 0:
print("x est positif et impair")
else:
print("x n’est pas négatif et est pair")
 12/30/202

Test if - [elif] - [else]

 Exemple 2:
liste=[3,12,13,14,11]
for i in liste:
if i%2==2:
print(i, " est pair")
else :
print(i," est impair")
 Exemple 3
a=15
b=13
if a%2!=0 and b%2!=0 :
print(a," et ",b," sont impaires")

Les boucles

 Python propose deux sortes de boucles.

- Répéter : while : Répéter une portion de code tant qu’une
expression booléenne est vraie.
i=1
while i < 10:
print(i)
i = i+1
- Parcourir : for : Parcourir un itérable.
for x in range(10):
print(x)
 12/30/202

Les boucles

Exemple: Boucle while

n = int(input('Entrez un entier [1 .. 10] : '))

while not(1 <= n <= 10) :
n = int(input('Entrez un entier [1 .. 10], S.V.P. : '))

Les boucles

 La boucle for est utilisée pour parcourir une séquence (une liste, un tuple, un dictionnaire,
un ensemble ou une chaîne de caractères).
Exemple: boucle for
caracter=["a","b","c","d","e","f"]
for x in caracter:
print(x)
for x in "je suis libre":
print(x)
 12/30/202

Les boucles

for x in range(10,12): #range(10,12) correspond aux valeurs comprises entre 10 et 11.

print(x)

for x in range(1,100,10): #range(1,100,10) correspond aux valeurs comprises entre 1 et 100 par un pas de 10.

print(x)

Les boucles

Imbrication de boucle:
for x in range(3):
for y in range(5):
print(x," ",y)
 12/30/202

Les boucles

 interrompre une boucle : break

for x in range(1, 11):
if x == 5:
break
print(x, end=“ ")

i=1
while i < 10:
print(i,end=" ")
if i == 4:
break
i += 1

Les boucles

 Court-circuiter une boucle : continue

for x in range(1, 11):
if x == 5:
continue
print(x, end=“ ")
 12/30/202

Les fonctions
 Les fonctions ont un grand avantage de découper le programme en blocs aux spécifications bien
précises.

 L'instruction def définis une nouvelle fonction, elle est suivie du nom de la fonction et se termine
par ":". Le code se trouvant sous une instruction "def" devra être indenté d'une fois au moins

 l’instuction def est une instruction exécutable, elle génère un nouvel objet portant le nom fourni.

 Syntaxe :

def ma_fonc():
... <instruction>

Les fonctions

- Si la fonction retourne une valeur on utilise le mot clé return.

 Exemple:
def ma_fonction(x):
f=1
for i in range(1,x+1):
f=f*i
return (f)
x = input("Un nombre entier : ")
x=int(x)
z= ma_fonction(x)
print(z)
 12/30/202

Les fonctions

En python les fonctions peuvent renvoyer plusieurs valeurs:

import math
def cos_sin(x):
return [[Link](x),[Link](x)]
print(cos_sin(0))

Les fonctions

Python renvoie un tuple ou une liste de deux arguments (ou plus) est
notamment très pratique si on veut utiliser l’affectation multiple.
import math
def cos_sin(x):
return [Link](x),[Link](x)
x,y=cos_sin(0)
print(x," ",y)
 12/30/202

Les fonctions

Arguments d'une fonction:

Il est possible de passer des arguments sous plusieurs formes, la méthode la plus
simple consiste à envoyer les valeurs voulues par la fonction en respectant leurs
nombres et leurs types.

Exemple:
def fonction(arg_un=0, arg_deux=2, ..., narg=‘Bonjour'):

Les fonctions
Les variables globales:
une "déclaration" global doit se faire dans une fonction pour que la variable puisse être
utilisée depuis un autre bloc.
Exemple:
def element_negatif(liste):
nb=0
for x in liste:
if x>0:
nb+=1
return(nb)
maliste=[2,-9,-8,3,-1,4]
print(element_negatif(maliste))
 12/30/202

Les fonctions
Exemple :
def puissance(x,y):
f=1
for i in range(1,y+1):
f=f*x
return (f)
x = input("Un nombre entier : ")
x=int(x)
y = input("Un nombre entier : ")
y=int(y)
z= puissance(x,y)
print(z)

Les fonctions
La récursivité :
def fact(n):
if (n<=1):
return(1)
else :
return(n*fact(n-1))
x = input("Un nombre entier : ")
x=int(x)
print(fact(x))
 12/30/202

Les fonctions
Lambda
Outre l'instruction def, Python offre une autre forme pour créer des objets
fonctions, il s'agit de l'expression "lambda" .

Syntaxe: f = lambda x, y, z :

Lambda est une expression, et non une fonction.

Le corps de lambda est similaire à ce que l'on place dans l'instruction return du
bloc def.

Les fonctions

Une fonction lambda est une petite fonction anonyme qui peut prendre n'importe
quel nombre d'arguments, mais ne peut avoir qu'une seule expression.

Exemple: Lamda Exemple: def

f=lambda x,y,z: x+y+z def fonc(x,y,z):

print(fonc(1,3,3)) return x+y+z

print(fonc(1,2,3))
 12/30/202

Ex1:
dataset= [("kamal", 20), ("Mohamed", 21), ("karim", 32),("karima", 22),("Intissar", 50),("Ahmed",
36),("Ali", 40)]

- classer les personnes selon leurs ages

- filtrer les personnes ayant plus de 30 ans
- filtrer les personnes ayant un age entre 20 et 36ans
-Filtrer les personnes avec un âge supérieur à 30 ET un nom qui commence par "A"
- Filtrer uniquement les personnes autorisées #autorisations = ["Mohamed", "Ahmed", "Ali"]

- Filtrer selon plusieurs conditions :âge et initiale du nom(startswith(‘’).

dataset = [("kamal", 20), ("Mohamed", 21), ("karim", 32), ("karima", 22), ("Intissar", 50), ("Ahmed", 36),
("Ali", 40)]
# Filtrer les personnes avec un âge supérieur à 30 ET un nom qui commence par "A"
filtrer = filter(lambda x: x[1] > 30 and x[0].startswith("K"), dataset)
print(list(filtrer))
Filtrer à partir d'un autre critère (par exemple, une liste d'autorisation)
dataset = [("kamal", 20), ("Mohamed", 21), ("karim", 32), ("karima", 22), ("Intissar", 50), ("Ahmed",
36), ("Ali", 40)]
autorisations = ["Mohamed", "Ahmed", "Ali"]
# Filtrer uniquement les personnes autorisées
filtrer = filter(lambda x: x[0] in autorisations, dataset)
print(list(filtrer))
 12/30/202

dataset = [
{"nom": "kamal", "age": 20, "ville": "Casablanca"},
{"nom": "Mohamed", "age": 21, "ville": "Rabat"},
{"nom": "karim", "age": 32, "ville": "Tanger"},
{"nom": "Ahmed", "age": 36, "ville": "Fès"}
]

Filtrer les personnes vivant à Rabat ou Fès

filtrer = filter(lambda x: x["ville"] in ["Rabat", "Fès"], dataset)

print(list(filtrer))

l = ['younes', 'kamal']
l_majuscule = list(map(lambda nom: [Link](), l))
print(l_majuscule
 12/30/202

Les fonctions
Passage par valeur et passage par référence:

q Passage par valeur : signifie qu'on passe à la fonction lors de son appel, non pas
la référence de l'argument mais seulement sa valeur (une copie de l'argument).

q Passage par référence : signifie qu'on passe à la fonction lors de son appel une
référence de l'argument, donc essentiellement les deux références partagent la
même zone mémoire.

 En Python, tous les passages de paramètres se font par référence.

Les fonctions
Exemple:
def fin(L,a):
[Link](a)
L=[4,7,1,3]
fin(L,10)
print(L)
 12/30/202

Les Modules
o Les modules sont des programmes Python qui contiennent des
fonctions que l’on est amené à réutiliser souvent (on les appelle
aussi bibliothèques ou librairies).
o Les développeurs de Python ont mis au point de nombreux
modules qui effectuent une quantité phénoménale de tâches.
o prenez toujours le réflexe de vérifier si une partie du code que
vous souhaitez écrire n’existe pas déjà sous forme de module.
o La plupart de ces modules sont déjà installés dans les versions
standards de Python
o Exemple 1:
import random
random . randint (0, 500)

Les Modules

Exemple 2:
import random
random . randint (0, 1550)
dir(random)
help([Link])

- l’instruction import donne accès à toutes les fonctions du module random

- la fonction randint(0, 1550) du module random renvoie un nombre
entier tiré aléatoirement entre 0 inclus et 1550 inclus.
 12/30/202

Les Modules
- On peut importer une fonction spécifique d’un module donné grâce à l’instruction from.
Exemple 3:
from random import randint

randint (0 ,1550)

- On peut également importer toutes les fonctions d’un module :

Exemple 4:

from random import *

x = [1, 2, 3, 4]
shuffle (x)
print(x)
x= [2, 3, 1, 4]
shuffle (x)
print(x)
randint (0 ,50)

Les Modules
Exemple 4: Module os pour l’interaction avec le système
d’exploitation
- Tester l’existence d’un fichier sur votre disque dur.
import sys
import os
if os. path . exists ("[Link] "):
print ("le fichier est present ")
else :
[Link] (" le fichier est absent ")
 12/30/202

Les Modules
Exemple 5: Création d’un module
Créer un script python portant le nom « [Link]" contenant le code suivant:
x=input("donner un nombre")
x=int (x)
y=input("donner un nombre")
y=int (y)
z=x+y
print(x,"+",y,"=",z)
- Importer le module master en tapant:
import master
help(master)

Les Modules
Les docstrings:
- Lorsqu’on écrit un module, il est important de créer de la documentation
pour expliquer ce que fait le module et comment utiliser chaque fonction.

- Les commentaires (entre triple guillemets) situés en début de module et sous

chaque fonction s'appellent les docstrings. Ces docstrings permettent
notamment de fournir de l'aide Lorsqu'on invoque la commande help() :
 12/30/202

Les exceptions
- Les langages de programmation comme Python contiennent un système de gestion des
exceptions.
- Une exception est définie comme une anomalie de l’exécution d’un programme
requérant une action spéciale, en général l’arrêt de l’exécution.
- Une exception correspond à une erreur que Python rencontre lorsqu’il tente
d’exécuter les lignes de code qu’on lui soumet.
Exemple:

Les exceptions
- L’erreur provient de la fonction int() qui n’a pas pu convertir la chaîne
de caractères "gh" en nombre entier. En termes plus techniques, on dira
que « Python a levé une exception de type ValueError ».
- Il y a de nombreux types d’exceptions différents.
- Le bloc try : permet de tester si un bloc de code contient des erreurs.
- Le bloc except : permet de gérer l'erreur.
- Le bloc finally : permet d'exécuter un code, quel que soit le résultat des blocs try et
except.
try:
#bloc try
except:
# bloc except
finally:
#bloc finally
 12/30/202

Les exceptions
Exemple:
try:
x = int(input (" Entrez un nombre entier : "))
print(x)
except:
print("vous n'avez pas entré un entier")

 L’exception levée par la fonction int() (qui ne peut pas convertir "hg"
en nombre entier) est interceptée et déclenche l’affichage du message
d’avertissement.

Les exceptions
- Exemple :
while True :
try:
x = int(input (" Entrez un nombre entier : "))
print(x)
break
except:
print("vous n'avez pas entré un entier")
print("Entrez un nombre entier :")
 12/30/202

Les exceptions
- Division par zéro : ZeroDivisionError
Exemple:
def div(a,b):
try:
print(a/b)
except ZeroDivisionError:
print("Vous avez une division par zéro")
print("continuer")
div(4,0)

Les exceptions
 Nous testons le même exemple mais avec une erreur dans le type d’un
argument.
 12/30/202

Les exceptions
 Solution:

Les exceptions

- On peut déclencher une exception, on utilisant l'instruction raise:

Exemple:
 12/30/202

Les fichiers
- Python a plusieurs fonctions pour créer, lire, mettre à jour et supprimer des fichiers.
- La fonction principale pour manipuler les fichiers en Python est la fonction open().
- La fonction open() prend 8 paramètres dont les trois premiers sont: nom de fichier,
mode d'ouverture de fichier et encodage utilisé.
- Il existe quatre modes différentes pour ouvrir un fichier:
- "r" (read) : Ouvre un fichier en lecture, erreur si le fichier n'existe pas
- "a" (append): Ouvre un fichier en mode ajout, crée le fichier s'il n'existe pas.
- "w" ( Write) : Ouvre un fichier en écriture, crée le fichier s'il n'existe pas.
- "x" (Create) - Crée le fichier spécifié et renvoie une erreur si le fichier existe.

Les fichiers
- Création d’un fichier:
Pour créer un nouveau fichier en Python, on utilise la fonction open() avec l'un des paramètres
suivants:
-"x" : crée un fichier, renvoie une erreur si le fichier existe;
-"a" : crée un fichier si le fichier spécifié n'existe pas;
-"w" :crée un fichier si le fichier spécifié n'existe pas.
Exemple: création d’un fichier avec le mode "w"
f=open("[Link]","w",encoding="utf8")
for i in range(10):
[Link]("fichier "+str(i)+"\n")
[Link]()
 12/30/202

Les fichiers

Exemple: si on veut ajouter dans le même fichier : mode "a"

f=open("[Link]","a",encoding="utf8")
for i in range(10,50):
[Link]("fichier "+str(i)+"\n")
[Link]()

Les fichiers
Exemple: Le mode "x"
 On ouvre le fichier crée précédemment avec le mode "x":
 12/30/202

Les fichiers
La lecture d’un fichier:
 Pour ouvrir un fichier en lecture, on utilise le mode "r":
f=open("[Link]","r",encoding="utf8")

 En python, il y a plusieurs méthodes pour lire un fichier: Read, readline, readlines

- read:(n) : retourne n caractère du fichier à partir de la position courante.

- readline(): lit une ligne et la retourne.

- readlines(): retourne toutes lignes dans une liste.

Les fichiers
Exemple :read()
f=open("[Link]","r",encoding="utf8")
print([Link](9))
[Link]()

Exemple : readline()
 12/30/202

Les fichiers
Exemple : readlines()

f=open("[Link]","r",encoding="utf8")
print([Link]())
[Link]()

Les fichiers
 On peut également ouvrir un fichier en utilisant une boucle:
Exemple:

f=open("[Link]","r",encoding="utf8")
for line in f:
print(line)
[Link]()
 12/30/202

Les fichiers
Suppression d'un fichier:
- Pour pouvoir supprimer un fichier, il faut importer le module os.
- Avant de le supprimer, il faut vérifier que le fichier existe pour ne pas générer Une erreur.
Exemple:

Les fichiers
 Si on exécute le même programme:
 12/30/202

Les fichiers
Gestionnaires de contexte Python

 Un gestionnaire de contexte, en Python, est un mécanisme d'acquisition et de libération de ressources

qui empêche les fuites de ressources et garantit que les actions de démarrage et de nettoyage (sortie)
sont toujours effectuées.

 Une ressource est fondamentalement un composant informatique à disponibilité limitée, par exemple
des fichiers, des sockets réseau, etc. Le fait de refuser de libérer une ressource lorsqu'un processus a
fini de l'utiliser est appelé fuite de ressource . Un exemple serait de laisser un fichier ouvert après y
avoir écrit, rendant ainsi impossible à d'autres processus de l'acquérir.

Les fichiers
 Exemple:
with open("[Link]","r",encoding="utf8") as f:
for line in f:
print(line)

 Le fichier sera ouvert et fermé avec le contexte manager.

 12/30/202

Programmation Orientée Objet

La POO est un paradigme de programmation qui repose sur des objets

et leurs interactions. En Python, presque tout est un objet. La POO
permet d’organiser le code de manière modulaire et réutilisable en
regroupant les données (attributs) et les fonctions (méthodes) dans des
classes

Les classes et les objets

- Python est un langage de programmation orienté objet.

- En Python, tout est objet et chaque objet a ses propriétés et ses méthodes.

- Une classe est comme un constructeur d'objets ou un modèle pour créer des objets.

- Pour créer une classe, on utilise le mot-clé class:

 12/30/202

Avantages de la POO
Réutilisabilité : Le code est structuré en classes, ce qui facilite la
réutilisation et la maintenance.
Lisibilité : Les classes regroupent les données et les comportements liés.
Évolutivité : Facile d'ajouter de nouvelles fonctionnalités via des sous-
classes.
Modularité : Les objets permettent de diviser le code en blocs
indépendants.

Concepts fondamentaux de la POO

Classe :Une classe est un modèle ou un plan qui définit les propriétés et
comportements d'un objet.
Objet : Un objet est une instance concrète d'une classe.
Encapsulation : Regrouper des données et des méthodes qui les manipulent dans
une classe, en limitant l'accès direct pour protéger les données.
Héritage : Une classe peut hériter des attributs et méthodes d'une autre classe
(classe parent).
Polymorphisme : Permet aux objets de différents types d'être traités de manière
uniforme.
Abstraction : Cacher les détails d'implémentation et ne montrer que les
fonctionnalités essentielles.
 12/30/202

Programme orientée objet:

- Un ensemble d’objets qui communiquent entre eux par échange de messages.

- Un objet : est défini par un état et un comportement

- Un Etat : ensemble d’attributs.

- Un Comportement: un ensemble de services (fonctions) ( méthodes) que l’objet peut

exécuter.

- Dans un modèle objet pur, seules les m´méthodes d’un objet peuvent accéder aux
attributs de l’état.
 12/30/202

Exemple1:
- Un modèle à partir duquel on fabrique

un objet. class test:

x = 'master'
- Création d’objet = instanciation y = 'génie Informatique'
#Objets de la classe test
- Une classe doit fournir au moins une obj1=test()
méthode dite constructeur qui permet print(obj1.x)
print(obj1.y)
de créer des objets.

Exemple 2:
 La fonction init () : class Etudiant:
def __init__(self,nom,prenom,cin,age,note):
- Toutes les classes ont une fonction appelée init (), print("Je l'étudiant: ")
[Link]=nom
qui est toujours exécutée lorsque un objet de la classe [Link]=prenom
[Link] = cin
est crée (constructeur). [Link] = age
[Link]= note
E1 = Etudiant("votre nom","votre prenom","age","cin","note")
- La fonction init () permet d'affecter des valeurs
print([Link])
aux propriétés de l'objet ou à d'effectuer des print([Link])
print([Link])
opérations nécessaires lors de la création d'un objet print([Link])
print([Link])
 12/30/202

Exemple 3:
 Méthodes d'objets: class Etudiant:
def __init__(self,nom,prenom,cin,age,note):
[Link]=nom
- Les objets peuvent également contenir [Link]=prenom
[Link] = cin
des méthodes. Les méthodes de l'objet [Link] = age
[Link]= note
sont des fonctions qui appartiennent à def affiche(self):
print("Cin: ",[Link])
l'objet. print("Name : ",[Link])
print("Cin: ",[Link])
print("Name : ",[Link])
print("Note : ",[Link])
E1 = Etudiant("younes", "CHIHAB",18,15,12)
[Link]()

 Le paramètre self: class Etudiant:

def __init__(self,nom,prenom,cin,age,note):
- Le paramètre self est une référence à [Link]=nom
l'objet lui même d’une classe et est utilisé pour [Link]=prenom
[Link] = cin
accéder aux variables qui appartiennent à la [Link] = age
[Link]= note
classe.
def affiche(self):
print("Cin: ",[Link])
- Il n'a pas besoin d'être nommé self, on peut
print("Name : ",[Link])
l'appeler comme on veut, mais ça doit être le print("Cin: ",[Link])
print("Name : ",[Link])
premier paramètre de n'importe quelle fonction print("Note : ",[Link])
de la classe: E1 = Etudiant("younes", "CHIHAB",18,15,12)
[Link]()
 12/30/202

class Etudiant:
 Le paramètre self: def __init__(self,nom,prenom,cin,age,note):
[Link]=nom
[Link]=prenom
[Link] = cin
[Link] = age
Exemple:4 [Link]= note
def affiche(self):
print("Cin: ",[Link])
print("Name : ",[Link])
print("Cin: ",[Link])
print("Name : ",[Link])
print("Note : ",[Link])
E1 = Etudiant("younes","CHIHAB",18,15,12)
[Link]()
print("----------------------------")
[Link](E1)

class Etudiant:
- Modifier les propriétés de l'objet: def __init__(self,nom,prenom,cin,age,note):
On peut modifier les propriétés d'un objet comme suit: print("Je suis :")
[Link]=nom
[Link]=prenom
[Link] = cin
[Link] = age
Exemple: 5 [Link]= note
def affiche(self):
print("Nom: ",[Link])
print("Prenom : ",[Link])
print("Cin: ",[Link])
print("Age : ",[Link])
print("Note : ",[Link])
E1 = Etudiant("younes","CHIHAB",18,15,12)
[Link]="master"
[Link]()
 12/30/202

class Etudiant:
def __init__(self,nom,prenom,cin,age,note):
 Supprimer les propriétés d'un objet:
print("Je suis :")
[Link]=nom
On peut supprimer les propriétés d'un objet en [Link]=prenom
utilisant del. [Link] = cin
[Link] = age
[Link]= note
def affiche(self):
Exemple: 7 print("Nom: ",[Link])
print("Prenom : ",[Link])
print("Cin: ",[Link])
print("Age : ",[Link])
print("Note : ",[Link])
E1 = Etudiant("younes","CHIHAB",18,15,12)
del [Link]
[Link]()

class Etudiant:
def __init__(self,nom,prenom,cin,age,note):
 Supprimer un objet: print("Je suis :")
On peut supprimer aussi un objet en utilisant del: [Link]=nom
[Link]=prenom
[Link] = cin
[Link] = age
[Link]= note
Exemple: 8 def affiche(self):
print("Nom: ",[Link])
print("Prenom : ",[Link])
print("Cin: ",[Link])
print("Age : ",[Link])
print("Note : ",[Link])
E1 = Etudiant("younes","CHIHAB",18,15,12)
del E1
[Link]()
 12/30/202

Afficher un objet d'une classe : __str__: Exemple: 8

class Etudiant:
- Pour pouvoir appeler print sur un objet def __init__(self,cin,name,note):
[Link] = cin
d'une classe, il faut implémenter la [Link] = name
[Link]= note
méthode spéciale __str__ : def __str__(self):
return(str([Link])+" "+[Link]+"
"+str([Link]))
E1 = Etudiant("E1","xxxxxx",25)
E2 = Etudiant("E2","yyyyyyy",21)
print(E1)
print(E2)

- Calculer le nombre d'éléments d'un objet d'une classe : class Etudiant:

__len__: def __init__(self,cin,name,note):
[Link] = cin
Pour pouvoir appeler la fonction len sur un objet d'une classe, il faut
[Link] = name
implémenter la méthode spéciale __len__ :
[Link]= note
def __str__(self):
return(str([Link])+" "+[Link]+"
Exemple: 9 "+str([Link]))
def __len__(self):
return(len([Link]))
E1 = Etudiant("E1","xxxxxxxx",18)
E2 = Etudiant("E2","yyyy",21)
print(len(E1))
print(len(E2))
 12/30/202

class Etudiant:
Test d'appartenance à un objet d'une classe : __contains__: def __init__(self, cin, name,note):
[Link] = cin
Pour pouvoir appliquer le test d'appartenance à un objet d'une classe, [Link] = name
[Link]= note
il faut implémenter la méthode spéciale __contains__: def __str__(self):
return(str([Link])+" "+[Link]+"
"+str([Link]))
Exemple: 10 def __len__(self):
return(len([Link]))
def __contains__(self,item):
return(item in [Link])
E1 = Etudiant("E1","xxxx",18)
print("a" in E1)
print("x" in E1)

- Retourner les attributs d'un objet dans un dictionnairee: __dict__:

class Etudiant:
Exemple: 11 def __init__(self, apogée,
name,note):
[Link]ée = apogée
[Link] = name
[Link]= note
def __str__(self):
return(str([Link]ée)+"
"+[Link]+" "+str([Link]))
def __len__(self):
return(len([Link]))
def __contains__(self,item):
return(item in [Link])
E1 = Etudiant("E1","xxxx",18)
print(E1.__dict__)
 12/30/202

- L'héritage est la capacité de définir une nouvelle classe qui est une version modifiée d'une
classe existante.
- Exemple: -Pour définir un tabouret:
- trois pieds.
- une assise.
- Pour définir une chaise:
- trois pieds.
- une assise
- Un dossier
- Il y a des points communs non ? Une chaise n'est rien d'autre qu'un tabouret avec un dossier.
- Les caractéristiques permettant de définir un tabouret ou une chaise sont assimilables à des
attributs. Nous pouvons donc définir une classe « tabouret » et une classe « chaise ».
 Cependant, plutôt que d'écrire du code en doublon dans notre classe « chaise », nous allons
la faire hériter de la classe « tabouret », puis lui ajouter un attribut dossier.