Formation en Python_Niveau1_2023.pptx

Séance 1
1-Faites connaissance avec Python
▪ Pourquoi apprendre Python ?
▪ Choisir l’environnement de développement
▪ Installer Python !
2-Hello, Python
▪ Une introduction à la syntaxe Python
▪ Affectation de variables et aux nombres
▪ Modifier des chaînes de caractères
▪ Modifier des nombres
▪ Le casting

1-Faites connaissance avec Python
• Typage dynamique : pas besoin de déclarer le type des variables !
• La syntaxe épurée de Python : l’indentation est obligatoire
• Multi paradigme : impératif et orienté-objet
• Extensible : Interfaçable avec d’autres bibliothèques et modules
Ce cours couvre les principales compétences Python dont vous aurez besoin
pour commencer à utiliser Python pour la science des données, applications
web, applications bureaux, Iot, Robotique, Application mobile, Big Data
Lien de téléchargement : https://www.python.org/download/

Mise en route
Nous pouvons utiliser Python Interpreter selon deux modes:
1. Mode interactif
Un interpréteur Python en mode interactif est appelé Python Shell. Pour
démarrer le shell Python, entrez la commande python dans invite de commandes
Pour sortir de l’interpréteur, entrez
simplement : exit() (attention aux
parenthèses !) puis appuyez sur la
touche entrée.

2. Mode script
En plus d'installer un interpréteur Python, le programme
d'installation de Python installe également un environnement de
développement intégré léger IDLE.
IDLE a également un éditeur de
texte intégré pour écrire des
programmes Python.
Python Shell
Editeur

Définir une variable
Pour définir une variable, nous allons taper son nom, un signe égal puis sa valeur.
>>> """Ma ligne commence ici...
... … et se continue ici
... """
● Nombres (integers and floats)
● Chaînes de caractères (strings)
● Booléens (booleans)
Un booléen est une information Vraie ou Fausse. Ce type nous sera très utile un peu
plus tard lorsque nous commencerons à comparer des valeurs entre elles. Sans
surprise, vrai est True et faux est False
>>> 1 < 2
True
⇒ Vous pouvez utiliser des guillemets doubles ou simples, mais pensez à utiliser les mêmes au début et à la fin
>>> quote = "San Antonio a dit : 'Ecoutez-moi, Monsieur Shakespeare: Nous avons beau être ou ne pas
être, nous sommes !'"

Affectation de variable
Affectation de variable : Ici, nous créons une variable appelée A et lui affectons la valeur 0 à l'aide de =, qui
s'appelle l'opérateur d'affectation.
Python ne nous oblige pas à faire ici :
1. nous n'avons pas besoin de "déclarer" A avant de lui attribuer
2. nous n'avons pas besoin de dire à Python à quel type de valeur A va faire référence.
⇒ En fait, nous pouvons même continuer à réaffecter A pour faire référence à un autre type de chose comme une
chaîne ou un booléen.

Nombres et arithmétique en
Python
Il existe deux grands types de nombres en Python : les entiers (integers) et les décimaux (floats).
>>> my_integer = 4
>>> my_float = 1.3
type() est la deuxième fonction intégrée que nous avons vue (après print()), et c'est une autre bonne à
retenir. Il est très utile de pouvoir demander à Python "quel genre de chose est-ce ?".
print(5 / 2)
print(6 / 2)
print(5 // 2)
print(6 // 2)
type(19.95) type(my_float )
total = "Spam " * my_integer
print(total)

Python
print(min(1, 2, 3))
print(max(1, 2, 3))
print(abs(32))
print(abs(-32))
print(float(10))
print(int(3.33))
# They can even be called on strings!
print(int('807') + 1)
● En plus d'être les noms des deux principaux types numériques de Python, int et float peuvent
également être appelés en tant que fonctions qui convertissent leurs arguments dans le type
correspondant
● abs() renvoie la valeur absolue d'un argument :
● min() et max() renvoient respectivement le minimum et le maximum de leurs arguments
Fonctions prédéfinie

Python
L'opérateur * peut être utilisé pour multiplier deux nombres (3 * 3 équivaut à 9), mais nous pouvons également multiplier une chaîne par
un nombre, pour obtenir une version qui a été répétée autant de fois. Python propose un certain nombre de petites astuces effrontées
comme celle-ci où les opérateurs comme * et + ont une signification différente selon le type de chose auquel ils sont appliqués. (Le terme
technique pour cela est la surcharge de l'opérateur.)

Quiz
Q1 - Which of the following function
removes all leading whitespace in string?
string
A - lower()
B - lstrip()
C - max(str)
D - min(str)
Q2 - Which of the following function
converts a string to all uppercase? string
A - upper()
B - isdecimal()
C - swapcase()
D - title()
Q3 - Which of the following function checks
in a string that all characters are in
uppercase?Bolean
A - isupper()
B - join(seq)
C - len(string)
D - ljust(width[, fillchar])

Rappel : Variables Python
Variables : Les variables sont des conteneurs pour stocker des valeurs de données.
Création de variables
Python n'a pas de commande pour déclarer une variable.
Une variable est créée au moment où vous lui attribuez une valeur pour la première fois.
Exemple
x = 5
y = "John"
print(x)
print(y)

Rappel : Variables Python
 Les variables n'ont pas besoin d'être déclarées avec un type particulier et
peuvent même changer de type après avoir été définies.
x = 4 # x is of type int
x = "Sally" # x is now of type str
print(x)
Casting : Si vous souhaitez spécifier le type de données d'une variable, vous
pouvez le faire avec cast.
x = str(3) # x will be '3'
y = int(3) # y will be 3
z = float(3) # z will be 3.0

Rappel : Python - Noms des variables
Noms des variables
Une variable peut avoir un nom court (comme x et y) ou un nom plus descriptif (age, carname, total_volume). Règles pour
les variables Python :
1) Un nom de variable doit commencer par une lettre ou le caractère de soulignement
2) Un nom de variable ne peut pas commencer par un chiffre
3) Un nom de variable ne peut contenir que des caractères alphanumériques et des traits de soulignement (Az, 0-9 et _ )

Rappel : Python - Noms des variables
Les noms de variables sont sensibles à la casse (age, Age et AGE sont trois variables différentes)
Exemple
Noms des variables légales :
myvar = "John"
my_var = "John"
_my_var = "John"
myVar = "John"
MYVAR = "John"
myvar2 = "John"

 Variables Python - Attribuer plusieurs valeurs
De nombreuses valeurs à plusieurs variables :
Python vous permet d'attribuer des valeurs à plusieurs variables sur une seule ligne :
Exemple
x, y, z = "Orange", "Banana", "Cherry"
print(x)
print(y)
print(z)

Python - Variables de sortie
 La fonction Python print()est souvent utilisée pour générer des variables.
x = "Python is awesome"
print(x)
 Dans la print()fonction, vous affichez plusieurs variables, séparées par une virgule :
x = "Python"
y = "is"
z = "awesome"
print(x, y, z)
 Vous pouvez également utiliser l' + opérateur pour générer plusieurs variables :
x = "Python "
y = "is "
z = "awesome"
print(x + y + z)

 Pour les nombres, le +caractère fonctionne comme un opérateur mathématique :
x = 5
y = 10
print(x + y)
 Dans la print()fonction, lorsque vous essayez de combiner une chaîne et un nombre avec l' +
opérateur, Python vous renvoie une erreur :
x = 5
y = "John"
print(x + y)
 La meilleure façon de sortir plusieurs variables dans la print()fonction est de les séparer par
des virgules, qui prennent même en charge différents types de données
x = 5
y = "John"
print(x, y)
Python - Variables de sortie

Les structures conditionnelles if, if…else et if…elif…else en Python
 Égal à : a == b
 Pas égal à : a != b
 Inférieur à : a < b
 Inférieur ou égal à : a <= b
 Supérieur à : a > b
 Supérieur ou égal à : a >= b
Ces conditions peuvent être utilisées de plusieurs manières, le plus souvent dans des "instructions if" et des
boucles.
Python prend en charge les conditions logiques habituelles des mathématiques :
Conditions Python et instructions If

Une "instruction if" est écrite à l'aide du mot- clé if .
Si déclaration :
a = 33
b = 200
if b > a:
print("b is greater than a")
Dans cet exemple, nous utilisons deux variables, a et b , qui sont utilisées dans le cadre de l'instruction if pour
tester si b est supérieur à a . Comme a est 33 , et b est 200 , nous savons que 200 est supérieur à 33, et donc
nous affichons à l'écran que "b est supérieur à a".

Indentation
Python s'appuie sur l'indentation (espace au début d'une ligne) pour définir la portée dans le
code. D'autres langages de programmation utilisent souvent des accolades à cette fin.
Exemple
Si l'instruction, sans indentation (soulèvera une erreur):
a = 33
b = 200
if b > a:
print("b is greater than a") # you will get an error

Booléens et conditionnels
● Python a un type de variable appelé bool. Il a deux valeurs possibles : True et False.
Booléens & Opérations de comparaison
● Nous obtenons généralement des valeurs booléennes à partir d'opérateurs booléens. Ce sont des opérateurs qui répondent
aux questions oui/non. Les opérateurs de comparaisons permettent de comparer entre eux des objets de tous les types de
base. Le résultat d’un test de comparaison produit des valeurs booléennes.

Booléens et conditionnels
Booléens & Opérations de comparaison
'3' == 3
3.0 == 3
def can_run_for_president(age):
"""Can someone of the given age run for president in the US?"""
# The US Constitution says you must be at least 35 years old
return age >= 35
print("Can a 19-year-old run for president?", can_run_for_president(19))
print("Can a 45-year-old run for president?", can_run_for_president(45))

Les Listes
 Les listes sont utilisées pour stocker plusieurs éléments dans une seule variable.
 Les listes sont l'un des 4 types de données intégrés à Python utilisés pour stocker des collections de données,
les 3 autres sont Tuple , Set et Dictionary , tous avec des qualités et une utilisation différentes.
1) List est une collection ordonnée et modifiable. Autorise les membres en double.
2) Tuple est une collection ordonnée et immuable. Autorise les membres en double.
3) Set est une collection non ordonnée, non modifiable* et non indexée. Aucun membre en double.
4) Dictionary est une collection ordonnée** et modifiable. Aucun membre en double
Les listes sont créées à l'aide de crochets :
Créer une liste:
thislist = ["apple", "banana", "cherry"]
print(thislist)
Définition & Déclaration

Les Listes
Éléments de la liste
 Les éléments de liste sont ordonnés, modifiables et autorisent les valeurs en double.
● Les éléments de la liste sont indexés, le premier élément a index [0], le deuxième élément a index [1]etc.
● Lorsque nous disons que les listes sont ordonnées, cela signifie que les éléments ont un ordre défini et
que cet ordre ne changera pas.
● Si vous ajoutez de nouveaux éléments à une liste, les nouveaux éléments seront placés à la fin de la
liste.
● La liste est modifiable, ce qui signifie que nous pouvons modifier, ajouter et supprimer des éléments dans
une liste après sa création.

Les Listes
Éléments de la liste
Autoriser les doublons : Puisque les listes sont indexées, les listes peuvent avoir des éléments avec la même
valeur.
thislist = ["apple", "banana", "cherry", "apple", "cherry"]
print(thislist)
Longueur de la liste
Pour déterminer le nombre d'éléments d'une liste, utilisez la len()fonction :
Afficher le nombre et le type d'éléments dans la liste :
print(len(thislist))
print(type(thislist))

Les Listes
● Les listes en Python représentent des séquences ordonnées de valeurs.
L2 = [2, 3, 5, 7] #Liste des entiers
L3 = ['Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi] #Liste des chaînes de caractères
L4 = ['6', 'A', 'K'] #Liste de différents types de variables
L1 = [] #Liste vide
● Une liste peut contenir un mélange de différents types de variables

Les Listes
Le constructeur list()
Il est également possible d'utiliser le constructeur list() lors de la création d'une nouvelle liste.
Utilisation du list()constructeur pour créer une liste :
thislist = list(("apple", "banana", "cherry")) # note the double round-brackets
print(thislist)

Indexing
Les Listes
● Vous pouvez accéder à des éléments de liste individuels avec des crochets
● Python utilise une indexation de base zéro, donc le premier élément a l'index 0
L3 = ['Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi] #Liste des chaînes de caractères
⇒ Afficher le premier jour de la semaine:
L3[0] #L’index 0
Lundi
⇒ Afficher le premier jour de la semaine:
⇒ Afficher le dernier jour de la semaine:
L3[-1] #L’index -1
Vendredi
L3[1] #L’index 1
Mardi

Trancher une liste
Les Listes
Quelles sont les trois premiers jours de la semaine ? Nous pouvons répondre à cette question en utilisant
le slicing:
L3[0:3]
['Lundi', 'Mardi', 'Mercredi']
⇒ à partir de l'index 0 et en continuant jusqu'à mais sans inclure l'index 3
Les index de début et de fin sont tous deux facultatifs. Si je laisse de côté l'index de début, il est
supposé être 0. Je pourrais donc réécrire l'expression ci-dessus comme suit:
L3[:3]
['Lundi', 'Mardi', 'Mercredi']
Si je laisse de côté l'index de fin, il est supposé être la longueur de la liste:
L3[3:]
['Jeudi', 'Vendredi]

Modification des listes
Les Listes
Pour modifier la valeur d'un élément spécifique, reportez-vous au numéro d'index :
Modifiez le deuxième élément :
thislist[1] = "blackcurrant"
print(thislist)
Modifier une plage de valeurs d'éléments
Pour modifier la valeur des éléments dans une plage spécifique, définissez une liste avec les nouvelles valeurs et référez-vous à la plage de
numéros d'index où vous souhaitez insérer les nouvelles valeurs :
Remplacez les valeurs "banane" et "cerise" par les valeurs "cassis" et "pastèque" :
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "mango"]
thislist[1:3] = ["blackcurrant", "watermelon"]
print(thislist)
Si vous insérez plus d'éléments que vous n'en remplacez, les nouveaux éléments seront insérés là où vous avez spécifié et les éléments
restants se déplaceront en conséquence.

Modification des listes
Les Listes
Remarque : La longueur de la liste change lorsque le nombre d'éléments insérés ne correspond
pas au nombre d'éléments remplacés.
Si vous insérez moins d'éléments que vous n'en remplacez, les nouveaux éléments seront insérés là où
vous avez spécifié et les éléments restants se déplaceront en conséquence :
Modifiez la deuxième et la troisième valeur en les remplaçant par une seule valeur :
thislist[1:3] = ["watermelon"]
print(thislist)

Insérer des éléments
Les Listes
 Pour insérer un nouvel élément de liste, sans remplacer aucune des valeurs existantes, nous pouvons
utiliser la méthode insert() .
 La méthode insert() insère un élément à l'index spécifié.
Insérez "pastèque" comme troisième élément :
thislist.insert(2, "watermelon")
print(thislist)
>>>['apple', 'banana', 'watermelon', 'cherry']

Ajouter des éléments de liste
Les Listes
 Pour ajouter un élément à la fin de la liste, utilisez la méthode append() :
 Utilisation de la méthode append() pour ajouter un élément :
thislist.append("orange")
print(thislist)
Insérer des éléments
 Pour insérer un élément de liste à un index spécifié, utilisez la méthode insert().
 La méthode insert() insère un élément à l'index spécifié :
Insérer un élément en deuxième position :
thislist.insert(1, "orange")
print(thislist)

Ajouter des éléments de liste
Les Listes
Étendre la liste
Pour ajouter des éléments d' une autre liste à la liste actuelle, utilisez la méthode extend().
Ajoutez les éléments de tropical à thislist:
tropical = ["mango", "pineapple", "papaya"]
thislist.extend(tropical)
print(thislist)
>>>['apple', 'banana', 'cherry', 'mango', 'pineapple', 'papaya']
=> Les éléments seront ajoutés à la fin de la liste.

Supprimer les éléments de la liste
Les Listes
 Supprimer l'élément spécifié
La méthode remove() supprime l'élément spécifié.
thislist.remove("banana") # Supprimer "banane"
print(thislist)
 Supprimer l'index spécifié
La pop()méthode supprime l'index spécifié.
Thislist. # Supprimez le deuxième élément
print(thislist)
 Si vous ne spécifiez pas l'index, la pop()méthode supprime le dernier élément.
thislist.pop() #Supprimez le dernier élément
print(thislist)

Supprimer les éléments de la liste
Les Listes
Le mot clé del supprime également l'index spécifié :
Supprimez le premier élément :
del thislist[0]
print(thislist)
Le mot-clé del peut également supprimer complètement la liste.
Supprimez toute la liste :
del thislist
print(thislist) #this will cause an error because you have succsesfully deleted "thislist".

Effacer la liste
Les Listes
La méthode clear() vide la liste.
La liste demeure, mais elle n'a pas de contenu.
Effacez le contenu de la liste :
thislist.clear()
print(thislist) #[]

Boucle dans une liste
Les Listes
Vous pouvez parcourir les éléments de la liste en utilisant une boucle for:
Afficher tous les éléments de la liste, un par un :
for x in thislist:
print(x)

Fonctions de liste
Les Listes
● Python a plusieurs fonctions utiles pour travailler avec des listes.
len(planets)
sorted(planets)
primes = [2, 3, 5, 7]
sum(primes)
max(primes)
● Nous avons précédemment utilisé le min et le max pour obtenir le minimum ou le maximum de
plusieurs arguments. Mais nous pouvons également passer un seul argument de liste

Les méthodes
Les Listes
● list.append modifie une liste en ajoutant un élément à la fin
● list.pop supprime et renvoie le dernier élément d'une liste
planets.append('Pluto')
planets.pop()
● Trouver l’index d’un élément en utilisant la méthode list.index.
planets.index('Earth')
"Earth" in planets
● Pour éviter de mauvaises surprises , nous pouvons utiliser l'opérateur in pour déterminer si une liste
contient une valeur particulière

Les tuples
● Les tuples sont presque exactement les mêmes que les listes. Ils ne diffèrent que de deux manières.
1 : La syntaxe pour les créer utilise des parenthèses au lieu de crochets
t = (1, 2, 3)
2 : Ils ne sont pas modifiables (ils sont immuables)
t[0] = 100

Tuples
 Les tuples sont utilisés pour stocker plusieurs éléments dans une seule variable.
 Un tuple est une collection ordonnée et inchangeable .
 Les tuples sont écrits entre parenthèses.
Créez un tuple :
thistuple = ("apple", "banana", "cherry")
print(thistuple)

Tuples
 Les éléments de tuple sont ordonnés, non modifiables et autorisent les valeurs en double.
 Les éléments de tuple sont indexés, le premier élément a index [0], le deuxième élément a index [1] etc.
 Ordonné
 Lorsque nous disons que les tuples sont ordonnés, cela signifie que les éléments ont un ordre défini et que cet ordre ne changera pas.
 Non modifiable
 Les tuples sont immuables, ce qui signifie que nous ne pouvons pas modifier, ajouter ou supprimer des éléments après la création du tuple.
 Autorise les doublons
 Puisque les tuples sont indexés, ils peuvent avoir des éléments avec la même valeur

Tuples
 Pour déterminer le nombre d'éléments d'un tuple, utilisez la
fonction len():
 Afficher le nombre d'éléments dans le tuple :
print(len(thistuple))

Tuples
 Créer un tuple avec un élément
 Pour créer un tuple avec un seul élément, vous devez ajouter une virgule après l'élément, sinon Python ne le reconnaîtra pas
comme un tuple.
 Un tuple d'élément, rappelez-vous la virgule :
thistuple = ("apple",)
print(type(thistuple)) #NOT a tuple
thistuple = ("apple")
print(type(thistuple))

Tuples
 Types de données
 Les éléments de tuple peuvent être de n'importe quel type de données :
Types de données chaîne, int et booléen :
tuple1 = ("apple", "banana", "cherry")
tuple2 = (1, 5, 7, 9, 3)
tuple3 = (True, False, False)
Un tuple peut contenir différents types de données :
 Un tuple avec des chaînes, des entiers et des valeurs booléennes :
tuple1 = ("abc", 34, True, 40, "male")

Tuples
 Le constructeur tuple()
 Il est également possible d'utiliser le constructeur tuple() pour créer un tuple.
 Utilisation de la méthode tuple() pour créer un tuple :
thistuple = tuple(("apple", "banana", "cherry")) # note the double round-brackets
print(thistuple)

Tuples
Rappel
 Il existe quatre types de données de collecte dans le langage de
programmation Python :
1) List est une collection ordonnée et modifiable. Autorise les membres
en double.
2) Tuple est une collection ordonnée et non modifiable. Autorise les
membres en double.

Accéder aux éléments Tuple
Vous pouvez accéder aux éléments de tuple en vous référant au numéro d'index, entre crochets :
 Imprimez le deuxième élément du tuple :
print(thistuple[1])
Remarque : Le premier élément a l'index 0.Indexation négative
 L'indexation négative signifie commencer par la fin.
-1 fait référence au dernier élément, -2 fait référence à l'avant-dernier élément, etc.
 Imprimez le dernier élément du tuple :
print(thistuple[-1])
Tuples

 Vous pouvez spécifier une plage d'index en spécifiant où commencer et où terminer la plage.
 Lors de la spécification d'une plage, la valeur de retour sera un nouveau tuple avec les éléments spécifiés.
 Renvoie les troisième, quatrième et cinquième éléments :
thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[2:5])
Remarque : La recherche commencera à l'index 2 (inclus) et se terminera à l'index 5 (non inclus).
 Plage d'indices négatifs
 Spécifiez des index négatifs si vous souhaitez commencer la recherche à partir de la fin du tuple :
 Cet exemple renvoie les éléments de l'index -4 (inclus) à l'index -1 (exclu)
thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[-4:-1])
Tuples

 Vérifier si l'article existe
Pour déterminer si un élément spécifié est présent dans un tuple, utilisez le mot clé in :
 Vérifiez si "apple" est présent dans le tuple :
if "apple" in thistuple:
print("Yes, 'apple' is in the fruits tuple")
Tuples

 Mettre à jour les tuples
 Les tuples sont immuables, ce qui signifie que vous ne pouvez pas modifier, ajouter ou supprimer des éléments une fois le tuple créé.
 Mais il existe des solutions de contournement.
 Modifier les valeurs de tuple
 Une fois qu'un tuple est créé, vous ne pouvez pas modifier ses valeurs. Les tuples sont inchangeables ou immuables comme on l'appelle aussi.
 Mais il existe une solution de contournement. Vous pouvez convertir le tuple en une liste, modifier la liste et reconvertir la liste en un tuple.
 Convertissez le tuple en liste pour pouvoir le changer :
x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)
print(x)
Tuples

Ajouter des articles
 Commeles tuples sont immuables, ils n'ont pas de append()méthode intégrée, mais il existe d'autres façons d'ajouter des éléments à un tuple.
 1. Convertir en liste : Tout commela solution de contournement pour modifier un tuple, vous pouvez le convertir en liste, ajoutervotre ou vos éléments et le reconvertir en tuple.
 Convertissezle tuple en liste, ajoutez "orange" et reconvertissez-le en tuple :
y = list(thistuple)
y.append("orange")
thistuple = tuple(y)
 2. Ajouter un tuple à un tuple . Vous êtes autorisé à ajouter des tuples aux tuples, donc si vous voulez ajouter un élément (ou plusieurs), créez un nouveau tuple avec le ou les éléments et ajoutez-le au tuple existant :
 Créez un nouveau tuple avec la valeur "orange", et ajoutez ce tuple :
y = ("orange",)
thistuple += y
print(thistuple)
Tuples

Boucle à travers un tuple
Vous pouvez parcourir les éléments de tuple en utilisant une boucle for.
Parcourez les éléments et imprimez les valeurs :
for x in thistuple:
print(x)
Boucle à travers les numéros d'index
 Vous pouvez également parcourir les éléments du tuple en vous référant à leur numéro d'index.
Utilisez les fonctions range()et len()pour créer un itérable approprié.
 Imprimez tous les articles en vous référant à leur numéro d'index :
for i in range(len(thistuple)):
print(thistuple[i])
Tuples

Joindre deux tuples
 Pour joindre deux tuples ou plus, vous pouvez utiliser l' + opérateur :
 Joindre deux tuples :
tuple1 = ("a", "b" , "c")
tuple2 = (1, 2, 3)
tuple3 = tuple1 + tuple2
print(tuple3)
 Multiplier les tuples
 Si vous souhaitez multiplier le contenu d'un tuple un certain nombre de fois, vous pouvez utiliser l' * opérateur :
 Multipliez le tuple des fruits par 2 :
fruits = ("apple", "banana", "cherry")
mytuple = fruits * 2
print(mytuple)
Tuples

 Méthodes tuple
 Python a deux méthodes intégrées que vous pouvez utiliser sur les tuples.
 Description
 Count() : Renvoie le nombre de fois qu'une valeur spécifiée apparaît dans un
tuple
 Index () : Recherche le tuple pour une valeur spécifiée et renvoie la position de
l'endroit où il a été trouvé
Tuples

 Renvoie le nombre de fois où la valeur 5 apparaît dans le tuple :
thistuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)
x = thistuple.count(5)
print(x)
 Définition et utilisation
 La count()méthode renvoie le nombre de fois qu'une valeur spécifiée apparaît dans le tuple.
 Syntaxe
 tuple.count(value)
 Valeurs des paramètres :
 value Required. The item to search for
Tuples

 Recherchez la première occurrence de la valeur 8 et renvoyez sa position :
thistuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)
x = thistuple.index(8)
print(x)
Définition et utilisation
 La index()méthode trouve la première occurrence de la valeur spécifiée.
 La index()méthode lève une exception si la valeur n'est pas trouvée.
Syntaxe
 tuple.index(value)
 value Required. The item to search for
Tuples

Les Sets
 Les Sets (ensembles) sont utilisés pour stocker plusieurs éléments dans une seule variable.
 Set est l'un des 4 types de données intégrés à Python utilisés pour stocker des collections de données, les 3 autres sont List , Tuple et Dictionary , tous avec des qualités et une utilisation
différentes.
 Un ensemble est une collection non ordonnée , non modifiable et non indexée .
Remarque : les éléments de l'ensemble ne sont pas modifiables, mais vous pouvez supprimer des éléments et en ajouter de nouveaux.
 Les ensembles sont écrits avec des accolades.
Créer un ensemble :
thisset = {"apple", "banana", "cherry"}
print(thisset)

Les Sets
 Remarque : les ensembles ne sont pas ordonnés, vous ne pouvez donc pas être sûr de l'ordre dans lequel les éléments apparaîtront.
 Définir les éléments
 Les éléments d'ensemble ne sont pas ordonnés, ne peuvent pas être modifiés et n'autorisent pas les valeurs en double.
 Non ordonné
 Non ordonné signifie que les éléments d'un ensemble n'ont pas d'ordre défini.
 Les éléments d'ensemble peuvent apparaître dans un ordre différent chaque fois que vous les utilisez et ne peuvent pas être référencés par un index ou une clé.
 Non modifiable
 Les éléments de l'ensemble sont immuables, ce qui signifie que nous ne pouvons pas modifier les éléments une fois l'ensemble créé.
 Une fois qu'un ensemble est créé, vous ne pouvez pas modifier ses éléments, mais vous pouvez supprimer des éléments et en ajouter de nouveaux.

Les Sets
 Doublons non autorisés
 Les ensembles ne peuvent pas avoir deux éléments avec la même valeur.
 Les valeurs en double seront ignorées :
thisset = {"apple", "banana", "cherry", "apple"}
print(thisset)
 Remarque : Les valeurs True et 1 sont considérées comme identiques dans les ensembles et sont traitées comme des doublons :
 True et 1 est considéré comme la même valeur :
thisset = {"apple", "banana", "cherry", True, 1, 2}
print(thisset)

Les Sets
Obtenir la longueur d'un ensemble
Pour déterminer le nombre d'éléments d'un ensemble, utilisez la fonction len().
Obtenir le nombre d'éléments dans un ensemble :
print(len(thisset))
Éléments d'ensemble - Types de données
Les éléments d'ensemble peuvent être de n'importe quel type de données :
Types de données chaîne, int et booléen :
set1 = {"apple", "banana", "cherry"}
set2 = {1, 5, 7, 9, 3}
set3 = {True, False, False}
Un ensemble peut contenir différents types de données :
Un ensemble avec des chaînes, des entiers et des valeurs booléennes :
set1 = {"abc", 34, True, 40, "male"}

Les Sets
taper()
Du point de vue de Python, les ensembles sont définis comme des objets avec le type de données 'set' : <class 'set'>
Quel est le type de données d'un Set?
myset = {"apple", "banana", "cherry"}
print(type(myset))
Le constructeur set()
Il est également possible d'utiliser le constructeur set() pour créer un ensemble.
Utilisation du constructeur set() pour créer un ensemble :
thisset = set(("apple", "banana", "cherry")) # note the double round-brackets
print(thisset)
Collections Python (tableaux)
* Les éléments de l'ensemble ne sont pas modifiables, mais vous pouvez supprimer des éléments et en ajouter de nouveaux.
**À partir de la version 3.7 de Python, les dictionnaires sont classés . Dans Python 3.6 et versions antérieures, les dictionnaires ne sont pas ordonnés .

Les Sets
Accéder aux éléments
 Vous ne pouvez pas accéder aux éléments d'un ensemble en vous référant à un index ou à une clé.
 Mais vous pouvez parcourir les éléments de l'ensemble à l'aide d'une for boucle ou demander si une valeur spécifiée est présente dans un ensemble à l'aide du in.
Parcourez l'ensemble et afficher les valeurs :
for x in thisset:
print(x)
Vérifiez si "banane" est présent dans l'ensemble :
print("banana" in thisset)
Modifier les éléments
Une fois qu'un ensemble est créé, vous ne pouvez pas modifier ses éléments, mais vous pouvez ajouter de nouveaux éléments.

Les Sets
Ajouter des articles
Une fois qu'un ensemble est créé, vous ne pouvez pas modifier ses éléments, mais vous pouvez ajouter de nouveaux éléments.
Pour ajouter un élément à un ensemble, utilisez la méthode add().
thisset.add("orange")
print(thisset)
Ajouter des ensembles
Pour ajouter des éléments d'un autre ensemble dans l'ensemble actuel, utilisez la méthode update().
Ajouter des éléments de tropical dans thisset:
tropical = {"pineapple", "mango", "papaya"}
thisset.update(tropical)
print(thisset)

Les Sets
Ajouter n'importe quel itérable
L'objet dans la méthode update() ne doit pas nécessairement être un ensemble, il peut s'agir de n'importe quel
objet itérable (tuples, listes, dictionnaires, etc.).
Ajouter des éléments d'une liste à un ensemble :
mylist = ["kiwi", "orange"]
thisset.update(mylist)
print(thisset)

Les Sets
Retirer l'objet
Pour supprimer un élément d'un ensemble, utilisez la méthode remove() ou la méthode discard().
Supprimez "banane" en utilisant la remove() méthode :
thisset.remove("banana")
print(thisset)
Remarque : Si l'élément à supprimer n'existe pas, remove ()génère une erreur.
Supprimez "banane" en utilisant la discard() méthode :
thisset.discard("banana")
print(thisset)
Remarque : si l'élément à supprimer n'existe pas, discard() ne générera PAS d'erreur.
Vous pouvez également utiliser la pop()méthode pour supprimer un élément, mais cette méthode supprimera un élément aléatoire, vous ne pouvez donc pas être sûr de l'élément qui est supprimé.

Les Sets
Vous pouvez également utiliser pop() pour supprimer un élément, mais cette méthode supprimera un élément aléatoire, vous ne pouvez donc pas être sûr de l'élément qui est supprimé.
Supprimez un élément aléatoire en utilisant la méthode pop() :
x = thisset.pop()
print(x)
print(thisset)
Remarque : les ensembles ne sont pas ordonnés , donc lorsque vous utilisez la pop()méthode, vous ne savez pas quel élément est supprimé.
La méthode clear() vide l'ensemble :
thisset.clear()
print(thisset)
Le mot-clé del supprimera complètement l'ensemble :
del thisset
print(thisset)

Les Sets
Vous pouvez parcourir les éléments définis en
utilisant une boucle for :
Parcourir l'ensemble et afficher les valeurs :
for x in thisset:
print(x)

Les Sets
Jointure des Sets
Joindre deux ensembles
 Il existe plusieurs façons de joindre deux ensembles ou plus en Python.
 Vous pouvez utiliser la méthode union() qui renvoie un nouvel ensemble contenant tous les éléments des deux ensembles, ou la méthode update() qui insère tous les éléments d'un ensemble dans un autre :
La méthode union() renvoie un nouvel ensemble avec tous les éléments des deux ensembles :
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set3 = set1.union(set2)
print(set3)
La méthode update() insère les éléments de set2 dans set1 :
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set1.update(set2)
print(set1)
Remarque : Les deux méthodes union()et update() excluront tous les éléments en double.

Les Sets
Conservez UNIQUEMENT les doublons
La méthode intersection_update() ne conservera que les éléments présents dans les deux ensembles.
Conservez les éléments qui existent à la fois dans set x et set y:
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
x.intersection_update(y)
print(x)
La méthode intersection() renverra un nouvel ensemble, qui ne contient que les éléments présents dans les deux ensembles.
Renvoie un ensemble qui contient les éléments qui existent à la fois dans set xet set y:
z = x.intersection(y)
print(z)

Les Sets
Conservez tout, mais PAS les doublons
La méthode symmetric_difference_update() ne conservera que les éléments qui ne sont PAS présents dans les deux ensembles.
Conservez les éléments qui ne sont pas présents dans les deux ensembles :
x.symmetric_difference_update(y)
print(x)
 La méthode symmetric_difference() renverra un nouvel ensemble, qui contient uniquement les éléments qui ne sont PAS présents dans les deux ensembles.
Renvoie un ensemble contenant tous les éléments des deux ensembles, à l'exception des éléments présents dans les deux :
z = x.symmetric_difference(y)
print(z)
Remarque : Les valeurs True et 1 sont considérées comme identiques dans les ensembles et sont traitées comme des doublons :
True et 1 est considéré comme la même valeur :
x = {"apple", "banana", "cherry", True}
y = {"google", 1, "apple", 2}
z = x.symmetric_difference(y)

Les Sets
 Définir les méthodes
Python possède un ensemble de méthodes intégrées que vous pouvez utiliser sur des ensembles :
 add() Adds an element to the set
 clear() Removes all the elements from the set
 copy() Returns a copy of the set
 difference() Returns a set containing the difference between two or more sets
 difference_update() Removes the items in this set that are also included in another, specified set
 discard() Remove the specified item
 intersection() Returns a set, that is the intersection of two other sets
 intersection_update() Removes the items in this set that are not present in other, specified set(s)

Les Sets
 Définir les méthodes
 isdisjoint() Returns whether two sets have a intersection or not
 issubset() Returns whether another set contains this set or not
 issuperset() Returns whether this set contains another set or not
 pop() Removes an element from the set
 remove() Removes the specified element
 symmetric_difference() Returns a set with the symmetric differences of two sets
 symmetric_difference_update() inserts the symmetric differences from this set and another
 union() Return a set containing the union of sets
 update() Update the set with the union of this set and others

 Dictionnaires
Dictionnaire
 Les dictionnaires sont utilisés pour stocker des valeurs de données dans des paires clé:valeur.
 Un dictionnaire est une collection ordonnée, modifiable et qui n'autorise pas les doublons.
 Depuis Python version 3.7, les dictionnaires sont ordonnés . Dans Python 3.6 et versions antérieures, les dictionnaires ne sont pas ordonnés .
Les dictionnaires sont écrits avec des accolades et ont des clés et des valeurs :
Créer et imprimer un dictionnaire :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(thisdict)

 Dictionnaires
Éléments du dictionnaire
 Les éléments du dictionnaire sont ordonnés, modifiables et n'autorisent pas les doublons.
 Les éléments du dictionnaire sont présentés dans des paires clé:valeur et peuvent être référencés à l'aide du nom de la clé.
Imprimer la valeur "brand" du dictionnaire :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(thisdict["brand"])
Ordonné ou non ordonné?
 Depuis Python version 3.7, les dictionnaires sont ordonnés . Dans Python 3.6 et versions antérieures, les dictionnaires ne sont pas ordonnés .
 Lorsque nous disons que les dictionnaires sont ordonnés, cela signifie que les éléments ont un ordre défini et que cet ordre ne changera pas.
 Non ordonné signifie que les éléments n'ont pas d'ordre défini, vous ne pouvez pas faire référence à un élément en utilisant un index.

 Dictionnaires
Modifiable
Les dictionnaires sont modifiables, ce qui signifie que nous pouvons modifier, ajouter ou supprimer des éléments après la création du
dictionnaire.
Doublons non autorisés
Les dictionnaires ne peuvent pas avoir deux éléments avec la même clé :
Les valeurs en double écraseront les valeurs existantes :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964,
"year": 2020}
print(thisdict)

 Dictionnaires #fin de
revision
Longueur du dictionnaire
Pour déterminer le nombre d'éléments d'un dictionnaire, utilisez la fonction len():
Afficher le nombre d'éléments dans le dictionnaire :
print(len(thisdict))
Les valeurs des éléments du dictionnaire peuvent être de n'importe quel type de données :
Types de données chaîne, entier, booléen et liste :
thisdict = {
"brand": "Ford",
"electric": False,
"year": 1964,
"colors": ["red", "white", "blue"]
}

 Dictionnaires
Du point de vue de Python, les dictionnaires sont définis comme des objets avec le type de données 'dict' : <class 'dict'>
Imprimer le type de données d'un dictionnaire :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(type(thisdict))
Le constructeur dict()
Il est également possible d'utiliser le constructeur dict() pour créer un dictionnaire.
Utilisation de la méthode dict() pour créer un dictionnaire :
thisdict = dict(name = "John", age = 36, country = "Norway")
print(thisdict)

 Dictionnaires
Accéder aux éléments du dictionnaire
Vous pouvez accéder aux éléments d'un dictionnaire en vous référant à son nom de clé, entre crochets :
Obtenez la valeur de la clé "model":
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
x = thisdict["model"]
Il existe également une méthode appelée get()qui vous donnera le même résultat :
Obtenez la valeur de la clé "model":
x = thisdict.get("model")

 Dictionnaires
Obtenir des clés
La méthode keys() renverra une liste de toutes les clés du dictionnaire.
Obtenez une liste des clés :
x = thisdict.keys()
La liste des clés est une vue du dictionnaire, ce qui signifie que toute modification apportée au dictionnaire sera reflétée dans la
liste des clés.
Ajoutez un nouvel élément au dictionnaire d'origine et vérifiez que la liste des clés est également mise à jour :
car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
x = car.keys()
print(x) #before the change
car["color"] = "white"
print(x) #after the change

 Dictionnaires
Obtenir des valeurs
La méthode values() renverra une liste de toutes les valeurs du dictionnaire.
Obtenez une liste des valeurs :
x = thisdict.values()
La liste des valeurs est une vue du dictionnaire, ce qui signifie que toute modification apportée au dictionnaire sera reflétée
dans la liste des valeurs.
Modifiez le dictionnaire d'origine et vérifiez que la liste des valeurs est également mise à jour :
car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
x = car.values()
car["year"] = 2020

 Dictionnaires
Obtenir des valeurs
Ajoutez un nouvel élément au dictionnaire d'origine et vérifiez que la liste des valeurs est également mise à jour :
car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
x = car.values()
car["color"] = "red"

 Dictionnaires
Obtenir des articles
La méthode items() renverra chaque élément d'un dictionnaire, sous forme de tuples dans une liste.
Obtenir une liste des paires clé:valeur
x = thisdict.items()
La liste renvoyée est une vue des éléments du dictionnaire, ce qui signifie que toute modification apportée au dictionnaire sera
reflétée dans la liste des éléments.
Modifiez le dictionnaire d'origine et vérifiez que la liste des éléments est également mise à jour :
car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
x = car.items()
car["year"] = 2020

 Dictionnaires
Obtenir des articles
Ajoutez un nouvel élément au dictionnaire d'origine et vérifiez que la liste des éléments est également mise à jour :
car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
x = car.items()
car["color"] = "red"

 Dictionnaires
Vérifier si la clé existe
Pour déterminer si une clé spécifiée est présente dans un dictionnaire, utilisez le mot-clé in:
Vérifiez si "modèle" est présent dans le dictionnaire :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
if "model" in thisdict:
print("Yes, 'model' is one of the keys in the thisdict dictionary")

 Dictionnaires
Modifier les éléments du dictionnaire
Changer les valeurs
Vous pouvez modifier la valeur d'un élément spécifique en vous référant à son nom de clé :
Remplacez "l'année" par 2018 :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict["year"] = 2018
Mettre à jour le dictionnaire
La méthode update() mettra à jour le dictionnaire avec les éléments de l'argument donné.
L'argument doit être un dictionnaire ou un objet itérable avec des paires clé:valeur.
Mettez à jour "l'année" de la voiture en utilisant la méthode update() :
thisdict = {"brand": "Ford","model": "Mustang","year": 1964}
thisdict.update({"year": 2020})

 Dictionnaires
Ajouter des éléments de dictionnaire
Ajout d'éléments
L'ajout d'un élément au dictionnaire se fait en utilisant une nouvelle clé d'index et en lui attribuant une valeur :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict["color"] = "red"
print(thisdict)
Mettre à jour le dictionnaire
La méthode update() mettra à jour le dictionnaire avec les éléments d'un argument donné. Si l'élément n'existe pas, l'élément
sera ajouté.
L'argument doit être un dictionnaire ou un objet itérable avec des paires clé:valeur.
Ajoutez un élément de couleur au dictionnaire en utilisant la méthode update() :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.update({"color": "red"})

 Dictionnaires
Supprimer les éléments du dictionnaire
Il existe plusieurs méthodes pour supprimer des éléments d'un dictionnaire :
La méthode pop() supprime l'élément avec le nom de clé spécifié :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.pop("model")
print(thisdict)
La méthode popitem() supprime le dernier élément inséré (dans les versions antérieures à 3.7, un élément aléatoire est
supprimé à la place) :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.popitem()
print(thisdict)

 Dictionnaires
Le mot-clé del supprime l'élément avec le nom de clé spécifié :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
del thisdict["model"]
print(thisdict)
Le mot-clé del peut également supprimer complètement le dictionnaire :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
del thisdict
print(thisdict) #this will cause an error because "thisdict" no longer exists.

 Dictionnaires
La méthode clear() vide le dictionnaire :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.clear()
print(thisdict)

 Dictionnaires
Boucle dans un dictionnaire
Vous pouvez parcourir un dictionnaire en boucle en utilisant une boucle for.
Lors d'une boucle dans un dictionnaire, la valeur de retour sont les clés du dictionnaire, mais il existe également des méthodes pour renvoyer
les valeurs .
Imprimez tous les noms de clé dans le dictionnaire, un par un :
for x in thisdict:
print(x)
Imprimer toutes les valeurs du dictionnaire, une par une :
for x in thisdict:
print(thisdict[x])
Vous pouvez également utiliser la méthode values() pour renvoyer les valeurs d'un dictionnaire :
for x in thisdict.values():
print(x)
Vous pouvez utiliser la méthode keys() pour renvoyer les clés d'un dictionnaire :
for x in thisdict.keys():
print(x)
Boucle à la fois sur keys et values , en utilisant la items()méthode :
for x, y in thisdict.items():
print(x, y)

 Dictionnaires
Copier un dictionnaire
Vous ne pouvez pas copier un dictionnaire simplement en tapant dict2 = dict1, car :
Dict2 ne sera qu'une référence à dict1, et les modifications apportées dans dict1 le seront également automatiquement dans dict2.
Il existe plusieurs façons de faire une copie, l'une consiste à utiliser la méthode intégrée copy() .
Faites une copie d'un dictionnaire avec la méthode copy():
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
mydict = thisdict.copy()
print(mydict)
Une autre façon de faire une copie consiste à utiliser la fonction intégrée dict().
Faire une copie d'un dictionnaire avec la fonction dict():
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
mydict = dict(thisdict)
print(mydict)

 Dictionnaires
Dictionnaires imbriqués
Un dictionnaire peut contenir des dictionnaires, c'est ce qu'on appelle des dictionnaires imbriqués.
Créez un dictionnaire contenant trois dictionnaires :
myfamily = {
"child1" : {
"name" : "Emil",
"year" : 2004
},
"child2" : {
"name" : "Tobias",
"year" : 2007
},
"child3" : {
"name" : "Linus",
"year" : 2011
}
}

 Dictionnaires
Ou, si vous souhaitez ajouter trois dictionnaires dans un nouveau dictionnaire :
Créez trois dictionnaires, puis créez un dictionnaire qui contiendra les trois autres dictionnaires :
child1 = {
"name" : "Emil",
"year" : 2004
}
child2 = {
"name" : "Tobias",
"year" : 2007
}
child3 = {
"name" : "Linus",
"year" : 2011
}
myfamily = {
"child1" : child1,
"child2" : child2,
"child3" : child3
}

 Dictionnaires
Ou, si vous souhaitez ajouter trois dictionnaires dans un nouveau dictionnaire :
Créez trois dictionnaires, puis créez un dictionnaire qui contiendra les trois autres dictionnaires :
child1 = {
"name" : "Emil",
"year" : 2004
}
child2 = {
"name" : "Tobias",
"year" : 2007
}
child3 = {
"name" : "Linus",
"year" : 2011
}
myfamily = {
"child1" : child1,
"child2" : child2,
"child3" : child3}
Accéder aux éléments dans les dictionnaires imbriqués
Pour accéder aux éléments d'un dictionnaire imbriqué, vous utilisez le nom des dictionnaires, en commençant par le dictionnaire
externe :
Imprimez le nom de l'enfant 2 :

 Dictionnaires
Méthodes de dictionnaire
Python possède un ensemble de méthodes intégrées que vous pouvez utiliser sur les dictionnaires.
Method Description
clear() Removes all the elements from the dictionary
copy() Returns a copy of the dictionary
fromkeys() Returns a dictionary with the specified keys and value
get() Returns the value of the specified key
items() Returns a list containing a tuple for each key value pair
keys() Returns a list containing the dictionary's keys
pop() Removes the element with the specified key
popitem() Removes the last inserted key-value pair
setdefault() Returns the value of the specified key. If the key does not exist: insert the key, with the specified
value
update() Updates the dictionary with the specified key-value pairs
values() Returns a list of all the values in the dictionary

Dictionnaires
Essayez d'insérer la partie manquante pour que le code fonctionne comme prévu :
 Utilisez la méthode get pour imprimer la valeur de la clé "model" du dictionnaire car.
car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964}
Print(car.get("model"))
 Modifiez la valeur "year" de 1964 à 2020.
car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964}
car["year"] = 2020
 Utilisez la méthode pop pour supprimer "modèle" du dictionnaire de la voiture.
car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
car.pop("model")

Les Boucles
Python a deux commandes de boucle primitive :
 tant que(while)
 Pour (for)

Les Boucles
La boucle while
Avec la boucle while, nous pouvons exécuter un ensemble d'instructions tant qu'une condition est vraie.
Les boucles while sont utilisées en premier lieu dans Python lorsque le nombre d’itérations nécessaires n’est pas
déterminé à l’avance.
Afficher i tant que i est inférieur à 6 :
i = 1
while i < 6:
print(i)
i += 1
Remarque : n'oubliez pas d'incrémenter i, sinon la boucle continuera indéfiniment.
La boucle while nécessite que les variables pertinentes soient initialisées. Dans cet exemple, nous devons définir une
variable d'indexation, i , que nous définissons sur 1.
1
2
3
4
5

Les Boucles
Comment fonctionne la boucle while en Python ?
La boucle while de Python fonctionne de manière similaire à l’instruction de branchement if-else de Python. Les deux structures de contrôle se
composent de deux parties :
1) Une condition qui est évaluée
2) Un corps contenant des instructions
 La différence réside dans le nombre de fois où le corps est exécuté. Le corps d’une instruction if est exécuté au maximum une fois :
if condition:
run_once()
 Contrairement à l’instruction if, le corps de la boucle while en Python peut être exécuté plusieurs fois :
while condition:
run_again()

Les Boucles
La déclaration continue
Avec l'instruction continue, nous pouvons arrêter
l'itération en cours et continuer avec la suivante :
Exemple
Passez à l'itération suivante si i vaut 3 :
i = 0
while i < 6:
i += 1
if i == 3:
continue
print(i)
La déclaration de rupture
Avec l'instruction break, nous pouvons arrêter la boucle
même si la condition while est vraie :
Exemple
Sortir de la boucle quand i vaut 3 :
i = 1
while i < 6:
print(i)
if i == 3:
break
i += 1
1
2
3
1
2
4
5
6

Les Boucles
La déclaration Else
Cette déclaration while-loop-else, qui est unique à Python. Le bloc else n'est exécuté que si la boucle while est épuisée.
Avec l'instruction else, nous pouvons exécuter un bloc de code une fois lorsque la condition n'est plus vraie :
Exemple
Afficher un message une fois que la condition est fausse :
i = 1
while i < 6:
print(i)
i += 1
else:
print("i is no longer less than 6")
1
2
3
4
5
i is no longer less than 6

Les Boucles
Une boucle for est utilisée pour itérer sur une séquence (c'est-à-dire une liste, un tuple, un dictionnaire, un ensemble ou une chaîne).
Cela ressemble moins au mot-clé for dans d'autres langages de programmation et fonctionne plus comme une méthode itérative que l'on trouve dans d'autres langages de programmation orientés objet.
Avec la boucle for , nous pouvons exécuter un ensemble d'instructions, une fois pour chaque élément d'une liste, d'un tuple, d'un ensemble, etc.
Afficher chaque fruit dans une liste de fruits :
fruits = ["apple", "banana", "cherry"]
for x in fruits:
print(x)
La boucle for ne nécessite pas de variable d'indexation à définir au préalable.

Les Boucles
Boucle sur une chaîne
Même les chaînes sont des objets itérables, elles contiennent une séquence de
caractères :
Exemple
Parcourez les lettres du mot "banane":
for x in "banana":
print(x)

Les Boucles
Avec l' instruction break , nous pouvons arrêter la boucle avant qu'elle n'ait parcouru tous les éléments :
Exemple
Sortir de la boucle quand x est "banane":
for x in fruits:
print(x)
if x == "banana":
break

Les Boucles
Avec l' instruction break , nous pouvons arrêter la boucle avant qu'elle n'ait parcouru tous les éléments :
Exemple
Sortez de la boucle quand x est "banane", mais cette fois la pause vient avant l'impression :
for x in fruits:
if x == "banana":
break
print(x)

Les Boucles
La déclaration continue
Avec l' instruction continue , nous pouvons arrêter l'itération actuelle de la boucle et continuer avec la suivante :
Exemple
Ne pas afficher banane :
for x in fruits:
if x == "banana":
continue
print(x)

Les Boucles
La fonction range()
Pour parcourirun ensemblede code un nombre de fois spécifié, nous pouvons utiliser la fonction range(),
La fonction range() renvoie une séquence de nombres, commençant par 0 par défaut, et incrémentée de 1 (par défaut), et se termine à un nombre spécifié.
Exemple
Utilisation de lafonction range() :
for x in range(6):
print(x)
Notez que range(6) n'est pas les valeurs de 0 à 6, mais les valeurs de 0 à 5.
La fonction range() prend par défaut 0 comme valeur de départ, mais il est possible de spécifierla valeur de départ en ajoutant un paramètre : range(2, 6), ce qui signifie des valeurs de 2 à 6 (mais n'incluant pas 6) :
Exemple
Utilisation du paramètre start :
for x in range(2, 6):
print(x)
La fonction range() par défaut incrémente la séquence de 1, cependant il est possiblede spécifier la valeur d'incrémentation en ajoutant un troisième paramètre : range(2, 30, 3 ) :
Exemple
Incrémentez la séquencede 3 (la valeur par défaut est 1) :
for x in range(2, 30, 3):
print(x)

Les Boucles
Sinon dans la boucle For
Le mot clé else dans une boucle for spécifie un bloc de code à exécuter lorsque la boucle est terminée :
Exemple
Imprimez tous les nombres de 0 à 5, et imprimez un message lorsque la boucle est terminée :
for x in range(6):
print(x)
else:
print("Finally finished!")
Remarque : Le elsebloc ne sera PAS exécuté si la boucle est arrêtée par une breakinstruction.
Exemple
Cassez la boucle quand xest 3, et voyez ce qui se passe avec le elsebloc :
for x in range(6):
if x == 3: break
print(x)
else:
print("Finally finished!")
#If the loop breaks, the else block is not executed.
0
1
2
3
4
5
Finally
finished!

Les Boucles
Boucles imbriquées
Une boucle imbriquée est une boucle à l'intérieur d'une boucle.
La "boucle interne" sera exécutée une fois pour chaque itération de la "boucle externe":
Exemple
Imprimez chaque adjectif pour chaque fruit :
adj = ["red", "big", "tasty"]
for x in adj:
for y in fruits:
print(x, y)
La déclaration de pass
forles boucles ne peuvent pas être vides, mais si, pour une raison quelconque, vous avez une forboucle sans contenu, insérez l' passinstruction pour éviter d'obtenir une erreur.
Exemple
for x in [0, 1, 2]:
pass #having an empty for loop like this, would raise an error without the pass statement
red apple
red banana
red cherry
big apple
big banana
big cherry
tasty apple
tasty banana
tasty cherry

Fonctions
 Une fonction est un bloc de code qui ne s'exécute que lorsqu'elle est appelée.
 Vous pouvez transmettre des données, appelées paramètres, dans une fonction.
 Une fonction peut renvoyer des données en conséquence.
 Création d'une fonction
En Python, une fonction est définie à l'aide du mot-clé def :
def my_function():
print("Hello from a function")
 Appel d'une fonction
Pour appeler une fonction, utilisez le nom de la fonction suivi de parenthèses :
Exemple
def my_function():
print("Hello from a function")
my_function()

Fonctions
 Arguments
 Les informations peuvent être transmises aux fonctions en tant qu'arguments.
 Les arguments sont spécifiés après le nom de la fonction, entre parenthèses.
 Vous pouvez ajouter autant d'arguments que vous le souhaitez, séparez-les simplement par une virgule.
 L'exemple suivant a une fonction avec un argument (fname). Lorsque la fonction est appelée, nous transmettons un prénom, qui est utilisé à l'intérieur de la fonction pour afficher le nom complet :
Exemple
def my_function(fname):
print(fname + " Refsnes")
my_function("Emil")
my_function("Tobias")
my_function("Linus")
 Les arguments sont souvent abrégés en args dans les documentations Python.

Fonctions
Paramètres ou arguments ?
Les termes paramètre et argument peuvent être utilisés pour la même chose : des
informations transmises à une fonction.
Du point de vue d'une fonction :
Un paramètre est la variable répertoriée entre parenthèses dans la définition de la
fonction.
Un argument est la valeur qui est envoyée à la fonction lorsqu'elle est appelée.

Fonctions
Nombre d'arguments
Par défaut, une fonction doit être appelée avec le bon nombre d'arguments. Cela signifie que si votre fonction attend 2 arguments, vous
devez appeler la fonction avec 2 arguments, ni plus, ni moins.
Exemple
Cette fonction attend 2 arguments et obtient 2 arguments :
def my_function(fname, lname):
print(fname + " " + lname)
my_function("Emil", "Refsnes")
Si vous essayez d'appeler la fonction avec 1 ou 3 arguments, vous obtiendrez une erreur :
Exemple
Cette fonction attend 2 arguments, mais n'en obtient qu'un :
def my_function(fname, lname):
print(fname + " " + lname)
my_function("Emil")

Fonctions
Arguments arbitraires, *args
Si vous ne savez pas combien d'arguments seront transmis à votre fonction, ajoutez * avant le nom du paramètre
dans la définition de la fonction.
De cette façon, la fonction recevra un tuple d'arguments et pourra accéder aux éléments en conséquence :
Exemple
Si le nombre d'arguments est inconnu, ajoutez un * avant le nom du paramètre :
def my_function(*kids):
print("The youngest child is " + kids[2])
my_function("Emil", "Tobias", "Linus")
#The youngest child is Linus
Les arguments arbitraires sont souvent abrégés en *args dans les documentations Python.

Fonctions
Arguments de mots clés
Vous pouvez également envoyer des arguments avec la syntaxe clé = valeur .
De cette façon, l'ordre des arguments n'a pas d'importance.
Exemple
def my_function(child3, child2, child1):
print("The youngest child is " + child3)
my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")
L'expression Keyword Arguments est souvent abrégée en kwargs dans les documentations
Python.

Fonctions
Arguments de mots-clés arbitraires, **kwargs
Si vous ne savez pas combien d'arguments de mots clés seront transmis à votre fonction,
ajoutez deux astérisques : **avant le nom du paramètre dans la définition de la fonction.
De cette façon, la fonction recevra un dictionnaire d'arguments et pourra accéder aux éléments
en conséquence :
Exemple
Si le nombre d'arguments de mots clés est inconnu, ajoutez un double **avant le nom du
paramètre :
def my_function(**kid):
print("His last name is " + kid["lname"])
my_function(fname = "Tobias", lname = "Refsnes")
Les arguments Kword arbitraires sont souvent abrégés en **kwargs dans les documentations
Python.

Fonctions
Valeur de paramètre par défaut
L'exemple suivant montre comment utiliser une valeur de paramètre par défaut.
Si nous appelons la fonction sans argument, elle utilise la valeur par défaut :
Exemple
def my_function(country = "Norway"):
print("I am from " + country)
my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")

Fonctions
Passer une liste comme argument
Vous pouvez envoyer n'importe quel type de données d'argument à une fonction (chaîne,
nombre, liste, dictionnaire, etc.), et il sera traité comme le même type de données à l'intérieur de
la fonction.
Par exemple, si vous envoyez une List comme argument, ce sera toujours une List lorsqu'elle
atteindra la fonction :
Exemple
def my_function(food):
for x in food:
print(x)
my_function(fruits)

Fonctions
Valeurs de retour
Pour laisser une fonction renvoyer une valeur, utilisez l'instruction return:
Exemple
def my_function(x):
return 5 * x
print(my_function(3))

Fonctions
La déclaration de pass
Les définitions de fonction ne peuvent pas être vides, mais si, pour une raison quelconque, vous
avez une définition de fonction sans contenu, insérez-la dans l'instruction pass pour éviter
d'obtenir une erreur.
Exemple
def myfunction():
Pass
# avoir une définition de fonction vide comme celle-ci, générerait une erreur sans l'instruction
pass

Fonctions
 Récursivité
 Python accepte également la récursivité des fonctions, ce qui signifie qu'une fonction définie
peut s'appeler elle-même.
 La récursivité est un concept mathématique et de programmation courant. Cela signifie qu'une
fonction s'appelle elle-même. Cela a l'avantage de signifier que vous pouvez parcourir les
données pour atteindre un résultat.
 Le développeur doit être très prudent avec la récursivité car il peut être assez facile de se
glisser dans l'écriture d'une fonction qui ne se termine jamais, ou qui utilise des quantités
excessives de mémoire ou de puissance de processeur. Cependant, lorsqu'elle est écrite
correctement, la récursivité peut être une approche de programmation très efficace et
mathématiquement élégante.

Fonctions
Dans cet exemple, tri_recursion() est une fonction que nous avons définie pour s'appeler elle-même ("recurse"). Nous utilisons la variable k
comme donnée, qui décrémente ( -1 ) à chaque fois que nous récursons. La récursivité se termine lorsque la condition n'est pas supérieure à
0 (c'est-à-dire lorsqu'elle vaut 0).
Pour un nouveau développeur, cela peut prendre un certain temps pour comprendre comment cela fonctionne exactement, la meilleure façon
de le savoir est de le tester et de le modifier.
Exemple de récursivité
def tri_recursion(k):
if(k > 0):
result = k + tri_recursion(k - 1)
print(result)
else:
result = 0
return result
print("nnRecursion Example Results")
tri_recursion(6)
Recursion Example
Results
1
3
6
10
15
21

Fonctions
 Rappel : Récursivité
Points clés
1) Une fonction récursive est une fonction qui s’appelle elle-même. Ces appels sont les appels
récursifs.
2) Les appels récursifs d’une fonction récursive sont stockés dans la pile d’exécution.
3) Une fonction récursive peut vite être gourmande en mémoire en saturant la pile d’exécution.
4) La récursivité est un moyen de répéter des blocs d’instructions sans utiliser de boucle while ou
for.
5) En Python, l’implémentation d’une fonction récursive est semblable à celle des autres
fonctions, à ceci près qu’une fonction récursive doit impérativement contenir un retour avec le
mot clé return pour faire les appels récursifs.
6) Méthode : Lorsque l’on écrit une fonction récursive en Python, on peut partager son code en
deux parties.
a. Une condition d’arrêt pour stopper les appels récursifs.
b. Les appels récursifs.

fonction fct1(x,y)
SI x==0 ALORS
retourne y
SINON
retourne fct1(x-1,x+y)
FINSI
Fonctions
fonction fct2(n)
SI n=1 ALORS
retourne 0
SINON
return 1+fct2(n/2)
FINSI
1) Quel est le type de ces
fonctions ? Pourquoi ?
2) Traduire en python
fonction fct3(n)
SI n=0 ALORS
retourne
FINSI
fct3(n/2)
Ecrire(n%2)

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

Les fonctions
Principe et généralités
Par exemple, si vous appelez la fonction len(x) de la manière suivante :
voici ce qui se passe :
● vous appelez len() en lui passant une liste en argument (ici la liste [0, 1, 2]) ;
● la fonction calcule la longueur de cette liste ;
● elle vous renvoie un entier égal à cette longueur.
>>> len([0, 1, 2])
3

Les fonctions
La fonction help()
help(print)
help() affiche deux choses :
● L'en-tête de cette fonction print(value,..., sep=’ ‘). Dans ce cas, cela nous indique que print()
peut prendre un argument appelé sep, et que cela décrit ce que nous mettons entre tous les
autres arguments lorsque nous les affichons.
● Une brève description en anglais de ce que fait la fonction.
2
2
1
1

Les Fonctions
Les fonctions de conversion
 Python possède certaines fonctions qui nous permettent de modifier le type de certaines données, c’est-à-dire de les “convertir”. Ces fonctions portent le nom du type de donnée souhaitée :
 La fonction str() retourne une chaine de caractères à partir d’une donnée qu’on va lui passer en argument ;
 La fonction int() retourne un entier à partir d’un nombre ou d’une chainecontenant un nombre qu’on va lui passeren argument ;
 La fonction float() retourne un nombre décimal à partir d’un nombre ou d’une chaine contenant un nombre qu’on va lui passer en argument ;
 La fonction complex() retourne un nombre complexe à partir d’un nombre ou d’une chainecontenant un nombre qu’on va lui passer en argument ;
 La fonction bool() retourne un booléen à partir d’une donnéequ’on va lui passeren argument ;
 La fonction list() retourne une liste à partir d’une donnée itérable (unedonnée dont on peut parcourirles valeurs) ;
 La fonction tuple() retourne un tuple à partir d’une donnée itérable;
 La fonction dict() crée un dictionnaire à partir d’un ensemblede paires clef = “valeur” ;
 La fonction set() retourne un ensemble (set) à partir d’une donnée itérable.

Fonction & Variable
 Définition de la portée des variables en Python
 En Python, nous pouvons déclarer des variables n’importe où dans notre script : au début du script, à l’intérieur de boucles, au sein de nos fonctions, etc.
 L’endroit où on définit une variable dans le script va déterminer l’endroit où la variable va être accessible c’est-à-dire utilisable.
 Le terme de “portée des variables” sert à désigner les différents espaces dans le script dans lesquels une variable est accessible c’est-à-dire utilisable. En Python, une variable
peut avoir une portée locale ou une portée globale.

Fonction & Variable
 Variables globales et variables locales en Python
 Les variables définies dans une fonction sont appelées
variables locales. Elles ne peuvent être utilisées que localement
c’est-à-dire qu’à l’intérieur de la fonction qui les a définies.
 Tenter d’appeler une variable locale depuis l’extérieur de la
fonction qui l’a définie provoquera une erreur.

Fonction & Variable
 Cela est dû au fait que chaque fois qu’une fonction est appelée, Python réserve pour elle (dans la mémoire de l’ordinateur) un
nouvel espace de noms (c’est-à-dire une sorte de dossier virtuel). Les contenus des variables locales sont stockés dans cet
espace de noms qui est inaccessible depuis l’extérieur de la fonction.
 Cet espace de noms est automatiquement détruit dès que la fonction a terminé son travail, ce qui fait que les valeurs des
variables sont réinitialisées à chaque nouvel appel de fonction

Fonction & Variable
 Les variables définies dans l’espace global du script, c’est-à-dire en dehors de toute fonction sont appelées des variables globales. Ces variables sont accessibles (= utilisables) à travers l’ensemble du
script et accessible en lecture seulement à l’intérieur des fonctions utilisées dans ce script.
 Pour le dire très simplement : une fonction va pouvoir utiliser la valeur d’une variable définie globalement mais ne va pas pouvoir modifier sa valeur c’est-à-dire la redéfinir. En effet, toute variable définie
dans une fonction est par définition locale ce qui fait que si on essaie de redéfinir une variable globale à l’intérieur d’une fonction on ne fera que créer une autre variable de même nom que la variable
globale qu’on souhaite redéfinir mais qui sera locale et bien distincte de cette dernière.

Fonction & Variable
 Modifier une variable globale depuis une fonction
 Dans certaines situations, il serait utile de pouvoir modifier la valeur d’une variable globale depuis une fonction, notamment dans
le cas où une fonction se sert d’une variable globale et la manipule.
 Cela est possible en Python. Pour faire cela, il suffit d’utiliser le mot clef global devant le nom d’une variable globale utilisée
localement afin d’indiquer à Python qu’on souhaite bien modifier le contenu de la variable globale et non pas créer une variable
locale de même nom.

Les fonctions
La Docstring
● Python n'est pas assez intelligent pour lire mon code et le transformer en une belle description anglaise.
⇒ Cependant, lorsque j'écris une fonction, je peux fournir une description dans ce qu'on appelle la
docstring.
⇒ La docstring est une chaîne entre guillemets triples (qui peut s'étendre sur plusieurs lignes) qui vient
immédiatement après l'en-tête d'une fonction. Lorsque nous appelons help() sur une fonction, il affiche la
docstring

Les fonctions
● Fonction avec paramètre
Syntaxe & Renvoi de résultats (Returning vs Printing)
Pour définir une fonction, Python utilise le mot-clé def. Si on souhaite que la fonction renvoie quelque chose, il faut utiliser
le mot-clé return.
Notez que la syntaxe de def utilise les deux-points comme les boucles for et while ainsi que les tests if, un bloc
d’instructions est donc attendu. De même que pour les boucles et les tests, l'indentation de ce bloc d'instructions (qu'on
appelle le corps de la fonction) est obligatoire.
Ici, le résultat renvoyé par la fonction est stocké dans
la variable res.

Fonction sans paramètre
def compteur3():
i = 0
while i < 3:
print(i)
i = i + 1
print("bonjour")
compteur3()
compteur3()
Fonctions

Les fonctions
Syntaxe & Renvoi de résultats (Returning vs Printing)
● Une fonction ne prend pas forcément un argument et ne renvoie pas forcément une valeur, par exemple :
● Dans ce cas la fonction, hello() se contente d'afficher la chaîne de
caractères "bonjour" à l'écran. Elle ne prend aucun argument et ne
renvoie rien.
● Par conséquent, cela n'a pas de sens de vouloir récupérer dans
une variable le résultat renvoyé par une telle fonction. Si on essaie
tout de même, Python affecte la valeur None qui signifie rien en
anglais:

Les fonctions
Passage d'arguments
Le nombre d'arguments que l'on peut passer à une fonction est variable. Nous avons vu ci-dessus des fonctions auxquelles on
passait 0 ou 1 argument. Le nombre d'argument est donc laissé libre à l'initiative du programmeur qui développe une nouvelle
fonction.
Une particularité des fonctions en Python est que vous n'êtes pas obligé de préciser le type des arguments que vous lui passez,
dès lors que les opérations que vous effectuez avec ces arguments sont valides.
Python est en effet connu comme étant un langage au « typage dynamique », c'est-à-dire qu'il reconnaît pour vous le type des
variables au moment de l'exécution. Par exemple :

Les fonctions
Utilisation des fonctions dans un script
Pour cette première approche des fonctions, nous n’avons utilisé jusqu’ici que des fonctions dans des scripts et pas de
programme principal dans le script. Veuillez donc essayer vous-même le petit programme ci-dessous, lequel calcule le volume
d’une sphère à l’aide de la formule :
A bien y regarder, ce programme comporte deux parties :
● les deux fonctions cube() et volume_sphere()
● le corps principal du programme.
⇒ Dans le corps principal du programme, il y a un appel de la fonction volume_sphere().
A l’intérieur de la fonction volume_sphere(), il y a un appel de la fonction cube().
⇒ Notez bien que les deux parties du programme ont été disposées dans un certain ordre :
● d’abord la définition des fonctions,
● et ensuite le corps principal du programme.
Cette disposition est nécessaire, parce que l’interpréteur exécute les lignes d’instructions du programme l’une après l’autre, dans l’ordre où
elles apparaissent dans le code source. Dans le script, la définition des fonctions doit donc précéder leur utilisation.

Formation en Python_Niveau1_2023.pptx

Contenu connexe

Similaire à Formation en Python_Niveau1_2023.pptx

Formation en Python_Niveau1_2023.pptx