ajout introduction, fondamentaux et activité programmation
This commit is contained in:
134
FONDAMENTAUX.md
Normal file
134
FONDAMENTAUX.md
Normal file
@@ -0,0 +1,134 @@
|
||||
## Chapitre 2 : Concepts fondamentaux des graphes
|
||||
|
||||
### 2.1 Définitions de base
|
||||
|
||||
Un graphe est une structure mathématique permettant de modéliser un ensemble d’éléments et les relations entre eux. Il est défini par deux ensembles principaux :
|
||||
|
||||
- Les sommets (ou nœuds), qui représentent les entités (personnes, lieux, objets, etc.).
|
||||
- Les arêtes (ou liens), qui représentent les relations entre ces entités. Une arête connecte deux nœuds.
|
||||
|
||||
#### Définition formelle :
|
||||
|
||||
Un graphe G est un couple G = (V, E) , où :
|
||||
|
||||
- V est l’ensemble des sommets (nœuds),
|
||||
- E est l’ensemble des arêtes (liens) reliant des paires de sommets.
|
||||
|
||||
Exemple : Dans un réseau social, chaque personne est un sommet, et une arête peut représenter une relation d’amitié entre deux personnes.
|
||||
|
||||
--------------
|
||||
|
||||
|
||||
|
||||
### 2.2 Graphes dirigés et non dirigés
|
||||
|
||||
Les graphes peuvent être classés en deux grandes catégories selon la nature des relations qu’ils modélisent :
|
||||
|
||||
#### Graphe non dirigé
|
||||
|
||||
Dans un graphe non dirigé, les arêtes n’ont pas de direction. Cela signifie que si une arête relie les sommets u et v , alors la relation est symétrique : u est en relation avec v , et réciproquement.
|
||||
Exemple : Un graphe non dirigé peut modéliser un réseau d’amis. Si Alice et Bob sont amis, cette relation est mutuelle, donc il n’y a pas de direction particulière.
|
||||
$$
|
||||
u \longleftrightarrow v
|
||||
$$
|
||||
|
||||
#### Graphe dirigé :
|
||||
|
||||
Dans un graphe dirigé, les arêtes ont une direction. Une arête allant de u vers v signifie qu’il y a une relation de u vers v , mais pas nécessairement dans l’autre sens. C’est utile pour modéliser des relations asymétriques.
|
||||
Exemple : Sur Twitter, si Alice suit Bob, cela ne signifie pas nécessairement que Bob suit Alice en retour. La relation est donc dirigée de Alice vers Bob.
|
||||
$$
|
||||
u \longrightarrow v
|
||||
$$
|
||||
Application sociologique :
|
||||
|
||||
- Un graphe non dirigé peut modéliser les réseaux d’amitié ou de collaboration.
|
||||
- Un graphe dirigé peut représenter les relations de pouvoir ou d’influence dans un groupe (qui suit qui, qui influence qui).
|
||||
|
||||
-------
|
||||
|
||||
|
||||
|
||||
### 2.3 Graphes pondérés et non pondérés
|
||||
|
||||
Un graphe peut également être pondéré, ce qui signifie que chaque arête est associée à un poids. Ce poids peut représenter la force de la relation entre deux nœuds.
|
||||
|
||||
#### Graphe non pondéré :
|
||||
|
||||
Un graphe non pondéré attribue une valeur égale à toutes les arêtes. C’est la représentation la plus simple, où la présence d’une arête signifie simplement qu’il y a une relation entre deux nœuds, sans indication de son intensité.
|
||||
|
||||
#### Graphe pondéré :
|
||||
|
||||
Dans un graphe pondéré, chaque arête est associée à une valeur numérique qui peut représenter :
|
||||
• La fréquence des interactions (par exemple, combien de fois deux individus ont interagi).
|
||||
• La force de la relation (par exemple, la force d’une amitié ou d’une collaboration).
|
||||
$$
|
||||
u \xrightarrow{w} v
|
||||
$$
|
||||
Où w est le poids de l’arête reliant u et v .
|
||||
|
||||
### Application sociologique :
|
||||
|
||||
Un graphe pondéré peut modéliser des interactions sociales en intégrant la fréquence des interactions (par exemple, combien de fois deux individus ont communiqué) ou la proximité sociale entre des individus. Par exemple, dans une enquête sociologique, il est possible de pondérer les relations selon la fréquence de communication entre individus dans un groupe.
|
||||
|
||||
------------
|
||||
|
||||
### 2.4 Concepts clés : degré, chemins et cycles
|
||||
|
||||
Pour analyser un graphe, il est important de comprendre plusieurs concepts fondamentaux :
|
||||
|
||||
#### Degré d’un sommet :
|
||||
|
||||
Le degré d’un sommet est le nombre d’arêtes qui lui sont connectées.
|
||||
• Degré entrant : Le nombre d’arêtes qui arrivent vers le sommet (dans un graphe dirigé).
|
||||
• Degré sortant : Le nombre d’arêtes qui partent du sommet (dans un graphe dirigé).
|
||||
Exemple : Dans un réseau social, le degré d’un utilisateur correspond au nombre de connexions qu’il a (combien de personnes sont ses amis ou ses followers).
|
||||
|
||||
#### Chemin :
|
||||
|
||||
Un chemin dans un graphe est une suite de sommets reliés par des arêtes. Il peut représenter une chaîne de relations entre des individus.
|
||||
Exemple : Dans un réseau social, un chemin peut représenter la distance sociale entre deux individus (combien de relations directes ou indirectes les séparent).
|
||||
|
||||
#### Cycle :
|
||||
|
||||
Un cycle est un chemin qui revient à son point de départ. Dans une analyse de réseaux sociaux, un cycle peut représenter des boucles de rétroaction ou des groupes fermés d’interaction.
|
||||
|
||||
Application sociologique :
|
||||
|
||||
Ces concepts sont essentiels pour comprendre des phénomènes tels que :
|
||||
|
||||
- Centralité : Qui est le plus connecté dans un réseau ?
|
||||
- Distance sociale : Combien d’intermédiaires séparent deux individus dans un groupe ?
|
||||
- Communautés fermées : Quels individus forment des groupes qui interagissent exclusivement entre eux ?
|
||||
|
||||
-----------------
|
||||
|
||||
### 2.5 Modélisation des graphes dans des exemples sociologiques
|
||||
|
||||
Il est important de comprendre que ces concepts ne sont pas purement théoriques. Ils sont utilisés de manière pratique pour modéliser des relations complexes dans des contextes sociologiques.
|
||||
|
||||
Exemple : Réseau de collaborations scientifiques
|
||||
Imaginons que nous voulions modéliser un réseau de collaborations entre chercheurs dans un domaine donné :
|
||||
|
||||
- Chaque chercheur est un nœud.
|
||||
- Une arête relie deux chercheurs s’ils ont coécrit un article ensemble.
|
||||
- Le degré d’un chercheur mesure combien de collaborateurs il possède.
|
||||
- Un chemin entre deux chercheurs montre combien de collaborations les séparent (peut-être en passant par des collègues communs).
|
||||
|
||||
Dans ce réseau, des chercheurs avec un degré élevé peuvent être vus comme des acteurs centraux dans la diffusion des idées ou des innovations scientifiques.
|
||||
|
||||
Nous avons maintenant une compréhension de base de ce qu’est un graphe et comment il peut être utilisé pour modéliser des relations sociales. Dans le prochain chapitre, nous explorerons des algorithmes spécifiques permettant d’analyser ces graphes, comme les parcours en largeur (BFS) et en profondeur (DFS), qui sont des outils essentiels pour extraire des informations pertinentes à partir de graphes complexes.
|
||||
|
||||
Questions pour approfondir :
|
||||
|
||||
```markdown
|
||||
1. Pouvez-vous identifier dans votre quotidien des situations qui pourraient être modélisées comme des graphes ? (Par exemple, vos interactions avec vos amis, collègues ou réseaux sociaux).
|
||||
2. Comment ces concepts de degré, chemin et cycle peuvent-ils s’appliquer à l’étude de vos propres réseaux ?
|
||||
```
|
||||
|
||||
-----
|
||||
|
||||
Auteur : Florian Mathieu
|
||||
|
||||
Licence CC BY NC
|
||||
|
||||
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.
|
||||
149
README.md
Normal file
149
README.md
Normal file
@@ -0,0 +1,149 @@
|
||||
## Algorithmes des graphes
|
||||
|
||||
|
||||
|
||||
### Introduction contextuelle
|
||||
|
||||
|
||||
|
||||
**1.1 Les graphes : un outil essentiel en sciences sociales**
|
||||
|
||||
|
||||
|
||||
Dans le cadre de la sociologie quantitative, les graphes sont des outils puissants pour modéliser et analyser les relations entre individus, groupes et institutions. En effet, une grande partie des études sociologiques se concentre sur les **interactions entre les individus** et sur la manière dont ces interactions influencent des phénomènes sociaux tels que la diffusion des idées, la formation de communautés, ou l’influence sociale.
|
||||
|
||||
Les graphes permettent de représenter ces relations de façon structurée et d’appliquer des méthodes d’analyse rigoureuses pour en extraire des informations pertinentes.
|
||||
|
||||
Un **graphe** est une structure composée de deux ensembles :
|
||||
|
||||
• Les **nœuds** (ou sommets) qui représentent les entités (par exemple, des individus dans une communauté).
|
||||
|
||||
• Les **arêtes** (ou liens) qui représentent les relations entre ces entités (par exemple, les relations d’amitié, de collaboration, ou d’interaction).
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
**Exemple : Réseaux sociaux**
|
||||
|
||||
|
||||
|
||||
Prenons l’exemple d’un **réseau social** comme Facebook, LinkedIn ou Twitter. Dans ce contexte :
|
||||
|
||||
• Chaque **utilisateur** est un nœud du graphe.
|
||||
|
||||
• Une **arête** relie deux nœuds lorsqu’il existe une relation sociale entre ces utilisateurs (par exemple, ils sont amis, ils se suivent, ou ils interagissent).
|
||||
|
||||
<img src="assets/fb.png" alt="fb" />
|
||||
|
||||
*Exemple de graphe représentant des relations sur Facebook*
|
||||
|
||||
|
||||
|
||||
<img src="assets/X.png" alt="X" style="zoom: 50%;" />
|
||||
|
||||
|
||||
|
||||
*Exemple de graphe représentant des relations sur Twitter / X.*
|
||||
|
||||
|
||||
|
||||
Ce type de représentation permet de répondre à plusieurs questions pertinentes en sociologie :
|
||||
|
||||
• Quels individus jouent un rôle central dans un réseau social ?
|
||||
|
||||
• Comment l’information se diffuse-t-elle au sein d’un groupe ?
|
||||
|
||||
• Quelles sous-communautés ou groupes se forment dans une société donnée ?
|
||||
|
||||
|
||||
|
||||
-------------------
|
||||
|
||||
**1.2 Types de graphes couramment utilisés en sociologie**
|
||||
|
||||
|
||||
|
||||
Il existe plusieurs types de graphes, chacun adapté à différents types de relations sociales et de données. Voici les plus courants :
|
||||
|
||||
• **Graphe non dirigé** : Un graphe où les relations entre les nœuds ne sont pas orientées. Cela signifie que si une relation existe entre A et B, elle est réciproque. Par exemple, dans un réseau d’amis, si A et B sont amis, cela est vrai dans les deux sens.
|
||||
|
||||
• **Graphe dirigé** : Un graphe où les relations ont une direction. Cela est utile pour représenter des relations non réciproques, comme les relations de suivi sur Twitter, où un utilisateur A peut suivre un utilisateur B, mais B ne suit pas nécessairement A.
|
||||
|
||||
• **Graphe pondéré** : Chaque arête d’un graphe est associée à un poids qui peut représenter la force d’une relation (par exemple, la fréquence des interactions entre deux individus). Cela permet de modéliser des relations plus fines et nuancées.
|
||||
|
||||
• **Graphe biparti** : Ce type de graphe est utile lorsqu’il s’agit de modéliser des relations entre deux types distincts d’entités. Par exemple, il peut être utilisé pour représenter les relations entre des individus et des événements (comme des personnes assistant à des conférences) ou des individus et des opinions (qui supporte telle ou telle idée politique).
|
||||
|
||||
|
||||
|
||||
**Exemple : Graphe biparti en sociologie**
|
||||
|
||||
|
||||
|
||||
Dans une étude de sociologie politique, on pourrait modéliser un **graphe biparti** où :
|
||||
|
||||
|
||||
|
||||
• Les **nœuds de gauche** représentent des individus.
|
||||
|
||||
• Les **nœuds de droite** représentent des opinions ou partis politiques.
|
||||
|
||||
• Une **arête** existe entre un individu et une opinion s’il soutient cette idée.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Ce type de représentation permet d’analyser les relations complexes entre les individus et leurs idéologies ou appartenances politiques, et de voir comment ces relations évoluent dans le temps ou dans des contextes sociaux spécifiques.
|
||||
|
||||
|
||||
|
||||
**1.3 Applications sociologiques des graphes**
|
||||
|
||||
|
||||
|
||||
Les graphes offrent une **flexibilité exceptionnelle** pour modéliser et analyser une grande variété de phénomènes sociaux. Voici quelques exemples d’applications courantes en sociologie :
|
||||
|
||||
|
||||
|
||||
1. **Analyse des réseaux sociaux** :
|
||||
|
||||
L’analyse des réseaux sociaux permet d’identifier les individus les plus influents dans un groupe donné, de comprendre comment l’information ou les idées se diffusent, et de repérer des sous-groupes au sein de plus grandes communautés.
|
||||
|
||||
• **Centralité** : Un concept clé dans cette analyse est la notion de **centralité**. Un individu central dans un réseau est souvent celui qui a le plus d’interactions (mesuré par le nombre d’arêtes) ou celui qui est le mieux placé pour diffuser l’information dans le groupe.
|
||||
|
||||
• **Diffusion des idées** : Les graphes permettent aussi de modéliser la propagation des idées ou des innovations au sein d’une société, en identifiant les chemins les plus courts ou les relais clés dans la diffusion.
|
||||
|
||||
2. **Détection de communautés** :
|
||||
|
||||
Les graphes peuvent être utilisés pour détecter des **communautés** au sein d’un réseau, c’est-à-dire des groupes d’individus plus fortement connectés entre eux qu’au reste du réseau. Ces communautés peuvent représenter des groupes d’intérêts communs, des sous-cultures ou des classes sociales dans des contextes plus larges.
|
||||
|
||||
• **Exemple : Groupes d’amis dans un lycée** : On peut modéliser les interactions entre étudiants et utiliser des algorithmes pour identifier les groupes d’amis les plus cohésifs.
|
||||
|
||||
3. **Étude des inégalités sociales** :
|
||||
|
||||
Les graphes peuvent également servir à modéliser et analyser des phénomènes tels que les **inégalités sociales**. Par exemple, en étudiant les relations de collaboration ou de mentorat dans une entreprise, un graphe peut révéler des structures de pouvoir ou des barrières à la mobilité sociale.
|
||||
|
||||
• **Accès aux ressources** : En étudiant la distribution des liens dans un réseau, il est possible de comprendre qui a accès à des ressources critiques (telles que des informations ou des opportunités professionnelles) et qui est marginalisé.
|
||||
|
||||
|
||||
|
||||
**Transition vers les concepts techniques :**
|
||||
|
||||
Dans le chapitre suivant, nous allons introduire les **concepts fondamentaux des graphes** en informatique et voir comment ils peuvent être formalisés et analysés à l’aide de différents algorithmes.
|
||||
|
||||
-------
|
||||
|
||||
Auteur : Florian Mathieu
|
||||
|
||||
Licence CC BY NC
|
||||
|
||||
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.
|
||||
BIN
programmation/.DS_Store
vendored
Normal file
BIN
programmation/.DS_Store
vendored
Normal file
Binary file not shown.
144
programmation/GENERALITES.md
Normal file
144
programmation/GENERALITES.md
Normal file
@@ -0,0 +1,144 @@
|
||||
---
|
||||
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 Langages et 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é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.
|
||||
|
||||
___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
|
||||
|
||||
Tout langage est constitué de 2 ensembles :
|
||||
|
||||
```mermaid
|
||||
flowchart TD
|
||||
subgraph Langage
|
||||
Grammaire --> Vocabulaire
|
||||
end
|
||||
```
|
||||
|
||||
> __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 |
|
||||
| :--: | :--: | :--: |
|
||||
|  |  |  |
|
||||
|
||||
> __Algorithme__ (Selon Le Robert) : Ensemble fini des règles opératoires propres à un calcul. Ce terme vient d'__Al-Khwarizmi__, mathématicien du 9ème siècle.
|
||||
|
||||
|
||||
Source : Wikipedia
|
||||
|
||||
> Autrement dit, un __algorithme__ est une suite finie d'instructions exprimées en __langage naturel__.
|
||||
|
||||
Un __programme__ est l'_implantation_ 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.
|
||||
|
||||
|
||||
|
||||
Exemple : _Le calcul de l'hypoténuse dans un triangle rectangle_
|
||||
|
||||
__Algorithme__ : Dans un triangle rectangle, le carré de la longueur de l’hypoténuse est égal à la somme des carrés des longueurs des deux autres côtés.
|
||||
|
||||
__Implantation en Java__ :
|
||||
|
||||
```java
|
||||
class Hypotenuse
|
||||
{
|
||||
public static void main(String[] args)
|
||||
{
|
||||
double adjacent=4, oppose=3, hypotenuse;
|
||||
hypotenuse= Math.sqrt((adjacent*adjacent)+(oppose*oppose));
|
||||
System.out.println("La longueur de l'hypotenuse est : " + hypotenuse);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
__Implantation en Python__ :
|
||||
|
||||
```python
|
||||
import math
|
||||
|
||||
adjacent = 4
|
||||
opposite = 3
|
||||
hypotenuse = math.sqrt(adjacent**2 + opposite**2)
|
||||
print("La longueur de l'hypotenuse est :", hypotenuse)
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
## 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.
|
||||
193
programmation/NOTEBOOK.ipynb
Normal file
193
programmation/NOTEBOOK.ipynb
Normal file
File diff suppressed because one or more lines are too long
30
programmation/README.md
Normal file
30
programmation/README.md
Normal file
@@ -0,0 +1,30 @@
|
||||
# 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
|
||||
|
||||
| Section | Description |
|
||||
| -------------------------------------------------- | -------------------------------------------------- |
|
||||
| [Généralités sur la programmation](GENERALITES.md) | Introduction à la programmation |
|
||||
| [Python](NOTEBOOK.ipynb) | Introduction à Python |
|
||||
| [Variables](chapitre_1/README.md) | Exploration et utilisation des variables en Python |
|
||||
| [Structures conditionnelles](chapitre_2/README.md) | Apprendre les if, elif et else |
|
||||
| [Boucles](chapitre_3/README.md) | Comprendre les boucles while et for |
|
||||
| [Fonctions](chapitre_4/README.md) | Création et utilisation des fonctions en Python |
|
||||
|
||||
## Attendus du Programme
|
||||
|
||||
| Contenus | Capacités attendues |
|
||||
| ------------------------------------------------------------ | ------------------------------------------------------------ |
|
||||
| Constructions élémentaires | Mettre en évidence un corpus de constructions élémentaires. Séquences, affectation, conditionnelles, boucles bornées, boucles non bornées, appels de fonction. |
|
||||
| Diversité et unité des langages de programmation | Repérer, dans un nouveau langage de programmation, les traits communs et les traits particuliers à ce langage. |
|
||||
| Spécification | Prototyper une fonction. Décrire les préconditions sur les arguments. Décrire des postconditions sur les résultats.|
|
||||
| Mise au point de programmes | Utiliser des jeux de tests. |
|
||||
| Utilisation de bibliothèques | Utiliser la documentation d’une bibliothèque. |
|
||||
BIN
programmation/assets/CODE.png
Normal file
BIN
programmation/assets/CODE.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 6.3 KiB |
BIN
programmation/assets/OPEN.png
Normal file
BIN
programmation/assets/OPEN.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 5.2 KiB |
BIN
programmation/assets/REC.png
Normal file
BIN
programmation/assets/REC.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 4.9 KiB |
BIN
programmation/assets/RUN.png
Normal file
BIN
programmation/assets/RUN.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 6.9 KiB |
BIN
programmation/assets/al-khwarizmi.jpeg
Normal file
BIN
programmation/assets/al-khwarizmi.jpeg
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 16 KiB |
BIN
programmation/assets/cookie.jpeg
Normal file
BIN
programmation/assets/cookie.jpeg
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 656 KiB |
BIN
programmation/assets/diagramme.png
Normal file
BIN
programmation/assets/diagramme.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 23 KiB |
BIN
programmation/assets/ikea.jpeg
Normal file
BIN
programmation/assets/ikea.jpeg
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 324 KiB |
BIN
programmation/assets/interface_bashton.png
Normal file
BIN
programmation/assets/interface_bashton.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 831 KiB |
BIN
programmation/assets/interface_bashton_2.png
Normal file
BIN
programmation/assets/interface_bashton_2.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 71 KiB |
BIN
programmation/assets/mappy.png
Normal file
BIN
programmation/assets/mappy.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.0 MiB |
19
programmation/chapitre_1/README.md
Normal file
19
programmation/chapitre_1/README.md
Normal file
@@ -0,0 +1,19 @@
|
||||
# Les variables
|
||||
|
||||
L'activité consiste en un TD comprenant un __cours dirigé__ et des __exercices__ relatifs à la notion de _variable_ en Python.
|
||||
|
||||
## Pré-requis
|
||||
|
||||
Avoir pris en main l'éditeur en ligne [Basthon](../NOTEBOOK.ipynb)
|
||||
|
||||
## Consignes
|
||||
|
||||
1. Télécharger le fichier [TD.ipynb](./TD.ipynb),
|
||||
2. Se rendre sur [Basthon](https://notebook.basthon.fr/),
|
||||
3. Ouvrir le fichier TD.ipynb téléchargé,
|
||||
4. Suivre le déroulé du TD, les réponses sont à mettre directement dans votre fichier,
|
||||
5. À la fin de la séance, n'oubliez pas de sauvegarder votre fichier sur votre clé USB ou espace personnel.
|
||||
|
||||
## Pour aller plus loin
|
||||
|
||||
Une fois le TD __fini__ et __validé__, vous pouvez effectuer l'[activité suivante](../chapitre_2/)
|
||||
842
programmation/chapitre_1/TD.ipynb
Normal file
842
programmation/chapitre_1/TD.ipynb
Normal file
@@ -0,0 +1,842 @@
|
||||
{
|
||||
"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",
|
||||
"<type 'int'>\n",
|
||||
"```\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 5.3. Type flottant (float)\n",
|
||||
"\n",
|
||||
"Pour affecter (on dit aussi assigner) la valeur 1,70 à la variable nommée `taille`\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> taille = 1.7\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"La fonction `print` affiche la valeur de la variable :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> print(taille)\n",
|
||||
"1.7\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"La fonction `type` renvoie le type de la variable :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> type (taille)\n",
|
||||
"<type 'float'>\n",
|
||||
"```\n",
|
||||
"La notation scientifique est acceptée :\n",
|
||||
"```python\n",
|
||||
">>> taille = 1.7e2 #taille en cm où 1m = 100cm = 10**2cm\n",
|
||||
">>> print (taille)\n",
|
||||
"170.0\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 5.4. Type chaine de caractères (str)\n",
|
||||
"\n",
|
||||
"Pour affecter (on dit aussi assigner) la valeur `lundi` à la variable nommée `jour`\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> jour = 'lundi' # autre possibilité jour = \"lundi\"\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"La valeur doit être entre guillemet simple (autrement dit côte) ou guillemet double.\n",
|
||||
"\n",
|
||||
"La fonction `print` affiche la valeur de la variable :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> print(jour)\n",
|
||||
"lundi\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> mois = \"septembre\"\n",
|
||||
">>> print (jour, mois) # print permet d'afficher plusieurs valeurs à la suite, ne pas oublier la virgule\n",
|
||||
"lundi septembre\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"La fonction `type` renvoie le type de la variable :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> type (jour)\n",
|
||||
"<type 'str'>\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"La fonction `len` renvoie la longueur (length) de la chaîne de caractères :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> print(len(jour))\n",
|
||||
"4\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 5.4.1 À 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 5.4.1\n",
|
||||
"\n",
|
||||
"Comme vous le voyez, on peut ajouter deux chaînes : c'est une ___concaténation___, la mise bout à bout de plusieurs chaînes de caractères."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 5.4.2 À Faire\n",
|
||||
"\n",
|
||||
"Copier et exécuter les instructions suivantes\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> mot = \"lycée\"\n",
|
||||
">>> print(mot[0])\n",
|
||||
"???\n",
|
||||
">>> print(mot[1])\n",
|
||||
"???\n",
|
||||
">>> print(mot[1:4])\n",
|
||||
"???\n",
|
||||
">>> print(mot[2:])\n",
|
||||
"???\n",
|
||||
">>> print(mot[:2])\n",
|
||||
"???\n",
|
||||
">>> print(mot[-1])\n",
|
||||
"???\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Bilan 5.4.2\n",
|
||||
"\n",
|
||||
"Selon les résultats obtenus, que permet d'obtenir l'utilisation des crochets sur une variable de type chaine de caractères :\n",
|
||||
"\n",
|
||||
"- variable[indice] : ???\n",
|
||||
"- variable[indice1:indice2] : ???\n",
|
||||
"- variable[indice:] : ???\n",
|
||||
"- variable[:indice] : ???\n",
|
||||
"- variable[-1] : ???\n",
|
||||
"\n",
|
||||
"Par convention, on appelle _indice_ les valeurs entre crochets."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 5.5 Conversion de type\n",
|
||||
"\n",
|
||||
"Cependant, on ne peut pas ajouter n'importe quoi.\n",
|
||||
"\n",
|
||||
"Copier et exécuter les instructions suivantes :\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": [
|
||||
"## 6. Les fonctions mathématiques\n",
|
||||
"\n",
|
||||
"Pour utiliser les fonctions mathématiques, il faut commencer par importer le module math :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> import math\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"La fonction `dir` renvoie la liste des fonctions et données d'un module :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> dir(math)\n",
|
||||
"['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan',\n",
|
||||
"'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf',\n",
|
||||
"'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum',\n",
|
||||
"'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p',\n",
|
||||
"'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Pour appeler une fonction d'un module, la syntaxe est la suivante : `module.fonction(arguments)`\n",
|
||||
"\n",
|
||||
"Exemple :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> math.sqrt(9)\n",
|
||||
"3.0\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"La fonction `help` affiche l'aide, c'est-à-dire ce que fait la fonction\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> help(sqrt)\n",
|
||||
"Help on built-in function sqrt in module math:\n",
|
||||
"\n",
|
||||
"sqrt(x, /)\n",
|
||||
" Return the square root of x.\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 7. Saisie utilisateur : fonction `input`\n",
|
||||
"\n",
|
||||
"Copier et exécuter l'instruction suivante :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> input(\"As-tu un message ? \")\n",
|
||||
"???\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Bilan : La fonction `input` permet d'obtenir une valeur saisie par l'utilisateur.\n",
|
||||
"\n",
|
||||
"___N.B : La valeur saisie est toujours du <type 'str'>___"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 6. Exercices"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 1\n",
|
||||
"\n",
|
||||
"L’indice de masse corporelle (IMC) est le seul indice validé par l’Organisation mondiale de la santé pour évaluer les éventuels risques pour la santé.\n",
|
||||
"\n",
|
||||
"Il s'exprime par la formule `IMC = poids (kg) / taille (m²)`\n",
|
||||
"\n",
|
||||
"Je mesure 170cm pour un poids de 3/4 de quintal. \n",
|
||||
"\n",
|
||||
"1. Exprimer les différentes données sous forme de variables et l'expression permettant de calculer l'IMC.\n",
|
||||
"2. Donner les instructions permettant de donner les types des différentes variables et du résultat obtenu."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 2\n",
|
||||
"\n",
|
||||
"Afficher la taille en octets et en bits d'un fichier de 536 kio.\n",
|
||||
"\n",
|
||||
"On donne : \n",
|
||||
"\n",
|
||||
"- 1 kio (1 kibi octet) = 1024 octets !!!\n",
|
||||
"- 1 octet = 8 bits"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 3\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 4\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 5\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": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 6\n",
|
||||
"\n",
|
||||
"À partir de deux variables `prenom` et `nom`, afficher les initiales (par exemple LM pour Léa Martin)."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 7\n",
|
||||
"\n",
|
||||
"L'identifiant d'accès au réseau du lycée est construit de la manière suivante : initiale du prénom puis les 8 premiers caractères du nom.\n",
|
||||
"\n",
|
||||
"Exemple : Alexandre Lecouturier → alecoutur\n",
|
||||
"\n",
|
||||
"A partir des deux variables `prenom` et `nom`, construire l'identifiant."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 8\n",
|
||||
"\n",
|
||||
"Écrire un programme qui donne la pointure du pied demandé à l'utilisateur et affiche la taille du pied sachant qu'en France, la pointure correspond à 3/2 de la longueur du pied exprimée en centimètres et à laquelle on a au préalable ajouté un centimètre. (Vous pouvez vérifier votre résultat via ce [site](https://2-grande-taille.com/conversion-pointures)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 9\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"Écrire un programme qui demande 2 entiers sous la forme \"a, h\" où a et h sont des nombres à 1 seule chiffre représentant respectivement la base et la hauteur d'une triangle rectangle. Afficher l'aire du triangle."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 10\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"Écrire un programme qui demande 3 entiers sous la forme \"a, b, c\" où a, b et c sont des nombres à 1 seule chiffre et calculer l'aire du triangle quelconque formés par ces 3 longueurs.\n",
|
||||
"\n",
|
||||
"__N.B : Le calcul de l'aire d'un triangle quelconque s'effectue par l'application de la formule du Héron.__"
|
||||
]
|
||||
},
|
||||
{
|
||||
"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.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
519
programmation/chapitre_2/.ipynb_checkpoints/TD-checkpoint.ipynb
Normal file
519
programmation/chapitre_2/.ipynb_checkpoints/TD-checkpoint.ipynb
Normal file
@@ -0,0 +1,519 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# TD - Les instructions conditionnelles\n",
|
||||
"\n",
|
||||
"> « _Si j'aurais su, j'aurais pas venu_ », réplique du Petit Gibus dans le film \"La Guerre des boutons\" d'Yves Robert."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 1. Définition\n",
|
||||
"\n",
|
||||
"> 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.\n",
|
||||
"\n",
|
||||
"En reprenant (et corrigeant) la citation du Petit Gibus, l'instruction conditionnelle devient « _Si j'avais su alors je ne serais pas venu_ ».\n",
|
||||
"\n",
|
||||
"> Une __condition__ est une instruction qui est soit vraie, soit fausse. On parle alors d’une _instruction booléenne_ ou _variable booléenne_.\n",
|
||||
"\n",
|
||||
"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."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 2. Comparaisons de variables\n",
|
||||
"\n",
|
||||
"Les opérateurs de comparaisons sont :\n",
|
||||
"\n",
|
||||
"- `<` : inférieur\n",
|
||||
"- `<=` : inférieur ou égal\n",
|
||||
"- `>`: supérieur\n",
|
||||
"- `>=`: supérieur ou égal\n",
|
||||
"- `==` : est égal à\n",
|
||||
"- `!=`: est différents de\n",
|
||||
"\n",
|
||||
"Le résultat d'une comparaison est toujours un booléen\n",
|
||||
"\n",
|
||||
"- `True` si la comparaison est vraie\n",
|
||||
"- `False` si la comparaison est Fausse\n",
|
||||
"\n",
|
||||
"Remarque : on ne peut comparer que des objets comparables\n",
|
||||
"\n",
|
||||
"⚠ ___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."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 2.1 À faire\n",
|
||||
"\n",
|
||||
"1. Déterminer (sans les exécuter) chaque instruction ci-dessous :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> a = 5\n",
|
||||
">>> b = 18 \n",
|
||||
">>> c = 12.3\n",
|
||||
">>> mot1 = \"Hello\"\n",
|
||||
">>> mot2 = \"World\"\n",
|
||||
"# \n",
|
||||
">>> print(a > b)\n",
|
||||
"#\n",
|
||||
">>> print(b // a == 3)\n",
|
||||
"#\n",
|
||||
">>> print(b % a == 3)\n",
|
||||
"#\n",
|
||||
">>> print(a - b > 2)\n",
|
||||
"#\n",
|
||||
">>> print(type(c) == float)\n",
|
||||
"#\n",
|
||||
">>> print(mot1 != mot2)\n",
|
||||
"#\n",
|
||||
">>> print(mot1 < mot2)\n",
|
||||
"#\n",
|
||||
">>> print(mot1 > 2)\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"2. Vérifier les résultats attendus avec les résultats constatés"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Dans une suite d'instructions on est souvent amené à faire des choix.\n",
|
||||
"\n",
|
||||
"## 3. Cas : Si...Alors\n",
|
||||
"\n",
|
||||
"**Si** une ou plusieurs conditions sont réalisées **Alors** on exécute une ou plusieurs instructions\n",
|
||||
"\n",
|
||||
"La structure en Python : On __indente__ (une tabulation) les instructions qui doivent s'exécuter si la condition est vérifiée\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
"if condition :\n",
|
||||
" instruction1\n",
|
||||
" instruction2\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Exemple qui affiche si les variables `a` et `b` sont des entiers pairs\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"a = 12\n",
|
||||
"if a % 2 == 0:\n",
|
||||
" print(a, \" est un entier pair\")\n",
|
||||
" \n",
|
||||
"b = 13\n",
|
||||
"if b % 2 == 0:\n",
|
||||
" print(b,\" est un entier pair\")\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 4. Cas : Si ...Alors...Sinon\n",
|
||||
"\n",
|
||||
"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.\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
" if condition:\n",
|
||||
" instruction1\n",
|
||||
" instruction2\n",
|
||||
" else:\n",
|
||||
" instruction3\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Exemple :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"a = 12\n",
|
||||
"\n",
|
||||
"if a % 2 == 0:\n",
|
||||
" print(a, \" est un entier pair\")\n",
|
||||
"else:\n",
|
||||
" print(a,\" est un entier impair\")\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"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",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### À Faire\n",
|
||||
"\n",
|
||||
"Soit l'algorithme qui détermine la réponse de Yoda en fonction de la taille qui lui est communiquée :\n",
|
||||
"\n",
|
||||
"```txt\n",
|
||||
" Demander la taille\n",
|
||||
" Si la taille est supérieure à 1m80 alors\n",
|
||||
"\tla réponse est 'Maître, vous vous prenez pour Chewbacca'\n",
|
||||
" Sinon si la taille est supérieure à 1m20 alors\n",
|
||||
" la réponse est 'Maitre, vous vous prenez pour Luc Skywalker'\n",
|
||||
" Sinon si la taille est supérieure à 0.80m alors\n",
|
||||
" la réponse est \"Maitre, ce n'est pas la taille qui compte\"\n",
|
||||
" Sinon la réponse est 'Maitre, vous vous sous-estimez'\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Compléter le code suivant pour qu'il implante l'algorithme ci-dessus :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"taille = input('Combien mesures-tu ?')\n",
|
||||
"...\n",
|
||||
"print(reponse)\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Exercices"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 1\n",
|
||||
"\n",
|
||||
"L’indice de masse corporelle (IMC) est le seul indice validé par l’Organisation mondiale de la santé pour évaluer la corpulence d’un individu et donc les éventuels risques pour la santé.\n",
|
||||
"\n",
|
||||
"La formule de calcul a été vu lors de l'activité 1 sur les variables.\n",
|
||||
"\n",
|
||||
"L'OMS fournit l'interprétation suivante de l'état de santé en fonction de l'IMC :\n",
|
||||
"\n",
|
||||
"| Indice de masse corporelle (IMC) | Interprétation (d'après l'OMS) | \n",
|
||||
"| :--: | :--: |\n",
|
||||
"| moins de 18,5\t| Insuffisance pondérale (maigreur) |\n",
|
||||
"| 18,5 à 25 |\tCorpulence normale |\n",
|
||||
"| 25 à 30 | Surpoids |\n",
|
||||
"| 30 à 35 | Obésité modérée |\n",
|
||||
"| 35 à 40 | Obésité sévère |\n",
|
||||
"| plus de 40\t| Obésité morbide ou massive |\n",
|
||||
"\n",
|
||||
"Voici une liste de caractéristiques de célébrités anonymisées (i.e le nom a été changé par décence). \n",
|
||||
"\n",
|
||||
"| Célébrité | Taille (en cm) | Poids (en kg) | Interprétation |\n",
|
||||
"| :--: | :--: | :--: | :--: |\n",
|
||||
"| B | 169 | 56 | |\n",
|
||||
"| E | 157 | 48 | |\n",
|
||||
"| A | 175 | 90 | |\n",
|
||||
"| M | 205 | 200 | |\n",
|
||||
"| V | 163 | 42 | |\n",
|
||||
"| P | 170 | 75 | |\n",
|
||||
"| S | 191 | 113 | |\n",
|
||||
"\n",
|
||||
"1. Écrire un programme qui permet d'afficher l'état de santé en fonction de l'IMC, selon l'OMS, en utilisant des instructions conditionnelles.\n",
|
||||
"\n",
|
||||
"2. Compléter le tableau en fonction de vos résultats."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 2\n",
|
||||
"\n",
|
||||
"1. Écrire un programme qui demande 3 entiers de manières consécutives et affiche le minimum des 3 entiers\n",
|
||||
"2. Écrire un programme qui demande 3 entiers de manières consécutives et affiche le maximum des 3 entiers"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 3\n",
|
||||
"\n",
|
||||
"Écrire un programme pour vérifier si un nombre saisi par un utilisateur est divisible par 3 et 13 ou non,"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 4\n",
|
||||
"\n",
|
||||
"Écrire un programme pour vérifier si un caractère saisi par l'utilisateur est une voyelle ou une consonne."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 5\n",
|
||||
"\n",
|
||||
"Écrire un programme pour entrer le numéro du jour de la semaine (1-7) et affiche le nom du jour de la semaine correspondant"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 6\n",
|
||||
"\n",
|
||||
"Modifier le code suivant pour qu'il y ait 4 couleurs différentes en fonction de la position(abscisse) de la souris\n",
|
||||
"\n",
|
||||
"**mouseX** renvoie l'abscisse de la souris (0 pour le coin supérieur gauche de la fenêtre)\n",
|
||||
"\n",
|
||||
"( 0 à 50 , 50 à 100, 100 à 150 et 150 à 200)\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"from p5 import *\n",
|
||||
"\n",
|
||||
"def setup():\n",
|
||||
" createCanvas(200,200) # crée une fenêtre de 200 x 200 pixels\n",
|
||||
"\n",
|
||||
"def draw():# cette fonction s'exécute en boucle 60 fois par seconde...\n",
|
||||
" # les conditions pour la couleur du fond d'écran\n",
|
||||
" if mouseX > 0 and mouseX < 100: # teste la position (abscisse) de la souris sur la moité gauche (0 à 100)\n",
|
||||
" background(255,120,0) # \n",
|
||||
" elif mouseX > 100 and mouseX < 200:# teste la position (abscisse) de la souris sur la moité droite (100 à 200)\n",
|
||||
" background(0,255,120) #\n",
|
||||
" else:\n",
|
||||
" background(0,0,255) # fond bleu\n",
|
||||
"run()\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 7\n",
|
||||
"\n",
|
||||
"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:\n",
|
||||
"\n",
|
||||
"- 0 < mouseX <100 et 0 < mouseY < 100, la couleur affichée doit être le bleu\n",
|
||||
"- 100 < mouseX < 200 et 0 < mouseY < 100, la couleur affichée doit être le vert\n",
|
||||
"- 0 < mouseX < 100 et 100 < mouseY < 200, la couleur affichée doit être le rouge\n",
|
||||
"- 100 < mouseX < 200 et 100 < mouseY < 200, la couleur affichée doit être le jaune"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 8\n",
|
||||
"\n",
|
||||
"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.\n",
|
||||
"\n",
|
||||
"- l'instruction **circle(50,50,40)** dessine un cercle de centre (50,50 ) et de diamètre 40.\n",
|
||||
"- l'instruction **dist(x1,y1,x2,y2)** calcule la distance entre les points de coordonnées (x1,y1) et (x2,y2).\n",
|
||||
"- **dist(mouseX,mouseY,50,50) < 20** teste si la souris est dans l'un des cercles.\n",
|
||||
"\n",
|
||||
"Compléter le code de façon que le fond change de couleur au survol des 4 cercles.\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"from p5 import *\n",
|
||||
"\n",
|
||||
"def setup():\n",
|
||||
" createCanvas(200,200) # crée une fenêtre de 200 x 200 pixels\n",
|
||||
"\n",
|
||||
"def draw():# cette fonction s'exécute en boucle 60 fois par seconde...\n",
|
||||
" if dist(mouseX,mouseY,50,50) < 20:\n",
|
||||
" background(255,255,0)\n",
|
||||
" # à modifier ici\n",
|
||||
" else:\n",
|
||||
" background(51,51,51)\n",
|
||||
" # ne pas modifier...\n",
|
||||
" fill(0,0,0)\n",
|
||||
" circle(50,50,40)\n",
|
||||
" circle(150,150,40)\n",
|
||||
" circle(150,50,40)\n",
|
||||
" circle(50,150,40)\n",
|
||||
" \n",
|
||||
"run()\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 9\n",
|
||||
"\n",
|
||||
"Le code ci-dessous montre \"une balle\" se déplaçant sur un axe horizontal dans une fenêtre en rebondissant sur les bords.\n",
|
||||
"\n",
|
||||
"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.\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"from p5 import *\n",
|
||||
"\n",
|
||||
"def setup():\n",
|
||||
" global bx,by,vx,vy,r\n",
|
||||
" r = 20\n",
|
||||
" bx = 50\n",
|
||||
" by = 50\n",
|
||||
" vx = 4\n",
|
||||
" vy = 5\n",
|
||||
" createCanvas(400,200) # crée une fenêtre de 200 x 200 pixels\n",
|
||||
"\n",
|
||||
"def draw():# cette fonction s'exécute en boucle 60 fois par seconde...\n",
|
||||
" global bx,by,vx,vy,r\n",
|
||||
" background(0,0,0)# fond noir\n",
|
||||
" # mouvement du cercle sur l'axe horizontal\n",
|
||||
" bx = bx + vx\n",
|
||||
" # rebond sur les bords gauche et droit\n",
|
||||
" if bx < r or bx > 400 - r:\n",
|
||||
" vx = -vx\n",
|
||||
" # dessin du cercle\n",
|
||||
" fill(255,0,0)\n",
|
||||
" circle(bx,by,2*r) \n",
|
||||
" \n",
|
||||
"run()\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 10\n",
|
||||
"\n",
|
||||
"Reprendre le code précédent et faire en sorte que la \"balle\" change de couleur à chaque rebond\n",
|
||||
"\n",
|
||||
"Pour utiliser une couleur aléatoire, on pourra utiliser l'instruction: `fill(random(255),random(255),random(255))`"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"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.8.8"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
19
programmation/chapitre_2/README.md
Normal file
19
programmation/chapitre_2/README.md
Normal file
@@ -0,0 +1,19 @@
|
||||
# Les instructions conditionnelles
|
||||
|
||||
L'activité consiste en un TD comprenant un __cours dirigé__ et des __exercices__ relatifs à la notion d'_instructions conditionnelles_ en Python.
|
||||
|
||||
## Pré-requis
|
||||
|
||||
Avoir effectué l'activité sur les [variables](../chapitre_1/)
|
||||
|
||||
## Consignes
|
||||
|
||||
1. Télécharger le fichier [TD.ipynb](./TD.ipynb),
|
||||
2. Se rendre sur [Basthon](https://notebook.basthon.fr/),
|
||||
3. Ouvrir le fichier TD.ipynb téléchargé,
|
||||
4. Suivre le déroulé du TD, les réponses sont à mettre directement dans votre fichier,
|
||||
5. À la fin de la séance, n'oubliez pas de sauvegarder votre fichier sur votre clé USB ou espace personnel.
|
||||
|
||||
## Pour aller plus loin
|
||||
|
||||
Une fois le TD __fini__ et __validé__, vous pouvez effectuer l'[activité suivante](../chapitre_3/)
|
||||
519
programmation/chapitre_2/TD.ipynb
Normal file
519
programmation/chapitre_2/TD.ipynb
Normal file
@@ -0,0 +1,519 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# TD - Les instructions conditionnelles\n",
|
||||
"\n",
|
||||
"> « _Si j'aurais su, j'aurais pas venu_ », réplique du Petit Gibus dans le film \"La Guerre des boutons\" d'Yves Robert."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 1. Définition\n",
|
||||
"\n",
|
||||
"> 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.\n",
|
||||
"\n",
|
||||
"En reprenant (et corrigeant) la citation du Petit Gibus, l'instruction conditionnelle devient « _Si j'avais su alors je ne serais pas venu_ ».\n",
|
||||
"\n",
|
||||
"> Une __condition__ est une instruction qui est soit vraie, soit fausse. On parle alors d’une _instruction booléenne_ ou _variable booléenne_.\n",
|
||||
"\n",
|
||||
"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."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 2. Comparaisons de variables\n",
|
||||
"\n",
|
||||
"Les opérateurs de comparaisons sont :\n",
|
||||
"\n",
|
||||
"- `<` : inférieur\n",
|
||||
"- `<=` : inférieur ou égal\n",
|
||||
"- `>`: supérieur\n",
|
||||
"- `>=`: supérieur ou égal\n",
|
||||
"- `==` : est égal à\n",
|
||||
"- `!=`: est différents de\n",
|
||||
"\n",
|
||||
"Le résultat d'une comparaison est toujours un booléen\n",
|
||||
"\n",
|
||||
"- `True` si la comparaison est vraie\n",
|
||||
"- `False` si la comparaison est Fausse\n",
|
||||
"\n",
|
||||
"Remarque : on ne peut comparer que des objets comparables\n",
|
||||
"\n",
|
||||
"⚠ ___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."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 2.1 À faire\n",
|
||||
"\n",
|
||||
"1. Déterminer (sans les exécuter) chaque instruction ci-dessous :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
">>> a = 5\n",
|
||||
">>> b = 18 \n",
|
||||
">>> c = 12.3\n",
|
||||
">>> mot1 = \"Hello\"\n",
|
||||
">>> mot2 = \"World\"\n",
|
||||
"# \n",
|
||||
">>> print(a > b)\n",
|
||||
"#\n",
|
||||
">>> print(b // a == 3)\n",
|
||||
"#\n",
|
||||
">>> print(b % a == 3)\n",
|
||||
"#\n",
|
||||
">>> print(a - b > 2)\n",
|
||||
"#\n",
|
||||
">>> print(type(c) == float)\n",
|
||||
"#\n",
|
||||
">>> print(mot1 != mot2)\n",
|
||||
"#\n",
|
||||
">>> print(mot1 < mot2)\n",
|
||||
"#\n",
|
||||
">>> print(mot1 > 2)\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"2. Vérifier les résultats attendus avec les résultats constatés"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Dans une suite d'instructions on est souvent amené à faire des choix.\n",
|
||||
"\n",
|
||||
"## 3. Cas : Si...Alors\n",
|
||||
"\n",
|
||||
"**Si** une ou plusieurs conditions sont réalisées **Alors** on exécute une ou plusieurs instructions\n",
|
||||
"\n",
|
||||
"La structure en Python : On __indente__ (une tabulation) les instructions qui doivent s'exécuter si la condition est vérifiée\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
"if condition :\n",
|
||||
" instruction1\n",
|
||||
" instruction2\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Exemple qui affiche si les variables `a` et `b` sont des entiers pairs\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"a = 12\n",
|
||||
"if a % 2 == 0:\n",
|
||||
" print(a, \" est un entier pair\")\n",
|
||||
" \n",
|
||||
"b = 13\n",
|
||||
"if b % 2 == 0:\n",
|
||||
" print(b,\" est un entier pair\")\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 4. Cas : Si ...Alors...Sinon\n",
|
||||
"\n",
|
||||
"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.\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
" if condition:\n",
|
||||
" instruction1\n",
|
||||
" instruction2\n",
|
||||
" else:\n",
|
||||
" instruction3\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Exemple :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"a = 12\n",
|
||||
"\n",
|
||||
"if a % 2 == 0:\n",
|
||||
" print(a, \" est un entier pair\")\n",
|
||||
"else:\n",
|
||||
" print(a,\" est un entier impair\")\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"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",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### À Faire\n",
|
||||
"\n",
|
||||
"Soit l'algorithme qui détermine la réponse de Yoda en fonction de la taille qui lui est communiquée :\n",
|
||||
"\n",
|
||||
"```txt\n",
|
||||
" Demander la taille\n",
|
||||
" Si la taille est supérieure à 1m80 alors\n",
|
||||
"\tla réponse est 'Maître, vous vous prenez pour Chewbacca'\n",
|
||||
" Sinon si la taille est supérieure à 1m20 alors\n",
|
||||
" la réponse est 'Maitre, vous vous prenez pour Luc Skywalker'\n",
|
||||
" Sinon si la taille est supérieure à 0.80m alors\n",
|
||||
" la réponse est \"Maitre, ce n'est pas la taille qui compte\"\n",
|
||||
" Sinon la réponse est 'Maitre, vous vous sous-estimez'\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Compléter le code suivant pour qu'il implante l'algorithme ci-dessus :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"taille = input('Combien mesures-tu ?')\n",
|
||||
"...\n",
|
||||
"print(reponse)\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Exercices"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 1\n",
|
||||
"\n",
|
||||
"L’indice de masse corporelle (IMC) est le seul indice validé par l’Organisation mondiale de la santé pour évaluer la corpulence d’un individu et donc les éventuels risques pour la santé.\n",
|
||||
"\n",
|
||||
"La formule de calcul a été vu lors de l'activité 1 sur les variables.\n",
|
||||
"\n",
|
||||
"L'OMS fournit l'interprétation suivante de l'état de santé en fonction de l'IMC :\n",
|
||||
"\n",
|
||||
"| Indice de masse corporelle (IMC) | Interprétation (d'après l'OMS) | \n",
|
||||
"| :--: | :--: |\n",
|
||||
"| moins de 18,5\t| Insuffisance pondérale (maigreur) |\n",
|
||||
"| 18,5 à 25 |\tCorpulence normale |\n",
|
||||
"| 25 à 30 | Surpoids |\n",
|
||||
"| 30 à 35 | Obésité modérée |\n",
|
||||
"| 35 à 40 | Obésité sévère |\n",
|
||||
"| plus de 40\t| Obésité morbide ou massive |\n",
|
||||
"\n",
|
||||
"Voici une liste de caractéristiques de célébrités anonymisées (i.e le nom a été changé par décence). \n",
|
||||
"\n",
|
||||
"| Célébrité | Taille (en cm) | Poids (en kg) | Interprétation |\n",
|
||||
"| :--: | :--: | :--: | :--: |\n",
|
||||
"| B | 169 | 56 | |\n",
|
||||
"| E | 157 | 48 | |\n",
|
||||
"| A | 175 | 90 | |\n",
|
||||
"| M | 205 | 200 | |\n",
|
||||
"| V | 163 | 42 | |\n",
|
||||
"| P | 170 | 75 | |\n",
|
||||
"| S | 191 | 113 | |\n",
|
||||
"\n",
|
||||
"1. Écrire un programme qui permet d'afficher l'état de santé en fonction de l'IMC, selon l'OMS, en utilisant des instructions conditionnelles.\n",
|
||||
"\n",
|
||||
"2. Compléter le tableau en fonction de vos résultats."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 2\n",
|
||||
"\n",
|
||||
"1. Écrire un programme qui demande 3 entiers de manières consécutives et affiche le minimum des 3 entiers\n",
|
||||
"2. Écrire un programme qui demande 3 entiers de manières consécutives et affiche le maximum des 3 entiers"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 3\n",
|
||||
"\n",
|
||||
"Écrire un programme pour vérifier si un nombre saisi par un utilisateur est divisible par 3 et 13 ou non,"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 4\n",
|
||||
"\n",
|
||||
"Écrire un programme pour vérifier si un caractère saisi par l'utilisateur est une voyelle ou une consonne."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 5\n",
|
||||
"\n",
|
||||
"Écrire un programme pour entrer le numéro du jour de la semaine (1-7) et affiche le nom du jour de la semaine correspondant"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 6\n",
|
||||
"\n",
|
||||
"Modifier le code suivant pour qu'il y ait 4 couleurs différentes en fonction de la position(abscisse) de la souris\n",
|
||||
"\n",
|
||||
"**mouseX** renvoie l'abscisse de la souris (0 pour le coin supérieur gauche de la fenêtre)\n",
|
||||
"\n",
|
||||
"( 0 à 50 , 50 à 100, 100 à 150 et 150 à 200)\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"from p5 import *\n",
|
||||
"\n",
|
||||
"def setup():\n",
|
||||
" createCanvas(200,200) # crée une fenêtre de 200 x 200 pixels\n",
|
||||
"\n",
|
||||
"def draw():# cette fonction s'exécute en boucle 60 fois par seconde...\n",
|
||||
" # les conditions pour la couleur du fond d'écran\n",
|
||||
" if mouseX > 0 and mouseX < 100: # teste la position (abscisse) de la souris sur la moité gauche (0 à 100)\n",
|
||||
" background(255,120,0) # \n",
|
||||
" elif mouseX > 100 and mouseX < 200:# teste la position (abscisse) de la souris sur la moité droite (100 à 200)\n",
|
||||
" background(0,255,120) #\n",
|
||||
" else:\n",
|
||||
" background(0,0,255) # fond bleu\n",
|
||||
"run()\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 7\n",
|
||||
"\n",
|
||||
"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:\n",
|
||||
"\n",
|
||||
"- 0 < mouseX <100 et 0 < mouseY < 100, la couleur affichée doit être le bleu\n",
|
||||
"- 100 < mouseX < 200 et 0 < mouseY < 100, la couleur affichée doit être le vert\n",
|
||||
"- 0 < mouseX < 100 et 100 < mouseY < 200, la couleur affichée doit être le rouge\n",
|
||||
"- 100 < mouseX < 200 et 100 < mouseY < 200, la couleur affichée doit être le jaune"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 8\n",
|
||||
"\n",
|
||||
"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.\n",
|
||||
"\n",
|
||||
"- l'instruction **circle(50,50,40)** dessine un cercle de centre (50,50 ) et de diamètre 40.\n",
|
||||
"- l'instruction **dist(x1,y1,x2,y2)** calcule la distance entre les points de coordonnées (x1,y1) et (x2,y2).\n",
|
||||
"- **dist(mouseX,mouseY,50,50) < 20** teste si la souris est dans l'un des cercles.\n",
|
||||
"\n",
|
||||
"Compléter le code de façon que le fond change de couleur au survol des 4 cercles.\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"from p5 import *\n",
|
||||
"\n",
|
||||
"def setup():\n",
|
||||
" createCanvas(200,200) # crée une fenêtre de 200 x 200 pixels\n",
|
||||
"\n",
|
||||
"def draw():# cette fonction s'exécute en boucle 60 fois par seconde...\n",
|
||||
" if dist(mouseX,mouseY,50,50) < 20:\n",
|
||||
" background(255,255,0)\n",
|
||||
" # à modifier ici\n",
|
||||
" else:\n",
|
||||
" background(51,51,51)\n",
|
||||
" # ne pas modifier...\n",
|
||||
" fill(0,0,0)\n",
|
||||
" circle(50,50,40)\n",
|
||||
" circle(150,150,40)\n",
|
||||
" circle(150,50,40)\n",
|
||||
" circle(50,150,40)\n",
|
||||
" \n",
|
||||
"run()\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 9\n",
|
||||
"\n",
|
||||
"Le code ci-dessous montre \"une balle\" se déplaçant sur un axe horizontal dans une fenêtre en rebondissant sur les bords.\n",
|
||||
"\n",
|
||||
"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.\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"from p5 import *\n",
|
||||
"\n",
|
||||
"def setup():\n",
|
||||
" global bx,by,vx,vy,r\n",
|
||||
" r = 20\n",
|
||||
" bx = 50\n",
|
||||
" by = 50\n",
|
||||
" vx = 4\n",
|
||||
" vy = 5\n",
|
||||
" createCanvas(400,200) # crée une fenêtre de 200 x 200 pixels\n",
|
||||
"\n",
|
||||
"def draw():# cette fonction s'exécute en boucle 60 fois par seconde...\n",
|
||||
" global bx,by,vx,vy,r\n",
|
||||
" background(0,0,0)# fond noir\n",
|
||||
" # mouvement du cercle sur l'axe horizontal\n",
|
||||
" bx = bx + vx\n",
|
||||
" # rebond sur les bords gauche et droit\n",
|
||||
" if bx < r or bx > 400 - r:\n",
|
||||
" vx = -vx\n",
|
||||
" # dessin du cercle\n",
|
||||
" fill(255,0,0)\n",
|
||||
" circle(bx,by,2*r) \n",
|
||||
" \n",
|
||||
"run()\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 10\n",
|
||||
"\n",
|
||||
"Reprendre le code précédent et faire en sorte que la \"balle\" change de couleur à chaque rebond\n",
|
||||
"\n",
|
||||
"Pour utiliser une couleur aléatoire, on pourra utiliser l'instruction: `fill(random(255),random(255),random(255))`"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"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.8.8"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
19
programmation/chapitre_3/README.md
Normal file
19
programmation/chapitre_3/README.md
Normal file
@@ -0,0 +1,19 @@
|
||||
# Les boucles
|
||||
|
||||
L'activité consiste en un TD comprenant un __cours dirigé__ et des __exercices__ relatifs à la notion de _boucles_ en Python.
|
||||
|
||||
## Pré-requis
|
||||
|
||||
Avoir effectué l'activité sur les [instructions conditionnelles](../chapitre_2/)
|
||||
|
||||
## Consignes
|
||||
|
||||
1. Télécharger le fichier [TD.ipynb](./TD.ipynb),
|
||||
2. Se rendre sur [Basthon](https://notebook.basthon.fr/),
|
||||
3. Ouvrir le fichier TD.ipynb téléchargé,
|
||||
4. Suivre le déroulé du TD, les réponses sont à mettre directement dans votre fichier,
|
||||
5. À la fin de la séance, n'oubliez pas de sauvegarder votre fichier sur votre clé USB ou espace personnel.
|
||||
|
||||
## Pour aller plus loin
|
||||
|
||||
Une fois le TD __fini__ et __validé__, vous pouvez effectuer l'[activité suivante](../chapitre_4/)
|
||||
734
programmation/chapitre_3/TD.ipynb
Normal file
734
programmation/chapitre_3/TD.ipynb
Normal file
@@ -0,0 +1,734 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "experimental-referral",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# TD - Les boucles"
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "alive-youth",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 1. Définition\n",
|
||||
"\n",
|
||||
"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__."
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "romance-grounds",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 1.1. Exemple introductif\n",
|
||||
"\n",
|
||||
"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)."
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "controlled-construction",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 1.2. À Faire \n",
|
||||
"\n",
|
||||
"Compléter le programme Python suivant afin d'obtenir le nombre d'utilisateurs du réseau _KILESTBIEN_ au bout de 10 mois.\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"nb_utilisateurs = 500000\n",
|
||||
"nb_utilisateurs = nb_utilisateurs * 1.05\n",
|
||||
"???\n",
|
||||
"print(???)\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "awful-usage",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "related-harmony",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 1.3. Problématique\n",
|
||||
"\n",
|
||||
"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.\n",
|
||||
"\n",
|
||||
"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 ?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "representative-vertical",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 2. Boucle bornée\n",
|
||||
"\n",
|
||||
"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.2., il est possible d'écrire la suite d'instructions suivantes : \n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"nb_utilisateurs = 500000\n",
|
||||
"for i in range(10):\n",
|
||||
" nb_utilisateurs = nb_utilisateurs * 1.05\n",
|
||||
"print(nb_utilisateurs)\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### À Faire\n",
|
||||
"\n",
|
||||
"Modifier le code précédent pour répondre à la problématique."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "sublime-frame",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "czech-andrews",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 2.1. Construction d'une boucle bornée\n",
|
||||
"\n",
|
||||
"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).\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"for element in sequence:\n",
|
||||
" bloc_instructions\n",
|
||||
"````\n",
|
||||
"\n",
|
||||
"__Remarques__ :\n",
|
||||
"\n",
|
||||
"- `element` est une variable créée par le `for`, ce n'est pas à vous de l'instancier. Elle prend successivement chacune des valeurs figurant dans la sequence parcourue,\n",
|
||||
"- __ne pas oublier les deux points à la fin de la ligne__ avec `for` qui permettent d'ouvrir le bloc d'instructions à exécuter (à répéter),\n",
|
||||
"- les instructions à effectuer sont indentées d'une tabulation par rapport au `for`,\n",
|
||||
"- au contraire du pseudo-code, on n'écrit pas en Python de fin pour car celui-ci est matérialisé la fin des indentations."
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "olympic-winner",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 2.2. Utilisation de la fonction `range()`\n",
|
||||
"\n",
|
||||
"- 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$. \n",
|
||||
"- ⚠ Attention : comme le premier entier est 0, le n-ième est numéroté $n - 1$.\n",
|
||||
"- 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$.\n",
|
||||
"- Le bloc d'instructions à répéter doit être indenté (d'une tabulation) et sera donc ici exécuté $n$ fois."
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "searching-journal",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### 2.2.1. À Faire\n",
|
||||
"\n",
|
||||
"On considère le programme Python suivant.\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"a = 2\n",
|
||||
"for i in range(4):\n",
|
||||
" a = a + 1\n",
|
||||
" print(a)\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"1. Quel est le bloc d'instructions répété dans la boucle `for` ?\n",
|
||||
"2. Combien de fois est-il répété ?\n",
|
||||
"3. Combien de valeurs sont affichées au cours de l'exécution de ce programme ?\n",
|
||||
"4. Quelle est la valeur finale de la variable `a` ?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "broke-warrant",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### 2.2.2. À Faire\n",
|
||||
"\n",
|
||||
"On considère le programme Python suivant :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"a = 1\n",
|
||||
"b = 5\n",
|
||||
"for i in range(3):\n",
|
||||
" a = 2 * a\n",
|
||||
" b = b + a\n",
|
||||
"print(b)\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"On va commencer par analyser le code pour le comprendre.\n",
|
||||
"\n",
|
||||
"1. Quel est le bloc d'instructions répété dans la boucle `for` ? Combien de fois est-il répété ?\n",
|
||||
"2. Expliquez pourquoi il n'y a qu'une seule valeur qui s'affiche dans la console si on exécute le code ?\n",
|
||||
"3. Recopiez et complétez le tableau ci-dessous avec les valeurs des variables `i`, `a` et `b` à chaque tour de boucle.\n",
|
||||
"\n",
|
||||
"| `i` | `a` | `b` |\n",
|
||||
"| :--: | :--: | :---: |\n",
|
||||
"| | 1 | 5 |\n",
|
||||
"| 0 | ??? | ??? |\n",
|
||||
"| ??? | ??? | ??? |\n",
|
||||
"| ??? | ??? | ??? |\n",
|
||||
"\n",
|
||||
"4. Quelle est la valeur finale de la variable `b` ?\n",
|
||||
"5. Exécutez ensuite le code et vérifiez ce qu'il produit."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "danish-oxide",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "informative-insulation",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 2.3. Boucle bornée sur une chaine de caractères\n",
|
||||
"\n",
|
||||
"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.\n",
|
||||
"\n",
|
||||
"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 :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"for element in variable: # se traduit par \"pour chaque element de variable\"\n",
|
||||
" bloc_instructions\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"**Remarques** :\n",
|
||||
"\n",
|
||||
"- `variable` peut être une chaîne de caractères (type `str`) ou une liste (type `list`).\n",
|
||||
"- Dans ce cas, la variable `element` prend successivement chacune des valeurs de `variable`."
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "abroad-health",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### 2.3.1. Par ses caractères\n",
|
||||
"\n",
|
||||
"On peut parcourir une chaîne directement par ses caractères."
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "acquired-reset",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"##### 2.3.1.1. À Faire\n",
|
||||
"\n",
|
||||
"1. Copier et exécuter le code suivant.\n",
|
||||
"```python\n",
|
||||
"a = \"SNT\"\n",
|
||||
"for lettre in a:\n",
|
||||
"\tprint(lettre)\n",
|
||||
"```\n",
|
||||
"2. Quel est le résultat obtenu ?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "bacterial-hamburg",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "upper-adjustment",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"#### 2.3.2. Par l'indice de ses caractères\n",
|
||||
"\n",
|
||||
"On peut aussi utiliser la fonction `range()` pour parcourir les caractères par leurs indices.\n",
|
||||
"\n",
|
||||
"##### 2.3.2.1. À Faire\n",
|
||||
"\n",
|
||||
"1. Copier et exécuter le code suivant.\n",
|
||||
"```python\n",
|
||||
"a = \"SNT\"\n",
|
||||
"for i in range(len(a)):\n",
|
||||
"\tprint(a[i])\n",
|
||||
"```\n",
|
||||
"2. Quel est le résultat obtenu ?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "strategic-mason",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 3. Exercices"
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "artificial-water",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 1 - La punition\n",
|
||||
"\n",
|
||||
"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__._»\n",
|
||||
"\n",
|
||||
"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_.\"\n",
|
||||
"\n",
|
||||
"Écrire un programme Python qui permet de facilement retranscrire la punition."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "frozen-cherry",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "daily-richards",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 2 - Table de Multiplication\n",
|
||||
"\n",
|
||||
"1. Recopiez le programme suivant :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"nombre = int(input(\"De quel nombre voulez-vous la table de multiplication ? \"))\n",
|
||||
"\n",
|
||||
"for compteur in range(10):\n",
|
||||
"\tprint(nombre)\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"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."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "adjustable-serum",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "derived-perfume",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 3 - Problème de l'échiquier de Sissa\n",
|
||||
"\n",
|
||||
"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.\n",
|
||||
"\n",
|
||||
"On se demande combien de grains seront posés sur la dernière case du plateau d'échecs (qui en compte 64).\n",
|
||||
"\n",
|
||||
"Pour résoudre ce problème, on peut utiliser le programme suivant :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"grains = 1\n",
|
||||
"\n",
|
||||
"for compteur in range(???):\n",
|
||||
" grains = ???\n",
|
||||
"\n",
|
||||
"print(\"Nombre de grains sur la dernière case :\", grains)\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"1. Compléter ce programme, et exécutez-le.\n",
|
||||
"2. Combien de grains de riz y aura-t-il sur la dernière case de l'échiquier ?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "breeding-stack",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "north-diabetes",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 4 - Petite tortue qui dessine\n",
|
||||
"\n",
|
||||
"Le module `turtle` (*tortue*) permet de dessiner avec Python.\n",
|
||||
"\n",
|
||||
"Dans cet exercice on veut écrire un programme qui permet de dessiner des formes géométriques. Voici le code incomplet du programme.\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import turtle # pour utiliser le module turtle\n",
|
||||
"\n",
|
||||
"\"\"\"Fonction qui dessine un carré de coté 100 pixels\"\"\"\n",
|
||||
"turtle.forward(100) # pour avancer de 100 pixels\n",
|
||||
"turtle.left(90) # pour tourner de 90° à gauche\n",
|
||||
"turtle.forward(100)\n",
|
||||
"turtle.left(90)\n",
|
||||
"# À Compléter\n",
|
||||
"\n",
|
||||
"turtle.done() # pour afficher le dessin\n",
|
||||
"```\n",
|
||||
"1. Modifiez le programme afin que la tortue dessine un `carré`, en utilisant une boucle `for`.\n",
|
||||
"2. Modifiez le programme afin que la tortue dessine un `triangle`, en utilisant une boucle `for`.\n",
|
||||
"3. Modifiez le programme afin que la tortue dessine un `octogone`, en utilisant une boucle `for`."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "capital-minnesota",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "human-accommodation",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 4. Compléments sur la fonction range\n",
|
||||
"\n",
|
||||
"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).\n",
|
||||
"\n",
|
||||
"Après avoir regardé la [vidéo](https://www.youtube.com/watch?v=07IGOcpiE7o), répondez aux questions qui suivent. Vous vérifierez ensuite en utilisant un éditeur de code Python."
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "phantom-presentation",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"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 !*\n",
|
||||
"\n",
|
||||
"2. - Programme 1 :\n",
|
||||
"\n",
|
||||
" ```python\n",
|
||||
" for i in range(10):\n",
|
||||
" print(i)\n",
|
||||
" ```\n",
|
||||
" - Programme 2 :\n",
|
||||
"\n",
|
||||
" ```python\n",
|
||||
" for k in range(2, 10):\n",
|
||||
" print(k)\n",
|
||||
" ```\n",
|
||||
" - Programme 3 :\n",
|
||||
"\n",
|
||||
" ```python\n",
|
||||
" for ind in range(2, 10, 3):\n",
|
||||
" print(ind)\n",
|
||||
" ```\n",
|
||||
"\n",
|
||||
"3. Exécutez successivement les trois codes et vérifiez vos réponses à la question précédente."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "saving-conducting",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "brutal-password",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 5. Boucle non bornée\n",
|
||||
"\n",
|
||||
"## 5.1 Retour à l'exemple introductif\n",
|
||||
"\n",
|
||||
"Bien que l'exigence d'obtenir 3 millions d'utilisateurs dans 3 ans avec un taux de croissance de 5% par mois n'est pas satisfaite, les banquiers donnent une deuxième chance à _KILESTBIEN_.\n",
|
||||
"\n",
|
||||
"Ils souhaitent connaitre exactement quel sera le nombre de mois nécessaires pour que le nombre d'utilisateurs atteignent 7 millions d'utilisateurs, avec un taux de croissance à 4% par mois.\n",
|
||||
"\n",
|
||||
"Ils investirons 1 million d'euros seulement si la barre des 7000000 d'utilisateurs est atteinte dans les 5 ans.\n",
|
||||
"\n",
|
||||
"Ici, nous ne connaissons pas le nombre de mois, impossible d'utiliser une boucle bornée...par contre, il est possible de partir du premier mois et de calculer le nombre d'utilisateurs croissant...__tant qu'__il n'atteint pas 7 millions !\n",
|
||||
"\n",
|
||||
"### À Faire\n",
|
||||
"\n",
|
||||
"Modifier le code suivant pour répondre à la problématique.\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
"nb_utilisateurs = 500000\n",
|
||||
"nb_mois = 0\n",
|
||||
"while nb_utilisateurs < 3000000:\n",
|
||||
" nb_utilisateurs = nb_utilisateurs * 1.05\n",
|
||||
" nb_mois = nb_mois + 1\n",
|
||||
"print(nb_mois)\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "expensive-kenya",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "thirty-bibliography",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 5.2 Construction d'une boucle non bornée\n",
|
||||
"\n",
|
||||
"En Python, les boucles \"Tant que\" se codent en utilisant l'instruction while :\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
"while condition:\n",
|
||||
" bloc_instructions\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"__Remarques__ :\n",
|
||||
"\n",
|
||||
"- `condition` est une __variable booléenne__ qui est soit vraie (True) soit fausse (False),\n",
|
||||
"- Tant que `condition` vaut True les instructions du bloc sont répétées,\n",
|
||||
"- On passe à la suite du programme dès que condition vaut False. Cela signifie que si condition reste vraie tout le temps, la boucle `while` boucle à l'infini, ce qui pourra causer des problèmes plus ou moins importants,\n",
|
||||
"- Ne pas oublier les deux points à la fin de la ligne avec while qui permettent d'ouvrir le bloc d'instructions à exécuter (à répéter),\n",
|
||||
"- les instructions à effectuer sont indentées d'une tabulation par rapport au `while`."
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "ethical-director",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 5.2.1. À Faire\n",
|
||||
"\n",
|
||||
"Copier et exécuter le code suivant.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"a = 3\n",
|
||||
"while a < 14:\n",
|
||||
" a = a + 2\n",
|
||||
" print(a) # pour voir l'évolution de la variable a\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"1. Quel est le résultat obtenu ?\n",
|
||||
"2. Combien d'itérations ont-elles été nécessaires pour que la boucle se termine ?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "authorized-applicant",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "adjusted-arthritis",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 6. Exercices"
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "wrapped-compound",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 5 - Final Countdown\n",
|
||||
"\n",
|
||||
"Écrire un programme, utilisant une boucle non bornée et affiche un décompte. La valeur de `départ` est égale à 10. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "african-rings",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "introductory-salon",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 6 - Divisions successives\n",
|
||||
"\n",
|
||||
"Proposer un programme qui utilise une boucle `Tant que` qui a pour but d'afficher les restes successifs de la division entière d'un entier naturel $a$ par un entier naturel $b$.\n",
|
||||
"\n",
|
||||
"Vous pouvez tester votre programme en prenant comme valeurs :\n",
|
||||
"\n",
|
||||
"- $a$ = 21, $b$ = 10\n",
|
||||
"- $a$ = 21, $b$ = 2\n",
|
||||
"- $a$ = 64, $b$ = 2\n",
|
||||
"- $a$ = 64, $b$ = 16\n",
|
||||
"\n",
|
||||
"En lisant le résultat obtenu, que permet de faire ce programme ?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "under-nursery",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "retained-witch",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 7 - Indice\n",
|
||||
"\n",
|
||||
"Écrire un programme qui étant donné une variable `nom` égale au vôtre, stocke l'indice de la première voyelle dans une variable `indice`.\n",
|
||||
"\n",
|
||||
"__Exemple__ :\n",
|
||||
"```python\n",
|
||||
"nom = \"MATHIEU\"\n",
|
||||
"# \n",
|
||||
"# code du programme\n",
|
||||
"# \n",
|
||||
"indice = 1 # A est la première lettre du nom. Elle se trouve à l'indice 1\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "extraordinary-priest",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "still-joshua",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 8 - Retour de la tortue\n",
|
||||
"\n",
|
||||
"En reprenant les fonctions `forward`, `left`et `done` de la tortue, vus à l'exercice 4, décriver un programme permettant d'obtenir la figure suivante :\n",
|
||||
"\n",
|
||||
"La solution peut s'écrire sous la forme de l'algorithme suivant :\n",
|
||||
"\n",
|
||||
"```txt\n",
|
||||
"Tant que longueur > 0 \n",
|
||||
"\tla tortue avance sur une distance de longueur\n",
|
||||
"\tla tortue tourne de 90° à gauche\n",
|
||||
"\tlongueur diminue de 10\n",
|
||||
"Fin du tant que\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Etes vous certain que la boucle s'arrête à un moment donné ? Pourquoi ?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "neutral-burden",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"id": "assumed-freight",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 9 - Re-Retour de la tortue\n",
|
||||
"\n",
|
||||
"Ici, il s'agit de tracer une spirale, mais à la différence de l'exercice précédent, la longueur décroit de 10% à chaque itération.\n",
|
||||
"\n",
|
||||
"La solution peut s'écrire sous la forme de l'algorithme suivant :\n",
|
||||
"\n",
|
||||
"```txt\n",
|
||||
"Tant que longueur > 0 \n",
|
||||
"\tla tortue avance sur une distance de longueur\n",
|
||||
"\tla tortue tourne de 90° à droite\n",
|
||||
"\tlongueur est multipliée par 0.9 # Décroissance de 10% à chaque itération\n",
|
||||
"Fin du tant que\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Implanter l'algorithme en Python et exécuter le.\n",
|
||||
"\n",
|
||||
"Que se passe-t-il ? Pourquoi ? Modifier le code pour y remédier."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "geological-sampling",
|
||||
"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.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
15
programmation/chapitre_4/README.md
Normal file
15
programmation/chapitre_4/README.md
Normal file
@@ -0,0 +1,15 @@
|
||||
# Les fonctions
|
||||
|
||||
L'activité consiste en un TD comprenant un __cours dirigé__ et des __exercices__ relatifs à la notion de _fonctions_ en Python.
|
||||
|
||||
## Pré-requis
|
||||
|
||||
Avoir effectué l'activité sur les [boucles](../chapitre_3/)
|
||||
|
||||
## Consignes
|
||||
|
||||
1. Télécharger le fichier [TD.ipynb](./TD.ipynb),
|
||||
2. Se rendre sur [Basthon](https://notebook.basthon.fr/),
|
||||
3. Ouvrir le fichier TD.ipynb téléchargé,
|
||||
4. Suivre le déroulé du TD, les réponses sont à mettre directement dans votre fichier,
|
||||
5. À la fin de la séance, n'oubliez pas de sauvegarder votre fichier sur votre clé USB ou espace personnel.
|
||||
588
programmation/chapitre_4/TD.ipynb
Normal file
588
programmation/chapitre_4/TD.ipynb
Normal file
@@ -0,0 +1,588 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# TD - Les fonctions"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 1. Exemple introductif\n",
|
||||
"\n",
|
||||
"La mention au bac se calcule en fonction de la moyenne selon les critères suivants :\n",
|
||||
"\n",
|
||||
"| Moyenne | Mention |\n",
|
||||
"| :--: | :--: |\n",
|
||||
"| Inférieur à 10 (exclu) | Aucune |\n",
|
||||
"| De 10 à 12 (exclu) | Passable |\n",
|
||||
"| De 12 à 14 (exclu) | Assez bien |\n",
|
||||
"| De 14 à 16 (exclu) | Bien |\n",
|
||||
"| De 16 à + | Très Bien |\n",
|
||||
"\n",
|
||||
"Imaginons que l'on souhaite connaitre la mention pour 2 élèves, il est possible d'écrire et d'exécuter les instructions suivantes :\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"moyenne = 13.5 # moyenne de l'élève 1\n",
|
||||
"if moyenne < 10:\n",
|
||||
" mention = \"Aucune\"\n",
|
||||
"elif moyenne < 12:\n",
|
||||
" mention = \"Passable\"\n",
|
||||
"elif moyenne < 14:\n",
|
||||
" mention = \"Assez Bien\"\n",
|
||||
"elif moyenne < 16:\n",
|
||||
" mention = \"Bien\"\n",
|
||||
"else:\n",
|
||||
" mention = \"Très Bien\"\n",
|
||||
"print(\"la mention pour l'élève 1 est : \", mention)\n",
|
||||
"moyenne = 10.75 # moyenne de l'élève 2\n",
|
||||
"if moyenne < 10:\n",
|
||||
" mention = \"Aucune\"\n",
|
||||
"elif moyenne < 12:\n",
|
||||
" mention = \"Passable\"\n",
|
||||
"elif moyenne < 14:\n",
|
||||
" mention = \"Assez Bien\"\n",
|
||||
"elif moyenne < 16:\n",
|
||||
" mention = \"Bien\"\n",
|
||||
"else:\n",
|
||||
" mention = \"Très Bien\"\n",
|
||||
"print(\"la mention pour l'élève 2 est : \", mention)\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"On constate que l'on doit répéter le bloc d'instructions conditionnelles.\n",
|
||||
"\n",
|
||||
"__Y a-t-il un moyen de factoriser ce bloc d'instuctions ?__"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 2. Solution : les fonctions\n",
|
||||
"\n",
|
||||
"Utilisons la syntaxe suivante :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"la mention pour l'élève 1 est : Assez Bien\n",
|
||||
"la mention pour l'élève 2 est : Passable\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"def obtenir_mention(moyenne):\n",
|
||||
" if moyenne < 10:\n",
|
||||
" mention = \"Aucune\"\n",
|
||||
" elif moyenne < 12:\n",
|
||||
" mention = \"Passable\"\n",
|
||||
" elif moyenne < 14:\n",
|
||||
" mention = \"Assez Bien\"\n",
|
||||
" elif moyenne < 16:\n",
|
||||
" mention = \"Bien\"\n",
|
||||
" else:\n",
|
||||
" mention = \"Très Bien\"\n",
|
||||
" return mention\n",
|
||||
" \n",
|
||||
"print(\"la mention pour l'élève 1 est : \", obtenir_mention(13.5))\n",
|
||||
"print(\"la mention pour l'élève 2 est : \", obtenir_mention(10.75))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"$\\Rightarrow$ Le bloc calculant la mention est défini une et une seule fois !!"
|
||||
]
|
||||
},
|
||||
{
|
||||
"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."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 3. Appel à une fonction"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Lorsque l'on exécute le code qui définit une fonction, aucune valeur n'est renvoyée ! Cela a seulement pour objectif d'enregistrer la fonction en mémoire."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# à exécuter : il ne se passera rien (visuellement)\n",
|
||||
"def inverse(x):\n",
|
||||
" return 1 / x"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Pour utiliser une fonction il faut l'__appeler__. On appelle une fonction par son nom en donnant des arguments (des valeurs) à ses paramètres. Dans ce cas, la fonction va renvoyer la ou les valeurs attendues."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"0.5"
|
||||
]
|
||||
},
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# appel à la fonction : qui renvoie alors ce qu'il faut !\n",
|
||||
"\n",
|
||||
"inverse(2)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"0.1"
|
||||
]
|
||||
},
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# un autre appel à la fonction : qui renvoie alors ce qu'il faut !\n",
|
||||
"\n",
|
||||
"inverse(10)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"- Une fonction est __définie une__ et __une seule fois__,\n",
|
||||
"- À chaque appel, la fonction calcule et produit un résultat dépendant des valeurs des paramètres passés,\n",
|
||||
"- Pour un même ensemble de valeurs de paramètres, le résultat produit est toujours le même. On dit qu'une fonction est __déterministe__ (ou __pure__)."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Remarque : au premier `return` rencontré l'exécution de la fonction est stoppée : si on veut renvoyer plusieurs valeurs on ne peut pas utiliser plusieurs return ; il faut séparer les valeurs à renvoyer par des virgules."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### À Faire\n",
|
||||
"\n",
|
||||
"1. Écrire une fonction `obtenir_mention` qui prend en paramètre une note, sous la forme d'un flottant et renvoie une mention, sous la forme d'une chaine de caractères.\n",
|
||||
"2. Quelles instructions permettent d'appeller la fonction pour les moyennes des 2 élèves de l'exemple introductif ?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 4. Prototyper une fonction"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Pour expliquer le fonctionnement d'une fonction, on lui ajoute un __prototype__ juste sous la ligne de définition. En Python les prototypes sont appelés _docstrings_. On peut y accéder dans le code source ou simplement en utilisant la fonction `help()`.\n",
|
||||
"\n",
|
||||
"Le prototype doit décrire le __rôle__ de la fonction, le __type des paramètres__, __type de la valeur de retour__ et les __conditions d'utilisation__."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def inverse(x):\n",
|
||||
" '''\n",
|
||||
" Calcule l'inverse de x\n",
|
||||
" :param x: (int) un entier\n",
|
||||
" :return: l'inverse de x\n",
|
||||
" '''\n",
|
||||
" return 1 / x"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Que se passe-t-il pour $x = 0$ ?"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Il faut a minima que le prototype contienne les cas d'utilisation et les pré-conditions sur les paramètres."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def inverse(x):\n",
|
||||
" '''\n",
|
||||
" Calcule l'inverse de x\n",
|
||||
" :param x: (int) un entier\n",
|
||||
" :return: l'inverse de x\n",
|
||||
" :C.U: x != 0\n",
|
||||
" '''\n",
|
||||
" return 1 / x"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Help on function inverse in module __main__:\n",
|
||||
"\n",
|
||||
"inverse(x)\n",
|
||||
" Calcule l'inverse de x\n",
|
||||
" :param x: (int) un entier\n",
|
||||
" :return: l'inverse de x\n",
|
||||
" :C.U: x != 0\n",
|
||||
"\n",
|
||||
"\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"help(inverse)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"__N.B : Toute fonction doit comporter un prototype clair et explicite car la fonction peut être utilisée par une personne qui ne l'a pas programmé et doit savoir ce qu'elle fournit comme service sans devoir lire et comprendre son code.__"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 6. Valeur de paramètre par défaut"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 7. Portée des variables\n",
|
||||
"\n",
|
||||
"Les variables définies dans les fonctions, ses paramètres ou autres, sont appelés des __variables locales__, par opposition aux __variables globales__, qui sont définies dans flot d'exécution du programme."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"3\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Je défini une variable globale x\n",
|
||||
"x = 3\n",
|
||||
"# Je défini une fonction avec comme paramètre x\n",
|
||||
"def double(x):\n",
|
||||
" # Il s'agit d'une nouvelle variable locale x non liée à la variable globale x\n",
|
||||
" return 2 * x\n",
|
||||
"\n",
|
||||
"# J'appelle la fonction double avec x = 2\n",
|
||||
"double(2)\n",
|
||||
"\n",
|
||||
"print(x)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"La variable globale `x` reste inchangée"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 7.1. Mauvaise pratique "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 19,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"6\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Je défini une variable globale x\n",
|
||||
"x = 3\n",
|
||||
"# Je défini une fonction sans paramètre\n",
|
||||
"def double():\n",
|
||||
" # Je modifie la variable globale x\n",
|
||||
" global x\n",
|
||||
" x = 2 * x\n",
|
||||
"\n",
|
||||
"# J'appelle la fonction double, x = 3 à ce stade\n",
|
||||
"double()\n",
|
||||
"\n",
|
||||
"print(x)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"La fonction `double` ne prend aucun paramètre mais utilise une variable globale, ce qui est une mauvaise pratique car potentiellement source d'erreurs."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 20,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"12\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"double()\n",
|
||||
"print(x)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 21,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"24\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"double()\n",
|
||||
"print(x)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"__N.B : Le résultat calculé et obtenu par une fonction doit dépendre et manipuler uniquement des paramètres et variables locales définis.__"
|
||||
]
|
||||
},
|
||||
{
|
||||
"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"
|
||||
]
|
||||
},
|
||||
{
|
||||
"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`."
|
||||
]
|
||||
},
|
||||
{
|
||||
"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."
|
||||
]
|
||||
},
|
||||
{
|
||||
"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"
|
||||
]
|
||||
},
|
||||
{
|
||||
"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."
|
||||
]
|
||||
},
|
||||
{
|
||||
"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.7"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
BIN
programmation/evolution_langages_1965_2019.mp4
Normal file
BIN
programmation/evolution_langages_1965_2019.mp4
Normal file
Binary file not shown.
Reference in New Issue
Block a user