Lecture Overview

• Arrays
• Collections
– Lists
– Tuples
– Sets
– Dictionaries

3
Les Tableaux
• En programmation, un tableau est une collection d’éléments du
même type. Les tableaux sont populaires dans la plupart des
langages de programmation tels que Java, C/C++, JavaScript,
etc. Cependant, Python n’a pas de type de données spécifique
pour représenter les tableaux.
• Les éléments suivants peuvent être utilisés pour représenter des
tableaux en Python:

– En utilisant des listes

– Via le module de array
– Avec le module NumPy
Lecture Overview
• Arrays
• Collections
– Lists
– Tuples
– Sets
– Dictionaries

5
An Array is …
• a container which can hold a fixed number of items, and
these items should be of the same type.
– Each item stored in an array is called an element.
– Each location of an element in an array has a numerical index, which is
used to identify the element.

Wait for Understanding Data lecture

to learn more about arrays.

6
Lecture Overview
• Arrays
– Création
– L’accès
– Modification
– Parcourir
– Ajout
– Suppression
• Collections
– Lists
– Tuples
– Sets
– Dictionaries 5
Création d’un Tableaux en python
• Un module est une bibliothèque ou un fichier contenant des fonctions et
des classes prêtes à l'emploi.
• Python dispose de modules intégrés, comme math, datetime, et ici, array.
• Pour utiliser les fonctionnalités d'un module, on utilise l'instruction import
• Nous devons importer le module « array » pour créer des tableaux.

import array as arr

tableau = [Link]('d', [1.0, 1.1, 1.2, 1.3])
print(tableau)

Sortie: array(‘d’, [1.0, 1.1, 1.2, 1.3])

Ici, nous avons créé un tableau de type double. La lettre ‘d’ est un code
de type. Cela détermine le type du tableau lors de la création.
 Type
Code de type Signification Type C Exemple
Python

'b' Entier signé sur 1 octet int signed char -128 à 127

Entier non signé sur 1

'B' int unsigned char 0 à 255
octet
Caractères Unicode (1
'u' str wchar_t "a", "b"
octet)

'h' Entier signé sur 2 octets int short -32,768 à 32,767

Entier non signé sur 2

'H' int unsigned short 0 à 65,535
octets
-2,147,483,648 à
'i' Entier signé sur 4 octets int int
2,147,483,647
Entier non signé sur 4
'I' int unsigned int 0 à 4,294,967,295
octets

'l' Entier signé sur 4 octets int long (similaire à 'i')

Entier non signé sur 4

'L' int unsigned long (similaire à 'I')
octets
Très grand entier
'q' Entier signé sur 8 octets int long long
négatif à positif
Entier non signé sur 8 unsigned long Très grand entier
'Q' int
octets long positif
Nombre à virgule
'f' float float Ex. 3.14
flottante (4 octets)
Ex.
Nombre à virgule
'd' float double 3.1415926535897
flottante (8 octets)
93
Création d’un Tableaux en python
• Exemple 2
import array as arr
array1 = [Link]('i')
[Link](1)
[Link](2)
print(array1)

Sortie: array(‘i’, [1, 2])

Les codes de type couramment utilisés sont listés

comme suit :
Accéder aux éléments d’un tableau
• Accédez aux éléments du tableau en vous référant au
numéro d’index. L’exemple suivant affiche le troisième
élément du tableau:

import array as arr

tab = [Link]('i', [1, 2, 3, 4, 5, 6])
print(tab[2])

Sortie: 3
Modifier la valeur d’un élément
• Pour modifier la valeur d’un élément spécifique, referez-
vous au numéro d’index. L’exemple suivant change le
deuxième élément:

import array as arr

tab = [Link]('i', [1, 2, 3, 4, 5, 6])

tab[1] = 100

print(tab)
Sortie: array(‘i’, [1, 100, 3, 4, 5, 6])
Parcourir un tableau en Python
• Parcourir les éléments du tableau en utilisant la boucle
for. L’exemple suivant affiche tous les éléments du
tableau, un par un:

import array as arr

tab = [Link]('i', [1, 2, 3, 4, 5, 6])
for i in tab:
print(i, end="\t")

Sortie :
Vérifier si un élément existe dans un
tableau
• Pour déterminer si un élément spécifié est présent dans
un tableau, utilisez le mot clé in. L’exemple suivant vérifie
si le nombre 5 est présent dans le tableau:

import array as arr

tab = [Link]('i', [1, 2, 3, 4, 5, 6])
if 5 in tab:
print("5 existe dans le tableau")

Sortie : 5 existe dans le tableau.

Longueur d'un tableau
• Pour déterminer le nombre d’éléments d’un tableau,
utilisez la fonction len(). L’exemple suivant affiche le
nombre d’éléments dans le tableau:

import array as arr

tab = [Link]('i', [1, 2, 3, 4, 5, 6])
print(len(tab))

Sortie: 6
 Ajouter des éléments au tableau
1- La méthode append():
• Pour ajouter un élément à la fin du tableau, utilisez la méthode append().
• L’exemple suivant ajoute le nombre 7 en utilisant la méthode append():
Syntaxe : [Link](elmnt)

import array as arr

tab = [Link]('i', [1, 2, 3, 4, 5, 6])
[Link](7)
print(tab)

Sortie: array(‘i’, [1, 2, 3, 4, 5, 6, 7])

Ajouter des éléments au tableau
2- La méthode insert :
On a aussi la méthode insert qui permet d’insérer un
élément à une position précise dans le tableau.
Syntaxe : [Link](pos, elmnt)
Exemple :

import array as arr

s1 = [Link]('i', [1, 2, 3]) A l’exécution :
s2 = [Link]('i', [4, 5, 6])
print(s1)
print(s2)
s3 = s1 + s2
print(s3)
[Link](4)
print(s1)
[Link](0, 10)
print(s1)
Ajouter des éléments au tableau
2- La méthode extend() :
La méthode extend() ajoute les éléments de liste spécifiés (ou tout
itérable) à la fin de la liste actuelle.
Syntaxe : [Link](iterable)
Exemple :
import array as arr
#Creating an array
my_array1 = [Link]('i',[1,2,3,4])
#Printing the elements of an array
print("Array Elements : ", my_array1)
#adding elements using extend method
list1=[100,13,15]
my_array1.extend(list1)
print("Elements After Extending : ", my_array1)
Sortie :
Array Elements : array('i', [1, 2, 3, 4])
Elements After Extending : array('i', [1, 2, 3, 4, 100, 13, 15])
Exercice 1 : Proposer un programme en python
qui permet d’insérer une valeur x à une position p
du tableau T [10,20,30,40,50]

Exercice 2: Tester le programme suivant et

conclure le rôle de la méthode extend :

import array
T= [Link]('i', range(1, 10))
print("Tableau initial: ",T)
[Link](100)
print("Après append :",T)
[Link](range(200, 205))
print("Après extend : ",T)
Exercice 1 : Proposer un programme en python
qui permet d’insérer une valeur x à une position p
du tableau T [10,20,30,40,50]

Exercice 2: Tester le programme suivant et

conclure le rôle de la méthode extend :
import array
T= [Link]('i', range(1, 10))
print("Tableau initial: ",T)
[Link](100)
print("Après append :",T)
[Link](range(200, 205))
print("Après extend : ",T)
Supprimer un élément du tableau
Il existe plusieurs méthodes pour supprimer des éléments
d’un tableau :
1- remove() :
La méthode remove() supprime l’élément spécifié:
Syntaxe : [Link](elmnt)
import array as arr

tab = [Link]('i', [1, 2, 3, 4, 5, 6])

[Link](4)

print(tab)

Sortie: array(‘i’, [1, 2, 3, 5, 6]).

Supprimer un élément du tableau
2- pop() :
La méthode pop() supprime l’index spécifié, (ou le dernier
élément si l’index n’est pas spécifié):
Syntaxe : [Link](pos)
import array as arr
tab = [Link]('i', [1, 2, 3, 4, 5, 6])
[Link]()
print(tab)

Sortie: array(‘i’, [1, 2, 3, 4, 5])

Exercice : Proposer un programme qui permet
de supprimer une valeur sachant sa position dans
le tableau

Exercice : Selon les résultats du programme

suivant, prédire le rôle de l’opérateur del
import array as Tab
T = [Link]('f', range(0, 10))
print("T initial : ",T)
del T[0]
print("T après del :",T)
del T[len(T)-1]
print("T apdès del : ",T)
del T
print("T :",T)
Exercice : Proposer un programme qui permet
de supprimer une valeur sachant sa position dans
le tableau

Exercice : Selon les résultats du programme

suivant, prédire le rôle de l’opérateur del
import array as Tab
T = [Link]('f', range(0, 10))
print("T initial : ",T)
del T[0]
print("T après del :",T)
del T[len(T)-1]
print("T apdès del:",T)
del T
print("T :",T)
Converti un Array 1D à une List
import array
# Création d'un tableau 1D
array_1D = [Link]('i', [1, 2, 3, 4, 5])
# Conversion en liste pour affichage
print("Tableau 1D :", array_1D.tolist() )

Sortie : Tableau 1D : [1, 2, 3, 4, 5]

9
Converti un Array 2D à une List
import array
# Création d'un tableau 2D comme une liste de tableaux 1D
array_2D = [
[Link]('i', [1, 2, 3]),
[Link]('i', [4, 5, 6]),
[Link]('i', [7, 8, 9])
]
print("Tableau 2D :")
for row in array_2D:
print([Link]() )
Sortie : Tableau 2D :
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
9
Converti un Array 3D à une List
import array
# Création d'un tableau 3D comme une liste de tableaux 2D
array_3D = [
[[Link]('i', [1, 2, 3]), [Link]('i', [4, 5, 6])],
[[Link]('i', [7, 8, 9]), [Link]('i', [10, 11, 12])], Sortie : Tableau 3D :

[[Link]('i', [13, 14, 15]), [Link]('i', [16, 17, 18])] [1, 2, 3]

] [4, 5, 6]

print("Tableau 3D :") [7, 8, 9]

for layer in array_3D: [10, 11, 12]

for row in layer: [13, 14, 15]

print([Link]()) # Conversion en liste pour affichage [16, 17, 18]

print([Link]() )

print(array_3D[1][0][2])
9
Remarque
• Le module array ne prend pas en charge directement des tableaux multidimensionnels comme
les bibliothèques spécialisées telles que NumPy.

• Pour manipuler facilement des tableaux 2D ou 3D, NumPy est généralement recommandé car il
offre un support natif et des outils efficaces pour ces structures.

import numpy as np
array_3D = [Link]([
[[1, 2, 3], [4, 5, 6]],
[[7, 8, 9], [10, 11, 12]],
[[13, 14, 15], [16, 17, 18]]
])
print("Tableau 3D avec NumPy :")
print(array_3D)

9
Lecture Overview
• Arrays
• Collections
– Lists
– Tuples
– Sets
– Dictionaries

7
A Collection Groups Similar Things

• List: ordered
• Set: unordered, no duplicates
• Tuple: unmodifiable list
• Dictionary: maps from values to values
Example: word → definition
What is a List?
• A list is an ordered sequence of values, where each
value is identified by an index.

• What operations should a list support efficiently and

conveniently?
– Creation
– Querying/Lookup
– Mutation

30
List Creation
• Use square brackets to specify a list.
• Separate each element with a comma.
e = [] # empty list

e = [0]* n # initialize list with n elements

a = [3, 4, 5]

b = [ 5, 3, 'hi' ]

c = [ 4, 'a', a ]

d = [ 3, 1, 2*2, 1, 10/2, 10-1 ]

To initialize a list, you can add the elements at the time of
declaration, or initialize it via a for loop. 31
List Creation: Example - 1
Méthode 1

x=[1,’bien’,20.25,3,‘ahmed']

Méthode 2

L = []
for i in range(0,10):
[Link](i**2)
print(L)

Remarque : on peut initialiser une liste comme suit:

L = [x*3 for x in 'ABCD']

print(L)
# Prints [AAA, 'BBB', 'CCC', 'DDD']
32
List Creation: Examples
Exemple 1-1

L = [-12, -20, 10, 15, 42]

L1 = [x for x in L if x >= 0]
print(L1)
# Prints [10,15,42]

Exemple 1-2

L = [-12, -20, 10, 15, 42]

L1 = []
for x in L:
if x >= 0:
[Link](x)
print(L1)
# Prints [10,15,42]
33
Exercices
Exercice 1 : programme en python qui permet de
sauvegarder les noms de 10 stagiaires saisi par l’utilisateur.

Exercice 2 : Remplir une liste avec 10 entiers donnés par

l’utilisateur .Puis, le programme trouve le plus grand et le plus
petit de ces nombres.

Exercice 3 : Proposer un programme qui demande un

nombre entier x entre 1 et 10 jusqu’à ce que la réponse
convienne. Puis, le programme remplit une liste L avec les
multiplicateurs de x qui sont entre 0 et [Link] affiche alors la
liste

Exercice 4 : Programme qui permet de lire 10 note. Puis

affiche les notes qui sont >moyenne
34
 List Creation: Example - 2
Techs = ['MIT', 'Caltech']
Ivys = ['Harvard', 'Yale', 'Brown']
Univs = [Techs, Ivys]
Univs1 = [['MIT','Caltech'],['Harvard','Yale','Brown']]

print('Univs =', Univs)

print('Univs1 =', Univs1)
print(Univs == Univs1)

>> Univs = [['MIT','Caltech'],['Harvard','Yale','Brown']]

>> Univs1 = [['MIT','Caltech'],['Harvard','Yale','Brown']]
>> True

38
Slicing : Accès aux éléments d'une liste

On peut accéder à un élément via son indice (positif ou négatif).

On peut aussi récupérer une plage d’éléments en utilisant
l’opérateur ‘ :’ .

Exemples :
print(x[0]) #le premier élément de la liste
print(x[-1]) #le dernier élément de la liste

x=[61,’142′,3,’k’,1,’f’]
print(x[0:3]) #les éléments entre l’index 0 et l’index 2
print(x[1:]) #les éléments après l’index 0
print(x[:2]) #les éléments avant l’index 2

39
Accès aux éléments d'une liste
Exercice :
Soit L une liste remplie par des données saisies au clavier.
On veut créer deux listes L1 et L2 de la manière suivante :
– L1 est la copie de la première moitié de L
– L2 est la copie de la deuxième moitié de L

40
Traitement classiques sur les
listes
• Insertion
• Removal
• Replacement
• Rearrangement

41
List Insertion
• [Link](x)
– Extend the list by inserting x at the end

• [Link](L)
– Extend the list by appending all the items in the argument list

• [Link](i, x)
– Insert an item before a given position.
– [Link](0, x) inserts at the front of the list
– [Link](len(a), x) is equivalent to [Link](x)

42
List Concatenation using + operator

list1 = ["a", "b", "c"]

list2 = [1, 2, 3]

list3 = list1 + list2

print(list3)
Not the arithmetic
addition operator

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

43
 List Insertion: Examples
Python statement Content of list1

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

>>> [Link](4) [1, 2, 3, 4]

>>> [Link](2, 5) [1, 2,

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

>>> list2 = [10, 20]

>>> [Link](list2) [1, 2,
[1, 2, 5,
5, 3,
3, 4,
4, 10,
10, 20]
20]

>>> [Link](list2) [1, 2,

[1, 2, 5,
5, 3,
3, 4,
4, 10,
10, 20,
20, [10,
[10, 20]]
20]]

>>> list1[7]
[10, 20]
>>> list1[7][0]
10
>>> list1[7][1]
20 24
List Insertion: Extend
[Link]() : Ajoute à la fin d’une liste, mais l’argument devrait
être un itérable.

Villes=['safi','agadir','tanger','fes','casa','Rabat' ]
print(Villes)
[Link](['taza','nadour','ouajda'])
print(Villes)
# ['safi', 'agadir', 'tanger', 'fes', 'casa', 'Rabat', 'taza',
'nadour', 'ouajda']

45
List Insertion: Extend
[Link](, ) : Pour ajouter un élément à la fin de la liste, on
peut utiliser la méthode append. Si on veut insérer l’élement
à une position spécifique, on doit utiliser la méthode insert.
Cette méthode insère l’objet dans la liste a à spécifié.

Villes=['safi','agadir','tanger','fes','casa','Rabat' ]
print(Villes)# ['safi', 'agadir', 'tanger', 'fes', 'casa', 'Rabat']
[Link](1,‘Marrakech')
print(Villes)# ['safi', ‘Marrakech', 'agadir', 'tanger', 'fes',
'casa', 'Rabat']

46
List Removal
• [Link](x)
– Remove the first item from the list whose value is x
– It is an error if there is no such item

• [Link]([i])
– Remove the item at the given position in the list, and return it.
– If no index is specified, [Link]() removes and returns the last item in
the list.

Notation from the Python Library Reference:

The square brackets around the parameter, “[i]”, means the argument is optional.
It does not mean you should type square brackets at that position.

47
 List Removal - Examples
Python statement Content of list1

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

>>> [Link](2) [1, 3]

>>> list2 = [Link]()

>>> [Link](list2) [1, 3, 1, 3]

>>> [Link](3) [1, 1, 3]

>>> [Link]() [1, 1]

48
 List Removal - Examples
[Link]() : Supprime l’objet de la liste a. Si n’est pas
dans un, une exception est levée :

Villes=['safi','agadir','tanger','fes','casa','Rabat' ]
print(Villes)# ['safi', 'agadir', 'tanger', 'fes', 'casa', 'Rabat']
[Link]('dakhla')
print(Villes)# ['safi', 'dakhla', 'agadir', 'tanger', 'fes', 'casa',
'Rabat']

49
List Removal - Examples
[Link](index=-1) : Cette méthode diffère de .remove () de
deux manières:
1- Vous spécifiez l’index de l’élément à supprimer, plutôt que
l’objet lui-même.
2- La méthode renvoie une valeur : l’élément qui a été
supprimé.

Villes=['safi','agadir','tanger','fes','casa','Rabat' ]
print(Villes)# ['safi', 'agadir', 'tanger', 'fes', 'casa', 'Rabat']
v=[Link](1)
print(v)#agadir
print(Villes)# ['safi', 'tanger', 'fes', 'casa', 'Rabat']

50
List Replacement
• mylist[index] = newvalue

• mylist[start : end] = newsublist

– Can change the length of the list
– start is inclusive, end is not
– mylist[ start : end ] = [] # removes multiple elements
– a[len(a):] = L # is equivalent to [Link](L)

51
List Slicing
mylist[startindex : endindex] evaluates to a
sublist of the original list
– mylist[index] evaluates to an element of the original list

• Arguments are like those to the range function

– mylist[start : end : step]
– start index is inclusive, end index is exclusive
– All 3 indices are optional

• Can assign to a slice: mylist[s : e] = yourlist

29
List Slicing: Examples
test_list = ['e0', 'e1', 'e2', 'e3', 'e4', 'e5', 'e6']

From e2 to the end of the list: test_list[2:]

From beginning up to (but not including) e5: test_list[:5]
Last element: test_list[-1]
Last four elements: test_list[-4:]
Everything except last three elements: test_list[:-3]
Reverse the list: test_list[::-1]
Get a copy of the whole list: test_list[:]

30
List Rearrangement
• [Link]()
– Sort the items of the list, in place.
– “in place” means by modifying the original list, not by creating a new
list.

• [Link]()
– Reverse the elements of the list, in place.

31
 Sorting
hamlet = "to be or not to be that is th question".split()
print("hamlet:", hamlet)

print("sorted(hamlet):", sorted(hamlet))
print("hamlet:", hamlet)

print("[Link]():", [Link]())
print("hamlet:", hamlet)

print("[Link]():", [Link]())
print("hamlet:", hamlet)

32
 Sorting
hamlet: ['to', 'be', 'or', 'not', 'to', 'be', 'that', 'is',
'the', 'question']

sorted(hamlet): ['be', 'be', 'is', 'not', 'or', 'question',

'that', 'the', 'to', 'to']

hamlet: ['to', 'be', 'or', 'not', 'to', 'be', 'that', 'is',

'the', 'question']

[Link](): None
hamlet: ['be', 'be', 'is', 'not', 'or', 'question', 'that',
'the', 'to', 'to']

[Link](): None
hamlet: ['to', 'to', 'the', 'that', 'question', 'or', 'not',
'is', 'be', 'be']
33
Sorting Algorithms Revisited

39
 Bubble Sort

• It repeatedly steps through the list

to be sorted,
• compares each pair of adjacent items
and swaps them if they are in the
wrong order.
• The pass through the list is repeated
until no swaps are needed, which
indicates that the list is sorted.
• The algorithm, which is a comparison
sort, is named for the way smaller
elements "bubble" to the top of the list. First step of the algorithm.

Image credit: [Link] 40

Bubble sort
def bubbleSort(alist):
for passnum in range(len(alist)-1,0,-1):
for i in range(passnum):
if alist[i]>alist[i+1]:
temp = alist[i]
alist[i] = alist[i+1]
alist[i+1] = temp

alist = [54,26,93,17,77,31,44,55,20]
bubbleSort(alist)
print(alist)

41
Insertion sort

• maintain a sorted sublist in the

lower positions of the list.
• Each new item is then
“inserted” back into the
previous sublist such that the
sorted sublist is one item larger.

42
Insertion Sort
def insertionSort(alist):
for index in range(1,len(alist)):
currentvalue = alist[index]
position = index

while position>0 and alist[position-1]>currentvalue:

alist[position]=alist[position-1]
position = position-1

alist[position]=currentvalue

alist = [54,26,93,17,77,31,44,55,20]
insertionSort(alist)
print(alist)

43
 Merge Sort
• Merge sort is a prototypical divide-and-conquer
algorithm.
– Split list into sub-lists in two until you reach pair of value
– Sort/swap pair of values if needed
– Merge and sort sub-lists
and repeat process until
you merge to the full list.

Image credit: [Link] 44

Merge Sort
def merge(left, right):
result = []
(i,j) = (0, 0)
while i<len(left) and j<len(right):
if left[i]<right[j]:
[Link](left[i])
i = i + 1
else:
[Link](right[j])
j = j + 1
while i<len(left):
[Link](left[i])
i = i + 1
while j<len(right):
[Link](right[j])
j = j + 1
return result
45
Merge Sort Visit this slide later when
we learned about
recursion.

def mergeSort(L):
if len(L)<2:
return L[:]
else:
middle = len(L)//2
left = mergeSort(L[:middle])
right = mergeSort(L[middle:])
return merge(left, right)

a = mergeSort([2,1,3,4,5,-1,8,6,7])

46
Three Ways to Define a List
• Explicitly write out the whole thing:
squares = [0, 1, 4, 9, 16, 25, 36, 49]

• Write a loop to create it:

squares = []
for i in range(8):
[Link](i*i)

• Write a list comprehension:

squares = [i*i for i in range(8)]

A list comprehension is a concise description of a list

A list comprehension is shorthand for a loop
47
 Syntax of a Comprehension

[(x,y) for x in seq1 for y in seq2 if sim(x,y) > threshold]

expression for clause (required) zero or more zero or more if clauses

assigns value to the additional
variable x for clauses

something
that can be
iterated

49
Semantics of a comprehension

[(x,y) for x in seq1 for y in seq2 if sim(x,y) > threshold]

result = []
for x in seq1:
for y in seq2:
if sim(x,y) > threshold:
[Link]( (x,y) )
… use result …

50
Cubes of the first 10 natural numbers

Goal:
Produce: [0, 1, 8, 27, 64, 125, 216, 343, 512, 729]
With a loop:
cubes = []
for x in range(10):
[Link](x**3)

With a list comprehension:

cubes = [x**3 for x in range(10)]
52
Powers of 2, 20 through 210

Goal: [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]

[2**i for i in range(11)]

53
Making a Matrix

Goal: A matrix were each element is the sum of it's row and column
numbers.

With a loop:

matrix = [] [[0, 1, 2, 3, 4],

for i in range(5): [1, 2, 3, 4, 5],
row = [] [2, 3, 4, 5, 6],
[3, 4, 5, 6, 7],
for j in range(5):
[4, 5, 6, 7, 8]]
[Link](i+j)
[Link](row)

With a list comprehension:

matrix = [[i+j for j in range(5)] for i in range(5)]

57
Function 4x2 – 4
With a loop:
num_list = []
for i in range(-10,11):
num_list.append(4*i**2 - 4)

With a list comprehension:

num_list = [4*i**2 - 4 for i in range(-10,11)]

58
Normalize a List
With a loop:
num_list = [6,4,2,8,9,10,3,2,1,3]
total = float(sum(num_list))
for i in range(len(num_list)):
num_list[i] = num_list[i]/float(total)

With a list comprehension:

num_list = [i/total for i in num_list]

59
Ternary Assignment

A common pattern in python

if x > threshold:
flag = True
else:
flag = False
Or

flag = False
if x > threshold:
flag = True
62
Ternary Assignment

A common pattern in python

if x > threshold:
flag = True
else:
flag = False

flag = True if x > threshold else False

Ternary Expression
Three elements

63
 Ternary Assignment
flag = True if x > threshold else False
Result if true Result if false
Condition

• Only works for single expressions as results.

• Only works for if and else (no elif)

64
Ternary Assignment

Goal: A list of 'odd' or 'even' if that index is odd or even.

the_list = []
for i in range(16):
if i%2 == 0:
the_list.append('even')
else:
the_list.append('odd')

the_list = []
for i in range(16):
the_list.append('even' if i%2 == 0 else 'odd')

the_list = ['even' if i%2 == 0 else 'odd' for i in range(16)]

65
Parcourir une liste
# Méthode 1 : x =element de la liste
L = ['I did it all', 4, 'peace']
for x in L:
print(x)

# Méthode 2 : I = indice
for i in range(len(L)):
print(L[i])

>> I did it all

>> 4
>> peace

77
List Creation: Example - 3
def findExtremeDivisors(n1, n2):
"""Assumes that n1 and n2 are positive ints
Returns a list containing the smallest common
divisor > 1 and the largest common divisor
of n1 and n2"""
minVal = None The None keyword is used to define
maxVal = None a null value, or no value at all.

for i in range(2, min(n1, n2) + 1):

if n1%i == 0 and n2%i == 0:
if minVal == None or i < minVal:
minVal = i
if maxVal == None or i > maxVal:
maxVal = i
return [[minVal], [maxVal]]

extreme_divisors= findExtremeDivisors(100, 200)

print(extreme_divisors)
[[2], [100]]
78
 How to Evaluate a List Expression

• [a, b, c, d]  list creation

– To evaluate: Same tokens “[]”
• evaluate each element to a value, from left to right with two distinct
• make a list of the values meanings
– The elements can be arbitrary values, including lists
List • ["a", 3, 3.14*r*r, fahr_to_cent(-40), [3+4, 5*6]]
expression

• a[b]  list indexing or dereferencing

Index – To evaluate:
expression • evaluate the list expression to a value
• evaluate the index expression to a value
• if the list value is not a list, execution terminates with an error
• if the element is not in range (not a valid index), execution terminates
with an error
• the value is the given element of the list value (counting from zero)
79
List Expression Examples
What does this mean (or is it an error)?
["four", "score", "and", "seven", "years"][2]

["four", "score", "and", "seven", "years"][0,2,3]

["four", "score", "and", "seven", "years"][[0,2,3]]

["four", "score", "and", "seven", "years"][[0,2,3][1]]

80
List Expression Examples
>>> ["four", "score", "and", "seven", "years"][2]
'and’

>>> ["four", "score", "and", "seven", "years"][0,2,3]

TypeError: list indices must be integers or slices, not tuple

>>> ["four", "score", "and", "seven", "years"][[0,2,3]]

TypeError: list indices must be integers or slices, not list

>>> ["four", "score", "and", "seven", "years"][[0,2,3][1]]

'and'

81
List Lookup
• Extracting part of the list:
– Single element: mylist[index]
– Sublist (“slicing”): mylist[startidx : endidx]

• Find/lookup in a list
– x in mylist
• Evaluates to a boolean value

– [Link](x)
• Return the int index in the list of the first item whose value is x.
It is an error if there is no such item.

– [Link](x)
• Return the number of times x appears in the list.

82
List Lookup: Exercise
def index(somelist, value):
"""Return the position of the first occurrence of
the element value in the list somelist.
Return None if value does not appear in
somelist."""
i = 0
for c in somelist:
if c == value:
return i
i = i + 1
return None
gettysburg = ["four", "score", "and",
”seven", "years", "ago"]
index(gettysburg, "and") # 2
index(gettysburg, "years”) # 4
[Link]('seven') # 1
83
Exercices :
Exercice1 :
Nous allons lire les notes de anas et amine dans n
matières (coefficient =1 pour chaque matière). on veut
afficher les moyennes d’Anas et Amine puis le nom de
celui ayant la meilleure moyenne

Exercice 2 :
Refaire l’exercice 1 avec l’utilisation de la fonction sum
Les méthodes sur les listes
Le type liste dispose de méthodes supplémentaires. Voici toutes les méthodes des
objets de type liste :
[Link](x) : Ajoute un élément à la fin de la liste. Équivalent à a[len(a):] = [x].
[Link](iterable) : Étend la liste en y ajoutant tous les éléments de l’itérable.
Équivalent à a[len(a):] = iterable.
[Link](i, x) : Insère un élément à la position indiquée. Le premier argument est la
position de l’élément courant avant lequel l’insertion doit s’effectuer, donc
[Link](0, x) insère l’élément en tête de la liste et [Link](len(a), x) est équivalent à
[Link](x).
[Link](x) : Supprime de la liste le premier élément dont la valeur est égale à x.
Une exception ValueError est levée s’il n’existe aucun élément avec cette valeur.
[Link]([i]) : Enlève de la liste l’élément situé à la position indiquée et le renvoie en
valeur de retour. Si aucune position n’est spécifiée, [Link]() enlève et renvoie le
dernier élément de la liste (les crochets autour du i dans la signature de la méthode
indiquent que ce paramètre est facultatif .
[Link]() : Supprime tous les éléments de la liste. Équivalent à del a[:].
[Link](x[, start[, end]]) : Renvoie la position du premier élément de la liste dont
la valeur égale x. Une exception ValueError est levée si aucun élément n’est trouvé.
[Link](x) : Renvoie le nombre d’éléments ayant la valeur x dans la liste.
[Link](key=None, reverse=False) : Ordonne les éléments dans la liste (les
arguments peuvent personnaliser l’ordonnancement, voir sorted() pour leur
explication).
[Link]() : Inverse l’ordre des éléments dans la liste.
[Link]() : Renvoie une copie superficielle de la liste. Équivalent à a[:].
Sorting: strings vs. numbers

• Sorting the powers of 5:

>>> sorted([125, 5, 3125, 625, 25])

[5, 25, 125, 625, 3125]

>>> sorted(["125", "5", "3125", "625", "25"])

['125', '25', '3125', '5', '625']

38
 Les fonctions et les procédures
Introduction
• Les fonctions et les procédures fonctionnent sur le même principe. La
différence réside dans le fait qu'une fonction renvoie un résultat, une
procédure ne renvoie rien.
• Il s’agit d’écrire des morceaux de code réutilisables, appelés fonctions
– Les fonctions ne sont pas exécutées dans un programme tant qu'elles ne
sont pas « appelées » ou « invoquées » dans un programme.
• Les caractéristiques de la fonction :
– A un nom
– A des paramètres (0 ou plus)
– A une docstring (facultatif mais recommandé)
– A un corps
– renvoie quelque chose

61
 Les fonctions et les procédures
Introduction
• Pour définir une fonction ou une procédure nous utilisons simplement le
mot clé def :

def ma_fonction():
print(" Hello World !!! “)
return True

• Remarque: Les parenthèses sont obligatoires, même si aucun argument

n'est passé.
• Nous pouvons voir ici que nous retournons un booléen. On utilise pour cela
le mot clé return. Si nous désirons renvoyer plusieurs variables, il suffit de
les écrire à la suite et de les récupérer dans des variables adaptées :

61
 COMMENT ÉCRIRE et
APPELER/INVOQUER UNE FONCTION

61
 Les fonctions et les procédures
Exemple

def ma_fonction(fnom, fprenom):

return "nom: " + fnom, "prenom: " + fprenom
>>> nom, prenom = ma_fonction("ALAMI", "Salma")
>>> print(nom)
nom: ALAMI
>>> print(prenom)
prenom: Salma

61
 Les fonctions
La portée des variables
La portée des variables est une notion importante dans la programmation.
En PYTHON, tout comme dans beaucoup d'autre langage, une variable peut
être locale ou globale.
Dans le premier cas, la variable n'existe qu'à l'intérieur de la
fonction(/procédure/...) où elle a été définie. Même si ailleurs dans le code
une variable porte le même nom, il s'agira néanmoins de deux variables
distinctes.
Cependant, il peut parfois être utile, même si cela n'est pas recommandé,
d'avoir une variable globale, autrement dit, accessible depuis n'importe où
dans le code.
Pour qu'une variable soit globale en PYTHON, il faut la définir au début du
code en utilisant le mot clé global.
De même au début de chaque fonction(/procédure /...), il faudra redéfinir
cette variable en globale pour que PYTHON comprenne que l'on veut faire
référence à la variable globale et non à une variable locale portant le même
nom.

61
 La portée des variables
• Le paramètre formel est lié à la valeur du paramètre réel lorsque la
fonction est appelée
• Nouvelle portée/cadre/environnement créé lors de la saisie d'une fonction
• La portée est le mappage des noms aux objets

61
 Les fonctions
La portée des variables

global ma_variable
...
def ma_procedure():
global ma_variable #j'appelle ici la variable globale
...
...
def ma_procedure2():
ma_variable = 3 #ici, c'est une variable locale

61
 Les fonctions Built-in
Python has some built-in functions thatare available without
importing any package
L'interpréteur Python propose quelques fonctions et types natifs qui sont
toujours disponibles. Ils sont listés ici par ordre alphabétique.

61
 Quelques fonctions prédéfinies
LEN
La commande len permet de connaître le nombre de caractères dans un
string ou encore le nombre d'éléments dans une liste

>>>ma_string = " bonjour "

>>>len(ma_string)
7
>>>ma_liste = [4,5," hello "]
>>>len(ma_liste)
3

61
 Quelques fonctions prédéfinies
Type
La commande type permet de connaître le type d'une variable.
Cette fonction est souvent utilisée afin de déterminer quel traitement est
le plus adapté à une variable donnée.
>>> mon_integer = 56321
>>> type(mon_integer)
<type 'int'>

INPUT
La fonction input permet, en ligne de commande, de demander à
l'utilisateur de renseigner des paramètres ou informations.
Il existe deux façons d'utiliser cette fonction:
>>>#Methode 1
>>>print (" Merci de renseigner votre nom: ")
>>>nom = input()
>>>#Methode 2
>>>nom = input(" Merci de renseigner votre nom: ")
>>>print(" votre nom est: ", nom)
61
 Quelques fonctions prédéfinies
GETPASS
Le rôle de la fonction getpass est identique à la fonction input à
un détail près: la confidentialité.

En effet, cette fonction ne réalise pas d’écho de votre saisie.

>>>mot_passe = getpass (" Merci de saisir un mot de passe:")

Merci de saisir un mot de passe:
>>>print(mot_passe)
MotDePasse

61
 Méthodes pour manipuler les chaines

On peut manipuler une chaîne de caractères grâce à certaines

de ces méthodes.
Les plus usitées sont les suivantes :

>Changement de casse

>>> ma_chaine='Hello World'

>>> ma_chaine
'Hello World'
>>> ma_chaine.lower()
'hello world'
>>> ma_chaine.upper()
'HELLO WORLD'

61
Méthodes pour manipuler les chaines
>Mettre la première lettre en majuscule

>>> ma_chaine='hello world'

>>> ma_chaine.capitalize()
'Hello world'

>Séparation de caractère, avec un caractère prédéfini

>>> ma_chaine.split('l')
['He', '', 'o Wor', 'd']

>Concaténation de chaîne, avec un caractère prédéfini

>>> ma_chaine.join('l')
>>> ma_chaine
'Hello World'
61
Méthodes pour manipuler les chaines
>Trouver la position d'une lettre
>>> ma_chaine = 'Hello world'
>>> ma_chaine.find('w')
6

>Compter le nombre d’occurrence d'un caractère

>>> ma_chaine = 'Hello world'

>>> ma_chaine.count('l')
3

>Supprimer les espaces en début et fin de chaîne

>>> ma_chaine = ' Ceci est un test '

>>> ma_chaine
' Ceci est un test '
>>> ma_chaine.strip()
'Ceci est un test'
61
Méthodes pour manipuler les chaines
>Enfin, tester le type de donnée contenu dans la chaîne (True si
vrai, False sinon)

>>>ma_chaine.isalpha() #Teste s'il n'y a exclusivement que des lettres

>>>ma_chaine.isdigit() #Teste s'il n'y a que des chiffres
>>>ma_chaine.isalnum() #Teste s'il y a des caracteres alphanumeriques
>>>ma_chaine.isspace() #Teste s'il n'y a que des espaces

61
 Aspect Liste Tuple Set Dictionnaire

Collection ordonnée et Collection ordonnée et Collection non ordonnée Collection de paires clé-
Définition
modifiable. immuable. et unique. valeur.

Délimiteurs [] () {} { } (avec : pour clé-valeur)

Ordre Ordonée Ordonnée Non Ordonnée Ordonnée

Modifiable (mais les

Immuable (pas modifiable Modifiable (mais les clés
Modification Modifiable(muable) éléments doivent être
après création). doivent être immuables).
immuables).

Les clés doivent être

Éléments dupliqués Autorisés Autorisés Non autorisés(uniques) uniques, mais les valeurs
peuvent être dupliquées.

Uniquement des éléments Clés : immuables ; Valeurs

Types d'éléments N'importe quel type N'importe quel type
immuables. : n'importe quel type.

Accès aux éléments Par index Par index Par recherche d'éléments. Par clé