AI28 – Machine Learning UTC

M. Alaya et S. Bouzebda FISA – GI04

Introduction à Python (partie 1)
Prise en main de l’environnement
Dans cette première partie, nous rappelons une liste non exhaustive des différents éléments constituant
la programmation en langage Python, notamment les notions de variables, fonctions, boucles, etc.. Nous
conseillons de consulter régulièrement la documentation fournie dans le site officiel de Python (https:
//[Link]/fr/3/) et/ou les références données en cours lors de la présentaion de l’UV.

1 Jupyter notebook
Un notebook jupyter consiste de cellules individuelles pouvant contenir du code Python, du texte (avec
formatage Markdown, HTML et LaTeX) ou des graphiques.

1.1 Raccourcis fréquemment utilisés pour manipuler les cellules:

• Exécuter une cellule: Touche SHIFT + ENTER (Entrée)
• Créer une nouvelle cellule vers le haut: Touche ECHAP (ESC) + A
• Créer une nouvelle cellule vers le bas bas: Touche ECHAP + B
• Couper une cellule: Touche ECHAP + X
• Copier une cellule: Touche ECHAP + C
• Coller une cellule: Touche ECHAP + V
• Afficher le nombre de ligne de code dans une cellule: Touche ECHAP + L
• Pour afficher la liste totale des raccourcis: Touche ECHAP + H
[ ]: from [Link] import Image
Image("./imgs/raccourcis_claviers.png")

1.2 Spécifier le type d’une cellule: code / markdown

Les trois types disponibles sont les suivants :
• Code (ECHAP + Y): le notebook interprète tout le contenu dans une cellule de code en lan-
gage Python. Lorsque vous écrivez du code Python, la saisie de certaines chaînes, par
exemple from ou le signe égal (=) indiquera au notebook de les colorier ou de les mettre
en surbrillance pour plus de clarté. Les lignes de codes commençant par le signe dièse (#)
seront interprétées comme des commentaires, colorées en vert et mises en italique. Elles
ne seront pas exécutées comme du code par le notebook.
• Markdown (ECHAP + M): cellules dans lesquelles le texte est soumis à un formatage selon
la syntaxe Markdown ; les éventuelles balises HTML et le code LaTeX sont également
interprétés
• Raw NBConvert (ECHAP + R): le notebook ne traite pas le contenu des cellules de type Raw
NBConvert (NBConvert brut). Ce type de cellule est rarement utilisé.

1
 1.3 Commentaires:
• Les commentaires en Python commencent avec un caractère croisillon, #, et s’étendent jusqu’à la fin
de la ligne. Un commentaire peut apparaître au début d’une ligne ou à la suite d’un espace ou de
code, mais pas à l’intérieur d’une chaîne de caractères littérale.
• Les commentaires se sont des petites lignes de codes qui ne sont pas prises en compte par l’ordinateur
au moment d’exécuter le programme et ainsi on peut écrire des commentaires pour documenter notre
code et le rendre plus compréhensible.

1.4 Numéro d’ordre d’exécution des cellules

• Il est très important d’exécuter les cellules de code dans l’ordre du programme. Les nombres entre
crochets peuvent ne pas se suivre un par un notamment si vous exécutez une même cellule plusieurs
fois de suite mais l’ordre de ces nombres doit être croissant au fur et à mesure que l’on avance dans
le fichier Notebook.
• Une fois exécutée, le résultat de l’exécution (sortie/output) s’affiche dans la cellule sous le code (cela
peut être un message d’erreur si votre code est erroné). Il peut ne rien s’afficher si le code ne le
demande pas.

1.5 Noyau de notebook

• Réinitialiser le fichier notebook.
• Interrompre le noyau.
• Effacer toutes les sorties.
• Reconnecter le notebook.
[ ]: Image("./imgs/[Link]")

2 Variables
2.1 Création d’une variable
Lors d’une création d’une variable en Python, il faut immédiatement lui affecter une valeur sinon Python
affiche une erreur de type NameError: name 'NOM_DE_LA_VARIABLE' is not defined.

[ ]: # Création d'une variable x avec une valauer égale à 1

x = 1

Pour afficher la variable x, on utilise la fonction print:

[ ]: print(x)

[ ]: # On peut changer la valeur de x à n'importe quel moment

x = 2
# On ré-imprime x
print(x)

[ ]: # Une ré-affectaion
x = x + 1 # Mise à jour de la valeur de la variable x en distant qu'elle est égale à la␣
,→velur actuelle de x + 1

print(x)

2
[ ]: # Une façon plus condensée de faire une réaffecation est d'utiliser
x += 1
print(x)

[ ]: # Création d'une deuxième variable

y = 3

2.2 Types de variables

2.2.1 Type integer int (entier)

[ ]: print("x est de type:", type(x))

2.2.2 Type float float (réel)

[ ]: z = 3.14
print("z est de type:", type(z))

2.2.3 Type string str (chaîne de caractère)

Pour l’affection on utilise soit l’apostrophe ou les guillemets.

[ ]: char = "Machine Learning"

# On peut l'imprimer
print(type(char))

[ ]: s = "Bonjour! Bienvenue dans l'UV: AI28-Machine Learning."

s

[ ]: [Link]()

[ ]: print([Link]())

[ ]: len(s)

[ ]: [Link]()[:40]

[ ]: sss = 'A'
sss += 'bc'
sss += "dE"
[Link]()

[ ]: [Link]().split('\n')

[ ]: ' '.join(['Il', 'fait', 'super', 'beau', "aujourd'hui"])

3
 2.2.4 Affectation simultanée
[ ]: # Création de deux variables sur la même ligne avec une affectation simultanée de deux␣
,→variables

v, w = 3, 4.5

2.3 Arithmétique

[ ]: print('x =', x, '\t', 'y =', y)

[ ]: print("Addition(x,y): x + y =", x + y)
print("Soustraction(x,y): x - y =", x - y)
print("Multiplication(x,y): x * y =", x * y)
print("Division(x,y):x / y =", x / y)
print("Puissance(x,y): x^y =", x ** y)

[ ]: # Une autre manière d'afficher les résultats en utilisant "\n" pour créer un saut de␣
,→ligne

print("Addition(x,y): x + y =", x + y, "\n")

print("Soustraction(x,y): x - y =", x - y, "\n")
print("Multiplication(x,y): x * y =", x * y, "\n")
print("Division(x,y):x / y =", x / y, "\n")
print("Puissance(x,y): x^y =", x ** y, "\n")

2.4 Expressions logiques, variables booléennes, opérateurs

Lors d’une comparaison, le résultat est de type booléen. Le type booléen nous permet de faire beaucoup
d’opérations de logique ainsi que des comparions:

[ ]: print(x <= y) # Permet de tester si x est inférieur ou égal à y

print(x >= y) # Permet de tester si x est supérieur ou égal à y
print(x < y) # Permet de tester si x est strictement inférieur à y
print(x > y) # Permet de tester si x est strictement supérieure à y
print(x == y) # Permet de tester l’égalité en valeur et en type entre x et y
print(x != y) # Permet de tester la différence en valeur ou en type entre x et y

[ ]: # Le booléen est un type de variable, on peut créer une variable ayant ce type par␣
,→exemple

boolean = True
print(boolean)

2.4.1 Opérateurs et logique

[ ]: print(False & True) # Opération AND (ET)

print(False | True) # Opération OR (OU)
print(False ^ True) # Opération XOR (OU exclusif): Le résultat est VRAI si les deux␣
,→opérandes ont des valeurs distinctes

4
 3 Fonctions
3.1 Expression lambda
L’expression lambda permet de créer une fonction de type mathématique. Pour utiliser l’expression
lambda lors d’une création d’une fonction il suffit d’écrire:
nom_de_la_fonction = lambda arguments: expression
[ ]: f = lambda x,y: x**2 + y # f(x,y) = x² + y

[ ]: # Appeler la fonction f
f(2,2)

3.2 Type générale d’une fonction Python

Pour développer des fonctions en toute généralité on utilise le prototype Python pour la création d’une
fonction:
def nom_de_la_fonctin(arguments):
intruction 1
intruction 2
...
return resultat
Les arguments se sont les valeurs dont on a besoin pour écrire les instructions dans la fonction.

[ ]: def IMC(poids, taille):

"""
L’indice de masse corporelle (IMC) permet d’évaluer rapidement la corpulence d'un␣
,→personne simplement avec son poids et sa taille.

"""
imc = poids / (taille ** 2)
return imc

[ ]: # Appeler la fonction IMC et passer des valeurs pour les arguments

IMC(75, 1.75)

Remarque. Les variables poids, taille, imc sont des variables internes, c’est à dire elles existent que dans la
fonction IMC. Les arguments poids et masse sont les keywords.

[ ]: # On peut aussi appeler la fonction IMC comme suit

IMC(poids=75, taille=1.75)

[ ]: # On peut affecter le résultat d'une fonction à une variable

var_imc = IMC(75, 1.75)
print(var_imc)

5
 3.3 Aide sous Python d’une fonction

[ ]: # Pour avoir la documentation de la fonction IMC

help(IMC)

Raccourci très utilisé pour avoir de l’aide sur une fonction dans un juypter notebook, il suffit de: taper
le nom_de_la_fonction puis TABULATION + SHIFT
Exemple:
`IMC + TABULATION + SHIFT`

4 Structures conditionnelles
Une structure de contrôle est un ensemble d’instructions qui permet de contrôler l’exécution du code. Il
existe différents types de structures de contrôle. Les deux types de structures les plus communément
utilisés sont les structures de contrôle conditionnelles qui permettent d’exécuter un bloc de code si une
certaine condition est vérifiée et les structures de contrôle de boucle qui permettent d’exécuter un bloc
de code en boucle tant qu’une condition est vérifiée.

4.1 Structure conditionnelle if / elif / else

• La condition if (“si”)
• La condition if...else (“si...sinon”)
• La condition if...elif...else (“si...sinon si... sinon”)
[ ]: x = 1
if x > 0.:
print(x, 'positif')
else:
print(x, 'négatif')

[ ]: x = -1
if x > 0: # Il faut que le résultat de la comparaison soit True pour donner x positif
print(x, 'positif')
else:
print(x, 'négatif')

[ ]: x = 0
if x > 0:
print(x, 'positif')
elif x == 0:
print(x, 'nul')
else:
print(x, 'négatif')

[ ]: x = 1
y = 2
if (x > 0) & (y > x): # Il faut que le résultat de l'opération logique AND (&) soit True␣
,→pour afficher x et y positifs

print(x, 'et', y, 'sont positifs')

6
 elif (x == 0) & (y == 0):
print(x, 'et', y, 'sont nuls')
else:
print(x, 'et', y, ' sont négatifs')

[ ]: # Crétion d'une fonction signe pour intégrer la structure conditionnelle if / elif /␣

,→else

def signe(x):
if x > 0:
print(x, 'positif')
elif x == 0:
print(x, 'nul')
else:
print(x, 'négatif')

[ ]: # Appels de la fonction signe pour différentes valeurs

signe(1)
signe(0)
signe(-1)

4.2 Boucle for

Elle permet de construire des algorithmes itératifs, c’est à dire les algorithmes dans lesquels les instructions
qui se répètent autant de fois qu’on désire, par exemple:

[ ]: for i in range(5):
print("Hello")

4.2.1 Fonction range

• range est une fonction de base dans Python qui permet de générer une séquence de nombre.
• range(5): séquence de nombres allant de 0 à 4.

[ ]: for element in range(5):

print(element)

[ ]: # Exécuter la ligne de code suivante pour avoir une aide de la fonction range
help(range)

[ ]: # range(start, stop[, step])

for element in range(5, 20, 5):
print(element)

[ ]: # Autre exemple
for element in range(20, -20, -5):
print(element)

[ ]: # Utiliser la fonction signe dans le boucle for

for element in range(20, -20, -5):
signe(element)

7
 4.3 Boucle while
On peut dire que la boucle while est un mélange de la structure conditionnelle if/elif/else et la boucle
for.
[ ]: x = -5
while x < 5:
print(x)
x += 2

[ ]: def fibonnacci(n):
# Retourne la suite de Fibonnacci jusqu'à la valeur n
terme_0 = 0
terme_1 = 1
while(terme_0 <= n):
print(terme_0)
terme_n = terme_0 + terme_1
terme_0 = terme_1
terme_1 = terme_n

5 Structures de données: listes et tuples

5.1 Listes
[ ]: liste_num = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # Création d'une liste numérique
liste_chr = ['Paris', 'Compiègne', 'Rouen'] # Liste de chaines de caractères
liste_de_listes = [liste_num, liste_chr] # Création d'une lsite de listes
liste_vide = [] # Création d'un liste vide
liste_de_listes_vides = [[]]

[ ]: print(liste_num)

[ ]: print(liste_chr)

[ ]: print(liste_de_listes)

[ ]: print(liste_vide)

[ ]: print(liste_de_listes_vides)

[ ]: # Taille (size) d'une liste

taille_liste_num = len(liste_num)
print(taille_liste_num)

[ ]: taille_liste_de_listes = len(liste_de_listes)
taille_liste_de_listes # La liste_de_listes contient deux listes donc elle est de taille␣
,→2

[ ]:

8
 # Attention il faut pas déclarer une liste par le nom list car il indique le type list␣
,→dans Python

print(type(liste_num)) # list est un type de variable dans Python

5.2 Tuples

[ ]: # Un tuple est une liste d'élements entre paranthèses, sauf qu'une fois il est créé, one␣
,→ne peut pas le modifier (immutable).

# Un tuple utilise moins de mémoire sur votre ordinateur qu'une liste. Utile pour faire␣
,→passer beaucoup de données,

# certes on utlise très rarement les tuples, en général on utlise les listes
tuple_1 = (1, 2, 3, 4, 5, 6, 7)
print(tuple_1)

[ ]: # Attention il ne faut pas déclarer un tuple par le mot tuple car il refère à un type de␣
,→variable dans Python

print(type(tuple_1))

5.3 Technique d’indexing

Les listes et les tuples forment ce qu’on appelle des séquences. Une séquence est une structure de données
qui suit un ordre (il y a un premier élément, un deuxième élément et ainsi de suite, jusqu’à atteindre un
dernier élément). En fait, chaque élément dans la liste ou tuple a un indice. Grâce à ce système d’indice on
peut accéder à n’importe quel élément dans la séquence.

[ ]: # Exemple
liste_chr

[ ]: liste_chr[0] # Premier élément dans la liste de chaines de caractères

[ ]: liste_chr[1] # Second élément dans la liste de chaines de caractères

[ ]: liste_chr[2] # Dernier élément dans la liste de chaines de caractères

[ ]: # 'Paris' est à l'index 0 dans la liste_chr

# 'Compiègne' est à l'index 1 dans la liste_chr
# 'Rouen' est à l'index 2 dans la liste_chr

[ ]: # Pour accéder directement au dernier élément dans une séquence on utilise l'index -1
print(liste_chr[-1])
print(tuple_1[-1])

[ ]: # Pour accéder directement à l'avant dernier élément dans une séquence on utilise␣
,→l'index -2

print(liste_chr[-2])
print(tuple_1[-2])

9
 5.4 Technique de slicing
Elle permet à accéder à une fourchette d’éléments dans une séquence en indiquant une fourchette d’index
Liste[index_début: index_fin: pas]
Çà nous rappelle la fonction range: range(début, fin, pas)

[ ]: # Prenons l'exemple de liste_num

print(liste_num)
# Pour extraire les 3 premiers listes d'éléments de la liste_num
print(liste_num[0:3])

[ ]: # On peut ignorer l'index 0 si on voulait faire le slicing à partir de cet index

print(liste_num[:3])

[ ]: # Extraire les éléments de la liste_num à partir de l'index 3 jusqu'à la fin

print(liste_num[3:])

[ ]: print(liste_num[3:8:2])

[ ]: print(liste_num[3:8:3]) # Extraire les éléments de la liste en commençant avec l'index 3␣

,→jusqu'à l'index 8 avec un pas 3

[ ]: print(liste_num[::3]) # Extraire tous les éléments de la liste avec un pas 3

[ ]: print(liste_num[::-3]) # Extraire tous les éléments à l'envers (de la fin jusqu'au␣

,→début) de la liste avec un pas 3

[ ]: # Inverser la liste_num
print(liste_num[::-1])

[ ]: # On peut changer la valeur d'un élément de la séquence

print(liste_chr, '\n')
liste_chr[2] = 'Compiègne'
print(liste_chr)

5.5 Différentes méthodes et actions sur une liste

Différentes méthodes qu’on peut utiliser et effectuer sur une liste:

[ ]: voitures = ['porsche', 'bmw', 'mercedes', 'peugeot', 'citroen']

5.5.1 Méthode append

Elle permet de rajouter un élément à la liste tout à la fin

[ ]: [Link]('toyota')# Permet de rajouter un élément à la liste tout à la fin

print(voitures)

10
 5.5.2 Méthode insert
Elle permet de rajouter un élément à un index bien déterminé de la liste

[ ]: [Link](3, 'opel') # Permet de rajouter l'élment opel à l'index 3 de la liste␣

,→voitures

print(voitures)

5.5.3 Méthode extend

Elle permet d’ajouter une liste à la fin d’une autre liste.

[ ]: voitures_1 = ['porsche', "nissan", 'mazda']

[Link](voitures_1)
print(voitures)

[ ]: len(voitures) # Taille de la liste

[ ]: # Trier la liste par ordre alphabétiques

[Link]()
print(voitures)

[ ]: # Trier la liste par ordre anti-alphabétique

[Link](reverse=True)
print(voitures)

[ ]: voitures

[ ]: # De même on peut aussi trier les lites numériques

liste_num = [34, -9, 5, 0, -3, -20, 3, 4.5, 9.5]
liste_num.sort() # Ordre croissant
liste_num

[ ]: liste_num.sort(reverse=True) # Ordre décroissant

liste_num

5.5.4 Méthode count

Elle permet de compter combien de fois un élément réapparait dans une liste.

[ ]: [Link]('porsche') # 'porsche' apparait deux fois dans la liste voitures

5.6 Liste dans les structures de contrôle

[ ]: # Vérifier si un élément est dans une liste
if 'renault' in voitures:
print('oui')
else:
print('non')

11
[ ]: # Boucle 'for' pour manipuler les éléments de la liste
for voiture in voitures:
print(voiture)

5.6.1 Commande enumerate

[ ]: # Extraire l'index d'un élément dans une liste
for index, element in enumerate(voitures):
print(index, element)

5.6.2 Commande zip

Elle permet d’utiliser la boucle for avec deux listes en parallèle

[ ]: for a, b in zip(voitures, liste_num):

print(a, b)

[ ]: # La boucle for s'arrêtera là ou la liste la plus courte s'arrête

for a, b in zip(voitures, liste_num[:5]):
print(a, b)

5.7 Dictionnaires (tableaux associatifs)

Le dictionnaire est une structure de données non ordonnée, c’est à dire que les valeurs n’ont pas d’index.
Par contre elles ont des clés (keys en anglais). On peut voir un dictionnaire comme un ensemble
d’affectation clé:valeur.
Attention lors d’une création d’un dictionnaire avec le nom dict, car il indique le type de variable dict (pour
dire dictionnaire) en Python.

[ ]: dictionnaire_chr = {'chat':'animal', 'voiture':'vehicule', 'ordinateur': 'informatique'}

# Afficher dictionnaire
print(dictionnaire_chr)

[ ]: # Type
print(type(dictionnaire_chr))

[ ]: # Taille de dictionnaire
print(len(dictionnaire_chr)) # 3 associations

[ ]: # ATTENTION: dans un dictionnaire chaque clé est unique

[ ]: dictionnaire_num = {
'PC windows':'3000',
'PC Apple': '500',
'PC Linux': '1500'
}

[ ]: # On peut créer des dictionnaires qui contient d'autres dictionnaires (Nested␣

,→dictionnaire)

12
 nested_dict = {
'dict_1': dictionnaire_chr,
'dict_2': dictionnaire_num
}

[ ]: print(nested_dict)

Les dictionnaires sont très utilisés dans le machine learning et le deep learning pour stocker les paramètres
de certains modèles (e.g., les paramètres d’un réseaux de neurones en deep). On peut l’utiliser dans dif-
férents fonctions et méthodes de certains algorithmes.

5.7.1 Opérations de bases sur les dictionnaires

Méthode values
[ ]: # Imprimer toutes les valeurs d'un dictionnaire
dictionnaire_num.values()

Méthode keys
[ ]: # Obtenir les clés d'un dictionnaire
dictionnaire_num.keys()

[ ]: # Taille d'un dictionnaire

len(dictionnaire_num)

[ ]: # Ajouter un élément dans un dictionnaire

dictionnaire_num['tablettes'] = 200
dictionnaire_num

[ ]: # Rappel: dans un dictionnaire, il n' y a pas d'ordre (pas de début, pas de fin)

Méthode get Elle permet de vérifier l’existence d’une clé dans un dictionnaire

[ ]: print(dictionnaire_num.get('smartphones'))
# Retourne rien (None)

[ ]: # Retourner une valeur par défaut

print(dictionnaire_num.get('smartphones', -1))
# Retourne -1

[ ]: print(dictionnaire_num.get('tablettes'))

Méthode fromkeys Elle permet de créer un dictionnaire tout entier à partir d’une liste de clés qu’on
fournit.
[ ]: liste = ['pain', 'gateau', 'glace']
dict_liste = {} # Déclarer un dictionnaire vide
dict_liste.fromkeys(liste)

[ ]: dict_liste.fromkeys(liste, '5') # Chaque clé est associée à une valeur 5 par défaut

13
 Méthode pop La méthode pop a deux effets: permet de retirer une association et de retourner sa valeur.

[ ]: dictionnaire_num

[ ]: dictionnaire_num.pop('PC Apple')

[ ]: dictionnaire_num

5.7.2 Dictionnaires dans les boucles for

[ ]: # Afficher uniquement les clés d'un dictionnaire
for i in dictionnaire_num:
print(i)

[ ]: # Afficher uniquement les valeurs d'un dictionnaire

for i in dictionnaire_num.values():
print(i)

Méthode items Afficher les clés et valeurs d’un dictionnaire au même temps.

[ ]: for key, val in dictionnaire_num.items():

print(key, val)

[ ]: # Listes en compréhension et dictionnaires en compréhension

liste = []
for i in range(5):
[Link](i**3)
print(liste)

[ ]: # Les listes en compréhension dévoile une pythonisation dans le code (çà fait plus␣
,→python), çà reflété une façon professionnelel de code

liste_comp = [i**3 for i in range(5)]

liste_comp

[ ]: # Le processus de la création de cette lsite se fait rapidement contrario à la méthode␣

,→classique

# On peut comparer le temps d'excution dans Python de ces deux façons

import time

tic = [Link]() # Mesurer le temps au début de l'algorithme

liste = []
for i in range(100):
[Link](i**3)
tac_class = [Link]() - tic # Mesurer le temps pour l'excecution
print("Temps d'exécution avec la méthode classique est: %s" %tac_class)

[ ]: tic = [Link]()
liste_comp = [i**3 for i in range(100)]
tac_comp = [Link]() - tic
print("Temps d'exécution avec la liste en compréhension est: %s" %tac_comp)

14
[ ]: print("ratio de temps est égal à :%s" %(tac_class / tac_comp))

[ ]: # Création d'une liste de listes avec la liste en compréhension

liste_comp_1 = [[i for i in range(4)] for j in range(4)]
liste_comp_1

5.7.3 5.7.3. Dictionnaire en compréhension

L’intérêt d’utiliser les dictionnaires en compréhension: plus professionnel, plus court, et plus performant
(plus rapide à s’exécuter).

[ ]: dictionnaire = dictionnaire_num
dictionnaire

[ ]: departements = ['GI', 'BMBI', 'GM']

dict_compr = {key:val for key, val in enumerate(departements)}
dict_compr

[ ]: dict_compr.values() # Afficher les différents valeurs de dcitionnaire dict_compr

[ ]: dict_compr.keys() # Afficher les différents clés de dictionnaire dict_compr

[ ]: # Création d'un dictionnaire à partir d'un zip de deux listes

followers = [300, 220, 170, 250]
reseaux = ['facebook', 'twitter', 'instagram', 'youtube']

dictionnaire_1 = {reseau:follower for reseau, follower in zip(reseaux, followers)}

dictionnaire_1

[ ]: # on peut rajouter une condition sur les éléments

dictionnaire_2 = {reseau:follower for reseau, follower in zip(reseaux, followers) if␣
,→follower > 230}

dictionnaire_2

6 Fonctions natives (built-in) de Python

[Link]
[ ]: from [Link] import HTML
HTML('<IFrame src="[Link] width=700␣
,→height=350>')

[ ]: x = -4
abs(x) # Retourne la valeur absolute de x

[ ]: x = 3.145678
round(x)

15
[ ]: liste = [2, -3, 4, -5, 67, -9]
max(liste) # Retourne la valeur maximale dans la liste

[ ]: min(liste) # Retourne la valeur minimale dans la liste

[ ]: sum(liste) # Retourne la somme des éléments de toute la liste

[ ]: liste_bool = [True, True, False, False, True]

[ ]: all(liste_bool) # Retourne True si tous les éléments de la liste sont True

[ ]: any(liste_bool) # Retourne True si un élément de la liste est True

[ ]: liste_num

[ ]: all(liste_num)

[ ]: liste_num[5] = 7
liste_num

[ ]: all(liste_num) # Retourne True car tous les éléments sont différents de 0

[ ]: Image("./imgs/fonctions_natives.png")

6.1 Conversions (casting)

[ ]: x = 3.5
type(x)

[ ]: x = int(x) # Convertir la variable x en entier integer

type(x)

[ ]: x = str(x)
type(x)

[ ]: x

[ ]: # Les termes list, tuple, dict, sont protégés par Python (réservés aux fonctions dans␣
,→Python)

[ ]: liste = [1, 2, 3, 5]
tuple_ = tuple(liste)
tuple_

[ ]: dictionnaire_num

[ ]: type(dictionnaire_num.values())

[ ]: list(dictionnaire_num.values())

16
[ ]: list(dictionnaire_num.keys())

6.2 Fonction format

Elle permet de personnaliser les chaînes de caractères, de les rendre dynamique

[ ]: time = 34
algorithm = 'LS'
message = "Le temps écoulé de l'algorithme {} est {} secondes".format(algorithm, time)
print(message)

[ ]: # Une autre façon de ré-écrire

time = 25
algorithm = 'RL'
message = f"Le temps écoulé de l'algorithme {algorithm} est {time} secondes"
print(message)

6.3 Fonction open

[ ]: f = open('[Link]', 'w') # Création d'une fichier en mode écriture (write (w))

[ ]: [Link]("bienvenue à l'UV AI28")

[Link]() # Fermer le fichier
# Dans votre répertoire de travail vous venez de créer un fichier qui s'appelle [Link]␣
,→contenant le message "bienvenue à l'UV AI28"

[ ]: f = open('[Link]', 'r') # Ouvrir le fichier [Link] en mode leacture (read (r))

[Link]() # Afficher le contenu dans le [Link]

[ ]: #
with open('[Link]', 'r') as f:
print([Link]())

[ ]: with open('[Link]', 'w') as f:

for i in range(5):
[Link]('{}² = {}\n'.format(i, i**2))

7 Documents Multimedia dans un notebook

7.1 Intégrer une image

[ ]: from [Link] import Image

Image("[Link]

17
 7.2 Intégrer une vidéo youtube

[ ]: from [Link] import YouTubeVideo

YouTubeVideo('EZJcm0_UOlE')

7.3 Intégrer une page web

[ ]: from [Link] import HTML

HTML('<IFrame src="[Link] width=700 height=350>')

8 Exercices
Exercice 1
Afficher dans une liste les carrées des nombres paires entre 0 et 20:
1. en utilisant les liste en compréhension.
2. en utilisant map.

Exercice 2
Définir la liste : liste = [17, 38, 10, 25, 72, 99, 0, -20], puis effectuez les actions suivantes:
1. Triez et affichez la liste.
2. Ajoutez l’élément 12 à la liste et affichez la liste.
3. Renversez et affichez la liste.
4. Affichez l’indice de l’élément 17.
5. Enlevez l’élément 38 et affichez la liste.
6. Affichez la sous-liste du 2ème et 3ème élément.
7. Affichez la sous-liste du début au 3ème élément.
8. Affichez la sous-liste du 3ème élément à la fin de la liste.
9. Affichez la sous-liste complète de la liste.

Exercice 3
Écrire une fonction compterMots ayant un argument (une chaîne de caractères) et qui renvoie un dictionnaire
qui contient la fréquence de tous les mots de la chaîne entrée.

18