suppression dossier programmation
This commit is contained in:
@@ -1,97 +0,0 @@
|
||||
# Prise en main de Python
|
||||
|
||||
## Introduction
|
||||
|
||||
Python est un langage de programmation interprété : on tape le code des programme dans un éditeur de code qui, lorsqu'on lui demande d'exécuter le code, utilise un interpréteur Python installé sur votre machine afin de lire le code et de le traduire à la machine afin qu'elle l'exécute au fur et à mesure.
|
||||
|
||||
Il existe de nombreux éditeur de code en Python.
|
||||
|
||||
D'autres éditeurs de code existent comme [Spyder](https://www.spyder-ide.org/), [Pyzo](https://pyzo.org/start.html), [Edupython](https://edupython.tuxfamily.org/), [Thonny](https://thonny.org/), d'autres permettent d'être exécuté en ligne [Basthon](https://console.basthon.fr/).
|
||||
|
||||
Nous allons utiliser la majorité du temps ce dernier. Ce document vise à le présenter pour faciliter sa prise en main.
|
||||
|
||||
## Basthon
|
||||
|
||||
### Définition
|
||||
|
||||
Basthon est l’acronyme de « Bac À Sable pour pyTHON ». Il ressemble au mot « baston », c’est une allusion à la « lutte » que peut parfois représenter l’apprentissage de la programmation, l’écriture d’un code ou son débogage.
|
||||
|
||||
Basthon est utilisé pour s’initier au langage de programmation Python, sans rien avoir à installer. Il suffit de disposer d’un navigateur (Firefox, Chrome ou Chromium) à jour et d’une connexion à Internet.
|
||||
|
||||
Il suffit de se rendre à l'url [https://console.basthon.fr/](https://console.basthon.fr/), l'interface suivante apparait :
|
||||
|
||||
|
||||
|
||||
### Se repérer dans l'interface
|
||||
|
||||
|
||||
|
||||
- La partie droite (1 sur l'image) est la `console`
|
||||
- La partie gauche (2 sut l'image) est l'`éditeur`
|
||||
|
||||
Ci-dessous, une description des principaux boutons de l'interface :
|
||||
|
||||
| Élément | Description|
|
||||
| :--: | :-- |
|
||||
|  | Remise à zéro : la console et la sortie graphique sont nettoyées et l’interprète Python est redémarré. |
|
||||
|  | Affiche la console (à la place de la sortie graphique). |
|
||||
|  | Affiche la sortie graphique (à la place de la console) pour visualiser un rendu Turtle, Matplotlib, etc. |
|
||||
|  | Bascule l’affichage en mode lumineux ou sombre. |
|
||||
|  | Lance l’exécution du contenu de l’éditeur dans la console. |
|
||||
|  | Ouvre un fichier Python (.py) dans l’éditeur. |
|
||||
|  | Télécharge le contenu de l’éditeur dans un fichier Python (fichier avec l'extension .py) |
|
||||
|
||||
### Première utilisation de l'interface
|
||||
|
||||
#### 1. À Faire
|
||||
|
||||
Dans la console, écrire l'instruction suivante et appuyer sur la touche ENTRÉE
|
||||
|
||||
```python
|
||||
print("Bonjour le monde !")
|
||||
```
|
||||
|
||||
On constate que l'interpréteur Python affiche `Bonjour le monde !`
|
||||
|
||||
#### 2. À Faire
|
||||
|
||||
1. Dans la console, écrire l'instruction suivante et appuyer sur la touche ENTRÉE
|
||||
|
||||
```python
|
||||
input("Votre prénom : ")
|
||||
```
|
||||
|
||||
2. On constate qu'une fenêtre de saisie apparait. Saisissez votre prénom et appuyez sur `OK`
|
||||
3. Quel est le résultat obtenu ?
|
||||
|
||||
#### 3. À Faire
|
||||
|
||||
1. Dans la console, écrire l'instruction suivante et appuyer sur la touche ENTRÉE
|
||||
|
||||
```python
|
||||
help(print)
|
||||
```
|
||||
|
||||
2. Dans la console, écrire l'instruction suivante et appuyer sur la touche ENTRÉE
|
||||
|
||||
```python
|
||||
help(input)
|
||||
```
|
||||
|
||||
On constate que l'instruction `help` affiche l'aide (en anglais) des instructions passées entre parenthèse. C'est une instruction bien utile pour connaitre le fonctionnement des instructions.
|
||||
|
||||
#### 4. À Faire
|
||||
|
||||
Dans la console, écrire l'instruction suivante et appuyer sur la touche ENTRÉE
|
||||
|
||||
```python
|
||||
clear
|
||||
```
|
||||
|
||||
On constate que cette instruction vide la console, ce qui est utile pour faire un peu le ménage lorsque l'on a saisi trop de code :-)
|
||||
|
||||
## Pour aller plus loin
|
||||
|
||||
La documentation complète et officielle de Basthon se trouve à cette url [https://basthon.fr/doc.html](https://basthon.fr/doc.html)
|
||||
|
||||
Vous êtes parés pour entamer la [prochaine activité](./activite_1) !
|
||||
@@ -1,117 +0,0 @@
|
||||
---
|
||||
title : Programmation - Généralités
|
||||
author : M. BODDAERT, M. MATHIEU
|
||||
license : CC-BY-NC-SA
|
||||
---
|
||||
|
||||
# Programmation - Généralités
|
||||
|
||||
📺 Pourquoi programme-t-on ? ([Vidéo](https://www.youtube.com/watch?v=7b3QupZc08Y&ab_channel=Lumni))
|
||||
|
||||
## Objectifs
|
||||
|
||||
Les objectifs de la séquence Programmation est de se questionner et répondre aux interrogations suivantes :
|
||||
|
||||
- Qu'est-ce qu'un __langage de programmation__ ?
|
||||
- __Pourquoi a-t-on besoin__ d'un langage de programmation ?
|
||||
- Qu'est-ce que __programmer__ ?
|
||||
- __Comment__ programme-t-on ?
|
||||
|
||||
## Définition
|
||||
|
||||
> __Langage__ (Selon le Larousse) : Capacité, observée chez tous les humains, d'exprimer leur pensée et de communiquer au moyen d'un système de signes vocaux et éventuellement graphiques.
|
||||
|
||||
- Le langage est un système permettant la communication entre 2 entités, 2 humains :
|
||||
|
||||
```mermaid
|
||||
flowchart LR
|
||||
A[Humain A] --> |Demande|B[Humain B]
|
||||
C[Humain A] --> |Demande|D[Humain B]
|
||||
D --> |Interprète|D
|
||||
E[Humain A] --> |Demande|F[Humain B]
|
||||
F --> |Interprète|F
|
||||
F --> |Répond|E
|
||||
```
|
||||
|
||||
Exemple :
|
||||
|
||||
```mermaid
|
||||
flowchart LR
|
||||
A[Passant A] --> |"Quelle heure est-il, s'il vous plait ?"|B[Passant B]
|
||||
C[Passant A] --> |"Quelle heure est-il, s'il vous plait ?"|D[Passant B]
|
||||
D --> |Regarde sa montre|D
|
||||
E[Passant A] --> |"Quelle heure est-il, s'il vous plait ?"|F[Passant B]
|
||||
F --> |Regarde sa montre|F
|
||||
F --> |Répond : 8h35|E
|
||||
```
|
||||
|
||||
- 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 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.
|
||||
|
||||
___Sans langage de programmation, un humain devrait connaitre et commander la machine en maitrisant son langage, donc écrire des 0 et des 1.___
|
||||
|
||||
```mermaid
|
||||
flowchart LR
|
||||
A[Langage Naturel] --> B[Langage de Programmation]
|
||||
B --> C[Langage Machine]
|
||||
```
|
||||
|
||||
### Constituants d'un langage
|
||||
|
||||
> __Vocabulaire__ : Ensemble des mots ou vocables d'une langue
|
||||
|
||||
Exemples :
|
||||
|
||||
- heure, quelle, table...
|
||||
- rehue, llequ, betal...
|
||||
|
||||
> __Grammaire__ (Selon le Larousse) : Ensemble des structures linguistiques propres à telle ou telle langue. Autrement dit, la grammaire indique l'ordre et les règles de structures du vocabulaire
|
||||
|
||||
Exemples :
|
||||
|
||||
- Quelle heure est-il ?
|
||||
- Il ? heure est quelle
|
||||
|
||||
## ...Mais avant de programmer
|
||||
|
||||
> Quelles sont les similitudes et différences entre ces 3 activités
|
||||
|
||||
| Itinéraire Mappy | Recette de cuisine | Montage de meuble IKEA |
|
||||
| :--: | :--: | :--: |
|
||||
|  |  |  |
|
||||
|
||||
|
||||
> Depuis quand emploie-t'on le terme algorithme ?
|
||||
|
||||
Al-Khwarizmi, mathématicien du 9ème siècle.
|
||||
|
||||
|
||||
|
||||
> __Algorithme__ (Selon Le Robert) : Ensemble fini des règles opératoires propres à un calcul.
|
||||
|
||||
Un __algorithme__ est une suite finie d'instructions exprimées en __langage naturel__.
|
||||
|
||||
Exemple :
|
||||
|
||||
- A demande Quelle heure est-il ?
|
||||
- B regarde sa montre
|
||||
- B répond 8h35
|
||||
|
||||
Exemple :
|
||||
|
||||
- A demande Quelle heure est-il ?
|
||||
- B répond 8h35
|
||||
- B Regarde sa montre
|
||||
|
||||
Un __programme__ est la traduction d'un algorithme dans un __langage de programmation__.
|
||||
|
||||
> __Programmer__ (Selon le Larousse) : Établir à l'avance une suite d'opérations ; planifier, déterminer à l'avance le moment et les modalités d'une action.
|
||||
|
||||
## Langage de Programmation au lycée
|
||||
|
||||
Au collège, vous avez déjà programmé mais en utilisant un langage de programmation par blocs : __Scratch__. Ce type de langage est très utile pour apprendre les bases de l’algorithmique et de la programmation mais ne constitue pas un langage utilisé pour programmer réellement. Pour cela, on utilise des langages dits textuels qui nécessitent d’écrire tout le code avec son clavier.
|
||||
|
||||
Au lycée, vous allez apprendre l’un de ces langages : le langage __Python__. Vous l’utiliserez dans différentes disciplines : Mathématiques, SNT, Physique-Chimie, spécialité NSI notamment.
|
||||
@@ -1,32 +0,0 @@
|
||||
# Programmation Python
|
||||
|
||||
## Présentation
|
||||
|
||||
Ce chapitre a pour objectif de répondre aux questions suivantes :
|
||||
|
||||
- Qu'est-ce que __programmer__ ?
|
||||
- Qu'est que __Python__ ?
|
||||
- Comment programmer en Python ?
|
||||
|
||||
## Progression
|
||||
|
||||
```mermaid
|
||||
flowchart LR;
|
||||
A[1. Généralités]-->B[2. Prise en main de Python];
|
||||
B-->C[3. Les variables];
|
||||
C-->D[4. Les instructions conditionnelles];
|
||||
D-->E[5. Les boucles];
|
||||
E-->F[6. Les fonctions];
|
||||
|
||||
click A "./programmation/GENERALITES.md" "Lien vers 1. Généralités" _self
|
||||
click B "./programmation/SPYDER.md" "Lien vers 2. Prise en main de Python" _self
|
||||
click C "./programmation/activite_1/" "Lien vers 3. Les variables" _self
|
||||
click D "./programmation/activite_2/" "Lien vers 4. Les instructions conditionnelles" _self
|
||||
click E "./programmation/activite_3/" "Lien vers 5. Les boucles" _self
|
||||
```
|
||||
|
||||
## Attendus du Programme
|
||||
|
||||
| Contenus | Capacités attendues |
|
||||
| ------------------------------------------------------------ | ------------------------------------------------------------ |
|
||||
| Affectations, variables<br />Séquences<br />Instructions conditionnelles<br />Boucles bornées et non bornées<br />Définitions et appels de fonctions | Écrire et développer des programmes pour répondre à des problèmes et modéliser des phénomènes physiques, économiques et sociaux. |
|
||||
@@ -1,92 +0,0 @@
|
||||
# Prise en main de l'outil Spyder
|
||||
|
||||
Le logiciel *__Spyder__* (Scientific Python Development EnviRonment) est un outil qui nous permettra, au fur et à mesure de l'année, de travailler sur la programmation en langage python. <br>
|
||||
|
||||
Il s'agit, pour simplifier, de l'interface entre la machine et vous : nous emploierons un langage de programmation afin de transmettre à l'ordinateur des instructions qui lui seront traduites en langage machine.
|
||||
|
||||
<br>
|
||||
|
||||
Ainsi, aucun risque de ne pas se faire comprendre par l'ordinateur.
|
||||
|
||||
```mermaid
|
||||
flowchart LR
|
||||
Nous -- Langage Python --> Spyder -- Langage Machine --> Ordinateur
|
||||
```
|
||||
|
||||
-----
|
||||
|
||||
Commençons donc par voir à quoi ressemble l'interface de *__Spyder__* :
|
||||
<br>
|
||||
|
||||
|
||||
|
||||
> 1. *La fenêtre principale*, à gauche, va vous permettre de taper du *code* et donc de *__programmer__*.<br>
|
||||
2. En haut à droite, *l'explorateur* vous donnera des conseils, vous affichera les fichiers ou les *__variables déclarées__* dans le programme.
|
||||
3. En bas à droite, *__l'interpreteur__* vous indiquera le résultat du code executé : on parlera également de *__sortie__*
|
||||
|
||||
En pratique, cela donne cet aspect :
|
||||
|
||||
> 
|
||||
|
||||
Ici, on peut voir le resultat du code que j'ai écrit.
|
||||
|
||||
----
|
||||
|
||||
Mais avant de se mettre au travail, il est essentiel de vous *__approprier__* le logiciel ! Pour celà, on va tout d'abord passer Spyder en français :
|
||||
|
||||
<li>Cliquez sur l'icône <b>outils</b> </li>
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
<li> Puis dans le menu qui s'affiche, selectionner <b><i><u>Application</u> </i> </b> puis à droite, l'onglet <b>Advanced Settings </b> </li>
|
||||
<br>
|
||||
|
||||
Et enfin choisissez Français, afin de pouvoir travailler dans de bonnes conditions.
|
||||
|
||||
|
||||
|
||||
----
|
||||
|
||||
> Il reste une petite chose à faire si vous le souhaitez : basculer sur le thème sombre.
|
||||
Ce choix est personnel, selon vos préférences, choisissez donc bien : vous allez passer l'année à travailler avec cet outil, autant avoir une interface qui vous plaise !
|
||||
|
||||
Dans le même menu, selectionnez Apparance, tout en haut. Puis changez (ou non !) le *__thème de l'interface__* et / ou le *__thème des icônes__*
|
||||
|
||||
|
||||
|
||||
-----
|
||||
|
||||
Puisque l'on parle des icônes, celles ci sont situées ici, au dessus de la fenêtre de code :
|
||||
|
||||
|
||||
|
||||
Retenez juste son emplacement pour le moment.
|
||||
|
||||
Maintenant, pour en finir avec le paramètrage de Spyder, il vous reste une tâche : décider de l'emplacement de vos fichiers et travaux. <br>
|
||||
|
||||
Il va falloir selectionner un emplacement accessible (votre espace perso, un dossier de votre session sur le disque dur, ou votre clé usb) auquel vous êtes certains et certaines d'avoir accès.
|
||||
|
||||
Pour cela, regarder en haut à droite de la fenêtre de Spyder, juste à côté de l'icone *outils* :
|
||||
|
||||
|
||||
|
||||
Cliquez donc sur l'icone *Dossier* qui se trouve à droite de la barre d'adresse afin de selectionner le répertoire source de vos travaux.
|
||||
|
||||
----
|
||||
|
||||
Reste une dernière chose à voir (promis c'est bientôt la fin) !
|
||||
|
||||
En Python, tout ce que vous pourrez écrire comme code se fait sur des fichiers .py (l'extension de fichier Python)
|
||||
|
||||
Vous pouvez trouvez cette information juste au dessus de la fenêtre principale de votre code :
|
||||
|
||||
|
||||
|
||||
Ici on nous rappelle donc le chemin du fichier, ainsi que son nom. Soyez attentifs lorsque vous débuterez un nouveau TP, de vous assurez que le fichier sur lequel vous travaillez soit bien le bon !
|
||||
|
||||
----
|
||||
|
||||
Et maintenant, au boulot avec le sourire
|
||||
@@ -1,496 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Premier pas en Python\n",
|
||||
"\n",
|
||||
"## 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 la touche ENTRÉE.\n",
|
||||
"\n",
|
||||
"### 1. À Faire\n",
|
||||
"\n",
|
||||
"1. Éxécuter le code suivant (_sans les ???_) :\n",
|
||||
"```python\n",
|
||||
"5 + 2\n",
|
||||
"???\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": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### Bilan 1\n",
|
||||
"\n",
|
||||
"- A travers ce premier exemple, on constate que Python sait faire des calculs !!\n",
|
||||
"- Lorsque l'on appuie sur ENTRÉE, python lit le code 5 + 2, calcule l'opération associée et restitue le résultat."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 2. À Faire\n",
|
||||
"\n",
|
||||
"1. Écrire et exécuter successivement les instructions suivantes (_sans les ???_) `\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 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 $//, \\%, **$ \n",
|
||||
"\n",
|
||||
"### 3. À 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 ma maison 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 3\n",
|
||||
"\n",
|
||||
"- Outre des entiers, Python permet d'utiliser des nombres décimaux,\n",
|
||||
"- La partie suivante explicitera plus l'utilisation et le comportement des nombre décimaux."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 4. À 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": [
|
||||
"## 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",
|
||||
"### 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",
|
||||
"### Valeur des variables\n",
|
||||
"\n",
|
||||
"#### Affecter une valeur à une variable\n",
|
||||
"\n",
|
||||
"##### 5. À 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 5\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.\n",
|
||||
"\n",
|
||||
"#### Afficher la valeur d’une variable\n",
|
||||
"\n",
|
||||
"Pour afficher la valeur d’une variable on utilise la fonction `print()`. Par exemple, pour afficher la valeur de la variable `note` on écrit simplement : `print(note)`. A l’exécution du code, la valeur s’affiche dans la console.\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"note = 12\n",
|
||||
"print(note)\n",
|
||||
"???\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Type des variables\n",
|
||||
"\n",
|
||||
"Dans les travaux à faire précédent, nous avons manipulé essentiellement des entiers, Python permet de manipuler d'autres types de variables :\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",
|
||||
"#### 6. À 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": [
|
||||
"#### 7. À Faire\n",
|
||||
"\n",
|
||||
"Copier et exécuter les instructions suivantes\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"a = \"Je suis\"\n",
|
||||
"b = \" Yoda \"\n",
|
||||
"a + b \n",
|
||||
"???\n",
|
||||
"b + a\n",
|
||||
"???\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### Bilan 7\n",
|
||||
"\n",
|
||||
"Comme vous le voyez, on peut ajouter deux chaînes : c'est une ___concaténation___.\n",
|
||||
"\n",
|
||||
"Cependant, on ne peut pas ajouter n'importe quoi :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"a = 'Je mesure '\n",
|
||||
"b = 1.12\n",
|
||||
"c = 'm'\n",
|
||||
"a + b + c\n",
|
||||
"???\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Cela ne marche pas car les variables ne sont pas du même *type*. Il faut les convertir en utilisant :\n",
|
||||
"\n",
|
||||
"- soit la fonction `str(nombre)` qui convertit le nombre en chaîne.\n",
|
||||
"- soit la fonction `int(chaîne)` qui convertit, si possible, la chaîne en entier.\n",
|
||||
"- soit la fonction `float(chaîne)` qui convertit, si possible ,la chaîne en flottant.\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"str(b)\n",
|
||||
"???\n",
|
||||
"a + str(b) + c\n",
|
||||
"???\n",
|
||||
"str(b) + c + a\n",
|
||||
"???\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 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 (a-z, 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 `snt` est différente de la variable `Snt`.\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).\n",
|
||||
"\n",
|
||||
"#### À Faire\n",
|
||||
"\n",
|
||||
"1. Quels sont les noms de variables incorrects parmi ceux proposés ? Vous indiquerez pourquoi."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"| 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 :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"| Variable | Nom de variable |\n",
|
||||
"| :-- | :--: |\n",
|
||||
"| le nombre de personnes aux yeux bleus de Seconde 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": [
|
||||
"## Exercices\n",
|
||||
"\n",
|
||||
"### Exercice 1\n",
|
||||
"\n",
|
||||
"On considère le programme Python suivant.\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"a = 8\n",
|
||||
"b = 3\n",
|
||||
"a = a - 4\n",
|
||||
"b = 2 * b\n",
|
||||
"a = a + b\n",
|
||||
"print(a)\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"1. Combien de variables sont utilisées ? Combien de valeurs différentes ont-elles prises au cours de l’exécution du programme ?\n",
|
||||
"2. Quelle est la valeur finale de la variable `a` ?\n",
|
||||
"3. Il est possible d’afficher plusieurs valeurs avec la fonction `print`. Par exemple, si on veut afficher les valeurs des variables `a` et `b` on écrit simplement `print(a, b)`. Modifiez la dernière ligne du programme et exécutez-le."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 2\n",
|
||||
"\n",
|
||||
"On considère le programme de calcul suivant.\n",
|
||||
"\n",
|
||||
"- A prend la valeur 5\n",
|
||||
"- Multiplier A par 3\n",
|
||||
"- Soustraire 4 au résultat\n",
|
||||
"- Elever le résultat au carré\n",
|
||||
"- Afficher le résultat\n",
|
||||
"\n",
|
||||
"Écrire un programme Python permettant de coder ce programme de calcul. Vérifiez ensuite en l'exécutant."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 3\n",
|
||||
"\n",
|
||||
"Sur un site de vente en ligne, on peut acheter différents articles. Un paquet de farine d'un kg coûte 1,15 € et une boîte de six oeufs coûte 1,50 €.\n",
|
||||
"\n",
|
||||
"Écrire un programme Python qui utilise deux variables pour stocker le nombre de paquets de farine et de boîtes d'oeufs souhaités puis, qui calcule et affiche le prix total à payer pour la commande."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.9.6"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
@@ -1,261 +0,0 @@
|
||||
---
|
||||
title : Activité 1 - Les variables
|
||||
author : M. BODDAERT
|
||||
license : CC-BY-NC-SA
|
||||
---
|
||||
# Premier pas en Python
|
||||
|
||||
## La console
|
||||
|
||||
La __console__ est un endroit où l'on peut écrire du code en Python.
|
||||
|
||||
Le code sera exécuté immédiatement dès validation de la ligne, c'est-à-dire dès que vous appuyer sur la touche ENTRÉE.
|
||||
|
||||
### 1. À Faire
|
||||
|
||||
1. Écrire et exécuter le code suivant (_sans les ???_) :
|
||||
|
||||
```python
|
||||
>>> 5 + 2
|
||||
???
|
||||
```
|
||||
2. Quel est le résultat obtenu ?
|
||||
|
||||
```txt
|
||||
|
||||
```
|
||||
|
||||
#### Bilan 1
|
||||
|
||||
- A travers ce premier exemple, on constate que Python sait faire des calculs !!
|
||||
- Lorsque l'on appuie sur ENTRÉE, python lit le code 5 + 2, calcule l'opération associée et restitue le résultat.
|
||||
|
||||
### 2. À Faire
|
||||
|
||||
1. Écrire et exécuter successivement les instructions suivantes (_sans les ???_) `
|
||||
|
||||
```python
|
||||
>>> 5 - 2
|
||||
???
|
||||
>>> 5 * 2
|
||||
???
|
||||
>>> 5 / 2
|
||||
???
|
||||
>>> 5 // 2
|
||||
???
|
||||
>>> 5 % 2
|
||||
???
|
||||
>>> 5 ** 2
|
||||
???
|
||||
```
|
||||
|
||||
2. Quels sont les résultats obtenus ? Compléter le tableau suivant en décrivant ce que fait l'opérateur de l'instruction.
|
||||
|
||||
| Opérateur | Description |
|
||||
| :--: | :-- |
|
||||
| $-$ | |
|
||||
| $*$ | |
|
||||
| $/$ | |
|
||||
| $//$ | |
|
||||
| $\%$ | |
|
||||
| $**$ | |
|
||||
|
||||
|
||||
#### Bilan 2
|
||||
|
||||
- Python permet l'utilisation des opérateurs arithmétiques usuelles $+, -, *, /$ sur les entiers,
|
||||
- Python permet l'utilisation d'opérateurs arithmétiques avec une syntaxe spécifique comme $//, \%, **$
|
||||
|
||||
### 3. À Faire
|
||||
|
||||
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)
|
||||
```python
|
||||
>>>
|
||||
|
||||
```
|
||||
2. Sachant qu'à mon prochain anniversaire j'aurai 9490 jours, écrire une instruction qui calcule mon âge, en nombre d'années :
|
||||
```python
|
||||
>>>
|
||||
|
||||
```
|
||||
3. Sachant que ma maison 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 ?
|
||||
```python
|
||||
>>>
|
||||
|
||||
```
|
||||
|
||||
#### Bilan 3
|
||||
|
||||
- Outre des entiers, Python permet d'utiliser des nombres décimaux,
|
||||
- La partie suivante explicitera plus l'utilisation et le comportement des nombre décimaux.
|
||||
|
||||
### 4. À Faire
|
||||
|
||||
Exécuter le code suivant. Que constatez-vous ?
|
||||
|
||||
```python
|
||||
>>> # 3 + 2
|
||||
???
|
||||
```
|
||||
|
||||
## Les variables
|
||||
|
||||
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.
|
||||
|
||||
### Définition
|
||||
|
||||
> 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__.
|
||||
|
||||
### Valeur des variables
|
||||
|
||||
#### Affecter une valeur à une variable
|
||||
|
||||
##### 5. À Faire
|
||||
|
||||
Copier et exécuter les instructions suivantes
|
||||
|
||||
```python
|
||||
>>> a = 5
|
||||
>>> b = 2
|
||||
>>> a + b
|
||||
???
|
||||
```
|
||||
##### Bilan 5
|
||||
|
||||
1. La syntaxe pour déclarer et affecter une valeur a une variable est `nom de la variable = valeur`
|
||||
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`.
|
||||
3. Lorsque Python interprète l'instruction 3, il lit les valeurs associées aux variables et effectue l'opération.
|
||||
|
||||
#### Afficher la valeur d’une variable
|
||||
|
||||
Pour afficher la valeur d’une variable on utilise la fonction `print()`. Par exemple, pour afficher la valeur de la variable note on écrit simplement : `print(note)`. A l’exécution du code, la valeur s’affiche dans la console.
|
||||
|
||||
### Type des variables
|
||||
|
||||
Dans les travaux à faire précédent, nous avons manipulé essentiellement des entiers, Python permet de manipuler d'autres types de variables :
|
||||
|
||||
- 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) ;
|
||||
- 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)
|
||||
- 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).
|
||||
|
||||
#### 6. À Faire
|
||||
|
||||
Indiquez le type des variables permettant de stocker (sur votre smartphone) les informations suivantes :
|
||||
|
||||
- le nom d’un contact
|
||||
- le numéro de téléphone d’un contact
|
||||
- un SMS
|
||||
- l’heure du réveil
|
||||
- le code de votre partage de connexion Wi-Fi
|
||||
- le pourcentage affiché de batterie restante
|
||||
- les notes aux deux derniers devoirs de Mathématiques de l'année dernière
|
||||
|
||||
#### 7. À Faire
|
||||
|
||||
Copier et exécuter les instructions suivantes
|
||||
|
||||
```python
|
||||
>>> a = "Je suis"
|
||||
>>> b = " Yoda "
|
||||
>>> a + b
|
||||
???
|
||||
>>> b + a
|
||||
???
|
||||
```
|
||||
|
||||
#### Bilan 7
|
||||
|
||||
Comme vous le voyez, on peut ajouter deux chaînes : c'est une ___concaténation___.
|
||||
|
||||
Cependant, on ne peut pas ajouter n'importe quoi :
|
||||
|
||||
```python
|
||||
>>> a = 'Je mesure '
|
||||
>>> b = 1.12
|
||||
>>> c = 'm'
|
||||
>>> a + b + c
|
||||
???
|
||||
```
|
||||
|
||||
Cela ne marche pas car les variables ne sont pas du même *type*. Il faut les convertir en utilisant :
|
||||
|
||||
- soit la fonction `str(nombre)` qui convertit le nombre en chaîne.
|
||||
- soit la fonction `int(chaîne)` qui convertit, si possible, la chaîne en entier.
|
||||
- soit la fonction `float(chaîne)` qui convertit, si possible ,la chaîne en flottant.
|
||||
|
||||
```python
|
||||
>>> str(b)
|
||||
???
|
||||
>>> a + str(b) + c
|
||||
???
|
||||
>>> str(b) + c + a
|
||||
???
|
||||
```
|
||||
|
||||
### Nom des variables
|
||||
|
||||
Chaque variable possède un nom qui permet d’identifier l’emplacement mémoire correspondant.
|
||||
|
||||
Dans le langage Python, il y a des règles à respecter pour nommmer les variables. Voici celles qui vous concernent :
|
||||
|
||||
- __Règle 1__ : un nom ne peut contenir que des lettres (a-z, A-Z), des chiffres (0 - 9) et le caractère _ (underscore).
|
||||
- __Règle 2__ : un nom ne peut pas commencer par un chiffre.
|
||||
- __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 `snt` est différente de la variable `Snt`.
|
||||
- __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.
|
||||
- __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).
|
||||
|
||||
#### À Faire
|
||||
|
||||
1. Quels sont les noms de variables incorrects parmi ceux proposés ? Vous indiquerez pourquoi.
|
||||
|
||||
- `prix achat`
|
||||
- `prix_achat`
|
||||
- `note`
|
||||
- `2ndeG`
|
||||
- `SecondeG`
|
||||
- `Seconde:G`
|
||||
- `dix-huit`
|
||||
|
||||
2. Proposez un nom de variable permettant de stocker :
|
||||
|
||||
- le nombre de personnes aux yeux bleus de Seconde G
|
||||
- le tarif d’un repas au self
|
||||
- l’aire d’un triangle (il n’y a qu’une seule figure)
|
||||
- la note à un devoir d’anglais
|
||||
|
||||
## Exercices
|
||||
|
||||
### Exercice 1
|
||||
|
||||
On considère le programme Python suivant.
|
||||
|
||||
```python
|
||||
a = 8
|
||||
b = 3
|
||||
a = a - 4
|
||||
b = 2 * b
|
||||
a = a + b
|
||||
print(a)
|
||||
```
|
||||
|
||||
1. Combien de variables sont utilisées ? Combien de valeurs différentes ont-elles prises au cours de l’exécution du programme ?
|
||||
2. Quelle est la valeur finale de la variable `a` ?
|
||||
3. Il est possible d’afficher plusieurs valeurs avec la fonction `print`. Par exemple, si on veut afficher les valeurs des variables `a` et `b` on écrit simplement `print(a, b)`. Modifiez la dernière ligne du programme et exécutez-le.
|
||||
|
||||
### Exercice 2
|
||||
|
||||
On considère le programme de calcul suivant.
|
||||
|
||||
- A prend la valeur 5
|
||||
- Multiplier A par 3
|
||||
- Soustraire 4 au résultat
|
||||
- Elever le résultat au carré
|
||||
- Afficher le résultat
|
||||
|
||||
Écrire un programme Python permettant de coder ce programme de calcul. Vérifiez ensuite en l'exécutant.
|
||||
|
||||
### Exercice 3
|
||||
|
||||
Sur un site de vente en ligne, on peut acheter différents articles. Un paquet de farine d'un kg coûte 1,15 € et une boîte de six oeufs coûte 1,50 €.
|
||||
|
||||
Écrire un programme Python qui utilise deux variables pour stocker le nombre de paquets de farine et de boîtes d'oeufs souhaités puis, qui calcule et affiche le prix total à payer pour la commande.
|
||||
@@ -1,284 +0,0 @@
|
||||
---
|
||||
title : Activité 2 - Les instructions conditionnelles
|
||||
author : M. BODDAERT
|
||||
license : CC-BY-NC-SA
|
||||
---
|
||||
# Les instructions conditionnelles
|
||||
|
||||
« _Si j'aurais su, j'aurais pas venu_ », réplique du Petit Gibus dans le film "La Guerre des boutons" d'Yves Robert.
|
||||
|
||||
## Définition
|
||||
|
||||
> Une __instruction conditionnelle__ permet de faire des choix en fonction de la valeur d’une __condition__. On parle souvent d’une instruction _si-alors_, ou _if-else_ en anglais.
|
||||
|
||||
En reprenant (et corrigeant) la citation du Petit Gibus, l'instruction conditionnelle devient « _Si j'avais su alors je ne serais pas venu_ ».
|
||||
|
||||
> Une __condition__ est une instruction qui est soit vraie, soit fausse. On parle alors d’une _instruction booléenne_ ou _variable booléenne_.
|
||||
|
||||
Par exemple, si une variable `note_francais` vaut 5 et qu’une variable `note_anglais` vaut 10 alors la condition `note_francais < note_anglais` est une condition qui est vraie, tandis que les conditions `note_francais > note_anglais` et `note_francais == note_anglais` sont fausses.
|
||||
|
||||
## Comparaisons de variables
|
||||
|
||||
Les opérateurs de comparaisons sont :
|
||||
|
||||
- `<` : inférieur
|
||||
- `<=` : inférieur ou égal
|
||||
- `>`: supérieur
|
||||
- `>=`: supérieur ou égal
|
||||
- `==` : est égal à
|
||||
- `!=`: est différents de
|
||||
|
||||
Le résultat d'une comparaison est toujours un booléen
|
||||
|
||||
- `True` si la comparaison est vraie
|
||||
- `False` si la comparaison est Fausse
|
||||
|
||||
Remarque : on ne peut comparer que des objets comparables
|
||||
|
||||
Attention, le test d'égalité entre deux variables se fait avec un double égal `==` (car le simple `=` permet d'affecter une valeur à une variable, Cf. [Activité 1](../activite_1/README.md)).
|
||||
|
||||
### À faire
|
||||
|
||||
Commenter chaque instruction ci-dessous
|
||||
|
||||
```python
|
||||
a = 5
|
||||
b = 18
|
||||
c = 12.3
|
||||
mot1 = "Hello"
|
||||
mot2 = "World"
|
||||
#
|
||||
print(a > b)
|
||||
#
|
||||
print(b // a == 3)
|
||||
#
|
||||
print(b % a == 3)
|
||||
#
|
||||
print(a - b > 2)
|
||||
#
|
||||
print(type(c) == float)
|
||||
#
|
||||
print(mot1 != mot2)
|
||||
#
|
||||
print(mot1 < mot2)
|
||||
#
|
||||
print(mot1 > 2)
|
||||
```
|
||||
|
||||
## Description
|
||||
|
||||
Dans une suite d'instructions on est souvent amené à faire des choix.
|
||||
|
||||
### Cas 1 : Si...Alors
|
||||
|
||||
**Si** une ou plusieurs conditions sont réalisées **Alors** on exécute une ou plusieurs instructions
|
||||
|
||||
La structure en Python : On indente (une tabulation) les instructions qui doivent s'exécuter si la condition est vérifiée
|
||||
|
||||
```
|
||||
if condition :
|
||||
instruction1
|
||||
instruction2
|
||||
```
|
||||
|
||||
Exemple qui affiche si les variables `a` et `b` sont des entiers pairs
|
||||
|
||||
```python
|
||||
a = 12
|
||||
if a % 2 == 0:
|
||||
print(a, " est un entier pair")
|
||||
|
||||
b = 13
|
||||
if b % 2 == 0:
|
||||
print(b," est un entier pair")
|
||||
```
|
||||
|
||||
### Cas 2 : Si ...Alors...Sinon
|
||||
|
||||
Dans cette structure, si la ou les conditions sont vraies, les instructions 1 et 2 sont exécutées. Sinon c'est l'instruction3 qui est exécutée.
|
||||
|
||||
```
|
||||
if condition:
|
||||
instruction1
|
||||
instruction2
|
||||
else:
|
||||
instruction3
|
||||
```
|
||||
|
||||
Exemple :
|
||||
|
||||
```python
|
||||
a = 12
|
||||
|
||||
if a % 2 == 0:
|
||||
print(a, " est un entier pair")
|
||||
else:
|
||||
print(a," est un entier impair")
|
||||
```
|
||||
|
||||
### Cas 3 : Si...Alors...Sinon Si
|
||||
|
||||
Dans cette structure on teste plusieurs conditions
|
||||
|
||||
```
|
||||
if condition1:
|
||||
instruction1
|
||||
elif condition2:
|
||||
instruction2
|
||||
instruction3
|
||||
elif condition3:
|
||||
instruction4
|
||||
else:
|
||||
instruction5
|
||||
```
|
||||
|
||||
Exemple :
|
||||
|
||||
Imaginons les conditions de passage d'un piéton en fonction du feu de signalisation et du nombre de voitures passantes :
|
||||
|
||||
```python
|
||||
if feu == 'VERT':
|
||||
print('Piéton, vous pouvez passer')
|
||||
elif voitures = 0 :
|
||||
print('Piéton, vous pouvez passer mais attention')
|
||||
else:
|
||||
print('Piéton, vous ne pouvez passer')
|
||||
```
|
||||
|
||||
### À Faire
|
||||
|
||||
Soit l'algorithme qui détermine la réponse de Yoda en fonction de la taille qui lui est communiquée :
|
||||
|
||||
```txt
|
||||
Demander la taille
|
||||
Si la taille est supérieure à 1m80 alors
|
||||
la réponse est 'Maître, vous vous prenez pour Chewbacca'
|
||||
Sinon si la taille est supérieure à 1m20 alors
|
||||
la réponse est 'Maitre, vous vous prenez pour Luc Skywalker'
|
||||
Sinon si la taille est supérieure à 0.80m alors
|
||||
la réponse est "Maitre, ce n'est pas la taille qui compte"
|
||||
Sinon la réponse est 'Maitre, vous vous sous-estimez'
|
||||
```
|
||||
|
||||
Compléter le code suivant pour qu'il implante l'algorithme ci-dessus :
|
||||
|
||||
```python
|
||||
taille = input('Combien mesures-tu ?')
|
||||
taille = float(taille)
|
||||
if taille > 1.8 :
|
||||
reponse = ???
|
||||
elif taille > 1.2 :
|
||||
reponse = ???
|
||||
elif taille > 0.8 :
|
||||
reponse = ???
|
||||
else :
|
||||
reponse = ???
|
||||
print(reponse)
|
||||
```
|
||||
|
||||
## Exercices
|
||||
|
||||
### Exercice 1
|
||||
|
||||
Modifier le code suivant pour qu'il y ait 4 couleurs différentes en fonction de la position(abscisse) de la souris
|
||||
|
||||
**mouseX** renvoie l'abscisse de la souris (0 pour le coin supérieur gauche de la fenêtre)
|
||||
|
||||
( 0 à 50 , 50 à 100, 100 à 150 et 150 à 200)
|
||||
|
||||
```python
|
||||
from p5 import *
|
||||
|
||||
def setup():
|
||||
createCanvas(200,200) # crée une fenêtre de 200 x 200 pixels
|
||||
|
||||
def draw():# cette fonction s'exécute en boucle 60 fois par seconde...
|
||||
# les conditions pour la couleur du fond d'écran
|
||||
if mouseX > 0 and mouseX < 100: # teste la position (abscisse) de la souris sur la moité gauche (0 à 100)
|
||||
background(255,120,0) #
|
||||
elif mouseX > 100 and mouseX < 200:# teste la position (abscisse) de la souris sur la moité droite (100 à 200)
|
||||
background(0,255,120) #
|
||||
else:
|
||||
background(0,0,255) # fond bleu
|
||||
run()
|
||||
```
|
||||
|
||||
### Exercice 2
|
||||
|
||||
Reprendre le code précédent(copier-coller) et en utilisant les instructions **mouseX** et **mouseY** (qui renvoie abscisse et ordonnée de la souris), faites en sorte qu'il y ait 4 couleurs différentes qui s'affichent suivant la position de la souris dans les quadrants:
|
||||
|
||||
- 0 < mouseX <100 et 0 < mouseY < 100, la couleur affichée doit être le bleu
|
||||
- 100 < mouseX < 200 et 0 < mouseY < 100, la couleur affichée doit être le vert
|
||||
- 0 < mouseX < 100 et 100 < mouseY < 200, la couleur affichée doit être le rouge
|
||||
- 100 < mouseX < 200 et 100 < mouseY < 200, la couleur affichée doit être le jaune
|
||||
|
||||
### Exercice 3
|
||||
|
||||
Dans le code suivant on affiche dans la fenêtre 4 cercles et la couleur de fond change si la souris survole l'un des cercles.
|
||||
|
||||
- l'instruction **circle(50,50,40)** dessine un cercle de centre (50,50 ) et de diamètre 40.
|
||||
- l'instruction **dist(x1,y1,x2,y2)** calcule la distance entre les points de coordonnées (x1,y1) et (x2,y2).
|
||||
- **dist(mouseX,mouseY,50,50) < 20** teste si la souris est dans l'un des cercles.
|
||||
|
||||
Compléter le code de façon que le fond change de couleur au survol des 4 cercles.
|
||||
|
||||
```python
|
||||
from p5 import *
|
||||
|
||||
def setup():
|
||||
createCanvas(200,200) # crée une fenêtre de 200 x 200 pixels
|
||||
|
||||
def draw():# cette fonction s'exécute en boucle 60 fois par seconde...
|
||||
if dist(mouseX,mouseY,50,50) < 20:
|
||||
background(255,255,0)
|
||||
# à modifier ici
|
||||
else:
|
||||
background(51,51,51)
|
||||
# ne pas modifier...
|
||||
fill(0,0,0)
|
||||
circle(50,50,40)
|
||||
circle(150,150,40)
|
||||
circle(150,50,40)
|
||||
circle(50,150,40)
|
||||
|
||||
run()
|
||||
```
|
||||
|
||||
### Exercice 4
|
||||
|
||||
Le code ci-dessous montre "une balle" se déplaçant sur un axe horizontal dans une fenêtre en rebondissant sur les bords.
|
||||
|
||||
Compléter le code de telle sorte que la balle se déplace aussi dans la verticale en rebondissant sur les bords inférieur et supérieur de la fenêtre.
|
||||
|
||||
```python
|
||||
from p5 import *
|
||||
|
||||
def setup():
|
||||
global bx,by,vx,vy,r
|
||||
r = 20
|
||||
bx = 50
|
||||
by = 50
|
||||
vx = 4
|
||||
vy = 5
|
||||
createCanvas(400,200) # crée une fenêtre de 200 x 200 pixels
|
||||
|
||||
def draw():# cette fonction s'exécute en boucle 60 fois par seconde...
|
||||
global bx,by,vx,vy,r
|
||||
background(0,0,0)# fond noir
|
||||
# mouvement du cercle sur l'axe horizontal
|
||||
bx = bx + vx
|
||||
# rebond sur les bords gauche et droit
|
||||
if bx < r or bx > 400 - r:
|
||||
vx = -vx
|
||||
# dessin du cercle
|
||||
fill(255,0,0)
|
||||
circle(bx,by,2*r)
|
||||
|
||||
run()
|
||||
```
|
||||
|
||||
### Exercice 5
|
||||
|
||||
Reprendre le code précédent et faire en sorte que la "balle" change de couleur à chaque rebond
|
||||
|
||||
Pour utiliser une couleur aléatoire, on pourra utiliser l'instruction: `fill(random(255),random(255),random(255))`
|
||||
@@ -1,219 +0,0 @@
|
||||
---
|
||||
title : Activité 3 - Les boucles
|
||||
author : M. BODDAERT
|
||||
license : CC-BY-NC-SA
|
||||
---
|
||||
# Les boucles
|
||||
|
||||
## Définition
|
||||
|
||||
Souvent, dans un programme, il est nécessaire de répéter un certain nombre de fois une (ou des) instruction(s). Pour cela, on utilise ce qu'on appelle des __boucles__.
|
||||
|
||||
### Exemple introductif
|
||||
|
||||
Le nombre d'utilisateurs d'un nouveau réseau social _KILESTBIEN_ est égal à 500 000 en janvier 2020. Ce nombre augmente de 5 % par mois, donc est multiplié par 1.05 chaque mois. Si on veut connaître le nombre d'utilisateurs 10 mois plus tard, il faut effectuer 10 fois de suite le même calcul (une multiplication par 1.05).
|
||||
|
||||
#### 1. À Faire
|
||||
|
||||
Compléter le programme Python suivant afin d'obtenir le nombre d'utilisateurs du réseau _KILESTBIEN_ au bout de 10 mois.
|
||||
|
||||
```python
|
||||
nb_utilisateurs = 500000
|
||||
nb_utilisateurs = nb_utilisateurs * 1.05
|
||||
???
|
||||
print(???)
|
||||
```
|
||||
|
||||
#### Problématique
|
||||
|
||||
Des banquiers veulent investir 1 million d'euros dans _KILESTBIEN_, mais ont une exigence. Ils souhaitent que le nombre d'utilisateurs du réseau soit au moins de 3 millions dans 3 ans.
|
||||
|
||||
Selon le taux de croissance du nombre d'utilisateurs de 5% par mois, vont-ils investir dans _KILESTBIEN_ ? Que faut-il modifier dans le programme précédent pour répondre à cette question ?
|
||||
|
||||
## Boucles bornée
|
||||
|
||||
Au lieu d'écrire 10 ou 36 lignes identiques il est préférable d'écrire une seule fois cette ligne et d'indiquer de l'exécuter 10 ou 36 fois : pour cela, on utilise une __boucle bornée__. En Python, au lieu d'écrire le programme du 1. À Faire, il est possible d'écrire :
|
||||
|
||||
```python
|
||||
nb_utilisateurs = 500000
|
||||
for i in range(10):
|
||||
nb_utilisateurs = nb_utilisateurs * 1.05
|
||||
print(nb_utilisateurs)
|
||||
```
|
||||
|
||||
### Construction d'une boucle bornée
|
||||
|
||||
Pour écrire une boucle bornée en Python on utilise le mot-clé `for`. Les boucles bornées sont par conséquent très souvent appelées *boucles for* (ou *boucles pour* en français).
|
||||
|
||||
### Utilisation de la fonction `range()`
|
||||
|
||||
- La fonction `range` permet de générer un intervalle sous la forme d'une liste d'entiers. Par exemple, l'appel `range(n)` génère $n$ entiers : $0, 1, 2, ..., n-1$.
|
||||
- ⚠ Attention : comme le premier entier est 0, le n-ième est numéroté $n - 1$.
|
||||
- La variable notée `i` prendra successivement (à chaque tour de boucle) les valeurs générées par la fonction `range`. Ici, `i` prendra les valeurs 0 puis 1 puis 2, ..., puis $n - 1$.
|
||||
- Le bloc d'instructions à répéter doit être indenté (d'une tabulation) et sera donc ici exécuté $n$ fois.
|
||||
|
||||
#### 2. À Faire
|
||||
|
||||
On considère le programme Python suivant.
|
||||
|
||||
```python
|
||||
a = 2
|
||||
for i in range(4):
|
||||
a = a + 1
|
||||
print(a)
|
||||
```
|
||||
|
||||
1. Quel est le bloc d'instructions répété dans la boucle `for` ?
|
||||
2. Combien de fois est-il répété ?
|
||||
3. Combien de valeurs sont affichées au cours de l'exécution de ce programme ?
|
||||
4. Quelle est la valeur finale de la variable `a` ?
|
||||
|
||||
#### 3. À Faire
|
||||
|
||||
On considère le programme Python suivant :
|
||||
|
||||
```python
|
||||
a = 1
|
||||
b = 5
|
||||
for i in range(3):
|
||||
a = 2 * a
|
||||
b = b + a
|
||||
print(b)
|
||||
```
|
||||
|
||||
On va commencer par analyser le code pour le comprendre.
|
||||
|
||||
1. Quel est le bloc d'instructions répété dans la boucle `for` ? Combien de fois est-il répété ?
|
||||
2. Expliquez pourquoi il n'y a qu'une seule valeur qui s'affiche dans la console si on exécute le code ?
|
||||
3. Recopiez et complétez le tableau ci-dessous avec les valeurs des variables `i`, `a` et `b` à chaque tour de boucle.
|
||||
| `i` | `a` | `b` |
|
||||
| :--: | :--: | :---: |
|
||||
| | 1 | 5 |
|
||||
| 0 | ??? | ??? |
|
||||
| ??? | ??? | ??? |
|
||||
| ??? | ??? | ??? |
|
||||
4. Quelle est la valeur finale de la variable `b` ?
|
||||
5. Exécutez ensuite le code et vérifiez ce qu'il produit.
|
||||
|
||||
## Exercices
|
||||
|
||||
### Exercice 1 - La punition
|
||||
|
||||
L'article 2.2 Les punitions scolaires d'une circulaire ministérielle du 13 Juillet 2000 rappelle qu' « _Il convient également de distinguer soigneusement les punitions relatives au comportement des élèves de l'évaluation de leur travail personnel. Ainsi n'est-il pas permis de baisser la note d'un devoir en raison du comportement d'un élève ou d'une absence injustifiée. Les __lignes et les zéros doivent également être proscrits__._»
|
||||
|
||||
Votre professeur était élève bien avant cette circulaire et a souvent été puni avec pour sanction le fait de devoir copier 100 fois sur une feuille la phrase suivante : "_Je ne discuterai plus avec mon camarade de classe pendant les cours_."
|
||||
|
||||
Écrire un programme Python qui permet de facilement transcire la punition.
|
||||
|
||||
### Exercice 2 - Table de Multiplication
|
||||
|
||||
1. Recopiez le programme suivant :
|
||||
|
||||
```python
|
||||
nombre = int(input("De quel nombre voulez-vous la table de multiplication ? "))
|
||||
|
||||
for compteur in range(10):
|
||||
print(nombre)
|
||||
```
|
||||
|
||||
2. Modifiez ce programme pour qu'il affiche la table de multiplication du nombre demandé, de 0 à 10. Par exemple, si l'utilisateur donne la valeur 6, le programme devrait afficher : 0, 6, 12, 18, …, 60.
|
||||
|
||||
### Exercice 3 - Problème de l'échiquier de Sissa
|
||||
|
||||
Selon [la légende](https://fr.wikipedia.org/wiki/Problème_de_l'échiquier_de_Sissa), pour remercier l'inventeur des échecs Sissa, le roi lui demanda de choisir sa récompense. Sissa demanda alors du riz : __un grain sur la première case, deux grains sur la seconde case, quatre grains sur la troisième case, huit grains sur la quatrième, et ainsi de suite jusqu'à la dernière case du jeu d'échec__. Le roi accepta.
|
||||
|
||||
On se demande combien de grains seront posés sur la dernière case du plateau d'échecs (qui en compte 64).
|
||||
|
||||
Pour résoudre ce problème, on peut utiliser le programme suivant :
|
||||
|
||||
```python
|
||||
grains = 1
|
||||
|
||||
for compteur in range(???):
|
||||
grains = ???
|
||||
|
||||
print("Nombre de grains sur la dernière case :", grains)
|
||||
```
|
||||
|
||||
1. Compléter ce programme, et exécutez-le.
|
||||
2. Combien de grains de riz y aura-t-il sur la dernière case de l'échiquier ?
|
||||
|
||||
### Exercice 4 - Petite tortue qui dessine
|
||||
|
||||
Le module `turtle` (*tortue*) permet de dessiner avec Python.
|
||||
|
||||
Dans cet exercice on veut écrire un programme qui permet de dessiner des formes géométriques. Voici le code incomplet du programme.
|
||||
|
||||
```python
|
||||
import turtle # pour utiliser le module turtle
|
||||
|
||||
"""Fonction qui dessine un carré de coté 100 pixels"""
|
||||
turtle.forward(100) # pour avancer de 100 pixels
|
||||
turtle.left(90) # pour tourner de 90° à gauche
|
||||
turtle.forward(100)
|
||||
turtle.left(90)
|
||||
# À Compléter
|
||||
|
||||
turtle.done() # pour afficher le dessin
|
||||
```
|
||||
1. Modifiez le programme afin que la tortue dessine un `carré`, en utilisant une boucle `for`.
|
||||
2. Modifiez le programme afin que la tortue dessine un `triangle`, en utilisant une boucle `for`.
|
||||
3. Modifiez le programme afin que la tortue dessine un `octogone`, en utilisant une boucle `for`.
|
||||
|
||||
## Boucle bornée avec le mot-clé `in`
|
||||
|
||||
Comme on l'a vu précédemment, il est possible de créer une boucle bornée en utilisant le mot-clé `in` associé au mot clé `range`. Cela permet de répéter les mêmes instructions sur un intervalle.
|
||||
|
||||
Cette section va nous permettre de voir une autre utilisation de la boucle bornée. En effet, il est possible d'itérer sur tous les éléments de certaines variables en utilisant le mot clé `in` de la façon suivante :
|
||||
|
||||
```python
|
||||
for element in variable: # se traduit pas "pour chaque element de variable"
|
||||
bloc_instructions
|
||||
```
|
||||
|
||||
**Remarques** :
|
||||
|
||||
- `variable` peut être une chaîne de caractères (type `str`) ou une liste (type `list`).
|
||||
- Dans ce cas, la variable `element` prend successivement chacune des valeurs de `variable`.
|
||||
|
||||
### 4. À Faire
|
||||
|
||||
1. Copier et exécuter le code suivant.
|
||||
```python
|
||||
a = "SNT"
|
||||
for lettre in a:
|
||||
print(lettre)
|
||||
```
|
||||
2. Quel est le résultat obtenu ?
|
||||
|
||||
## Compléments sur la fonction range
|
||||
|
||||
Dans les paramètres de la fonction `range` il est également possible de préciser une première valeur (si on ne veut pas commencer à zéro) ainsi que le pas (si on ne veut pas que les itérations se fassent de 1 en 1).
|
||||
|
||||
Après avoir regardé la vidéo ci-dessus, répondez aux questions qui suivent. Vous vérifierez ensuite en utilisant un éditeur de code Python.
|
||||
|
||||
<figure class="video_container">
|
||||
<iframe src="https://www.youtube.com/embed/07IGOcpiE7o" frameborder="0" allowfullscreen="true"> </iframe>
|
||||
</figure>
|
||||
1. Quelles sont les valeurs affichées dans la console lors de l'exécution de chacun des programmes ci-dessous ? *Attention, il faut répondre sans exécuter le code !*
|
||||
|
||||
2. - Programme 1 :
|
||||
|
||||
```python
|
||||
for i in range(10):
|
||||
print(i)
|
||||
```
|
||||
- Programme 2 :
|
||||
|
||||
```python
|
||||
for k in range(2, 10):
|
||||
print(k)
|
||||
```
|
||||
- Programme 3 :
|
||||
|
||||
```python
|
||||
for ind in range(2, 10, 3):
|
||||
print(ind)
|
||||
```
|
||||
|
||||
3. Exécutez successivement les trois codes et vérifiez vos réponses à la question précédente.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 16 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 206 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 82 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 70 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.4 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.4 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 3.2 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.4 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.6 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.6 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.3 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 396 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 656 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 23 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 29 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 40 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 47 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 324 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 666 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.0 MiB |
Binary file not shown.
|
Before Width: | Height: | Size: 38 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 627 KiB |
Reference in New Issue
Block a user