NSI
NSI

Fiche de révision :
La Programmation Python

Python est le langage de programmation central de la NSI Terminale. Maîtriser les types, les structures de contrôle, les fonctions et la POO est indispensable pour le bac.

Génère tes propres fiches de NSI en 10 secondes →

Essayer
NSI
Types de base Python
Définition
Python offre plusieurs types natifs : int (entier), float (flottant), str (chaîne), bool (True/False), list (liste mutable), dict (dictionnaire clé-valeur), tuple (liste immuable), set (ensemble sans doublons). Le typage est dynamique : une variable peut changer de type.
Question probable
Quels sont les principaux types de données en Python et leurs caractéristiques ?
Réponse
→Types de base : `42` (int), `3.14` (float), `"bonjour"` (str), `True` (bool). Conteneurs : `[1, 2, 3]` (list, mutable), `(1, 2, 3)` (tuple, immuable), `{"a": 1}` (dict, mutable), `{1, 2, 3}` (set, sans doublons). Différences clés : list vs tuple → tuple immuable, plus rapide et hashable. dict → accès par clé en O(1). set → test d'appartenance en O(1) et union/intersection. `type(x)` retourne le type. `isinstance(x, int)` vérifie le type.
Mnémotechnique
int/float/str/bool = simples. list = modifiable. tuple = immuable. dict = clé:valeur. set = ensemble sans doublons. "LEST : List/Ensemble(set)/String/Tuple."
1 / 5
NSI
Structures de contrôle
Définition
Python offre : if/elif/else (conditions), for (itération sur un itérable), while (boucle conditionnelle), try/except (gestion des exceptions). L'indentation est obligatoire et définit les blocs. `break` interrompt la boucle, `continue` passe à l'itération suivante.
Question probable
Comment gérer les exceptions en Python ? Donnez un exemple.
Réponse
→Les exceptions permettent de gérer les erreurs sans crasher le programme : ```python try: x = int(input("Entrez un nombre : ")) result = 10 / x except ValueError: print("Ce n'est pas un entier.") except ZeroDivisionError: print("Division par zéro impossible.") except Exception as e: print(f"Erreur inattendue : {e}") finally: print("Bloc toujours exécuté.") ``` `try` contient le code risqué. `except` capture les exceptions spécifiques. `finally` s'exécute toujours (fermeture de fichiers, etc.).
Mnémotechnique
if/elif/else → conditions. for/while → boucles. try/except → exceptions. "if for while try = IFWT." Indentation = syntaxe Python.
2 / 5
NSI
Fonctions Python
Définition
Une fonction est définie avec `def nom(paramètres): ... return valeur`. La portée des variables : variables locales (dans la fonction) et globales (hors de la fonction). Une variable locale masque une variable globale de même nom. `global x` force l'utilisation de la variable globale.
Question probable
Expliquez la notion de portée des variables en Python avec un exemple.
Réponse
→La portée détermine où une variable est accessible : ```python x = 10 # variable globale def ma_fonction(y): x = 20 # variable locale (masque le global) return x + y print(ma_fonction(5)) # 25 print(x) # 10 (global inchangé) def modifier_global(): global x x = 30 # modifie le global ``` Règle LEGB : Local → Enclosing → Global → Built-in. Les paramètres sont des variables locales. Les objets mutables (list) passés en argument peuvent être modifiés dans la fonction.
Mnémotechnique
def + return. Portée LEGB : Local → Enclosing → Global → Built-in. Local masque global. `global x` pour modifier le global. "LEGB comme Legal."
3 / 5
NSI
Paradigme objet (POO)
Définition
La programmation orientée objet en Python : `class NomClasse:` définit une classe. `__init__(self, ...)` est le constructeur. `self` désigne l'instance courante. Les méthodes sont des fonctions de la classe. L'héritage permet à une classe fille de réutiliser les attributs et méthodes de la classe mère.
Question probable
Définissez une classe Python avec héritage. Illustrez avec un exemple.
Réponse
→```python class Animal: def __init__(self, nom, age): self.nom = nom self.age = age def parler(self): return "..." def __str__(self): return f"{self.nom} ({self.age} ans)" class Chien(Animal): # hérite de Animal def parler(self): # surcharge return "Wouf !" d = Chien("Rex", 3) print(d) # Rex (3 ans) print(d.parler()) # Wouf ! print(isinstance(d, Animal)) # True ``` `super().__init__()` appelle le constructeur parent. La surcharge (override) redéfinit une méthode héritée.
Mnémotechnique
class + __init__ + self. Héritage : class Fille(Mère). Surcharge = redéfinit méthode. __str__ = représentation. "CIS : Classe-Instance-Self."
4 / 5
NSI
Modules Python utiles
Définition
Python fournit des modules standards : `math` (sqrt, pi, floor, ceil, log), `random` (random, randint, choice, shuffle), `os` (listdir, getcwd, path.exists), `json` (loads/dumps pour sérialiser/désérialiser). Import : `import math` ou `from math import sqrt`.
Question probable
Comment utiliser les modules math et random en Python ? Donnez des exemples.
Réponse
→```python import math import random import json # math print(math.sqrt(16)) # 4.0 print(math.pi) # 3.141592... print(math.log(100, 10)) # 2.0 # random print(random.randint(1, 6)) # dé à 6 faces liste = [1, 2, 3, 4, 5] random.shuffle(liste) # mélange print(random.choice(liste)) # élément aléatoire # json data = {"nom": "Alice", "age": 18} chaine = json.dumps(data) # dict → string JSON print(json.loads(chaine)) # string JSON → dict ```
Mnémotechnique
math : sqrt/pi/log. random : randint/choice/shuffle. os : fichiers/dossiers. json : serialisation. "MROJ : Math-Random-Os-Json."
5 / 5

Génère tes fiches NSI
en 10 secondes

Colle ton cours de NSI. FicheIA génère tes fiches structurées instantanément.

Générer mes fiches →

3 générations gratuites · Sans inscription

À lire aussi — NSI

Les Algorithmes

Voir la fiche →

Les Structures de Données

Voir la fiche →

Les Réseaux Informatiques

Voir la fiche →
Génère tes fiches NSI →

Gratuit · Sans inscription