Florian/1ereNSI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

typo de part et d'autres

Browse Source
This commit is contained in:
Florian Mathieu
2026-01-15 00:29:08 +01:00
parent 50270bd2d6
commit e5dd54c9d2
10 changed files with 459 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
programmation/GENERALITES.md
View File

@@ -51,7 +51,7 @@ flowchart LR
> Un __langage de programmation__ est un langage proche du langage naturel, utilisable par un humain, et exécutable, après traduction par une machine.
___Sans langage de programmation, un humain devrait connaitre et commander la machine en maitrisant son langage, donc écrire des 0 et des 1.___
___Sans langage de programmation, un humain devrait connaître et commander la machine en maîtrisant son langage, donc écrire des 0 et des 1.___
```mermaid
flowchart LR

411
programmation/chapitre_1/TD.ipynb
View File

File diff suppressed because one or more lines are too long

33
programmation/chapitre_2/TD.ipynb
View File

@@ -146,36 +146,7 @@
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 5. Cas : Si...Alors...Sinon Si\n",
"\n",
"Dans cette structure on teste plusieurs conditions\n",
"\n",
"```\n",
" if condition1:\n",
" instruction1\n",
" elif condition2:\n",
" instruction2\n",
" instruction3\n",
" elif condition3:\n",
" instruction4\n",
" else:\n",
" instruction5\n",
"```\n",
"\n",
"Exemple :\n",
"\n",
"Imaginons les conditions de passage d'un piéton en fonction du feu de signalisation et du nombre de voitures passantes :\n",
"\n",
"```python\n",
"if feu == 'VERT':\n",
"\tprint('Piéton, vous pouvez passer')\n",
"elif voitures = 0 : # le feu est rouge\n",
" print('Piéton, vous pouvez passer mais attention')\n",
"else: # le feu est rouge et il y a des voitures\n",
"\tprint('Piéton, vous ne pouvez passer')\n",
"```"
]
"source": "## 5. Cas : Si...Alors...Sinon Si\n\nDans cette structure on teste plusieurs conditions\n\n```\n if condition1:\n instruction1\n elif condition2:\n instruction2\n instruction3\n elif condition3:\n instruction4\n else:\n instruction5\n```\n\nExemple :\n\nImaginons les conditions de passage d'un piéton en fonction du feu de signalisation et du nombre de voitures passantes :\n\n```python\nif feu == 'VERT':\n\tprint('Piéton, vous pouvez passer')\nelif voitures == 0 : # le feu est rouge\n print('Piéton, vous pouvez passer mais attention')\nelse: # le feu est rouge et il y a des voitures\n\tprint('Piéton, vous ne pouvez passer')\n```"
},
{
"cell_type": "markdown",
@@ -516,4 +487,4 @@
},
"nbformat": 4,
"nbformat_minor": 2
}
}

102
programmation/chapitre_4/TD.ipynb
View File

@@ -108,53 +108,7 @@
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2. Déclaration d'une fonction\n",
"\n",
"Dans un langage de programmation, on utilise ce qu'on appelle des __fonctions__. Une __fonction__ est un ensemble d'instructions qui peut recevoir des __arguments__ et qui peut renvoyer un __résultat__ qui est souvent le contenu d'une ou plusieurs variables.\n",
"\n",
"En Python, on définit une fonction en utilisant l'instruction `def` (de l'anglais define, qui veut dire \"définir\") :\n",
"\n",
"```python\n",
"def nom_de_la_fonction(parametre1, parametre2, ..., parametreN):\n",
" corps_de_la_fonction\n",
"```\n",
"\n",
"- l'instruction `def` est suivie du nom de la fonction ;\n",
"- les __paramètres__ de la fonction sont ensuite écrits entre parenthèses et séparés par des virgules ;\n",
"- il existe des fonctions sans paramètre, les parenthèses sont néanmoins obligatoires et restent vides ;\n",
"- il ne faut pas oublier les __deux points__ après les parenthèses de la première ligne ;\n",
"- le corps de la fonction est un bloc d'instructions qui contient toutes les lignes qui doivent être exécutées lorsque la fonction est appelée. Le corps de la fonction doit nécessairement être __indenté__, c'est-à-dire qu'il doit être décalé d'une tabulation par rapport à l'instruction `def`.\n",
"\n",
"Très souvent, le corps de la fonction se terminera par l'instruction `return` suivie de la ou des valeurs que la fonction doit renvoyer. Si la fonction doit renvoyer plusieurs valeurs, celles-ci sont à séparer par des virgules.\n",
"\n",
"Ainsi, le schéma général d'une fonction Python est :\n",
"\n",
"```python\n",
"def nom_de_la_fonction(parametre1, parametre2, ..., parametreN):\n",
" instructions # sur plusieurs lignes éventuellement\n",
" return valeur1, valeur2, valeur3, etc. # souvent une fonction ne renvoie qu'une valeur\n",
"````\n",
"\n",
"Exemple : Voici la fonction inverse implantée en Python\n",
"\n",
"```python\n",
"def inverse(x):\n",
" y = 1 / x\n",
" return y\n",
"```\n",
"\n",
"que l'on peut aussi écrire plus simplement :\n",
"\n",
"```python\n",
"def inverse(x):\n",
" return 1 / y\n",
"```\n",
"\n",
"Identifiez dans ces deux fonctions écrites différemment : leur nom, leur(s) paramètre(s), leur corps, leur(s) valeur(s) renvoyée(s).\n",
"\n",
"Remarque : il existe des fonctions qui ne renvoient aucune valeur, l'instruction return n'est donc pas utilisée dans le corps de ces fonctions."
]
"source": "## 2. Déclaration d'une fonction\n\nDans un langage de programmation, on utilise ce qu'on appelle des __fonctions__. Une __fonction__ est un ensemble d'instructions qui peut recevoir des __arguments__ et qui peut renvoyer un __résultat__ qui est souvent le contenu d'une ou plusieurs variables.\n\nEn Python, on définit une fonction en utilisant l'instruction `def` (de l'anglais define, qui veut dire \"définir\") :\n\n```python\ndef nom_de_la_fonction(parametre1, parametre2, ..., parametreN):\n corps_de_la_fonction\n```\n\n- l'instruction `def` est suivie du nom de la fonction ;\n- les __paramètres__ de la fonction sont ensuite écrits entre parenthèses et séparés par des virgules ;\n- il existe des fonctions sans paramètre, les parenthèses sont néanmoins obligatoires et restent vides ;\n- il ne faut pas oublier les __deux points__ après les parenthèses de la première ligne ;\n- le corps de la fonction est un bloc d'instructions qui contient toutes les lignes qui doivent être exécutées lorsque la fonction est appelée. Le corps de la fonction doit nécessairement être __indenté__, c'est-à-dire qu'il doit être décalé d'une tabulation par rapport à l'instruction `def`.\n\nTrès souvent, le corps de la fonction se terminera par l'instruction `return` suivie de la ou des valeurs que la fonction doit renvoyer. Si la fonction doit renvoyer plusieurs valeurs, celles-ci sont à séparer par des virgules.\n\nAinsi, le schéma général d'une fonction Python est :\n\n```python\ndef nom_de_la_fonction(parametre1, parametre2, ..., parametreN):\n instructions # sur plusieurs lignes éventuellement\n return valeur1, valeur2, valeur3, etc. # souvent une fonction ne renvoie qu'une valeur\n````\n\nExemple : Voici la fonction inverse implantée en Python\n\n```python\ndef inverse(x):\n y = 1 / x\n return y\n```\n\nque l'on peut aussi écrire plus simplement :\n\n```python\ndef inverse(x):\n return 1 / x\n```\n\nIdentifiez dans ces deux fonctions écrites différemment : leur nom, leur(s) paramètre(s), leur corps, leur(s) valeur(s) renvoyée(s).\n\nRemarque : il existe des fonctions qui ne renvoient aucune valeur, l'instruction return n'est donc pas utilisée dans le corps de ces fonctions."
},
{
"cell_type": "markdown",
@@ -361,9 +315,7 @@
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 6. Valeur de paramètre par défaut"
]
"source": "## 6. Valeur de paramètre par défaut\n\nIl est possible de définir des valeurs par défaut pour les paramètres d'une fonction. Cela permet d'appeler la fonction sans fournir tous les arguments.\n\n```python\ndef saluer(prenom, message=\"Bonjour\"):\n return message + \" \" + prenom + \" !\"\n```\n\nExemples d'appels :\n\n```python\n>>> saluer(\"Alice\")\n'Bonjour Alice !'\n>>> saluer(\"Bob\", \"Salut\")\n'Salut Bob !'\n```\n\n**Remarques** :\n- Les paramètres avec valeur par défaut doivent être placés **après** les paramètres sans valeur par défaut\n- Cela permet de rendre certains paramètres optionnels"
},
{
"cell_type": "markdown",
@@ -496,65 +448,27 @@
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exercices\n",
"\n",
"- calcule le min de 2 valeurs passées en paramètre\n",
"- calcule le nombre de voyelles d'une chaine\n",
"- calcule le pgcd de 2 entiers\n",
"- remplace les voyelles par des nombres\n",
"\n",
"- Convertir de Farenheit à Celsius et inversement\n",
"- calculer le discriminant\n",
"- vérification du format d'une plaque d'immatriculation\n",
"- tortue qui trace des formes géomatriques\n",
"\n",
"- différence print / return"
]
"source": "## Exercices\n\n### Exercice 1\n\nÉcrire une fonction `minimum` qui calcule le minimum de 2 valeurs passées en paramètre.\n\n### Exercice 2\n\nÉcrire une fonction `compter_voyelles` qui calcule le nombre de voyelles d'une chaîne de caractères.\n\n### Exercice 3\n\nÉcrire une fonction `pgcd` qui calcule le PGCD de 2 entiers (algorithme d'Euclide).\n\n### Exercice 4\n\nÉcrire une fonction `remplacer_voyelles` qui remplace les voyelles par des nombres (a→4, e→3, i→1, o→0, u→µ)."
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exercice X\n",
"\n",
"L'énergie cinétique d'un objet de masse $m$ se déplaçant à la vitesse $v$ est:\n",
"\n",
"$$Ec = \\frac{1}{2} m v^{2}$$\n",
"\n",
"Créer une fonction `energie_cinetique` qui calcule sa valeur à partir des paramètres `masse` et `vitesse`."
]
"source": "### Exercice 5\n\nL'énergie cinétique d'un objet de masse $m$ se déplaçant à la vitesse $v$ est:\n\n$$Ec = \\frac{1}{2} m v^{2}$$\n\nCréer une fonction `energie_cinetique` qui calcule sa valeur à partir des paramètres `masse` et `vitesse`."
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exercice X\n",
"\n",
"Construire une fonction, utilisant le module `random`, qui tire au sort un nombre entier entre deux bornes données en arguments."
]
"source": "### Exercice 6\n\nConstruire une fonction `tirage_aleatoire`, utilisant le module `random`, qui tire au sort un nombre entier entre deux bornes données en arguments."
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exercice X\n",
"\n",
"Écrire une fonction pour calculer la `factorielle` d'un nombre (un entier non négatif). La fonction accepte le nombre en tant qu'argument. \n",
"\n",
"Exemple: factorielle de 5: 5! = 5x4x3x2x1 = 120"
]
"source": "### Exercice 7\n\nÉcrire une fonction `factorielle` pour calculer la factorielle d'un nombre (un entier non négatif). La fonction accepte le nombre en tant qu'argument. \n\nExemple: factorielle de 5: 5! = 5x4x3x2x1 = 120"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exercice X\n",
"\n",
"Écrire une fonction Python qui prend un nombre en paramètre et vérifiez si le nombre est premier ou non. \n",
"\n",
"Remarque: Un nombre premier est un nombre naturel supérieur à 1 et qui n'a pas de diviseur positif autre que 1 et lui-même."
]
"source": "### Exercice 8\n\nÉcrire une fonction `est_premier` qui prend un nombre en paramètre et vérifie si le nombre est premier ou non. \n\nRemarque: Un nombre premier est un nombre naturel supérieur à 1 et qui n'a pas de diviseur positif autre que 1 et lui-même."
},
{
"cell_type": "code",
@@ -585,4 +499,4 @@
},
"nbformat": 4,
"nbformat_minor": 2
}
}