En Python, les boucles sont une construction fondamentale pour l'exécution répétée de blocs de code. Les deux structures de boucle les plus couramment utilisées sont les boucles for et while.

1. Utilisation de la boucle for

La boucle for est généralement employée pour parcourir les éléments d'une séquence, telle qu'une liste, un tuple, une chaîne de caractères ou une plage de nombres.

Parcourir une liste

fruits = ['pomme', 'banane', 'cerise']
for fruit in fruits:
    print(fruit)

Parcourir une plage de nombres

La fonction range() génère une séquence de nombres que vous pouvez ensuite parcourir avec une boucle for.

for i in range(5):  # Génère les nombres de 0 à 4
    print(i)

for i in range(2, 7):  # La valeur de fin de range() est exclue, donc ici jusqu'à 6
    print(i)

2. Utilisation de la boucle while

La boucle while exécute un bloc de code tant qu'une condition spécifiée est vraie.

compteur = 0
while compteur < 5:
    print(compteur)
    compteur += 1  # Mise à jour de la condition pour éviter une boucle infinie

3. Parcourir un dictionnaire avec la boucle for

Vous pouvez itérer sur les clés, les valeurs ou les paires clé-valeur d'un dictionnaire.

Parcourir les clés

personne = {'nom': 'Jean', 'age': 30}
for cle in personne:
    print(cle)

Parcourir les valeurs

for valeur in personne.values():
    print(valeur)

Parcourir les paires clé-valeur

for cle, valeur in personne.items():
    print(cle, valeur)

4. Utilisation des compréhensions de liste et des expressions génératrices

Bien qu'elles ne soient pas des boucles traditionnelles, elles sont couramment utilisées pour créer des listes ou des générateurs.

Exemple de compréhension de liste

carres = [x**2 for x in range(5)]  # Crée une liste des carrés des nombres de 0 à 4
print(carres)

Exemple d'expression génératrice

carres_gen = (x**2 for x in range(5))  # Crée un générateur des carrés des nombres de 0 à 4
for carre in carres_gen:
    print(carre)

5. Utilisation de enumerate pour l'itération avec index et valeur

enumerate est utile lorsque vous avez besoin à la fois de l'index et de la valeur lors de l'itération sur une séquence.

fruits = ['pomme', 'banane', 'cerise']
for index, fruit in enumerate(fruits):
    print(index, fruit)

Ce sont les méthodes fondamentales pour implémenter des boucles en Python. Le choix dépend de vos besoins spécifiques.

Pour obtenir la longueur d'une liste en Python, utilisez la fonction intégrée len().

En Python, l'utilisation des instructions conditionnelles if est directe. Les blocs de code sont définis par l'indentation, et non par des parenthèses.

Pour accéder à un élément d'une liste à un index spécifique i, vous utilisez l'indexation.

tableau = [10, 20, 30, 40, 50]  # Liste d'exemple
i = 2  # Index souhaité
element = tableau[i]
print(element)  # Affiche: 30

Pour définir une liste en Python, vous pouvez utiliser des crochets.

liste_a = [valeur_a, valeur_b, valeur_c]

2. Utilisation des opérateurs logiques

Les opérateurs logiques and, or et not permettent de combiner plusieurs conditions.

x = 10
y = 20
if x > 5 and y > 15:
    print("x est supérieur à 5 ET y est supérieur à 15")

3. Utilisation de in et not in pour les tests d'appartenance

ma_liste = [1, 2, 3, 4, 5]
if 3 in ma_liste:
    print("3 est dans la liste")

4. Utilisation de is et is not pour tester l'identité

is vérifie si deux variables font référence au même objet en mémoire.

a = [1, 2, 3]
b = a
if a is b:
    print("a et b sont le même objet")

Pour effectuer une décrémentation (réduire la valeur d'une variable de 1) en Python, vous pouvez utiliser l'opérateur -=.

x = 5
x -= 1
print(x)  # Affiche: 4

Notez que Python n'utilise pas -- pour la décrémentation comme certains autres langages.

Pour vérifier la présence de doublons dans une séquence, l'utilisation d'un ensemble (set) est une méthode efficace.

def contient_doublons(lst):
    vus = set()
    for element in lst:
        if element in vus:
            return True
        vus.add(element)
    return False

liste_exemple = [1, 2, 3, 2, 4]
print(contient_doublons(liste_exemple))  # Affiche: True

La longueur d'un ensemble s'obtient également avec len().

1.3 Opérations de base sur les ensembles

Type d'opération	Méthode/Opérateur	Exemple de code	Description
Ajouter un élément unique	add()	fruits.add("raisin")	Ajoute un seul élément. Si l'élément existe déjà, rien ne se passe.
Ajouter plusieurs éléments	update()	fruits.update(["a", "b"])	Ajoute plusieurs éléments à partir d'un itérable (liste, tuple, chaîne, etc.).
Supprimer un élément	remove()	fruits.remove("pomme")	Supprime un élément spécifié. Lève une KeyError s'il n'existe pas.
Supprimer un élément (sans erreur)	discard()	fruits.discard("mangue")	Supprime un élément spécifié. Si l'élément n'existe pas, l'opération est ignorée silencieusement.
Supprimer et retourner un élément aléatoire	pop()	element_retire = fruits.pop()	Supprime et retourne un élément aléatoire. Lève une KeyError si l'ensemble est vide.
Vider l'ensemble	clear()	fruits.clear()	Supprime tous les éléments de l'ensemble.
Vérifier l'appartenance	Opérateur in	"banane" in fruits → True	Vérifie si un élément est présent dans l'ensemble, retourne un booléen.

Pour ajouter un élément à la fin d'une liste en Python :

Méthode	Exemple	Description
append()	liste.append(0)	Ajoute 0 à la fin de la liste.

Le tri des listes en Python est simple. La méthode sort() modifie la liste sur place.

ma_liste = [3, 1, 4, 1, 5, 9, 2]
ma_liste.sort()  # Tri par défaut (ascendant)
print(ma_liste)  # Affiche: [1, 1, 2, 3, 4, 5, 9]

# Tri descendant
ma_liste.sort(reverse=True)
print(ma_liste)

Pour créer une liste contenant d'autres listes (une liste imbriquée), vous pouvez utiliser des listes imbriquées.

liste_imbriquee = []
liste_imbriquee.append([1, 2, 3])
liste_imbriquee.append([4, 5, 6])
liste_imbriquee.append([7, 8, 9])

Les tables de hachage en Python sont principalement implémentées à l'aide de dictionnaires (dict).

1. Créer un dictionnaire

mon_dict = {}
# Ou en utilisant le constructeur dict()
mon_dict = dict()

2. Ajouter des paires clé-valeur

mon_dict['cle'] = 'valeur'

3. Accéder aux valeurs

valeur = mon_dict['cle']

4. Vérifier l'existence d'une clé

if 'cle' in mon_dict:
    print("La clé existe")
else:
    print("La clé n'existe pas")

5. Modifier une valeur

mon_dict['cle'] = 'nouvelle_valeur'

Il existe plusieurs façons de parcourir un dictionnaire en Python.

Méthode 1 : Parcourir les clés

mon_dict = {"a": 1, "b": 2, "c": 3}
for cle in mon_dict.keys():
    print(cle)

Pour trier les caractères d'une chaîne de caractères par ordre alphabétique, vous pouvez utiliser la fonction sorted().

chaine_originale = "python"
chaine_triee = ''.join(sorted(chaine_originale))
print(chaine_triee)

Chaîne de caractères

1. Définir une classe de nœud

Chaque nœud contient des données et un pointeur vers le nœud suivant.

class Noeud:
    def __init__(self, donnees):
        self.donnees = donnees
        self.suivant = None

La différence principale entre set et dict en Python réside dans leur structure et leur utilisation :

• dict stocke des paires clé-valeur pour un mappage et une recherche efficaces.
• set stocke des éléments uniques (similaires aux clés d'un dictionnaire) pour la déduplication et les tests d'appartenance.

Les deux sont basés sur des tables de hachage, offrant une complexité temporelle de O(1) pour les opérations courantes. dict utilise légèrement plus de mémoire car il stocke des valeurs.

En Python, le mot-clé None représente une valeur nulle ou l'absence d'une valeur. Il est équivalent à null dans d'autres langages.

Représentation

• True : représente une condition vraie, une existence ou un état affirmatif.
• False : représente une condition fausse, une non-existence ou un état négatif.

Pour exprimer des puissances de 10 en Python, utilisez l'opérateur **.

resultat = 10 ** 5  # Calcule 10 puissance 5
print(resultat) # Affiche: 100000

Pour obtenir le chiffre des unités d'un nombre, utilisez l'opérateur modulo (%).

num = 123
dernier_chiffre = num % 10
print(dernier_chiffre)  # Affiche: 3

Les fonctions globales en Python sont définies au niveau du module, en dehors de toute classe ou fonction spécifique. Elles sont accessibles directement depuis le module.

# exemple.py
def methode_globale():
    print("Ceci est une méthode globale")

def autre_fonction():
    methode_globale() # Appel de la méthode globale

Pour définir un nouvel objet en Python, vous créez une instance d'une classe.

1. Définir une classe : La classe sert de modèle pour les objets. ```

   class MaClasse: def init(self, attribut): self.attribut = attribut # Initialisation de l'attribut

    def methode(self):
        print("Ceci est une méthode")
   

2. Créer une instance de classe : Créez un nouvel objet en appelant le constructeur de la classe. ```

   mon_objet = MaClasse("Ceci est un attribut")

L'opérateur XOR (OU exclusif) en Python est ^. Il compare les bits : 1 si les bits sont différents, 0 s'ils sont identiques.

L'initialisation et la définition de la longueur d'une liste peuvent se faire ainsi :

compteur = [0] * 26

La comparaison de deux listes pour l'égalité se fait avec l'opérateur ==.

La fonction ord() en Python retourne la valeur Unicode d'un caractère unique.

Pour trouver la valeur maximale dans une liste, utilisez la fonction intégrée max().

nombres = [1, 3, 5, 7, 9]
valeur_max = max(nombres)
print(valeur_max)  # Affiche: 9

1. Tri d'un tableau 2D par la première colonne

arr = [[5, 2, 6], [1, 4, 3], [9, 8, 7]]
arr_trie = sorted(arr, key=lambda x: x[0])
print(arr_trie)

-1 dans l'indexation : En Python, -1 fait référence au dernier élément d'une liste. Par exemple, tableau_2d[-1][1] accède au deuxième élément de la dernière sous-liste.

L'initialisation d'un tableau 2D peut se faire avec des listes imbriquées.

Une liste Python peut être utilisée comme une pile (structure LIFO - Last In, First Out) :

• Empiler : append()
• Dépiler : pop()
• Consulter le sommet : Index [-1]

La longueur d'une liste est obtenue avec len().

Pour initialiser et définir des méthodes dans un objet en Python, vous utilisez les classes.

class MinStack(object):
    def __init__(self):
        self.stack = []
        self.min_stack = []

    def push(self, val):
        self.stack.append(val)
        if self.min_stack:
            self.min_stack.append(min(val, self.min_stack[-1]))
        else:
            self.min_stack.append(val)

    def pop(self):
        self.stack.pop()
        self.min_stack.pop()

    def top(self):
        return self.stack[-1]

    def getMin(self):
        return self.min_stack[-1]

Une liste vide en Python peut être évaluée comme False dans un contexte booléen (par exemple, if not ma_liste:).

Les fonctions, notamment pour la récursivité, sont définies avec le mot-clé def.

# Définition d'un nœud d'arbre binaire (exemple)
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

class Solution(object):
    def inorderTraversal(self, root):
        res = []
        def dfs(node):
            if not node:
                return
            dfs(node.left)
            res.append(node.val)
            dfs(node.right)
        dfs(root)
        return res

Recherche en profondeur (DFS)

DFS explore une branche aussi loin que possible avant de revenir en arrière (backtracking). Il utilise une pile (ou la récursion) et est efficace en mémoire. Il est utile pour trouver toutes les solutions possibles ou des chemins.

Recherche en largeur (BFS)

BFS explore le graphe niveau par niveau. Il utilise une file (queue) et est idéal pour trouver le chemin le plus court dans un graphe non pondéré. Il peut consommer plus de mémoire.

Différences clés

• Ordre de parcours : DFS "creuse", BFS "s'étend".
• Structure de données : DFS utilise une pile/récursion, BFS utilise une file.
• Cas d'usage : DFS pour l'exploration de l'espace des solutions, BFS pour les chemins les plus courts et les relations hiérarchiques.

Pour ajouter une copie d'une liste à une autre, utilisez le découpage [:] : res.append(nums[:]). Utiliser res.append(nums) sans découpage ajouterait une référence à la liste originale, et toute modification ultérieure de nums affecterait également l'élément dans res.