NSI 1ère générale

Tout le programme de NSI de 1ère générale : cours et quiz.

01

Représentation des données

5 cours

Représentation binaire des entiers et des bases

Dans cette leçon, tu vas apprendre à représenter et convertir des entiers entre la base 2 (binaire), la base 10 (décimale) et la base 16 (hexadécimale). Tu comprendras aussi combien de bits sont nécessaires pour coder un nombre et comment ces bases sont utilisées concrètement en informatique, par exemple pour les couleurs, les adresses mémoire ou les fichiers. Mots-clés : base binaire, base décimale, base hexadécimale, conversion de bases, bits, codage informatique.

Codage des entiers relatifs (complément à deux)

Dans cette leçon, tu vas apprendre comment les ordinateurs représentent les entiers relatifs grâce au codage en complément à deux. Tu verras comment coder et décoder un nombre négatif en binaire, quelles sont les valeurs représentables selon le nombre de bits, et pourquoi ce système simplifie les calculs arithmétiques en machine. Mots-clés : complément à deux, entiers relatifs, codage binaire, nombres négatifs, bits, arithmétique machine.

Nombres flottants et approximation

Dans cette leçon, tu vas comprendre comment les ordinateurs représentent les nombres réels grâce à la norme IEEE 754 en virgule flottante. Tu verras pourquoi certaines valeurs décimales ne peuvent pas être codées exactement, comment apparaissent les erreurs d’arrondi et quels cas particuliers (infini, NaN, sous-normaux) existent. Tu apprendras aussi les bonnes pratiques pour limiter ces imprécisions en programmation. Mots-clés : virgule flottante, IEEE 754, mantisse, exposant, erreurs d’arrondi, NaN.

Booléens et opérateurs logiques

Dans cette leçon, tu vas découvrir comment utiliser les valeurs booléennes True et False en Python et les combiner avec les opérateurs logiques and, or et not. Tu apprendras à construire des expressions logiques, à lire des tables de vérité et à comprendre le court-circuit logique, indispensable pour écrire des programmes efficaces et sûrs. Mots-clés : booléen, opérateurs logiques, Python, table de vérité, court-circuit, algèbre de Boole.

Codage des textes (ASCII, Unicode, etc.)

Cette leçon t’explique comment les ordinateurs transforment les lettres et symboles en suites de 0 et de 1 grâce aux systèmes d’encodage. Tu verras l’évolution de l’ASCII limité à 128 caractères, de l’ISO-8859-1 pour l’Europe de l’Ouest, jusqu’à l’Unicode et surtout UTF-8, aujourd’hui standard mondial. En Python, tu apprendras aussi à lire et écrire des fichiers texte en respectant l’encodage pour éviter les erreurs d’affichage. Mots-clés : encodage, ASCII, Unicode, UTF-8, Python, fichier texte.

02

Structures de données

4 cours

Regrouper des données avec les p-uplets

Cette leçon t’initie aux p-uplets en Python, des structures ordonnées et immuables qui regroupent plusieurs valeurs de types variés. Tu apprendras à les utiliser pour renvoyer plusieurs résultats dans une fonction, à améliorer la lisibilité grâce aux p-uplets nommés et à les appliquer pour représenter des données en table. Mots-clés : Python, p-uplet, tuple, namedtuple, structure de données, NSI.

Utiliser des tableaux et des matrices

Cette leçon t’explique comment utiliser les tableaux et matrices en Python pour organiser et traiter des données. Tu apprendras à accéder aux éléments avec des indices, à créer des tableaux avec des compréhensions, à manipuler des matrices grâce à une double indexation et à respecter les bonnes pratiques imposées par le programme. Mots-clés : Python, tableau, matrice, liste, indices, NSI.

Créer des tableaux de manière astucieuse (compréhensions)

Cette leçon t’enseigne comment utiliser les compréhensions en Python pour créer et transformer rapidement des tableaux et des dictionnaires. Tu découvriras leur syntaxe de base, leur usage avec des conditions ou des boucles imbriquées, leur application à des structures complexes comme les matrices ou les fichiers, ainsi que leur extension aux dictionnaires. Mots-clés : Python, compréhension, liste, dictionnaire, matrice, NSI.

Associer des valeurs avec des clés (dictionnaires)

Cette leçon t’explique comment utiliser les dictionnaires en Python pour associer des clés à des valeurs et organiser efficacement les données. Tu apprendras à créer, modifier et parcourir des dictionnaires, à les appliquer dans des situations concrètes et à les générer rapidement grâce aux compréhensions. Mots-clés : Python, dictionnaire, clé-valeur, compréhension de dictionnaire, structure de données, NSI.

03

Explorer des données en table

4 cours

Charger des données à partir d’un fichier

Cette leçon t’apprend à importer un fichier CSV en Python pour transformer un simple texte en table exploitable. Tu découvriras comment gérer les séparateurs, les encodages, structurer les données sous forme de listes ou dictionnaires et nettoyer les erreurs avant de les analyser. Mots-clés : Python, CSV, importation de données, encodage, table, NSI.

Chercher des informations dans une table

Cette leçon t’apprend à rechercher efficacement des informations dans une table de données en Python. Tu verras comment appliquer des critères simples ou combinés, vérifier la validité des champs, repérer les doublons et produire des regroupements utiles pour analyser les données. Mots-clés : Python, recherche de données, table, critères, doublons, regroupements.

Trier des données selon différents critères

Cette leçon t’explique comment trier une table de données en Python pour organiser les informations et les rendre plus lisibles. Tu découvriras le tri simple ou multi-critères, la gestion des valeurs manquantes, ainsi que l’import et le tri de données depuis un fichier CSV. Mots-clés : Python, tri de données, table, sorted, multi-critères, CSV.

Fusionner deux tables de données

Cette leçon t’explique comment fusionner deux tables de données en Python à partir d’un champ commun. Tu verras comment utiliser des boucles ou un dictionnaire indexé pour optimiser la fusion, gérer les cas particuliers (valeurs manquantes, doublons, incohérences) et garantir la cohérence du domaine de valeurs. Mots-clés : Python, fusion de tables, clé commune, dictionnaire indexé, domaine de valeurs, NSI.

04

Résoudre des problèmes avec des algorithmes

6 cours

Parcourir un tableau pour chercher ou calculer

Cette leçon t’apprend à parcourir un tableau pour rechercher ou calculer des informations. Tu verras comment effectuer une recherche séquentielle, calculer une moyenne, un maximum ou des occurrences, et utiliser des parcours conditionnels. Ces techniques posent les bases de l’algorithmique et permettent de raisonner sur le coût et les invariants. Mots-clés : Python, tableau, parcours séquentiel, recherche, moyenne, maximum, NSI.

Trier intelligemment une liste (tris par insertion et sélection)

Cette leçon présente deux algorithmes classiques de tri : le tri par insertion et le tri par sélection. Tu apprendras leur principe, leur invariant, leur terminaison et leur complexité. Ces méthodes simples mais fondamentales illustrent comment raisonner sur la correction et l’efficacité d’un algorithme. Mots-clés : Python, tri par insertion, tri par sélection, invariant, complexité quadratique, NSI.

Trouver vite dans un tableau trié (recherche dichotomique)

Cette leçon explique le fonctionnement de la recherche dichotomique, son implémentation, ses invariants et sa complexité. Tu y verras pourquoi elle est beaucoup plus rapide qu’une recherche linéaire, et comment Python fournit aussi le module `bisect` pour automatiser cette opération. Mots-clés : recherche dichotomique, recherche binaire, complexité logarithmique, invariant, Python, bisect.

Choisir le meilleur à chaque étape (algorithmes gloutons)

Cette leçon présente clairement le principe des algorithmes gloutons, leurs exemples typiques (rendu de monnaie, sac à dos, arbres couvrants) et leurs avantages/limites. Tu y vois qu’ils privilégient toujours le meilleur choix local, ce qui permet des solutions rapides mais pas toujours optimales. Mots-clés : algorithme glouton, optimisation, sac à dos, rendu de monnaie, graphes, approximation.

Classer par proximité (k plus proches voisins)

Cette leçon introduit clairement l’algorithme des k plus proches voisins : principe du vote majoritaire, rôle du paramètre k, importance des mesures de distance, exemples concrets (fruits), ainsi que ses avantages et limites. Elle montre comment une méthode simple peut servir à classer efficacement de nouvelles données par ressemblance. Mots-clés : k plus proches voisins, k-NN, classification, distance euclidienne, apprentissage automatique, intelligence artificielle.

Pourquoi mon algorithme fonctionne-t-il ? (invariants et terminaisons)

Cette leçon t’explique comment prouver qu’un algorithme est correct et qu’il s’arrête toujours. Tu y découvres les invariants, qui garantissent que la propriété visée reste vraie à chaque étape, et les variants, qui montrent que la boucle se termine. Des exemples concrets comme le tri par insertion ou la recherche d’un minimum illustrent cette démarche. Mots-clés : invariant, variant, preuve algorithmique, terminaison, correction d’algorithme, Première NSI.

05

Programmer efficacement

4 cours

Les bases de la programmation (conditions, boucles, fonctions)

Cette leçon t’initie aux trois briques essentielles de la programmation impérative : les conditions pour prendre des décisions, les boucles pour répéter des actions, et les fonctions pour organiser et réutiliser ton code. En les combinant, tu peux construire des programmes clairs, efficaces et capables de résoudre des problèmes variés. Mots-clés : conditions, boucles, fonctions, programmation impérative, Python, algorithmique.

Décrire ce que fait une fonction (spécifications, assertions)

Cette leçon t’explique comment spécifier correctement une fonction en distinguant ses préconditions (ce que les arguments doivent respecter) et ses postconditions (ce que la fonction garantit en sortie). Tu découvres aussi l’usage des assertions, qui servent de garde-fous pour vérifier automatiquement ces conditions et renforcer la fiabilité du code. Mots-clés : spécification de fonction, préconditions, postconditions, assertions, correction partielle, Python.

Tester son programme pour éviter les bugs

Cette leçon t’explique pourquoi et comment tester ton programme pour éviter les bugs. Tu découvres différents types de tests (classiques, limites, non-régression, automatisés) qui garantissent la robustesse et la fiabilité du code face à toutes les situations, même imprévues. Mots-clés : tests en programmation, cas limites, non-régression, tests automatisés, fiabilité du code, Python.

Explorer et utiliser des bibliothèques Python

Cette leçon t’explique ce qu’est une bibliothèque Python et pourquoi elle est essentielle pour programmer efficacement. Tu découvres comment utiliser les bibliothèques standards comme `math` ou `random`, comment lire leur documentation et comment exploiter des outils plus avancés comme `matplotlib` pour tracer des graphiques. Mots-clés : bibliothèque Python, module, import, math, random, matplotlib.

06

Comprendre comment fonctionne un ordinateur

4 cours

Comment une machine exécute un programme ? (modèle de von Neumann)

Cette leçon montre comment fonctionne un ordinateur à travers le modèle de von Neumann. Tu découvres ses composants (processeur, mémoire, entrées-sorties, bus), le cycle fetch-decode-execute qui fait tourner les programmes, un exemple concret d’addition et les forces et limites de ce modèle encore utilisé aujourd’hui. Mots-clés : von Neumann, processeur, mémoire, fetch-decode-execute, architecture.

Comment les ordinateurs communiquent-ils entre eux ? (réseaux)

Cette leçon explique comment fonctionnent les réseaux informatiques : les machines s’échangent des informations sous forme de paquets en suivant des protocoles communs. Tu découvres les éléments d’un réseau, le rôle des paquets et du protocole du bit alterné, ainsi que les protocoles majeurs TCP/IP et HTTP. Un exemple d’envoi de message montre concrètement ce processus. Mots-clés : réseau, paquets, protocoles, TCP/IP, HTTP.

À quoi sert un système d’exploitation ?

Cette leçon présente le rôle central du système d’exploitation : il gère les ressources matérielles (processeur, mémoire, périphériques), fournit une interface à l’utilisateur (graphique ou en ligne de commande) et coordonne l’exécution des programmes. Les principaux OS (Windows, macOS, Linux, Android, iOS) remplissent ces mêmes fonctions, même si leurs interfaces diffèrent. Mots-clés : système d’exploitation, ressources, multitâche, interface, Windows/Linux.

Comment interagir avec le monde réel ? (capteurs et actionneurs)

Cette leçon t’explique comment les ordinateurs interagissent avec le monde réel grâce aux capteurs et aux actionneurs. Les capteurs traduisent des phénomènes physiques (température, lumière, mouvement) en données numériques, tandis que les actionneurs convertissent des signaux en actions concrètes (moteur, LED, haut-parleur). Reliés à un programme, ils permettent aux objets connectés et aux robots de mesurer, décider et agir. Mots-clés : capteurs, actionneurs, objets connectés, robotique, Arduino, Raspberry Pi.

07

Créer des interfaces et interagir via le Web

4 cours

Construire une page Web interactive

Cette leçon montre comment une page Web interactive s’appuie sur trois couches : HTML pour la structure, CSS pour l’apparence et JavaScript pour gérer les événements et modifier le DOM. L’interactivité se prolonge par des échanges avec un serveur via des requêtes HTTP, encapsulées dans TCP/IP, en utilisant surtout les méthodes GET et POST. Les formulaires jouent un rôle central, avec validation côté client et contrôle côté serveur. Ainsi, l’interface visible et le dialogue réseau invisible travaillent ensemble pour rendre le Web dynamique et fiable. Mots-clés : HTML, CSS, DOM, JavaScript, événements, HTTP.

Gérer les actions de l’utilisateur (événements)

Dans cette leçon, tu découvres comment les événements permettent aux pages Web de réagir aux actions de l’utilisateur ou du navigateur. Tu apprends à utiliser JavaScript pour capter un clic, une saisie ou l’envoi d’un formulaire et à associer ces événements à des fonctions qui transforment la page en une véritable interface interactive. Mots-clés : événements JavaScript, DOM, gestionnaire d’événement, formulaire interactif, addEventListener, programmation Web.

Que se passe-t-il entre mon navigateur et un site ? (client/serveur)

Dans cette leçon, tu comprends comment ton navigateur (client) et un serveur dialoguent pour afficher une page Web. Tu découvres le rôle des protocoles IP, TCP et HTTP/HTTPS, qui assurent l’acheminement, la fiabilité et la sécurité des données, ainsi que le principe d’encapsulation qui organise leur voyage. Mots-clés : client serveur, protocole HTTP, protocole TCP, protocole IP, HTTPS, encapsulation.

Comprendre les formulaires et la transmission des données

Dans cette leçon, tu découvres comment un formulaire Web collecte les données saisies par l’utilisateur, puis les envoie au serveur via une requête HTTP en GET ou en POST. Tu comprends aussi le rôle du serveur, qui analyse ces informations, renvoie une réponse adaptée et utilise des codes HTTP pour indiquer l’état de la requête. Mots-clés : formulaire HTML, requête HTTP, méthode GET, méthode POST, serveur Web, code HTTP.

08

L’informatique, une histoire d’inventions

3 cours

De l’Antiquité à Internet : les grandes dates

Dans cette leçon, tu explores les grandes étapes de l’histoire de l’informatique, depuis les algorithmes antiques et les premières machines mécaniques jusqu’à l’avènement des microprocesseurs et d’Internet. Tu comprends comment chaque innovation, de Babbage à Turing puis au Web, a façonné notre monde numérique actuel. Mots-clés : histoire informatique, Babbage, Turing, von Neumann, microprocesseur, Internet.

Turing, Lovelace et les autres : les pionniers de l’informatique

Dans cette leçon, tu découvres les pionniers de l’informatique, de Babbage et Lovelace à Turing, von Neumann et Zuse, ainsi que leurs apports décisifs. Tu comprends comment leurs théories, architectures et machines ont jeté les bases de l’ordinateur moderne et ouvert la voie aux langages et systèmes actuels. Mots-clés : Ada Lovelace, Charles Babbage, Alan Turing, John von Neumann, Konrad Zuse, pionniers informatique.

Comment les machines ont-elles évolué jusqu’à nos objets connectés ?

Dans cette leçon, tu retraces l’évolution des machines informatiques, depuis la Pascaline de Pascal jusqu’aux objets connectés actuels. Tu comprends comment la miniaturisation, le microprocesseur, Internet et la mobilité ont transformé l’informatique en une présence continue dans notre quotidien. Mots-clés : histoire informatique, Pascaline, microprocesseur, Internet, smartphone, objets connectés.

Des cours et exercices de NSI de 1ère générale

Tu es en 1re et tu veux améliorer ton niveau en spé. NSI ? Ne bouge pas, tu es au bon endroit ! Découvre tout le programme de première, et bien plus encore ! Entraîne-toi grâce à nos quiz et exercices de NSI ! Tous nos contenus sont conformes au programme de première de NSI fournis et rédigés par notre partenaire et par des professeurs certifiés ou agrégés.

Ces leçons, quiz et exercices t’aideront à comprendre les cours de première de NSI et à te construire un socle de connaissances solides qui te seront très utiles pour le bac de spé. NSI l’année prochaine ! Tous ces contenus reprennent l’intégralité des choses à savoir pour réussir ton année et passer en terminale. Alors, fonce consulter ou télécharger tous les cours de NSI disponibles en PDF, et n’hésite pas à tester tes connaissances avec les quiz de première de NSI !