27/10/2024

Programmation sous Python

Plan
• Généralités
• Entrées/sorties formatées
• Les tests et les boucles
• Les Collections
• Les Fonctions et exceptions
• Les modules et package python
• Les Fenêtres graphiques
• Le Graphisme
• Les Fichiers
• Programmation Orienté Objet en python

1
 27/10/2024

Compilation et Interprétation
- Langage interprété :

Ce que nous écrirons …

traduction/exécution ligne par ligne.

- Langage compilé :

traduit la totalité du texte

3
source en une fois Avantages ?

Python (interprété)
Certains langages modernes tentent de combiner
les deux techniques afin de garder le meilleur de chacune.
.py .pyc

très facile à interpréter

portable
Avantages:
open-source, multi–plateformes, écrit en C.
puissant et simple à utiliser, exprime des tâches complexes en
utilisant seulement quelques lignes de code.
polyvalent :
- logiciels bureautiques
- applications web
- Calculs scientifiques et numériques complexes 4

2
 27/10/2024

Installation python/windows
1 – Télécharger l’installateur Python directement depuis le site
[Link]. La dernière version le jour d’écriture des slides est :
[Link]

2- Lancer le programme d’installation et cocher « add to path »

C:\> python -V
Python 3.x.z

Installation python/Linux

Sous linux python est préinstallé par défaut. Vérifier votre

version, si c’est pas la version 3 :
$ python --version
Python 2.7.9

Installé par :
# sudo apt-get install python3
# sudo dnf install python3

Sous windows/Linux
#pip install pandas

3
 27/10/2024

IDE python gratuit

Conventions générales
• Un programme en python est nommé nom_prog.py
• Une instruction par ligne
• Un programme python doit être identé

• Un commentaire mono-ligne commence par # (au début de

la ligne ou à la fin de code)

• Un commentaire multi-lignes doit commencer et se terminer

par trois guillemets """

• Langage non déclaratif

• Pas de ++ et -- pour incrémenter/décrémenter. Python

incrémente x de 1 par x += 1 ou x = x + 1 .
8

4
 27/10/2024

l‘Indentation
• L'indentation en python n'est pas seulement esthétique mais obligatoire
• Chaque niveau d'indentation représente un nouveau bloc de code.
• Un blocs de code est construit pour les boucles, les conditions, les
fonctions et les classes.
• Il est recommandé d’utiliser quatre espaces pour l'indentation. Sinon
un minimum d'un espace est obligatoire.
• La première ligne de code Python ne peut pas être indentée.
• Ne pas mélanger les tabulations et les espaces pour l'indentation

variables

• En Python, il n’est pas nécessaire de déclarer le type de

variables mais il ne faut pas utiliser une variable à laquelle on a
affecté aucune valeur :
>>> ecole="ensa"
>>> annee=2024
>>> annee=annee+1
>>> jour=jour-1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'jour' is not defined

Pour forcer la déclaration d’une variable :

nomvar : type = val
[bool, int, float, str]
10
Ex: message : str = "Hello World"

5
 27/10/2024

Saisie (input)

x = input("saisir la valeur de x : ")

ATTENTION : la variable lue est toujours de type str. Pour la

convertir en nombre, il faut utiliser la fonction int()ou la
fonction float() :

x = int(input("saisir la valeur de x : "))

11

Affichage (print)
print("nom=",nom, end="")
print("nom=%s \n\t age=%d \n\t note=%f" %(n,a,t))
String Format(): crée variable dynamique par placeholder {}
quantite = 3
article = "ImprimanteHP"
prix = 1800
1 - Nommage
print(“Article {a} coûte {p} dirhams".format(p=prix, a= article))
2- Indexation
cmd=“je commande {2} article {0} pour {1} dirhams"
print([Link](article,prix,quantite))

3- Positionnement
cmd = "je commande{} articles {} pour {:.2f} dirhams."
print([Link](quantite, article, prix))
12

6
 27/10/2024

f-string

f"…{}……"

Les espaces réservés {} peuvent contenir des variables, des

modificateurs, des fonctions et des opérations pour formater
une chaîne.

- Variables:
prix= 59
txt = f“le prix est {prix} dirhams“

f-string

- Modificateur:
Un modificateur est inclus en ajoutant deux points :
suivis d'un type de formatage, comme :
.2f, <,>,b,o,d,h….

prix = 20.123
print(f“{prix:.2f}“)  20.12
print(f'{prix:>8}')  20.123
print(f'{prix :->8}')  --20.123
print(f'{prix :-<8}')  20.123--
print(f'{prix:->15.8f}') ----20.12300000

7
 27/10/2024

f-string

Opérations: calcul ou test

prix = 59
tax = 0.25
txt = f“Le prix est {prix + (prix * tax)} dirhams"
txt = f“Cet artile est {'Chere' if prix>50 else ' Pas chere'}“

Fonctions :
txt = f“La surface est {sqrt(2) * my_fct(30)} mètre au
carré”

test

8
 27/10/2024

range(start, stop, step)

range(5,50,10)

range(10,1,-2)

boucle for for variable in séquence:

9
 27/10/2024

boucle while

Exécution tant qu’une condition est vérifiée. Ecrire un code pour

afficher ceci :

row = 1
while row <= 5:
*
col = 1
**
*** while col <= row:
**** print('*',end='')
****** col += 1
print('')
row +=1

break

Sortie immédiate du bloc for ou while en cours.

Exemple : recherche d'une valeur 9.0 dans une liste

lstvaleurs = [12.3,9.3,18.7,8.1,4.2]
trouve = False
for val in lstvaleurs:
if val == 9.0:
trouve = True
break # Pas la peine de continuer.
if trouve:
print("La valeur est présente")

10
 27/10/2024

Les collections python

1- Tableau array
Liste non
2- Liste list Séquences
modifiable 3-Tuple tuple Ordonnées
index
4- Chaîne string
Ordonné
5- Dictionnaire dict par clé

Sans doublon Pas d’ordre

Ajout (add) 6- Ensemble set sac d’objet

Les tableaux

11
 27/10/2024

tableau

Le tableau ne peut contenir qu'un seul type d'élément. Il est de

longueurs variables. Un tableau est créer par la fonction array()
[Link]()
2 modules
[Link]()

module array

i : int
f : float
d : doule
u : caractère

Exemple(array)

import array as arr

T1 = [Link]('i')
[Link](1)
[Link](2)
[Link] ( [ 30 , 40,30 ])
print([Link](30))
print(T1)
Sortie : 2
array(‘i’, [1, 2,30,40,30])

import array as arr

T1= [Link]('d', [1.0, 1.1, 1.2, 1.3,’ensa’])
print(tableau)
# tous les méthodes de list sont disponibles
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: must be real number, not str

12
 27/10/2024

Module numpy
import numpy as np
print("marice 2x4 de 1 : ", [Link]((2,4),dtype=int)) #float par défaut
print("marice 3x3 de 0 : ", [Link]((3,3),dtype=int)) #float par défaut
print("marice identité 3x3 : ", [Link](3,3))
print("marice 3x3 de rand : ", [Link](3, 3)) # entre 0 et 1
A=[Link]([ [2,2,-3], [-2,-1,-9], [6,4,4]])
print([Link](A))
print([Link](A))
print([Link](A))
print([Link](A))
print("A est une matrice de taille :", [Link](A))
print("A est une matrice de dimension :", [Link](A))
[Link]=(1,9)
print("après redimensionnement de A: ", A) marice 2x4 de 1 : [[1 1 1 1]
[1 1 1 1]]

Numpy
import numpy as np
print("marice 2x4 de 1 : ", [Link]((2,4),dtype=int)) #float par défaut
print("marice 3x3 de 0 : ", [Link]((3,3),dtype=int)) #float par défaut
print("marice identité 3x3 : ", [Link](3,3))
print("marice 3x3 de rand : ", [Link](3, 3)) # entre 0 et 1
A=[Link]([ [2,2,-3], [-2,-1,-9], [6,4,4]])
print([Link](A))
print([Link](A))
print([Link](A))
print([Link](A))
print("A est une matrice de taille :", [Link](A))
print("A est une matrice de dimension :", [Link](A))
[Link]=(1,9)
print("après redimensionnement de A: ", A) marice 3x3 de 0 : [[0 0 0]
[0 0 0]
[0 0 0]]

13
 27/10/2024

Numpy
import numpy as np
print("marice 2x4 de 1 : ", [Link]((2,4),dtype=int)) #float par défaut
print("marice 3x3 de 0 : ", [Link]((3,3),dtype=int)) #float par défaut
print("marice identité 3x3 : ", [Link](3,3))
print("marice 3x3 de rand : ", [Link](3, 3)) # entre 0 et 1
A=[Link]([ [2,2,-3], [-2,-1,-9], [6,4,4]])
print([Link](A))
print([Link](A))
print([Link](A))
print([Link](A))
print("A est une matrice de taille :", [Link](A))
print("A est une matrice de dimension :", [Link](A))
[Link]=(1,9)
print("après redimensionnement de A: ", A) marice identité 3x3 : [[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]

Numpy
import numpy as np
print("marice 2x4 de 1 : ", [Link]((2,4),dtype=int)) #float par défaut
print("marice 3x3 de 0 : ", [Link]((3,3),dtype=int)) #float par défaut
print("marice identité 3x3 : ", [Link](3,3))
print("marice 3x3 de rand : ", [Link](3, 3)) # entre 0 et 1
A=[Link]([ [2,2,-3], [-2,-1,-9], [6,4,4]])
print([Link](A))
print([Link](A))
print([Link](A))
print([Link](A))
print("A est une matrice de taille :", [Link](A))
print("A est une matrice de dimension :", [Link](A))
[Link]=(1,9)
print("après redimensionnement de A: ", A) marice 3x3 de rand :
[[0.73027733 0.11816261 0.12234324]
[0.08726113 0.52372866 0.18307537]
[0.12085452 0.01354457 0.71866588]]

14
 27/10/2024

Numpy
import numpy as np
print("marice 2x4 de 1 : ", [Link]((2,4),dtype=int)) #float par défaut
print("marice 3x3 de 0 : ", [Link]((3,3),dtype=int)) #float par défaut
print("marice identité 3x3 : ", [Link](3,3))
print("marice 3x3 de rand : ", [Link](3, 3)) # entre 0 et 1
A=[Link]([ [2,2,-3], [-2,-1,-9], [6,4,4]])
print([Link](A))
print([Link](A))
print([Link](A))
print([Link](A))
print("A est une matrice de taille :", [Link](A))
print("A est une matrice de dimension :", [Link](A))
[Link]=(1,9)
3
print("après redimensionnement de A: ", A) -9
6
0.3333333333333333

numpy
import numpy as np
print("marice 2x4 de 1 : ", [Link]((2,4),dtype=int)) #float par défaut
print("marice 3x3 de 0 : ", [Link]((3,3),dtype=int)) #float par défaut
print("marice identité 3x3 : ", [Link](3,3))
print("marice 3x3 de rand : ", [Link](3, 3)) # entre 0 et 1
A=[Link]([ [2,2,-3], [-2,-1,-9], [6,4,4]])
print([Link](A))
print([Link](A))
print([Link](A))
print([Link](A))
print("A est une matrice de taille :", [Link](A))
print("A est une matrice de dimension :", [Link](A))
[Link]=(1,9)
print("après redimensionnement de A: ", A)
A est une matrice de taille : 9
A est une matrice de dimension : (3, 3)
après redimensionnement de A:
[[ 2 2 -3 -2 -1 -9 6 4 4]]

15
 27/10/2024

array vs numpy
import numpy as np
import array as arr

T1= [Link]('i',[1, 2, 3])

T2 = [Link]('i',[4,5,6]) array('i', [1, 2, 3, 4, 5, 6])
print(T1+T2) array('i', [4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6])
print(4*T2)

Tab1 = [Link]([1, 2, 3])

Tab2 = [Link]([4,5,6]) [5 7 9]
print(Tab1+Tab2) [16 20 24]
print(4*Tab2)

array/numpy
import numpy as np
import array as arr

T1= [Link]('i',[1, 2, 3])

T2 = [Link]('i',[4,5,6]) array('i', [1, 2, 3, 4, 5, 6])
print(T1+T2) array('i', [4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6])
print(4*T2)

Tab1 = [Link]([1, 2, 3])

Tab2 = [Link]([4,5,6]) [5 7 9]
print(Tab1+Tab2) [16 20 24]
print(4*Tab2)

T3=[Link]([6,8,0,'ensa'])
print(T3) ['6' '8' '0' 'ensa']

16
 27/10/2024

Produit matriciel
import numpy as np
# produit, somme, transposé ...
m1 = [Link]([ [1, 2, 3], [4, 5, 6] ])
m2 = [Link]([ [2, 1, 3], [3, 2, 1] ])
m3 = [Link]([ [4],[2],[1] ])

Taille de m1= 6 de m3= 3

print("taille de m1=",[Link](m1)," de m3=",
[Link](m3))
m1*m2= [[ 2 2 9]
[12 10 6]]
print("m1*m2= ",m1*m2)
[Link](m1,m3)= [[11]
print("[Link](m1,m3)= ",[Link](m1,m3)) [32]]
print("m1@m3=", m1@m3) # python 3.5 m1@m3= [[11]
[32]]
print("transposé de m1=",m1.T) transposé de m1= [[1 4]
[2 5]
[3 6]]

[Link] (Algèbre Linéaire)

m1=[Link]([[2, 1, 3], [3, 2, 1],[4, 2, 1]])
print("det(m1)= " , [Link](m1))
print("inv(m1)= " , [Link](m1))
det(m1)= -5.000000000000001
inv(m1)= [[ 0. -1. 1. ]
[-0.2 2. -1.4]
[ 0.4 0. -0.2]]

A = [Link]([[3,1], [1,2]])
B = [Link]([[9],[8]])
print("solution du système AX=B est : ",[Link](A, B))
solution du système AX=B est : [[2.]
[ 3.]]

17
 27/10/2024

Inconvénients des Tableaux

Les tableaux présentent deux inconvénients majeurs:

1- statiques : leur taille est fixée lors de la compilation. Le programmeur

est obligé de prévoir par avance quelle sera la taille maximale du tableau
dont il aura besoin.
Même si numpy offre la méthode resize() qui change la taille du tableau
: créer un nouveau tableau et copie les valeurs de l’ancien tableau dans
le nouveau puis initialise le reste à 0.
>>a=[Link]([6,7])
>>[Link](9)
>>a
array([6, 7, 0, 0, 0, 0, 0, 0, 0])

Mais il le fait pas automatiquement!!!

2- Les tableaux n’accepte que les données de même types

Les Listes

18
 27/10/2024

SLICING

Fonctions membres de la class list

nom_list.nom_fonction(arg1, arg2…)

19
 27/10/2024

Nombre d’occurence

[Link](x,start,stop) retourne la 1ère position de

x dans la liste

>>> L5=[-4,3,8,-7,10,2,10,70,80,90]
>>> [Link](10)
4
>>> [Link](10,5,8)
6

Ajout

Étendre une liste

[Link] ([v1,v2,v3,….])

>>> [Link]([70,80,90])
[-4,3,8,-7,10,2,10,70,80,90]

20
 27/10/2024

Concaténation des listes

>>> L0=[2,9]
>>> L1=[1,8]
>>> [Link](L0)
>>> L1
[1, 8, [2, 9]]
>>> len(L1)
3

Modification d’un élt

21
 27/10/2024

Suppression d’un élt

remove (val) : supprime la première occurrence de val!!

>>> L0
[2, 9, 3, 50, 9, 70, 80, 90]
>>> [Link](9)
>>> L0
[2, 3, 50, 9, 70, 80, 90]

pop (index) : Supprime et retourne l’élément d’indice index (si pas donnée le dernier)

>>[Link](1)
3
>>> L5
[2, 50, 9, 70, 80, 90]
>> [Link]()
90
>> [Link]()
80
>> L5
[2, 50, 9, 70]

Inverse, copie et destruction

[Link]() inverse la liste

>>> L5=[-4,3,8,-7,10,2,10,70,80,90]
>>> [Link]()
>>> L5
[90, 80, 70, 10, 2, 10, -7, 8, 3, -4]

[Link]() retourne une liste copie

>>> L6=[Link]()
>>> L6
[-4,3,8,-7,10,2,10,70,80,90]

[Link]() destruction complète de la liste

>>> [Link]()
>>> L6
[]

22
 27/10/2024

tri

Récap (fonctions membres de list)

[Link](x): Renvoie le nombre d’occurrence de x dans la liste.
[Link](x, start, end): Renvoie la position du premier élément x de la liste. start et
end utilisés pour limiter la recherche à une sous-séquence particulière. L'indice
renvoyé est calculé relativement au début de la séquence complète et non
relativement à start.
[Link](x): Ajoute un élément à la fin de la liste
[Link](list2): Étend liste avec les éléments de list2
[Link](i, x): Insère un élément avant la position i.
[Link](x) : Supprime la première occurrence de x.
[Link]([i]): supprime et retourne l’élément situé à la position i sinon fin
[Link](): Supprime tous les éléments de la liste
[Link](): Inverse l'ordre des éléments dans la liste.
[Link]() : Renvoie une copie superficielle de la liste.
[Link](reverse=False): tri les éléments dans la liste.

23
 27/10/2024

suppression
del list_name[index]

>>> del L5
Supprime toute la liste L5

Taille, somme min et max

Len(ist_name) ou min(list_name) ou max(list_name) ou sum(list_name)

min, max et sum

lst = [15, 9, 55, 41, 35, 20, 62, 49]

print(min(lst),max(lst),sum(lst))

Output : 9 62 286

24
 27/10/2024

tri
sorted(list_name, reverse=bool)

filtrer

filter(Fonction, List)

lst = [15, 9, 55, 41, 35, 20, 62, 49]

e=filter(lambda x: x % 2 == 0, lst)
print (list(e))
Output : [20, 62]
Syntaxe : filter(fonction, séquence)
retourne <filter object > qui est un itérable.
list(e) créer une liste de tous les éléments renvoyés.

25
 27/10/2024

Boucle sur liste

liste = [ ['ensa', 'agadir', '2024'] , ['Cours', 'python', 'version3'] ]

Comment afficher chaque élément sur une ligne comme ci-dessous:
ensa
agadir
2024
Cours
python
version3
for i in liste :
for j in i :
print(j)

Liste à partir d’une suite

Exemple

26
 27/10/2024

Liste à partir d’autres listes

liste=[………]
Listes existantes

Sélection/calcul
sur chaque élément

1ère approche res = [ …………]

Nouvelle liste
liste=[………]
res = [ ]
for elt in liste:
if condition(elt) :
[Link](calcul(elt))

Construction de nouvelle liste des carrés des valeurs impairs :

lst1 = [1,6,9,2,7,4,12,11,21,4]
lst2 = [ ]
for v in lst1:
if v%2==1 :
[Link](v**2)

Construction à partir d’autres listes

2ème approche
res=[ expression]

res = [ calcul(v) for v in liste if condition(v) ]

Nous pouvons enchaîner les niveaux de boucles...

res = [ calcul(v1,v2) for v1 in liste1 for v2 in Liste2 if condition(v1,V2) ]

27
 27/10/2024

Exemple 1

1ème approche
# carrés des nombres impairs de lst1
lst1 = [1,6,9,2,7,4,12,11,21,4]
lst2 = [ ]
for v in lst1:
if v%2==1 :
[Link](v**2)

2ème approche

# carrés des nombres impairs de lst1

lst1 = [1,6,9,2,7,4,12,11,21,4]
lst2 = []
for v in lst1:
if v%2==1:
[Link](v**2)
lst2 = [ v**2 for v in lst1 if v%2==1 ]

Exemple2

Exemple : produits xy avec x et y de 1 à 4 et x≠y

 Approche 1 : append()
res = []
for x in range(1,5):
for y in range(1,5):
if x!=y:
[Link](x*y)

[2, 3, 4, 2, 6, 8, 3, 6, 12, 4, 8, 12]

 Approche 2: expression

res = [x*y for x in range(1,5) for y in range(1,5) if x!=y]

[2, 3, 4, 2, 6, 8, 3, 6, 12, 4, 8, 12]

28
 27/10/2024

Fonction sur liste construite

Calcul de l’ordonnée max d’une liste de points

lstpoints =[(1,3),(9,2),(7,7),(8,4),(6,11),(3,9)]

max( [ pt[1] for pt in lstpoints ] )

Somme des cubes des 20 premiers nombres multiples de 7:

sum( [ x**3 for x in range(7,7*20+1,7)] )

enumerate

Fonction qui ajoute un compteur à un objet itérable. Elle permet

d’énumérer les éléments d'une séquence et leur attribuer un index à partir
de 0 :
Le résultat sera :
fruits = ['pomme', 'banane', 'orange']
0 pomme
for index, fruit in enumerate(fruits): 1 banane
print(index, fruit) 2 orange

Vous pouvez également spécifier l'indice de départ via start.

etudiants = ['lotfi', 'aloua', 'rami', 'soulaymane'] 1 => lotfi

for (index, nom) in enumerate(etudiants, start=1): 2 => aloua
print (index,"=>",nom) 3 => rami
4 => soulaymane

29
 27/10/2024

Implémentation des listes python

Implémentation interne des Listes

La liste est implémenter avec un tableau dynamique :

• Python List utilise un tableau dynamique qui contient des

références ( pointeurs en C) vers d'autres objets.

• Python utilise la stratégie surallocation pour allouer un tableau

avec plus d'espace que nécessaire.

• Lorsque le tableau dynamiqe est rempli, un nouveaux tableau

plus grand est automatiquement crée et le contenu de l'ancien
tableau est copié dans le nouveau tableau.

30
 27/10/2024

allocation automatique

Tableau A plein

étape 1 : Allouer un nouveau tableau B avec

une plus grande capacité.

étape 2 : définissez B[i] = A[i], pour i = 0,

1, ……. n-1

 étape 3 : définir A=B pour réaffecter A à B

étape 4 : Insérez le nouvel élément dans le

nouveau tableau.

Implémentation interne CPython

typedef struct {
PyObject_VAR_HEAD //macro pour les types d’objets dont la longueur varie
PyObject ** ob_item;
Py_ssize_t allocated;
}PyListObject;

Macro C : directives de préprocesseur définies à l'aide du mot-clé #define .

#define : demande au préprocesseur de remplacer un mot par une valeur dans tout le
code : simple rechercher/remplacer fait par le préprocesseur avant la compilation.

#define : permet aussi de remplacer un mot par un code source dans tous votre
projet: c’est une macro.

31
 27/10/2024

Macro C PyObject_VAR_HEAD

Exemple de macro C simple:

#include <stdio.h>
# define MAJEUR(age, nom) if (age >= 18) \
printf("Vous etes majeur %s\n", nom);

int main(int argc, char *argv[])

{
MAJEUR(22, "radi")

return 0;
}

Une macro sur plusieurs lignes de code nécessite de placer un \ avant

chaque nouvelle ligne.
Dans main() l'appel de la macro ne prend pas de point-virgule à la fin.

Implémentation interne CPython

__sizeof__() : méthode intégrée qui renvoie la taille de la mémoire d'un objet en octets

>>> list=[]
>>> - Mémoire pour les méthodes
print(list.__sizeof__()) intégrées ….
40
>>> len(list)
0

>>> list=[10, "python"]

>>> len(l)
2
>>> print(list.__sizeof__())
56 # 40+ 2*8

32
 27/10/2024

Implémentation interne

Cependant, quelque chose de différent se produit

lorsque nous essayons d'utiliser le append() :

lst = []
print(lst.__sizeof__()) #40
[Link](10)
print(lst.__sizeof__()) #72

On vient donc d'ajexterne un élément, il fallait que ce

soit 48 : 40+8 ! mais pourquoi est-ce 72 ?

Implémentation interne

CPython implémente le concept de surallocation: si

vous utilisez append() [ou extend() ou insert() ] pour
ajouter des éléments à la liste, vous aurez 4 cases
d'allocation supplémentaires y compris l'espace pour
les éléments spécifiés et cela continue dans le modèle
0, 4, 8, 16, 25, 35, 46, 58, 72, 88, … et ainsi de suite.

72=40+8*4

33
 27/10/2024

Implémentation interne
Maintenant, lorsque nous ajoutons plus d'éléments, les espaces
alloués sont d'abord remplis

lst = []
print(lst.__sizeof__()) #40
[Link](10)
print(lst.__sizeof__()) #72
[Link]([22,33,44])
print(lst.__sizeof__()) #72

Après l’ajout des 3 éléments supplémentaires la taille est

restée 72..

Implémentation interne

Lorsque la liste est pleine et que de nouveaux

éléments sont encore ajoutés à la liste à l'aide des
fonctions membre, python alloue plus d’espace avec
le modèle de redimensionnement suivant :

newsize = floor (size + (size >> 3) + (size < 9 ? 3 : 6));

newsize = floor (1.125 * size + (size < 9 ? 3 : 6));

Résultat : 0, 4, 8, 16, 25, 35, 46, 58, 72, 88 ……

size : taille de la liste plus les éléments qu’o veut ajouter.

34
 27/10/2024

Implémentation interne

Si on ajoute un nouvel élément à la liste, la liste est à

nouveau sur-allouée:

lst = []
print(lst.__sizeof__()) #40
[Link](10)
print(lst.__sizeof__()) #72
[Link]([22,33,44])
print(lst.__sizeof__()) #72
[Link](99)
print(lst.__sizeof__()) #104=40+8*8

string / tuple / dictionnaire

35
 27/10/2024

string
Les chaînes sont des cas particulier des listes (listes de caractères).

String
-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
[index]
0 1 2 3 4 5 6 7 8 9 10

(11 éléments)
EnsaAgadir
s = "EnsaAgadir"
s[4] "A" s[6:9] "adi" s[::2] "EsAai"
s[:3] "Ens" s[7:] "dir" s[::-1] "ridagAasnE"

mess = "bonjour Le Monde"

if "hour" not in mess:
print("not in")

36
 27/10/2024

tuple

Le tuple est l’implémentation en lecture seule de la liste :

collection ordonnée non modifiables d’éléments hétérogènes.

Le tuple possède les mêmes méthodes que la liste, à l’exception

de celles permettant une modification.

Les éléments du tuple doivent être emballés entre parenthèses

et délimités par des virgules :
(elem1,elem2, elem3...)
Pour accéder aux éléments du tuple on spécifie les indices
entre crochets [ ] (comme pour les listes)

Modifier un tuple ???

Comment changer les valeurs d’un tuple?

Convertir le tuple en liste et après re-convertir la liste en tuple:

x =("ensa", "esta", "encg")

y = list(x)
y [2] = "fsa"
x = tuple (y)
print(x)

Sortie : x=("ensa", "esta", "fsa")

37
 27/10/2024

Lise de tuple
Soit la liste de données démographiques

demographie = [

("Maroc", "agadir", [(2024,162),(2020,180),(2016,240)] ),

("Maroc", "casablanca", [(2024,2459),(2020,9334)] ),

("Maroc", "Fès", [(2024,301),(2020,303),(2016,462)] ),

]

Afficher la population de Fès en 2016 ????

demographie[2][2][2][1] 462

parcours d’une liste de tuple

Soit la liste des tuples (code_matière, note):

notes= [ (P3,15), (M2,5), (I1,2), (C1,18) ]

Parcourir la liste et remplacer tous les notes inférieur à la note

éliminatoire 8 par 8.

Méthode 1 : Parcours des valeurs de la liste.

notes= [ (P3,15), (M2,5), (I1,2), (C1,18) ]

for v in notes:
if v[1] <8 :
print("Limite dépassée pour matière code=", v[0] )
v[1] =8 # erreur tuple ne peut pas être modifié

38
 27/10/2024

Boucle sur une séquence (parcours par indice)

Méthode 2 : Parcours de la liste par indice

notes= [ ("P3",15), ("M2",5), ("I1",2), ("C1",18) ]

for idx in range(len(notes)):
v = notes[idx]
if v[1] <8 :
print("Limite dépassée pour matière=", v[0])
# Et là, on peut modifier via l’index
notes[idx] = (v[0], 8)
print("notes:",notes)
Limite dépassée pour code= M2
Limite dépassée pour code= I1
notes: [('P3', 15), ('M2', 8), ('I1', 8), ('C1', 18)]

Boucle sur index/valeur d’une séquence

Méthode 3 : Parcours de la liste par (index,valeur) via enumerate

notes= [ ("P3",15), ("M2",5), ("I1",2), ("C1",18) ]

for idx, v in enumerate(notes):
if v[1] <8 :
print("Limite dépassée pour code=", v[0])
# Là, on peut modifier via l’index
notes[idx] = (v[0],8)
print(" notes:",notes)

Limite dépassée pour code= M2

Limite dépassée pour code= I1
notes: [('P3', 15), ('M2', 8), ('I1', 8), ('C1', 18)]

39
 27/10/2024

dictionnaire

Le dictionnaire , de type dict en Python associe des valeurs à des

clés.

C'est un type de conteneur comme les list et les tuple mais ce

n'est pas une séquence. Au sens où ses valeurs ne sont pas
indexées.

Les clés peuvent être de type : str, int, float, tuple mais pas une
liste : une liste objet mutable, ne peut pas être une clé de
dictionnaire.

Les valeurs du dictionnaire peuvent être de n'importe quel type.

À partir d’une clé, on peut alors accéder directement à la valeur

qui lui est associée.

dictionnaire

On utilise les accolades { } pour définir les éléments du

dictionnaire, c’est-à-dire les paires clé: valeur .

{clé1:valeur1, clé2:valeur2,....}

L’accès à une valeur du dictionnaire s’effectue en lui passant

.entre crochets la clé correspondante.

Les dictionnaires n’étant pas ordonnés (non indicés par des entiers
mais par des clés), la technique du slicing n’est pas applicable

40
 27/10/2024

dictionnaire
Les méthodes .keys(), .values() et .items() retournent les séquences
des clés, les valeurs et les (clés,valeurs) respectivement.
jours={1:"lundi",2:"mardi",3:"mercredi",4:"jeudi",5:"vendredi",6:"samedi",7:"dimanche"}
print ([Link]())
print ([Link]())
print ([Link]())

dict_items([(1, 'lundi'), (2, 'mardi'), (3, 'mercredi'), (4, 'jeudi'), (5, 'vendredi'), (6, 'samedi'), (7, 'dimanche')])
dict_keys([1, 2, 3, 4, 5, 6, 7])
dict_values(['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche'])

Pour ajexterne un couple de (clé,valeur) il suffit d'écrire :

d[nouvelle_clef]=nouvelle_valeur

Exercice

On considère le dictionnaire suivant dont les clés sont les noms des élèves et les valeurs
des clés sont les moyennes générales :

etudiants = {"etudiant_1" : 13 , "etudiant_2" : 17 , "etudiant_3" : 9 , "etudiant_4" : 15 ,

"etudiant_5" : 8 , "etudiant_6" : 14 , "etudiant_7" : 16 , "etudiant_8" : 12 ,
"etudiant_9" : 13 , "etudiant_10" : 15 , "etudiant_11" : 14 , "etudiant_112" : 9 ,
"etudiant_13" : 10 , "etudiant_14" : 12 , "etudiant_15" : 13 , "etudiant_16" : 7 ,
"etudiant_17" : 12 , "etudiant_18" : 15 , "etudiant_19" : 9 , "etudiant_20" : 17 ,}

Ecrire un programme Python qui partitionne ce dictionnaire en deux sous dictionnaires:

Admis : dont les clés sont les étudiants admis et les moyennes obtenues (moyenne
supérieurs ou égales à 10 ).

Ajournes : dont les clés sont les étudiants non admis et les moyennes obtenues
(moyenne inférieur ou égale à 10).

41
 27/10/2024

correction

etudiants = {"etudiant_1" : 13 , "etudiant_2" : 17 , "etudiant_3" : 9 , "etudiant_4" : 15 ,

"etudiant_5" : 8 , "etudiant_6" : 14 , "etudiant_7" : 16 , "etudiant_8" : 12 ,
"etudiant_9" : 13 , "etudiant_10" : 15 , "etudiant_11" : 14 , "etudiant_112" : 9 ,
"etudiant_13" : 10 , "etudiant_14" : 12 , "etudiant_15" : 13 , "etudiant_16" : 7 ,
"etudiant_17" : 12 , "etudiant_18" : 15 , "etudiant_19" : 9 , "etudiant_20" : 17}

Admis = dict({})
Ajournes = dict({})

for key , valeur in [Link]():

if(valeur < 10):
Ajournes[key] = valeur
else:
Admis[key] = valeur

print("Les etudiants admis : " , Admis)

print("Les etudiants non admis : " , Ajournes)

Exercice

Soit la liste comportant différents détails sur chaque créature se

trouvant dans un aquarium.

creatures = [
{"nom" : "sammy", "espèce" : "requin", "numéro de réservoir" : "11", "type" : "poisson"},
{"nom" : "ashley", "espèce" : "crabe", "numéro de réservoir" : "25", "type" : "crustacé"},
{"nom" : "jo", "espèce" : "guppy", "numéro de réservoir" : "18", "type" : "poisson"},
{"nom" : "jackie", "espèce" : "homard", "numéro de réservoir" : "21", "type" : "crustacé"},
{"nom" : "charlie", "espèce" : "poisson-clown", "numéro de réservoir" : "12", "type" :
"poisson"},
{"nom" : "olly", "espèce" : "Tortue verte", "Numéro de réservoir" : "34", "type" : "tortue"}
]

Ecrire un programme python pour chercher un espèce via une valeur

quelconque de de ses clés saisi par l’utilisateur.

42
 27/10/2024

Réponse
creatures = [
{"nom" : "sammy", "espèce" : "requin", "numéro de réservoir" : "11", "type" : "poisson"},
{"nom" : "ashley", "espèce" : "crabe", "numéro de réservoir" : "25", "type" : "crustacé"},
{"nom" : "jo", "espèce" : "guppy", "numéro de réservoir" : "18", "type" : "poisson"},
{"nom" : "jackie", "espèce" : "homard", "numéro de réservoir" : "21", "type" : "crustacé"},
{"nom" : "charlie", "espèce" : "poisson-clown", "numéro de réservoir" : "12", "type" : "poisson"},
{"nom" : "olly", "espèce" : "Tortue verte", "Numéro de réservoir" : "34", "type" : "tortue"}
]
x=input("entrer mot de recherche")
res=[]
for v in creatures:
if x in [Link]() :
[Link](v)
print (res)

[{'nom': 'ashley', 'espèce': 'crabe', 'numéro de réservoir': '25', 'type': 'crustacé'},

{'nom': 'jackie', 'espèce': 'homard', 'numéro de réservoir': '21', 'type': 'crustacé'}]

dictionnaire

Pour copier un dictionnaire :

- on ne fera pas dic2=dic1

(les 2 variables se référant dans ce cas au même objet)!!!

- Pour une copie superficielle : dic2 = [Link]().

- Pour une copie en profondeur : dic2=[Link](dic1)

[nécessitant l’importation du module copy]

43
 27/10/2024

Exemple
jours={1:"lundi",2:"mardi",3:"mercredi",4:"jeudi",5:"vendredi",6:"samedi",
7:"dimanche"}
days=jours
days[2]="‫"الثالثاء‬
print ([Link]())
print ([Link]())
dict_values(['lundi', '‫'الثالثاء‬, 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche'])
dict_values(['lundi', '‫'الثالثاء‬, 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche'])

import copy
jours={1:"lundi",2:"mardi",3:"mercredi",4:"jeudi",5:"vendredi",6:"samedi",
7:"dimanche"}
days=[Link](jours) # days=[Link]()
days[2]="‫"الثالثاء‬
print ([Link]())
print ([Link]())
dict_values(['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche'])
dict_values(['lundi', '‫'الثالثاء‬, 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche'])

deepcopy() vs copy()
>>> dict = {'1': ‘aloua', '2': 'alami', '3': 'salimi', '4': {'age': '20', 'niveau': 'B'} }

>>> import copy as cp

>>> cop=[Link]() # ou cop=[Link](dict)

>>> deep=[Link](dict)

>>> dict["4"]["age"]='30‘

>>> dict
{'1': ' aloua ', '2': 'alami', '3': 'salimi', '4': {'age': '30', 'niveau': 'B'}}

>>> cop
{'1': ' aloua ', '2': 'alami', '3': 'salimi', '4': {'age': '30', 'niveau': 'B'}}

>>> deep
{'1': ' aloua ', '2': 'alami', '3': 'salimi', '4': {'age': '20', 'niveau': 'B'}}

44
 27/10/2024

set
set est une collection non ordonnée, itérable, mutable (add() et
remove() et pop() ) et ne comporte aucun doublant. set n’est pas
une séquence (les éléments ne sont pas ordonnés, donc non
accessibles par des indices entiers), mais ils supportent l’itération
(l’ordre n’étant cependant pas significatif).

L’intérêt de set réside dans le fait qu’on peut appliquer à ces

objets des opérations propres aux ensembles (union,
intersection, différence…), d’où le nom de sets (ensembles).

On crée un set avec la fonction set(iterable) ou en énumérant les

éléments entre accolades {elem1, elem2, elem3...}.

Pour copier les données d’un set s1, on utilisera

s2=[Link]() ou s2=[Link](s1)

set
[Link](B) : Renvoie un set contenant tous les éléments des deux
ensembles, les doublons sont exclus : opérateur |
[Link](B) : Revoie l’intersection: opérateur &
[Link](B) : crée un set avec tous les éléments qui existe uniquement
dans A mais pas dans B : opérateur -
A.symmetric_difference(B) : Inclut tous les éléments de A et B sans les
éléments communs. Opérateur ^

x = {"apple", "banana", "cherry"}

y = {"google", "microsoft", "apple"}
z={"apple"}
r = [Link](y,z) # t= x | y | z
s=[Link](y,z) # s= x & y & z
t=[Link](y,z) # t= x-y-z
p=x.symmetric_difference(y) # p= x ^ y

r {'banana', 'microsoft', 'apple', 'google', 'cherry'}

S {'apple'}
t {'banana', 'cherry'}
P {'banana', 'microsoft', 'cherry', 'google'}

45
 27/10/2024

Exercice1

Ecrire un programme Python permettant d’afficher pour

une chaine de caractères donnée, le nombre
d’occurrences de chaque caractère dans la chaine.

ch=input("entre chaine")
p=set(ch)
for car in p:
print ("caractère %c figure %d fois" %(car, [Link](car)))

Comparaison

Critères LIST TUPLE DICTIONNAIRE SET

Doublons ?? oui oui non non

Modifiable ?? oui non oui Non

juste ajout

Ordonnée ?? oui oui Non Non

Création?? [] () {} {}

46
 27/10/2024

fonction

Exercice

Soit la liste comportant différents détails sur chaque créature se

trouvant dans un aquarium.

creatures = [
{"nom" : "sammy", "espèce" : "requin", "numéro de réservoir" : "11", "type" : "poisson"},
{"nom" : "ashley", "espèce" : "crabe", "numéro de réservoir" : "25", "type" : "crustacé"},
{"nom" : "jo", "espèce" : "guppy", "numéro de réservoir" : "18", "type" : "poisson"},
{"nom" : "jackie", "espèce" : "homard", "numéro de réservoir" : "21", "type" : "crustacé"},
{"nom" : "charlie", "espèce" : "poisson-clown", "numéro de réservoir" : "12", "type" :
"poisson"},
{"nom" : "olly", "espèce" : "Tortue verte", "Numéro de réservoir" : "34", "type" : "tortue"}
]

Ecrire une fonction pour filtrer la liste cratures extraire les espèces
via une valeur quelconque val de de ses clés.

47
 27/10/2024

Réponse

def filtre(creatures, val):

def filter_func(x): # fonction de filtrage

if val in [Link]():
return True
return False

return filter(filter_func, creatures)

print(list((filtre(creatures, "crustacé"))))

[{'nom': 'ashley', 'espèce': 'crabe', 'numéro de réservoir': '25', 'type': 'crustacé'},

{'nom': 'jackie', 'espèce': 'homard', 'numéro de réservoir': '21', 'type': 'crustacé'}]

Valeur par défaut des paramètres

def table(nbr, limite=10):

for i in range(limite + 1):
print ("%i * %i = %i" %(i, nbr, i*nbr))
0*8 0
table(8) 1*8 8
2 * 8 16
3 * 8 24
4 * 8 32
5 * 8 40
…………..
10 * 8 80
Il est ici possible d’appeler la fonctions de 2 façon:

•Soit en précisant le numéro de la table et limite : table(8, 20)

•Soit en ne précisant QUE le numéro de la table : table(8)

48
 27/10/2024

Utilisation des noms des paramètres

ll est possible d’appeler les paramètres par leur nom et peu

importe l’ordre dans lequel vous les appelez.

def maFonction(a=10, b="Bonjour", c=20):

print (b, a, c)

maFonction(c=30)
maFonction(c=8, b="Hello", a=3)
maFonction()

Arguments Arbitraires : *
Il est possible de déclarer une fonction qui accepte un nombre
quelconque de paramètres : on compacte les paramètres sous
la forme d’un tuple grâce à l’opérateur *.
Par convention, on appelle généralement ce tuple args :

def moy(*args):
nb = len(args)
somme = 0
for v in args:
somme += v
return somme / nb

print(moy (4,6,8,1,23))

49
 27/10/2024

Arguments Arbitraires : **

Une fonction peut également accepter un nombre quelconque

de paramètres en compactant les paramètres sous la forme
d’un dictionnaire grâce à l’opérateur **.
Par convention, on appelle généralement ce dictionnaire kw
ou kwargs :

def afficher_params(**kwargs):
for k, v in [Link]():
print("Paramètre", k, "qui a comme valeur", v)

afficher_params(prenom="aziz", age=174, filiere="SITCN")

Arguments Arbitraires : * , **
Il est possible d’associer les deux formes de compactage est
ainsi créer une fonction qui accepte n’importe quels
paramètres :

def fonction_libre(*args, **kwargs):

for k, v in [Link]():
print("Paramètre", k, "qui a comme valeur", v)

nb = len(args)
somme = 0
for v in args:
somme += v
return somme / nb

print(fonction_libre(4,6,8,1,prenom="aziz", age=17,filiere="SITCN"))

50
 27/10/2024

décompactage des paramètres : *

def fonction(*args):
Lors de l’appel d’une fonction, il nb = len(args)
est possible d’utiliser des somme = 0
paramètres sous forme d’une for v in args:
liste. On utilise pour cela
somme += v
l’opérateur * parfois appelé
unpack operator. return somme / nb

Le décompactage est possible t=[2,6,9,1]

pour toutes les structures de u=(4,2,8)
données itérables comme les v={3,8,2,3}
listes, les tuples ou les
ensembles.
print(fonction(*t))
print(fonction(*u))
print(fonction(*v))

décompactage des paramètres: **

Nous pouvons décompacter un dictionnaire lors de l’appel avec

l’opérateur ** :

def fonct( **kwargs):

for k, v in [Link]():
print("Paramètre", k, "qui a comme valeur", v)

dict={"prenom":"aziz", "age":17,"filiere":"SITCN"}
fonct(**dict)

51
 27/10/2024

Portée des variables

Il existe deux types de variables:
- Les variables globales (accessible n’importe où dans le code)
- Les variables locales (accessible uniquement à l’intérieur d’un bloc)

Une variable local n’est pas accessible en dehors de son bloc.

def add(a):
x=3
return a+x - x n’existent que dans la fonction. Il n’existe pas
en dehors de la fonctions
- X est détruit lorsque l’on sort du bloc de la
fonction.
print(add(4))
print(x) NameError: name ‘x' is not defined

Portée des variables

Une variable globale est accessible en lecture par une fonction.

Une variable globale ne peut pas être modifiée à l’intérieur

d’une fonction (la fonction crée une variable de même nom)

x=7 x=7
def add(a): def add(a):
return a+x x=3
11
return a+x
print(add(4))
print(add(4))
7
print(x) 7

52
 27/10/2024

Portée des variables

Si elle est déclarée globale, une variable peut être
modifiée à l’intérieur d’une fonction et changer pour
l’ensemble du programme.
x=7
def add(a):
global x
x=3
return a+x

print(add(4))
7
print(x) 3

Portée des variables

Compter le nombre de fois qu’une fonction est appelée

import sys
compteur = 0

def comptage() :
global compteur
compteur = compteur + 1
print(compteur)
if compteur==3 :
[Link](0)
1
for i in range (10): 2
comptage() 3

53
 27/10/2024

Imbrication des fonctions

Pour imbriquer les fonctions, la fonction interne est

appelée depuis l'intérieur de la fonction externe.

def externe():
print(‘externe fonction’)
def interne():
print('interne fonction’)
interne()

externe() externe fonction

interne fonction

portées non locales (portée englobante)

def externe():
message = 'externe fonction' Pour la fonction interne,
print(message) python ne trouve pas
la variable message dans la
def interne(): portée locale. Python la
print(message) externe fonction recherche donc dans la portée
interne() externe fonction englobante externe.

externe()

54
 27/10/2024

portées globale

message = 'global scope'

def externe():
def interne():
print(message) Python monte jusqu'à la portée
globale pour trouver la variable
interne() global scope

externe()

Modifier variable non locale

Une variable d'une portée non locale (englobante) ne peut

pas être modifiée directement depuis une portée locale.

def externe():
message = 'externe scope'
print(message)
def interne():
message = 'interne scope'
print(message)
interne()
externe scope
print(message) interne scope
externe() externe scope

55
 27/10/2024

Modifier variable non locale

Pour modifier des variables d'une portée non locale(englobante)

dans une portée locale, utilisez le mot clé nonlocal.

def externe():
message = 'externe scope'
print(message)
def interne():
nonlocal message
message = 'interne scope'
print(message)
interne()
externe scope
print(message) interne scope
externe() interne scope

Modifier variable non locale

Nous ne pouvons pas modifier une variable globale depuis une portée locale

message = 'externe scope'

def externe():
print(message)
def interne(): Utiliser plutôt le mot clé global
nonlocal message
message = 'interne scope'
print(message)
interne() SyntaxError: no binding for nonlocal 'message' found
print(message)
externe()

56
 27/10/2024

Fonction lambda

Syntaxe
lambda arguments : une expression
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.
L'expression est exécutée et le résultat est renvoyé.

x = lambda a : a + 10

print(x(5))

Ajoutez 10 à l'argument a et renvoyez le résultat :

Lambda (I.I. et sorted)

1 – Invocation Immédiat : s’exécute dès sa création

print((lambda x : x*x*x)(10))

2- paramètre key de soted: doit être une fonction

qui prend un seul argument et renvoie une clé à
utiliser à des fins de tri.

sorted(range(-5, 6), key=lambda x: x ** 2)

[0, -1, 1, -2, 2, -3, 3, -4, 4, -5, 5]

57
 27/10/2024

Lambda avec map()

3- map() : prend une fonction et un itérable

comme arguments, puis elle applique la fonction
à chaque élément de l'itérable.

l = [1, 2, 3, 4, 5, 6]
res = list(map(lambda x: x*x, l))
res=[v*v for v in l]
print(res)

Lambda avec filter()

4- filter() prend deux arguments: une fonction qui

retourne bool et un itérable.
Un élément est ajouté à l'itérable renvoyé
uniquement lorsque la fonction renvoie True.

l = [1, 2, 3, 4, 5, 6]
res = filter(lambda x: x % 2 == 0, l)
for num in res:
print(num, end=" ")

58
 27/10/2024

Lambda avec reduce()

5- reduce() est définie dans le module « functools »:

- Les deux premiers éléments de la séquence sont sélectionnés
et le résultat de l’expression est obtenu.
- L’étape suivante consiste à appliquer la même fonction au
résultat précédemment obtenu et au nombre suivant de
l’itérable
- Ce processus continue jusqu’à ce qu’il ne reste plus d’éléments
dans le conteneur.

reduce(lambda x, y : x+y, [1, 2, 3, 4, 5])

calcule ((((1+2)+3)+4)+5)

récursivité

59
 27/10/2024

Fonction récursif
Exemple : somme des n premiers naturels.
def sum1 ( n):
result = 0
while n > 0:
result += n
n -= 1
return result

def sum2 ( n):

if n==1 :
return 1
return sum2(n-1) +n

print (sum1(10))
print (sum2(10))
print(sum([n for n in range(10)]))

Même résultat : 55
119

Fonction récursif

renvoie (1+2+3+4+5+6+7+8+9)+10

sum(10) renvoie (1+2+3+4+5+6+7+8)+9

renvoie (1+2+3+4+5+6+7)+8
appel sum(9)

sum(8)
appel ………………
.................
renvoie (1) + 2
……………….

renvoie 1
sum(2)
appel

sum(1)
appel

60
 27/10/2024

Exemple
Ecrire une fonction récursive « Binaire » permettant
d’imprimer à l’écran la représentation binaire d’un
nombre N.

def binaire(N):
if N == 0:
return []
return binaire(N//2)+[N % 2]

print(binaire(129))

Exemple

Soit un tableau X de N entiers, écrire une fonction récursive simple

permettant de déterminer le maximum du tableau en utilisant la
recherche dichotomique.

def maximum(T):
if len(T) == 1:
return T[0]
m = len(T)//2
max1 = maximum(T[:m])
max2 = maximum(T[m:])
if max1 > max2:
return max1
return max2

61
 27/10/2024

Type de passage python

def f1(x): def f2(li): def f3(li):

x=4 li[0] = 42 li = [42, 73, 0]
return x return li return li

a=3 l = [1, 2, 3] l = [1, 2, 3]

f1(a) f2(l) f3(l)
print(a) # 3 print(l) # [42, 2, 3] print(l) # [1, 2, 3]

Python semble utiliser un Python n’utilise pas le Python n’utilise pas le

passage par valeur !!!! passage par valeur!!!! passage par référence !!!!

Objet Python
Un objet python est caractérisé par:
 son identité (un entier qui identifie de manière
unique l’objet) ;
 un type (qui identifie les opérations que vous pouvez
effectuer avec votre objet)
 le contenu de l'objet.

>>obj=[1,2,3]
>>> id(obj)
2698212637504 # the identity of `obj`
>>> type(obj)
<class 'list'> # the type of `obj`
>>> obj
[1, 2, 3] # the contents of `obj`

62
 27/10/2024

Objet mutable et immutable

• Un type est mutable si vous pouvez modifier le
contenu de ses objets sans modifier son identité
et son type.

• Les listes, les dictionnaires et les set sont

mutables : ce sont des conteneurs et vous pouvez
mettre des éléments à l'intérieur et les supprimer
sans changer le type et l’id

• int, float, bool, str et tuple sont immutables.

immutable

String est immutable car une fonction qui la modifie retourne un nouveau
objet avec un noveau id:
>>> ch="ensa"
>>> id(ch)
1470285519760
>>> id([Link]())
1470285314592

Une autre façon de vérifier que string est immutable et qu’elle ne supporte
pas l’attribution par indice:
>>> ch[2]='v'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

lorsqu'une chaîne est créée, elle reste la même. Si on change la chaîne alors on crée un autre objet. De
même pour int, float , tuple, bool…

63
 27/10/2024

Python : Passage par affectation

def f1(x): def f2(li): def f3(li):

x=4 li[0] = 42 li = [42, 73, 0]
return x return li return li

a=3 l = [1, 2, 3] l = [1, 2, 3]

f1(a) f2(l) f3(l)
print(a) # 3 print(l) # [42, 2, 3] print(l) # [1, 2, 3]

x=a
id(a) = id(x) li=l li=l
id(li) = id(l) id(li) = id(l)
Mais int est imutable: Le type liste est mutable: Mais li=[42,73,0]
Si on change x alors on crée On peut changer le contenu Change l’id de li vers
un autre objet sans changer le type et id. la nouvelle liste
id(a) # id(x) car imutable

Copie superficielle
Les listes et les dictionnaires ont une méthode membre copy qui
renvoie une copie superficielle de l'objet correspondant.
Regardons un exemple avec une liste :

>>> l0=[1,2,[]] >>> l0[0]=73

>>> l1=l0 >>> l1
>>> l2=[Link]() [73, 2, []]
>>> l1 is l0 >>> l2
True [1, 2, []]
>>> l2 is l0
l2 est une autre liste (ne point pas sur l0)
False
Avec copy la liste copié n'est pas le même objet
(id) que la liste externe d'origine

64
 27/10/2024

Copie superficielle

>>> l0[2].append(99)
>>> l2
[1,2, [99]]
>>> l1
[1,2, [99]]
Lorsque nous modifions le contenu de l0,
même l2 répercute ces changements...

Le dernier élément des deux pointe vers un objet liste.

C'est le contenu (interne) de l'objet vers lequel on pointe
qui a changé!

Parfois, nous ne voulons pas que des objets mutables

partagent des objets mutables internes.

Copie profonde
Pour ne pas partager des références aux objets internes lors de la
copie, nous devons effectuer une « copie profonde » de l’objet :
comme un algorithme récursif.
Voici une implémentation récursive simple d'une copie profonde
pour les listes qui contiennent d'autres listes :

def mydeepcopy(l):
return [elem if not isinstance(elem, list) else
mydeepcopy(elem) for elem in l ]
l1 = [42, 73, []]
l2= mydeepcopy(l1)
l1= [42, 73, [73]]
l1[2].append(73) l2= [42, 73, []]
print("l1=", l1)
print("l2=", l2)

65
 27/10/2024

deepcopy() du module Copy()

Malheureusement, notre méthode mydeepcopy() n'est pas
très robuste, ni générique, mais la bibliothèque standard
Python nous couvre !

Le module copy fournit deux fonction

[Link] : pour les copies superficielles
[Link] : pour les copies profondes

La méthode [Link]() est suffisamment intelligente

pour gérer les problèmes des définitions circulaires, par
exemple lorsqu'un objet contient un autre qui contient le
premier : une implémentation récursive naïve d'un
algorithme de copie profonde entrerait dans une boucle
infinie !

Modules et espaces de noms

66
 27/10/2024

Espaces de noms prog1

Chaque module définit un “espace de noms” global à ce module.

Fichier [Link]
Notes:
# module prog1  Les espaces de noms sont des dictionnaire:
x = 23 clé/valeur, la clé est l’espace de nom, la valeur est
y=9 une list
l = [1,2,3]  On peut utiliser dir() sur un espace de noms

import math
def f(p_x): print(dir(math) )
return 3*p_x+1 print(dir()) | print(dir("[Link]"))

x y l f

23 9 [1,2,3] la fonction f

Espaces de noms prog2

L'import effectue une recopie des noms, qui référencent les mêmes données.

Fichier [Link]
# module prog2
x=2
from prog1 import *
y = 11
[Link](4)
print(f(y))

67
 27/10/2024

Espaces de noms, prog2 (2/4)

L'import effectue une recopie des noms, qui référencent les mêmes
données.
Fichier [Link] Fichier [Link]
# module prog1 # module prog2
x = 23 x=2
y=9 from prog1 import *
l = [1,2,3] y = 11
[Link](4)
def f(p_x): print(f(y))
return 3*p_x+1

x y l f x y l f

23 9 [1,2,3] la fonction f 2

Espaces de noms, prog2 (3/4)

L'import effectue une recopie des noms, qui référencent les mêmes
données.
Fichier [Link] Fichier [Link]
# module prog1 # module prog2
x = 23 x=2
y=9 from prog1 import *
l = [1,2,3] y = 11
[Link](4)
def f(p_x): print(f(y))
return 3*p_x+1

x y l f x y l f

23 9 [1,2,3] la fonction f 2 11

68
 27/10/2024

Espaces de noms, prog2 (4/4)

L'import effectue une recopie des noms, qui référencent

les mêmes données.
Fichier [Link] Fichier [Link]
# module prog1 # module prog2
x = 23 x=2
y=9 from prog1 import *
l = [1,2,3] y = 11 Modification de prog2
[Link](4) visible par prog1 et
def f(p_x): print(f(y)) inversement
return 3*p_x+1

x y l f x y l f

23 9 [1,2,3,4] la fonction f 2 11

Espaces de noms

Le passage par le module permet de modifier des données partagées.

Fichier [Link] Fichier [Link]

# module prog1 # module prog3
x = 23 import prog1
y=9 x = -3
l = [1,2,3] prog1.y = 5
print(prog1.f(8))
def f(p_x):
return 3*p_x+1

x y l f prog1

23 9 [1,2,3] la fonction f

69
 27/10/2024

Espaces de noms

Le passage par le module permet de modifier des données partagées.

Fichier [Link] Fichier [Link]

# module prog1 # module prog3
x = 23 import prog1
y=9 x = -3
l = [1,2,3] prog1.y = 5
print(prog1.f(8))
def f(p_x):
return 3*p_x+1

x y l f prog1 x

23 9 [1,2,3] la fonction f -3

Espaces de noms

Le passage par le module permet de modifier des données partagées.

Fichier [Link] Fichier [Link]

# module prog1 # module prog3
x = 23 import prog1
y=9 x = -3
l = [1,2,3] prog1.y = 5
print(prog1.f(8))
def f(p_x):
return 3*p_x+1

x y l f prog1 x

23 5 [1,2,3] la fonction f -3

70
 27/10/2024

Espaces de noms, tout ensemble

Le passage par le module permet de modifier des données partagées.

Fichier [Link] Fichier [Link] Fichier [Link]

# module prog1 # module prog2 # module prog3
x = 23 x=2 import prog1
y=9 from prog1 import * x = -3
l = [1,2,3] y = 11 prog1.y = 5
[Link](4) print(prog1.f(8))
def f(p_x): print(f(y))
return 3*p_x+1

x y l f x y l f prog1 x

23 5 [1,2,3,4] la fonction f 2 11 -3

Algorithmes de tri

71
 27/10/2024

Tri par selection

Trouver le minimum du tableau et le positionner a la première
case, on le refait pour le reste du tableau en positionnant le
nouveau minimum a la deuxième case etc ...

Tri par selection

def tri_selection(t): def swap(t, i, j):
n=len(t) temp = t[i]
if n < 2: t[i] = t[j]
return t t[j] = temp
for i in range(n-1): def tri_selection(t, i, n):
min = t[i] # trouver minimum de la sous-liste
# non triée `t[i…n-1]` et remplacez-le par `t[i]`
for j in range(i+1, n): min = i
if t[j] < min: for j in range(i + 1, n):
min = t[j] if t[j] < t[min]:
t[j] = t[i] min = j
t[i] = min swap(t, min, i)
return t if i + 1 < n:
tri_selection(t, i + 1, n)
p=[25,20,58,10,42,12] return t
m=tri_selection(p) p=[25,20,58,10,42,12]
print(m) print(tri_selection(p,0,len(p)))

72
 27/10/2024

Tri par insertion

L'algorithme consiste à insérer un élément dans une liste déjà triée. Imaginer un
joueur de cartes qui dispose des cartes triées dans sa main gauche, et une carte
dans la main droite, Il va placer cette carte dans la main gauche de façon à ce
qu'elle reste triée.

Au départ, la main gauche est vide, donc elle bien triée. À chaque fois que l'on
insère une carte depuis la main droite, la main gauche reste triée, et la main
droite (l'ensemble des cartes non triées) perd une carte.

Tri insertion
import random
def tri_insertion(liste):
L = list(liste) # copie de la liste
N = len(L)
for i in range(1,N):
cle = L[i]
j = i-1
while j>=0 and L[j] > cle:
L[j+1] = L[j] # decalage
j = j-1
L[j+1] = cle
return L

liste = []
for k in range(10):
[Link]([Link](0,20))
liste_triee = tri_insertion(liste)
print(liste_triee)

73
 27/10/2024

Fonction fusion
L'algorithme maintient trois pointeurs, un pour chacun des deux tableaux et un pour
maintenir l'index actuel du tableau trié final.

Est-ce que nous avons atteint la fin de

l'un des tableaux?
-> Non
- Comparer les éléments actuels
des deux tableaux (T1[i] et T2[j])
- Copiez l'élément le plus petit
dans le tableau trié
- Déplacer le pointeur de
l'élément contenant un élément plus
petit (i ou j)
-> Oui
- Copiez tous les éléments
restants du tableau non vide

Tri par fusion

def fusion(L1,L2):
n1 = len(L1)
n2 = len(L2)
L12 = [0]*(n1+n2)
i1 = 0
i2 = 0
i=0
while i1<n1 and i2<n2:
if L1[i1] < L2[i2]:
L12[i] = L1[i1]
i1 += 1
else:
L12[i] = L2[i2]
i2 += 1
i += 1
while i1<n1:
L12[i] = L1[i1]
i1 += 1
i += 1
while i2<n2:
L12[i] = L2[i2]
i2 += 1
i += 1
return L12

74