PYTHON

Les Variables et les Types de Données

Déclaration de Variables

- Introduction aux Variables : Les variables sont des conteneurs pour stocker des données.

- Règles pour Nommer les Variables :

- Peut commencer par une lettre ou un underscore (_), mais pas par un chiffre.

- Peut contenir des lettres, des chiffres, et des underscores, mais pas d'autres caractères ou espaces.

- Les noms de variables sont sensibles à la casse (maVariable, MaVariable, et MAVARIABLE sont
différentes).

- Assignation de Valeurs : Utiliser le signe égal (=) pour assigner une valeur à une variable. Exemple : age
= 30.
 Les Variables et les Types de Données
Types de Données Primitifs

- Entiers (int) :

- Représentent des nombres entiers, positifs ou négatifs, sans partie décimale.

- Exemples : age = 30, nombre_negatif = -7.

- Flottants (float) :

- Représentent des nombres réels avec des parties décimales.

- Peuvent être déclarés directement avec un point décimal ou en utilisant e pour indiquer la puissance de
10. Exemple : hauteur = 1.75, vitesse_lumiere = 3.0e8.
 Les Variables et les Types de Données
- Chaînes de Caractères (str) :

- Représentent du texte entouré de guillemets simples ('...') ou doubles ("...").

- Peuvent contenir des lettres, des chiffres, des espaces et de nombreux symboles. Exemple : nom =
"Jean".

- Booléens (bool) :

- Représentent une vérité avec seulement deux valeurs possibles : True ou False.

- Souvent le résultat d'expressions conditionnelles. Exemple : est_majeur = True.

 Les Variables et les Types de Données
Conversion de Types

- Nécessité de la Conversion : Parfois, il est nécessaire de convertir une variable d'un type à un autre pour
effectuer certaines opérations.

- Conversion entre les Types :

- Vers Entiers : Utiliser int() pour convertir une chaîne ou un flottant en entier. Exemple : int('123') donne
123, int(12.34) donne 12.

- Vers Flottants : Utiliser float() pour convertir une chaîne ou un entier en flottant. Exemple :
float('12.34') donne 12.34, float(123) donne 123.0.

- Vers Chaînes : Utiliser str() pour convertir un entier ou un flottant en chaîne. Exemple : str(123) donne
'123', str(12.34) donne '12.34'.

- Importance de la Prudence : Faire attention lors de la conversion pour éviter la perte d'information
(comme la conversion de float à int) ou des erreurs (int('texte')).
 Les Variables et les Types de Données
Exemple 1: Manipulation de Variables et Types Simples
# Déclaration et assignation de variables
age = 25 # int

taille = 1.82 # float

nom = "Alice" # str

est_majeur = True # bool

# Affichage des variables

print(f"Nom: {nom}, Âge: {age}, Taille: {taille}m, Est majeur: {est_majeur}")

# Conversion de types

age_str = str(age) # Convertir int en str

taille_int = int(taille) # Convertir float en int (perte de la partie décimale)

print(f"Âge en chaîne: {age_str}, Taille en entier: {taille_int}")

 Les Variables et les Types de Données
Exemple 2: Calcul et Conversion
# Opérations arithmétiques

nombre1 = 10

nombre2 = 3

somme = nombre1 + nombre2

difference = nombre1 - nombre2

produit = nombre1 * nombre2

division = nombre1 / nombre2

# Affichage des résultats

print(f"Somme: {somme}, Différence: {difference }, Produit: {produit}, Division: {division :.2f}")

# Conversion de type

division_entiere = int(division) # Conversion de float à int

print(f"Division entière: {division_entiere }")

 Les opérateurs Arithmétiques et Logiques
Opérations Arithmétiques

● Addition (+) : Additionne deux nombres. Exemple : 5 + 3 donne 8.

● Soustraction (-) : Soustrait le second nombre du premier. Exemple : 5 - 3 donne 2.

● Multiplication (*) : Multiplie deux nombres. Exemple : 5 * 3 donne 15.

● Division (/) : Divise le premier nombre par le second. Donne toujours un résultat flottant. Exemple : 5 / 2
donne 2.5.

● Division Entière (//) : Divise le premier nombre par le second, mais arrondit le résultat à l'entier le plus
proche inférieur. Exemple : 5 // 2 donne 2.

● Modulo (%) : Donne le reste de la division du premier nombre par le second. Exemple : 5 % 2 donne 1.

● Exponentiation () : Élève le premier nombre à la puissance du second. Exemple : 2**3 donne 8.

 Les opérateurs Arithmétiques et Logiques
Opérations Logiques
● AND (and) : Renvoie True si les deux opérandes sont vrais, sinon False.
● OR (or) : Renvoie True si au moins un des opérandes est vrai, sinon False.
● NOT (not) : Inverse le booléen de l'opérande. Renvoie False si l'opérande est vrai, et True s'il est faux.
Priorité des Opérations
● Les opérations sont effectuées selon une certaine priorité : d'abord les parenthèses, suivies de
l'exponentiation, puis la multiplication, la division, la division entière, et le modulo, et enfin l'addition et la
soustraction.
● Les opérations logiques ont une priorité inférieure aux opérations arithmétiques : not a la priorité la plus
élevée, suivi de and, et enfin or.
Expressions et Évaluation
● Une expression est une combinaison de valeurs, de variables, d'opérateurs, et d'appels de fonctions qui sont
évalués par l'interpréteur Python pour produire une autre valeur.
● Une expression peut être aussi simple qu'une valeur seule ou aussi complexe que nécessaire pour effectuer
un calcul.
 Les opérateurs Arithmétiques et Logiques
# Opérations arithmétiques
print(10 + 5) # Addition
print(10 - 5) # Soustraction
print(10 * 5) # Multiplication
print(10 / 3) # Division
print(10 // 3) # Division entière
print(10 % 3) # Modulo
print(2 3) # Exponentiation

# Opérations logiques
print(True and False ) # Résultat: False
print(True or False ) # Résultat: True
print(not True ) # Résultat: False

# Priorité des opérations

print(5 + 2 * 3) # Résultat: 11, multiplication d'abord
print((5 + 2) * 3) # Résultat: 21, parenthèses d'abord

# Expression
resultat = ( 5 + 10 * 2) 2 / 10 - 3
print(resultat)
 Les Chaînes de Caractères et Leurs Opérations

Les chaînes de caractères, ou "strings" en anglais, sont des séquences de caractères utilisées pour stocker et
manipuler du texte en Python. Voici une exploration détaillée de leur création, manipulation et des
opérations courantes que l'on peut effectuer avec elles.

Création de Chaînes
- Utilisation de guillemets : En Python, les chaînes peuvent être délimitées par des guillemets simples ('...')
ou doubles ("..."). Il n'y a pas de différence fonctionnelle entre les deux, mais cela permet d'inclure un
guillemet de l'autre type à l'intérieur de la chaîne sans avoir à l'échapper.

chaine1 = 'Bonjour'
chaine2 = "Python"
 Les Chaînes de Caractères et Leurs Opérations

Concaténation et Répétition
- Concaténation (+) : Combine deux chaînes en une seule.

salutation = chaine1 + ', ' + chaine2 + '!'

print(salutation) # Affiche: Bonjour, Python!

- Répétition (*) : Répète une chaîne un nombre spécifié de fois.

rire = "ha" * 5
print(rire) # Affiche: hahahahaha
 Les Chaînes de Caractères et Leurs Opérations

Accès aux Caractères

- Indexation : Accède à un caractère dans une chaîne par son indice, en commençant par 0 pour le premier
caractère.

premier_caractere = salutation[0] # 'B'

- Slicing : Sélectionne une sous-chaîne à partir d'une plage d'indices.

sous_chaine = salutation[0:7] # 'Bonjour'

 Les Chaînes de Caractères et Leurs Opérations

Méthodes de Chaînes Courantes

- .upper() et .lower() : Convertit une chaîne en majuscules ou en minuscules.

print("python".upper()) # PYTHON
print("PYTHON".lower()) # python

- .strip() : Supprime les espaces au début et à la fin d'une chaîne.

print(" espace ".strip()) # 'espace'

- .find(sub) : Recherche une sous-chaîne et renvoie l'indice de sa première occurrence.

position = "recherche".find("che") # 2
 Les Chaînes de Caractères et Leurs Opérations

- .replace(old, new) : Remplace toutes les occurrences d'une sous-chaîne par une autre.

remplace = "bonbon".replace("bon", "mal") # 'malbon'

Formatage de Chaînes
- str.format() : Insère des valeurs dans une chaîne de caractères.

age = 25
message = "J'ai {} ans.".format(age)
print(message) # J'ai 25 ans.
 Les Chaînes de Caractères et Leurs Opérations

- F-strings (formatage littéral de chaînes) : Introduit en Python 3.6, permet d'incorporer directement des
expressions Python à l'intérieur des accolades {} d'une chaîne.

nom = "Alice"
f_message = f"Bonjour, {nom}!"
print(f_message) # Bonjour, Alice!

Ces opérations et méthodes sont fondamentales pour la manipulation de texte en Python, offrant une grande
flexibilité pour créer, modifier et travailler avec des données textuelles. L'utilisation efficace des chaînes de
caractères est essentielle dans de nombreux domaines, allant du traitement de données au développement
web.
 Les entrées et sorties de base

Dans le cadre de l'apprentissage de Python, maîtriser les fonctions d'entrée et de sortie de base est essentiel.
Ces fonctions permettent d'interagir avec l'utilisateur en recevant des données (input) et en affichant des
résultats ou des messages (print). Voici une exploration détaillée de ces fonctions.

La Fonction print()

- Affichage de texte simple et de variables : La fonction print() est utilisée pour afficher du texte, des
valeurs de variables ou une combinaison des deux à l'écran.

nom = "Alice"
print("Bonjour", nom) # Affiche: Bonjour Alice
 Les entrées et sorties de base
- Utiliser les séparateurs (sep) : Le paramètre sep permet de spécifier un séparateur entre les objets.

print("Python", "est", "amusant", sep="-") # Affiche: Python-est-amusant

- Utiliser les terminaisons de ligne (end) : Le paramètre end permet de spécifier ce qui sera imprimé à la fin
de l'expression.

print("Bonjour", end="! ")

print("Alice") # Affiche: Bonjour! Alice
 Les entrées et sorties de base
La Fonction input()

- Lire une entrée utilisateur : input() lit une ligne de texte entrée par l'utilisateur et la retourne sous forme de
chaîne de caractères.

nom = input("Entrez votre nom: ")

print("Bonjour,", nom)

- Conversion de l'entrée en types appropriés : Les données reçues via input() sont toujours des chaînes.
Pour les utiliser comme un autre type (int, float), vous devez les convertir explicitement.

age_str = input("Entrez votre âge: ")

age = int(age_str) # Convertit la chaîne en entier
print("Vous avez", age, "ans.")
 Les entrées et sorties de base
Exemples Pratiques

Exemple 1: Calculateur Simple

Écrire un script qui demande à l'utilisateur d'entrer deux nombres et affiche la somme.

nombre1 = float(input("Entrez le premier nombre: "))

nombre2 = float(input("Entrez le deuxième nombre: "))
somme = nombre1 + nombre2
print("La somme est:", somme)
 Les entrées et sorties de base
Exemple 2: Salutation Personnalisée
Demandez le nom de l'utilisateur et utilisez-le pour le saluer.

nom = input("Comment vous appelez-vous? ")

print("Bonjour,", nom)

Exemple 3: Convertisseur d'Unité

Convertissez les kilomètres en miles.

kilometres = float(input("Entrez la distance en kilomètres: "))

miles = kilometres * 0.621371
print(kilometres, "kilomètres équivalent à", miles, "miles.")
 Les conditions
Les conditions en Python permettent de diriger l'exécution du programme en fonction de la vérification de
certaines conditions. Elles sont essentielles pour la prise de décision dans le code et utilisent principalement
les mots-clés if, elif, et else.

1. Syntaxe de Base des Conditions

L'instruction if
- Usage: L'instruction if teste une condition. Si la condition est vraie (True), le bloc de code indenté qui suit
est exécuté.
- Exemple:

age = 20
if age >= 18:
print("Vous êtes majeur.")
 Les conditions
L'instruction else
- Usage: else est utilisée pour exécuter un bloc de code lorsque la condition testée par if est fausse (False).
- Exemple:

if age >= 18:

print("Vous êtes majeur.")
else:
print("Vous êtes mineur.")
 Les conditions
L'instruction elif
- Usage: elif, contraction de "else if", permet de tester plusieurs conditions de manière séquentielle.
- Exemple:

if age < 13:

print("Enfant")
elif age < 18:
print("Adolescent")
else:
print("Adulte")
 Les conditions
2. Conditions Combinées

Opérateurs Logiques
- and, or, not: Ces opérateurs permettent de combiner des conditions simples en conditions plus
complexes.
- Exemple:

if age >= 18 and age <= 65:

print("Vous êtes dans la tranche d'âge active.")
 Les conditions
Comparaisons Multiples
- Python permet de chaîner les comparaisons pour rendre le code plus lisible.
- Exemple:

if 18 <= age <= 65:

print("Vous êtes dans la tranche d'âge active.")
 Les conditions
3. Conditions avec Valeurs Falsy et Truthy

En Python, certaines valeurs sont considérées comme False dans un contexte booléen (appelées "Falsy"), et
d'autres comme True ("Truthy").

- Valeurs Falsy: None, False, 0, "" (chaîne vide), [] (liste vide), {} (dictionnaire vide), () (tuple vide), et
d'autres collections vides.
- Valeurs Truthy: Tout ce qui n'est pas Falsy.
 Les conditions
4. Utilisation des Conditions dans les Expressions

Les conditions peuvent être utilisées dans des expressions pour attribuer des valeurs ou effectuer des
opérations basées sur des vérifications conditionnelles.

- Expression conditionnelle (Ternaire):

statut = "majeur" if age >= 18 else "mineur"

print(f"Vous êtes {statut}.")

Les conditions sont un aspect fondamental de la programmation en Python, permettant de contrôler le flux
d'exécution du programme en fonction de différentes vérifications logiques. Elles sont utilisées dans
presque tous les types de programmes, des scripts simples aux applications complexes.
 BOUCLES
La boucle for en Python est un outil puissant pour itérer sur les éléments d'une séquence (comme une liste,
un tuple, un dictionnaire, un ensemble ou une chaîne de caractères) ou tout autre objet itérable.
Contrairement à beaucoup d'autres langages de programmation, Python simplifie les itérations avec sa
boucle for, en éliminant le besoin d'initialiser et d'incrémenter explicitement un compteur. Voici un guide
détaillé sur l'utilisation de la boucle for en Python.

Syntaxe de Base

La syntaxe de base de la boucle for est comme suit :

for variable in iterable:

# Bloc d'instructions à exécuter pour chaque élément

- variable : Nom de la variable qui prend la valeur du prochain élément dans l'itérable à chaque itération.

- iterable : Objet Python sur lequel on peut itérer, comme une liste, un tuple, etc.
 BOUCLES
Utilisation de range()

La fonction range() est souvent utilisée avec la boucle for pour exécuter une boucle un nombre déterminé
de fois.

- Syntaxe de range() : range(start, stop, step)

- start est inclusif, stop est exclusif, et step est l'incrément.

Exemple d'Incrémentation

for i in range(0, 5): # De 0 à 4

print(i)
 BOUCLES
Exemple de Décrémentation

for i in range(5, 0, -1): # De 5 à 1

print(i)

Boucles for avec Indices

Parfois, vous avez besoin de l'indice de l'élément en cours de traitement. Python propose deux façons de le
faire :

Utilisation de range() et len()

fruits = ["pomme", "banane", "mangue"]

for i in range(len(fruits)):

print(f"L'indice {i} est pour le fruit {fruits[i]}")

 BOUCLES
Itération sur des Séquences

Itération sur une Liste

fruits = ["pomme", "banane", "mangue"]

for fruit in fruits:

print(fruit)

Itération sur une Chaîne de Caractères

for lettre in "Python":

print(lettre)
 BOUCLES
Utilisation de enumerate()

for indice, fruit in enumerate(fruits):

print(f"L'indice {indice} est pour le fruit {fruit}")

Itération sur des Intervales

La boucle for avec range() peut être utilisée pour itérer sur un intervalle de nombres.

Itération avec un Pas Positif (Incrémentation)

for i in range(0, 10, 2): # Pas de 2

print(i) # Affiche les nombres pairs de 0 à 8

 BOUCLES
Itération avec un Pas Négatif (Décrémentation)

for i in range(10, 0, -2): # Pas de -2

print(i) # Affiche les nombres pairs de 10 à 2

Conseils et Bonnes Pratiques

- Utilisez enumerate() pour itérer sur des séquences lorsque vous avez besoin à la fois de l'indice et de la
valeur.

- Préférez la boucle for aux boucles while lorsque vous itérez sur des séquences ou des itérables connus.

- La fonction range() est particulièrement utile pour exécuter une instruction un nombre précis de fois.

La boucle for en Python est versatile et peut être utilisée pour simplifier de nombreux types de tâches
d'itération, rendant le code plus lisible et efficace.
 BOUCLES
La boucle while en Python permet d'exécuter un bloc de code tant qu'une condition donnée est vraie. Elle
est utilisée pour des itérations où le nombre de répétitions n'est pas connu à l'avance, ce qui la différencie
de la boucle for qui est préférée pour itérer sur des séquences ou lorsque le nombre d'itérations est fixe.
Voici un guide détaillé sur l'utilisation de la boucle while en Python, incluant la syntaxe, l'incrémentation,
la décrémentation, et l'utilisation d'intervalles.

Syntaxe de Base

La syntaxe de base de la boucle while est comme suit :

while condition:

# Bloc d'instructions à exécuter tant que la condition est vraie

- condition : Une expression qui est évaluée avant chaque itération. Si la condition est vraie (True), le bloc
de code indenté est exécuté. La boucle se termine lorsque la condition devient fausse (False).
 BOUCLES
Incrémentation et Décrémentation

Dans une boucle while, l'incrémentation ou la décrémentation des variables doit être gérée manuellement
pour éviter les boucles infinies.

Exemple d'Incrémentation

i = 0

while i < 5:

print(i)

i += 1 # Incrémente i de 1 à chaque itération

 BOUCLES
Exemple de Décrémentation

i = 5

while i > 0:

print(i)

i -= 1 # Décrémente i de 1 à chaque itération

 BOUCLES
Utilisation avec des Intervalles

La boucle while peut être utilisée pour itérer sur un intervalle de valeurs, bien que cela soit moins commun
que l'utilisation de for pour de telles tâches.

Exemple avec un Intervalle

i = 1

while i <= 10:

if i % 2 == 0:

print(i) # Affiche les nombres pairs entre 1 et 10

i += 1
 BOUCLES
Conseils d'Utilisation

- Éviter les Boucles Infinies : Assurez-vous que la condition de la boucle while deviendra fausse à un
moment donné. Cela implique souvent de modifier une variable utilisée dans la condition à chaque
itération.

- Utilisation de break : Le mot-clé break permet de sortir immédiatement d'une boucle while, quelle que
soit la condition. C'est utile pour arrêter une boucle en fonction de conditions supplémentaires.

- Utilisation de continue : continue peut être utilisé pour sauter le reste du bloc de code pour l'itération en
cours et passer à l'itération suivante de la boucle.
 BOUCLES
Exemples Pratiques

Demander un Mot de Passe

mot_de_passe_correct = "python"

mot_de_passe = ""

while mot_de_passe != mot_de_passe_correct:

mot_de_passe = input("Entrez le mot de passe : ")

print("Mot de passe correct !")

 BOUCLES
Utilisation de break pour Sortir d'une Boucle

while True:

reponse = input("Tapez 'exit' pour sortir : ")

if reponse == "exit":

break

print("Vous avez quitté la boucle.")

La boucle while est un outil flexible pour effectuer des itérations basées sur des conditions dynamiques,
offrant la possibilité de gérer des situations où le nombre d'itérations n'est pas connu d'avance.
 COLLECTIONS
En programmation, le terme "collection" se réfère à une structure de données qui permet de stocker et
d'organiser des éléments de manière à faciliter leur manipulation. En Python, les collections sont des objets
qui peuvent contenir plusieurs éléments, tels que des nombres, des chaînes de caractères, des objets, etc.
Ces collections peuvent être utilisées pour stocker, accéder et manipuler des données de manière plus
pratique que les types de données de base tels que les entiers, les flottants ou les chaînes de caractères.

Les collections couramment utilisées en Python comprennent les listes, les tuples, les ensembles et les
dictionnaires, ainsi que des structures plus avancées fournies par le module `collections` telles que
`Counter`, `defaultdict`, etc. Chacune de ces structures a ses propres caractéristiques et est adaptée à des
cas d'utilisation spécifiques.

En résumé, en Python, une collection est une structure de données qui permet de regrouper et de manipuler
plusieurs éléments de manière organisée et efficace.
 LES COLLECTIONS
1. **Liste (`list`) :**

- Une liste est une collection ordonnée et mutable d'éléments.

- Les éléments peuvent être de différents types (nombres, chaînes de caractères, objets, etc.).

- Les éléments sont indexés par des entiers, permettant un accès et une modification faciles.

- La syntaxe : `ma_liste = [1, 'deux', 3.0]`

2. **Tuple (`tuple`) :**

- Un tuple est une collection ordonnée et immuable d'éléments.

- Les éléments peuvent être de différents types.

- Les éléments sont indexés par des entiers comme dans les listes.

- La syntaxe : `mon_tuple = (1, 'deux', 3.0)`

 LES COLLECTIONS
3. **Ensemble (`set`) :**

- Un ensemble est une collection non ordonnée d'éléments uniques et immuables.

- Utile pour éliminer les doublons d'une séquence.

- Ne supporte pas l'indexation car l'ordre n'est pas garanti.

- La syntaxe : `mon_ensemble = {1, 2, 3}`

4. **Dictionnaire (`dict`) :**

- Un dictionnaire est une collection associative d'éléments sous forme de paires clé-valeur.

- Les clés sont uniques et immuables, et sont utilisées pour accéder aux valeurs associées.

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

- La syntaxe : `mon_dictionnaire = {'un': 1, 'deux': 2, 'trois': 3}`

 LES COLLECTIONS
En résumé, les listes sont utilisées pour des collections ordonnées et modifiables, les tuples pour des
collections ordonnées et immuables, les ensembles pour des collections non ordonnées d'éléments uniques,
et les dictionnaires pour des collections associatives avec des clés et des valeurs. Chacune de ces structures
offre des avantages spécifiques selon les besoins du programme.
 LES LISTES
Création d'une liste :

ma_liste = [1, 2, 3, 'quatre', 5]

Accès aux éléments par indice :

premier_element = ma_liste[0] # Accès au premier élément

dernier_element = ma_liste[-1] # Accès au dernier élément

Modification des éléments :

ma_liste[1] = 'deuxième' # Modification de l'élément à l'indice 1

 LES LISTES
Ajout d'éléments à la fin de la liste :

ma_liste.append(6) # Ajout de l'élément 6 à la fin de la liste

Concaténation de listes :

autre_liste = [7, 8, 9]

nouvelle_liste = ma_liste + autre_liste

Suppression d'éléments par valeur :

ma_liste.remove('quatre') # Suppression de l'élément 'quatre'

 LES LISTES
Suppression d'éléments par indice :

del ma_liste[2] # Suppression de l'élément à l'indice 2

Longueur de la liste :

longueur = len(ma_liste) # Retourne la longueur de la liste

Vérification de l'appartenance d'un élément à la liste :

appartient = 'deuxième' in ma_liste # Retourne True si 'deuxième' est

dans la liste
 LES LISTES
Parcours de la liste avec une boucle `for` :

for element in ma_liste:

print(element)

Copie de liste :

copie_liste = ma_liste.copy() # Crée une copie de la liste

Compter le nombre d'occurrences d'un élément :

nombre_occurrences = ma_liste.count(3) # Compte le nombre

d'occurrences de l'élément 3
 LES LISTES
Insérer un élément à un indice spécifique :

ma_liste.insert(2, 'insertion') # Insère 'insertion' à l'indice 2

Étendre la liste avec une autre liste :

ma_liste.extend([6, 7, 8]) # Étend la liste avec les éléments de la

liste fournie

Inverser l'ordre des éléments dans la liste (sur place) :

ma_liste.reverse() # Inverse l'ordre des éléments dans la liste

 LES LISTES
Trier la liste (sur place) :

ma_liste.sort() # Trie la liste par ordre croissant (pour les éléments

comparables)

Obtenir l'indice d'un élément spécifique :

indice = ma_liste.index('deuxième') # Retourne l'indice de 'deuxième'

Supprimer et récupérer le dernier élément :

dernier_element = ma_liste.pop() # Supprime et retourne le dernier

élément
 LES LISTES
Créer une liste avec une séquence de nombres :

sequence = list(range(1, 6)) # Crée une liste avec les nombres de 1 à

5

Filtrer les éléments de la liste avec une fonction lambda :

nouveaux_elements = list(filter(lambda x: isinstance(x, int),

ma_liste)) # Garde seulement les entiers dans la liste
 LES LISTES
La fonction `sorted()` en Python est utilisée pour trier une séquence, y compris les listes. Voici comment
vous pouvez l'utiliser avec une liste :

Utilisation de `sorted()` avec une liste :

ma_liste = [4, 2, 7, 1, 9]

liste_triee = sorted(ma_liste) # Retourne une nouvelle liste triée

Dans cet exemple, la fonction `sorted()` prend la liste `ma_liste` et retourne une nouvelle liste triée, sans
modifier la liste d'origine. Si vous souhaitez trier la liste sur place (modifier la liste existante), vous pouvez
utiliser la méthode `sort()` directement sur la liste :
 LES LISTES
Tri sur place avec la méthode `sort()` :

ma_liste.sort() # Trie la liste sur place

Maintenant, `ma_liste` serait modifiée pour être dans l'ordre croissant. Il est important de noter que `sort()`
agit directement sur la liste existante, tandis que `sorted()` crée une nouvelle liste triée sans modifier
l'originale.

En explorant ces méthodes, vous pourrez efficacement manipuler, transformer et exploiter la grande
flexibilité des listes en Python, grâce à leur nature mutable et ordonnée, pour répondre aux besoins
spécifiques de votre programme.
 LES DICTIONNAIRES
Creation Dictionnaire

Méthode 1 : Définir un dictionnaire directement

# Création d'un dictionnaire vide
mon_dictionnaire = {}

# Ajout d'éléments au dictionnaire

mon_dictionnaire['cle1'] = 'valeur1'
mon_dictionnaire['cle2'] = 'valeur2'

print(mon_dictionnaire)
 LES DICTIONNAIRES
Creation Dictionnaire

Méthode 2 : Utiliser la syntaxe du dictionnaire {}

# Création d'un dictionnaire avec des éléments

mon_dictionnaire = {'cle1': 'valeur1', 'cle2': 'valeur2'}

print(mon_dictionnaire)

Méthode 3 : Utiliser la fonction dict()

# Création d'un dictionnaire avec la fonction dict()

mon_dictionnaire = dict(cle1='valeur1', cle2='valeur2')

print(mon_dictionnaire)
 LES DICTIONNAIRES
Accès par clé

Vous pouvez accéder à la valeur associée à une clé spécifique dans le dictionnaire en utilisant la notation
des crochets `[]` avec la clé comme index :

mon_dictionnaire = {'cle1': 'valeur1', 'cle2': 'valeur2'}

print(mon_dictionnaire['cle1']) # Accès à la valeur associée à 'cle1'

 LES DICTIONNAIRES
Méthode get()

La méthode `get()` permet d'accéder à une valeur en spécifiant la clé. Elle renvoie la valeur associée à la clé
donnée. Si la clé n'existe pas, elle renvoie une valeur par défaut (par défaut, `None` si aucune n'est fournie)
:

mon_dictionnaire = {'cle1': 'valeur1', 'cle2': 'valeur2'}

print(mon_dictionnaire.get('cle2')) # Accès à la valeur associée à 'cle2'

 LES DICTIONNAIRES
Boucle à travers les clés

Vous pouvez parcourir toutes les clés d'un dictionnaire à l'aide de la boucle `for` et ensuite accéder à chaque
valeur en utilisant ces clés :

mon_dictionnaire = {'clé1': 'valeur1', 'clé2': 'valeur2'}

for cle in mon_dictionnaire:

print(cle, "->", mon_dictionnaire[cle])

 LES DICTIONNAIRES
Méthode items()

La méthode `items()` permet d'itérer à la fois sur les clés et les valeurs d'un dictionnaire :

mon_dictionnaire = {'cle1': 'valeur1', 'cle2': 'valeur2'}

for cle, valeur in mon_dictionnaire.items():

print(cle, "->", valeur)

Ces méthodes offrent différentes manières d'accéder aux données stockées dans un dictionnaire, en fonction
de vos besoins spécifiques.
 LES DICTIONNAIRES
Pour modifier un dictionnaire en Python, vous pouvez accéder à une clé spécifique et lui attribuer une
nouvelle valeur, ou bien utiliser des méthodes spécifiques pour ajouter, mettre à jour ou supprimer des
éléments. Voici quelques exemples de modifications courantes :

Modification d'une valeur existante

mon_dictionnaire = {'cle1': 'valeur1', 'cle2': 'valeur2'}

# Modification de la valeur associée à 'cle1'

mon_dictionnaire['cle1'] = 'nouvelle_valeur'

print(mon_dictionnaire)
 LES DICTIONNAIRES
Ajout d'un nouvel élément

mon_dictionnaire = {'clé1': 'valeur1', 'clé2': 'valeur2'}

# Ajout d'une nouvelle paire clé-valeur

mon_dictionnaire['clé3'] = 'valeur3'

print(mon_dictionnaire)
 LES DICTIONNAIRES
Méthode update()

La méthode `update()` permet de fusionner un dictionnaire avec un autre dictionnaire ou une séquence de
paires clé-valeur. Si une clé existe déjà, sa valeur sera mise à jour ; sinon, elle sera ajoutée :

mon_dictionnaire = {'clé1': 'valeur1', 'clé2': 'valeur2'}

# Mise à jour avec de nouvelles valeurs

mon_dictionnaire.update({'clé1': 'nouvelle_valeur', 'clé3':

'valeur3'})

print(mon_dictionnaire)
 LES DICTIONNAIRES
Méthode pop() et popitem()

La méthode `pop(clé)` permet de supprimer et de renvoyer la valeur associée à une clé spécifique. La
méthode `popitem()` supprime et renvoie la dernière paire clé-valeur ajoutée au dictionnaire :

mon_dictionnaire = {'cle1': 'valeur1', 'cle2': 'valeur2'}

# Suppression de la valeur associée à 'cle1'

valeur_supprimée = mon_dictionnaire.pop('cle1')

print(mon_dictionnaire)

print("Valeur supprimée :", valeur_supprimée)

 LES DICTIONNAIRES
mon_dictionnaire = {'cle1': 'valeur1', 'cle2': 'valeur2'}

# Suppression de la dernière paire clé-valeur

dernier_element_supprime = mon_dictionnaire.popitem()

print(mon_dictionnaire)

print("Dernier élément supprimé :", dernier_element_supprime)

Ces méthodes offrent différentes façons de modifier un dictionnaire en Python en fonction de vos besoins
spécifiques.
 LES DICTIONNAIRES
Parcourir un dictionnaire en Python peut se faire de plusieurs manières, en fonction des besoins spécifiques
de votre programme. Voici les principaux types de parcours :

1. Parcourir les clés du dictionnaire :

mon_dictionnaire = {'a': 1, 'b': 2, 'c': 3}

for cle in mon_dictionnaire:

print(cle)
 LES DICTIONNAIRES
2. Parcourir les valeurs du dictionnaire :

mon_dictionnaire = {'a': 1, 'b': 2, 'c': 3}

for valeur in mon_dictionnaire.values():

print(valeur)

3. Parcourir les paires clé-valeur du dictionnaire :

mon_dictionnaire = {'a': 1, 'b': 2, 'c': 3}

for cle, valeur in mon_dictionnaire.items():

print(cle, "->", valeur)

 LES DICTIONNAIRES
4. Parcourir les clés et récupérer les valeurs correspondantes :

mon_dictionnaire = {'a': 1, 'b': 2, 'c': 3}

for cle in mon_dictionnaire:

valeur = mon_dictionnaire[cle]

print(cle, "->", valeur)

 LES DICTIONNAIRES
5. Parcourir les paires clé-valeur à l'aide d'un itérateur :

mon_dictionnaire = {'a': 1, 'b': 2, 'c': 3}

iterateur = iter(mon_dictionnaire.items())

while True:

try:

cle, valeur = next(iterateur)

print(cle, "->", valeur)

except StopIteration:

break

Ces différentes méthodes de parcours offrent une flexibilité pour manipuler les données d'un dictionnaire
selon les besoins de votre application.