Dois-je vraiment apprendre toutes ces fonctions par cœur ?

Non, l'objectif n'est pas le par cœur, mais la familiarité. Tu dois savoir qu'elles existent et à quel problème elles répondent. Avec la pratique dans tes TP et projets, leur utilisation deviendra naturelle. Concentre-toi d'abord sur print(), input(), len(), les méthodes de listes et les conversions.

Quelle est la différence entre .sort() et sorted() ? C'est un piège classique ?

Absolument, c'est un classique ! ma_liste.sort() modifie ("trie sur place") la liste originale. La fonction sorted(ma_liste), elle, ne modifie pas ma_liste mais renvoie une nouvelle liste qui est la version triée de l'originale. Si tu as besoin de garder l'ordre original, utilise toujours sorted().

Pourquoi utiliser .get() sur un dictionnaire au lieu de faire mon_dict[clé] ?

Parce que mon_dict[clé] provoque une erreur KeyError si la clé n'existe pas, ce qui plante ton programme. mon_dict.get(clé, valeur_par_defaut) est plus robuste : il renvoie la valeur si la clé existe, sinon il renvoie tranquillement la valeur_par_defaut que tu as choisie (souvent 0 ou None). C'est essentiel pour les compteurs et les recherches.

Les fonctions map() et filter() sont-elles au programme de NSI ?

Le programme mentionne la "programmation fonctionnelle" et les concepts de fonction d'ordre supérieur (fonctions qui prennent des fonctions en argument). map() et filter() en sont des exemples parfaits. Même si tu ne les utilises pas systématiquement, les comprendre montre une bonne maîtrise des concepts et permet d'écrire un code plus concis et expressif, ce qui est toujours valorisé.

Les 20 fonctions Python indispensables en NSI

Pourquoi maîtriser ces fonctions est crucial en NSI ?

En Numérique et Sciences Informatiques (NSI), Python n'est pas juste un langage, c'est ton outil principal pour modéliser, résoudre des problèmes et comprendre les concepts fondamentaux de l'informatique. Contrairement à un cours classique, on ne te demande pas de tout apprendre par cœur, mais de savoir quand et comment utiliser les bons outils. Ces 20 fonctions sont les briques de base sur lesquelles tu vas construire tous tes projets et algorithmes. Les connaître te fera gagner un temps précieux pendant les TP, les évaluations et surtout lors de l'épreuve pratique du bac.

Les fonctions de base pour manipuler les données

Avant de plonger dans des algorithmes complexes, il faut être solide sur les fondamentaux. Ces fonctions sont utilisées dans 90% de tes programmes.

1. print() et input() : la communication avec l'utilisateur

La base de la base ! print() affiche un message à l'écran, tandis que input() permet de récupérer une saisie. N'oublie pas que input() renvoie toujours une chaîne de caractères (str). Pour obtenir un nombre, il faut convertir : age = int(input("Quel est ton âge ? ")).

2. len() : connaître la taille d'une structure

Cette fonction est universelle. Elle renvoie le nombre d'éléments dans une séquence : une chaîne, une liste, un tuple, un dictionnaire. Indispensable pour parcourir des structures de données avec des boucles for i in range(len(ma_liste)):.

3. type() : identifier le type d'une variable

En NSI, tu manipules différents types (int, float, str, list, dict, bool). type(ma_variable) te permet de déboguer ton code en vérifiant qu'une variable est bien du type attendu, surtout après une conversion ou une opération complexe.

4. int(), float(), str(), list() : les convertisseurs

Ces fonctions de casting (conversion de type) sont capitales. Tu les utiliseras constamment pour transformer une donnée d'un type à un autre. Par exemple, pour concaténer un nombre et du texte, il faut d'abord le convertir en chaîne : message = "Valeur : " + str(valeur).

5. range() : générer des séquences pour les boucles

Le moteur des boucles for. range(5) génère les nombres de 0 à 4. range(2, 10) de 2 à 9. range(0, 10, 2) de 0 à 8 avec un pas de 2. Essentiel pour itérer un nombre précis de fois ou pour parcourir une liste par indice.

Les fonctions clés pour les structures de données (listes, dictionnaires)

Les listes et les dictionnaires sont les structures les plus utilisées en NSI. Savoir les manipuler efficacement est une compétence clé.

6. .append() et .pop() : ajouter et retirer dans une liste

ma_liste.append(element) ajoute un élément à la fin. ma_liste.pop() retire et renvoie le dernier élément. ma_liste.pop(i) retire l'élément à l'indice i. Ces méthodes modifient la liste sur place.

7. .sort() et sorted() : trier les données

Attention à la différence ! ma_liste.sort() trie la liste elle-même (modification sur place). sorted(ma_liste) renvoie une nouvelle liste triée, sans modifier l'originale. Tu peux trier en ordre inverse avec reverse=True.

8. .keys(), .values(), .items() : explorer les dictionnaires

Pour parcourir un dictionnaire efficacement :

.keys() : donne les clés.
.values() : donne les valeurs.
.items() : donne les couples (clé, valeur). C'est la méthode la plus utilisée dans une boucle : for cle, valeur in mon_dict.items():.

9. .get() : récupérer une valeur dans un dictionnaire sans risque

Beaucoup plus sûr que mon_dict[cle] ! mon_dict.get(cle, valeur_par_defaut) renvoie la valeur si la clé existe, sinon il renvoie la valeur_par_defaut (sans provoquer d'erreur KeyError). Parfait pour les compteurs et les accumulations.

10. enumerate() : obtenir l'indice et la valeur dans une boucle

Plutôt que d'écrire for i in range(len(liste)):, utilise for i, valeur in enumerate(liste):. C'est plus propre, plus "pythonique", et tu as directement l'indice et l'élément. Tu peux même préciser l'indice de départ : enumerate(liste, start=1).

Les fonctions pour les chaînes de caractères et les fichiers

11. .split() et .join() : découper et assembler du texte

"bonjour tout le monde".split() donne la liste ['bonjour', 'tout', 'le', 'monde']. "-".join(['2026', '03', '30']) donne la chaîne "2026-03-30". Incontournable pour traiter des données textuelles (fichiers CSV, logs).

12. .strip(), .lower(), .upper() : nettoyer et uniformiser

.strip() enlève les espaces en début et fin de chaîne (très utile après un input()). .lower() et .upper() convertissent en minuscules/majuscules, essentiel pour faire des comparaisons de texte insensibles à la casse.

13. open(), .read(), .write() : gérer les fichiers

La base de la persistance des données. with open('fichier.txt', 'r') as f: contenu = f.read() pour lire. with open('fichier.txt', 'w') as f: f.write(texte) pour écrire (en écrasant). Le mot-clé with garantit la fermeture automatique du fichier, même en cas d'erreur.

Les fonctions avancées pour les algorithmes

14. max() et min() : trouver les extrêmes

Elles fonctionnent sur des listes de nombres, mais aussi sur des chaînes (ordre lexicographique) et peuvent prendre un itérable en argument. Très utiles pour des algorithmes de recherche de maximum/minimum sans avoir à tout réécrire.

15. sum() : faire des sommes rapidement

sum([1, 2, 3]) renvoie 6. Beaucoup plus efficace et lisible qu'une boucle. Tu peux même lui donner un point de départ : sum(iterable, start=10).

16. map() : appliquer une fonction à tous les éléments

Un concept important de programmation fonctionnelle. list(map(int, ['1', '2', '3'])) convertit chaque chaîne en entier, donnant [1, 2, 3]. C'est souvent combiné avec split() pour lire des données numériques.

17. filter() : filtrer une séquence

Permet de ne garder que les éléments qui satisfont une condition. list(filter(lambda x: x % 2 == 0, [1, 2, 3, 4])) renvoie [2, 4]. Très puissant pour le traitement de listes.

18. isinstance() : vérifier le type d'un objet (mieux que type())

Pour vérifier qu'une variable est d'un certain type, préfère isinstance(ma_variable, list) à type(ma_variable) == list. Cela fonctionne aussi avec l'héritage de classes (un concept que tu verras peut-être en Terminale).

19. round() : arrondir un nombre

round(3.14159, 2) donne 3.14. Le deuxième argument est le nombre de décimales. Attention aux subtilités d'arrondi des nombres flottants !

20. abs() : la valeur absolue

Simple mais essentielle dans de nombreux algorithmes (calcul de distance, d'écart, gestion d'erreur). abs(-5) renvoie 5.

Comment s'entraîner et aller plus loin ?

Connaître ces fonctions n'est que la première étape. La vraie maîtrise vient de la pratique. Voici une méthode efficace :

Crée un fichier "bac_a_sable.py" et teste chaque fonction avec des exemples variés.
Revisite tes anciens TP : identifie où tu aurais pu utiliser enumerate(), .get() ou sum() pour rendre ton code plus simple et plus élégant.
Affronte les sujets d'épreuve pratique en te chronométrant. Le jour du bac, cette familiarité te fera gagner des minutes cruciales.

N'oublie pas : l'aide intégrée de Python (help(len) ou ?len dans certains environnements) et la documentation officielle sont tes meilleurs alliés. Bon code !