+
+
### Progression
| Séquence | Contenu | Projets associés |
@@ -31,10 +34,4 @@
| 5 - b | Réseau : tcp / ip, dns... | Projet Filius |
| 6 | Projets finaux | Au choix |
-
-
-## Sitographie
-
-- [Gitlab de David Landry](https://gitlab.com/david_landry/nsi)
-- [Framagit de Christophe Mieszczak](https://framagit.org/tofmzk/informatique_git/-/tree/master/premiere_nsi)
-- [Site de David Roche](https://pixees.fr/informatiquelycee/n_site/nsi_prem.html)
+Le [programme officiel](programme_première.pdf)
diff --git a/programmation/GENERALITES.md b/programmation/GENERALITES.md
index 5c3f5a1..0290cb8 100644
--- a/programmation/GENERALITES.md
+++ b/programmation/GENERALITES.md
@@ -46,7 +46,7 @@ flowchart LR
```
- Le langage est propre à une communauté. Un __langage naturel__, ou langage ordinaire, est une langue « normale » parlée par un être humain (Exemple : le Français, l'anglais...)
-- Le __langage machine__ : directement interprétables par le processeur d'un ordinateur, mais peu lisibles aux yeux d'un humain,
+- Le __langage machine__ : directement interprétable par le processeur d'un ordinateur, mais peu lisible aux yeux d'un humain,
- Le __langage de programmation__ : Compréhensible par un humain et aisément traduisible en langage machine.
> Un __langage de programmation__ est un langage proche du langage naturel, utilisable par un humain, et exécutable, après traduction par une machine.
diff --git a/programmation/chapitre_1/TD.ipynb b/programmation/chapitre_1/TD.ipynb
index 3719eb9..2b14c13 100644
--- a/programmation/chapitre_1/TD.ipynb
+++ b/programmation/chapitre_1/TD.ipynb
@@ -1,842 +1 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# TD - Premier pas en Python\n",
- "\n",
- "## 1. La console\n",
- "\n",
- "La __console__ est un endroit où l'on peut écrire du code en Python.\n",
- "\n",
- "Le code sera exécuté immédiatement dès validation de la ligne, c'est-à-dire dès que vous appuyer sur le bouton Run.\n",
- "\n",
- "### 1.1. À Faire\n",
- "\n",
- "1. Éxécuter le code suivant (_sans les >>>_) :\n",
- "\n",
- "```python\n",
- ">>> 5 + 2\n",
- "```"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "2. Quel est le résultat obtenu ?"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### Bilan 1.1\n",
- "\n",
- "- A travers ce premier exemple, on constate que Python sait faire des calculs !!\n",
- "- Lorsque l'on appuie sur le bouton Run, python lit le code 5 + 2, calcule l'opération associée et restitue le résultat."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 1.2. À Faire\n",
- "\n",
- "1. Écrire et exécuter successivement les instructions suivantes (_sans les >>> et ???_) `\n",
- "\n",
- "```python\n",
- ">>> 5 - 2\n",
- "???\n",
- ">>> 5 * 2\n",
- "???\n",
- ">>> 5 / 2\n",
- "???\n",
- ">>> 5 // 2\n",
- "???\n",
- ">>> 5 % 2\n",
- "???\n",
- ">>> 5 ** 2\n",
- "???\n",
- "```"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "2. Quels sont les résultats obtenus ? Compléter le tableau suivant en décrivant ce que fait l'opérateur de l'instruction."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "| Opérateur | Description |\n",
- "| :--: | :-- |\n",
- "| - | | \n",
- "| * | |\n",
- "| / | |\n",
- "| // | |\n",
- "| % | |\n",
- "| * | |"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### Bilan 1.2\n",
- "\n",
- "- Python permet l'utilisation des opérateurs arithmétiques usuelles $+, -, *, /$ sur les entiers,\n",
- "- Python permet l'utilisation d'opérateurs arithmétiques avec une syntaxe spécifique comme $//, \\%, **$ "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 1.3. À Faire\n",
- "\n",
- "Exécuter le code suivant. Que constatez-vous ?\n",
- "\n",
- "```python\n",
- ">>> # 3 + 2\n",
- "???\n",
- "```"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 1.4. À Faire\n",
- "\n",
- "1. En prenant votre âge à votre prochaine date d'anniversaire (en nombre d'années), écrire une instruction qui calcule le nombre de jours équivalents (on considère qu'une année correspond à 365 jours)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "2. Sachant qu'à mon prochain anniversaire j'aurai 9490 jours, écrire une instruction qui calcule mon âge, en nombre d'années :"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "3. Sachant que mon logement se situe au 256 de la rue (dont je tairais le nom pour ne pas être localisé ;-)) et que toutes les maisons font 12 mètres et demi de longueur, à quelle distance se situe ma maison par rapport au début de la rue ?"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### Bilan 1.4\n",
- "\n",
- "- Outre des entiers, Python permet d'utiliser des nombres décimaux en utilisant le symbole \".\" pour séparer la partie entière et la partie décimale."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 2. Les variables\n",
- "\n",
- "En informatique, il est indispensable de conserver des informations de natures diverses. Par exemple, votre smartphone enregistre dans sa mémoire votre numéro de téléphone, les numéros de téléphones de vos contacts, vos messages (SMS), vos photos, vos applications, etc. Chacune de ces informations est stockée à un endroit précis dans la mémoire dans ce qu’on appelle une variable.\n",
- "\n",
- "### 2.1. Définition\n",
- "\n",
- "> Une __variable__ est un __espace de stockage__ de la mémoire (une case mémoire). Chaque variable est caractérisée par son __nom__, son __type__ et sa __valeur__.\n",
- "\n",
- "## 3. Valeur des variables\n",
- "\n",
- "### 3.1. Affecter une valeur à une variable\n",
- "\n",
- "#### 3.1.1. À Faire\n",
- "\n",
- "Copier et exécuter les instructions suivantes\n",
- "\n",
- "```python\n",
- ">>> a = 5\n",
- ">>> b = 2\n",
- ">>> a + b\n",
- "???\n",
- "```"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### Bilan 3.1.1\n",
- "\n",
- "1. La syntaxe pour déclarer et affecter une valeur a une variable est `nom_de_la_variable = valeur`\n",
- "2. Pour les instructions 1 et 2, Le signe `=` indique que la valeur 5 est affectée à la variable `a` et 2 à la variable `b`.\n",
- "3. Lorsque Python interprète l'instruction 3, il lit les valeurs associées aux variables et effectue l'opération."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 4. Nom des variables\n",
- "\n",
- "Chaque variable possède un nom qui permet d’identifier l’emplacement mémoire correspondant.\n",
- "\n",
- "Dans le langage Python, il y a des règles à respecter pour nommmer les variables. Voici celles qui vous concernent :\n",
- "\n",
- "- __Règle 1__ : un nom ne peut contenir que des lettres __en minuscule__ (a-z), des chiffres (0 - 9) et le caractère _ (underscore).\n",
- "- __Règle 2__ : un nom ne peut pas commencer par un chiffre.\n",
- "- __Règle 3__ : les noms sont sensibles à la casse, cela signifie qu’il y a une distinction entre les minuscules et les majuscules : la variable nommée `nsi` est différente de la variable `Nsi`.\n",
- "- __Règle 4__ : il est préférable de toujours choisir un nom de variable représentatif : par exemple, si vous voulez stocker le nom d’une personne dans une variable, il est préférable de l’appeler nom plutôt que x.\n",
- "- __Règle 5__ : il est préférable de ne pas utiliser de caractères accentués dans le nom d’une variable (nous n’entrerons pas dans le pourquoi du comment)."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 4.1. À Faire\n",
- "\n",
- "1. Quels sont les noms de variables incorrects parmi ceux proposés ? Vous indiquerez pourquoi.\n",
- "\n",
- "| Noms de variable | Correct ou Incorrect | Pourquoi (si Incorrect) |\n",
- "| :--:| :--: | :-- | \n",
- "| `prix achat` | | |\n",
- "| `prix_achat` | | |\n",
- "| `note` | | | \n",
- "| `2ndeG` | | |\n",
- "| `SecondeG` | | | \n",
- "| `Seconde:G`| | |\n",
- "| `dix-huit` | | |"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "2. Proposez un nom de variable permettant de stocker :\n",
- "\n",
- "| Variable | Nom de variable |\n",
- "| :-- | :--: |\n",
- "| le nombre de personnes aux yeux bleus de Premiere G | |\n",
- "| le tarif d’un repas au self | |\n",
- "| l’aire d’un triangle (il n’y a qu’une seule figure) | |\n",
- "| la note à un devoir d’anglais | |"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 5. Type des variables\n",
- "\n",
- "Dans les travaux à faire précédent, nous avons manipulé essentiellement des entiers.\n",
- "\n",
- "Python gère différents types de variables. \n",
- "\n",
- "L'objet de cette section est d'expliciter la notion de type et les opérations associées :\n",
- "\n",
- "- le type __entier__ : il désigne les entiers relatifs (positifs ou négatifs). En Python on parle du type `int` (pour integer qui signifie « entier » en anglais) ;\n",
- "- le type __flottant__ : il désigne les nombres décimaux (à virgule). En Python on parle du type `float` (pour floating qui signifie « flottant » en anglais)\n",
- "- le type __chaîne de caractères__ : il désigne toute suite ordonnée de caractères. En Python on parle du type `str` (pour string qui signifie « chaîne » en anglais).\n",
- "\n",
- "### 5.1. À Faire\n",
- "\n",
- "Indiquez le type des variables permettant de stocker (sur votre smartphone) les informations suivantes :\n",
- "\n",
- "| Variable | Type identifié |\n",
- "| :--: | :-- |\n",
- "| le nom d’un contact | |\n",
- "| le numéro de téléphone d’un contact | |\n",
- "| un SMS | |\n",
- "| l’heure du réveil | |\n",
- "| le code de votre partage de connexion Wi-Fi | |\n",
- "| le pourcentage affiché de batterie restante | |\n",
- "| les notes aux deux derniers devoirs de Mathématiques de l'année dernière | |"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 5.2. Type entier (int)\n",
- "\n",
- "Pour affecter (on dit aussi assigner) la valeur 17 à la variable nommée `age`\n",
- "\n",
- "```python\n",
- ">>> age = 17\n",
- "```\n",
- "\n",
- "La fonction `print` affiche la valeur de la variable :\n",
- "\n",
- "```python\n",
- ">>> print(age)\n",
- "17\n",
- "```\n",
- "\n",
- "La fonction `type` renvoie le type de la variable :\n",
- "\n",
- "```python\n",
- ">>> type (age)\n",
- "
