Chargement de Python...
Apprends pas à pas avec des exercices pratiques. Exécute du vrai code Python !
int, float, str, bool - les fondamentaux
Créer, manipuler, parcourir des listes
Répéter des actions, parcourir
Prendre des décisions dans le code
Paramètres, return, bonnes pratiques
Implémenter un algorithme de tri
Filtrer des tableaux (projet domotique)
Point, Segment, Polygone
Teste tes connaissances avec ces exercices du contrôle
Écris une fonction somme_liste(tableau) qui retourne la somme de tous les éléments d'une liste de nombres.
Rappel : Pas de fonction sum() ! Utilise une boucle.
somme_liste([1, 2, 3, 4, 5]) → 15 somme_liste([10, 20, 30]) → 60
1. Crée une variable total = 0 au début
2. Parcours chaque élément avec for element in tableau:
3. Ajoute chaque élément à total
4. Retourne total à la fin (en dehors de la boucle !)
def somme_liste(tableau):
total = 0
for element in tableau:
total = total + element
return total
Écris une fonction filtrer_superieur(tableau, seuil) qui retourne un nouveau tableau contenant uniquement les éléments supérieurs au seuil.
filtrer_superieur([1, 5, 3, 8, 2, 9], 4) → [5, 8, 9] filtrer_superieur([10, 20, 30], 25) → [30]
1. Crée un nouveau tableau vide : resultat = []
2. Parcours chaque élément du tableau
3. Si l'élément est strictement supérieur au seuil → resultat.append(element)
4. Retourne le tableau résultat
def filtrer_superieur(tableau, seuil):
resultat = []
for element in tableau:
if element > seuil:
resultat.append(element)
return resultat
Implémente la fonction tri_selection(tableau) qui trie le tableau en place par ordre croissant.
⚠️ INTERDIT d'utiliser sort() !
tri_selection([64, 25, 12, 22, 11]) → [11, 12, 22, 25, 64]
Principe du tri par sélection :
1. Pour chaque position i de 0 à n-1 :
2. Trouve le minimum dans la partie non triée (de i à la fin)
3. Échange l'élément à la position i avec le minimum trouvé
Échange : tableau[i], tableau[j] = tableau[j], tableau[i]
def tri_selection(tableau):
n = len(tableau)
for i in range(n):
# Trouver le minimum
indice_min = i
for j in range(i + 1, n):
if tableau[j] < tableau[indice_min]:
indice_min = j
# Échanger
tableau[i], tableau[indice_min] = tableau[indice_min], tableau[i]
return tableau
Crée une classe Point avec :
• Attributs privés _x et _y
• Getters get_x() et get_y()
• Setters set_x(val) et set_y(val)
p = Point(3, 4) p.get_x() → 3 p.get_y() → 4
Structure d'une classe :
1. def __init__(self, x, y): → le constructeur reçoit x et y
2. self._x = x → stocke x dans un attribut privé
3. def get_x(self): → retourne self._x
4. def set_x(self, val): → modifie self._x = val
class Point:
def __init__(self, x, y):
self._x = x
self._y = y
def get_x(self):
return self._x
def get_y(self):
return self._y
def set_x(self, val):
self._x = val
def set_y(self, val):
self._y = val
Crée une classe Segment avec :
• Constructeur qui prend 2 objets Point
• Méthode longueur() qui retourne la distance
Formule : √((x2-x1)² + (y2-y1)²) → utilise import math et math.sqrt()
s = Segment(Point(0, 0), Point(3, 4)) s.longueur() → 5.0
1. __init__(self, p1, p2) → stocke les 2 points
2. Dans longueur() :
• Récupère les coordonnées avec self._p1.get_x() etc.
• Calcule dx = x2 - x1 et dy = y2 - y1
• Retourne math.sqrt(dx**2 + dy**2)
class Segment:
def __init__(self, p1, p2):
self._p1 = p1
self._p2 = p2
def longueur(self):
dx = self._p2.get_x() - self._p1.get_x()
dy = self._p2.get_y() - self._p1.get_y()
return math.sqrt(dx**2 + dy**2)
Tout ce qu'il faut retenir pour le contrôle
for i in range(n-1):
i_min = i
for j in range(i+1, n):
if tab[j] < tab[i_min]:
i_min = j
tab[i], tab[i_min] = tab[i_min], tab[i]
def filtrer(tableau, critere):
resultat = []
for ligne in tableau:
if ligne[X] == critere:
resultat.append(ligne)
return resultat
Tu as réussi l'exercice !