Convert Asciidoc to markdown
Converted asciidoc to markdown using ai.
This commit is contained in:
1
.gitignore
vendored
1
.gitignore
vendored
@ -164,3 +164,4 @@ cython_debug/
|
||||
|
||||
/documentation/slides/
|
||||
.idea
|
||||
.vscode
|
||||
@ -1,17 +1,15 @@
|
||||
= Exercices
|
||||
# Exercices
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
print("La rue Rostand,")
|
||||
print(" se trouve au")
|
||||
print("Feu à droite")
|
||||
----
|
||||
```
|
||||
|
||||
== Exercice 2
|
||||
## Exercice 2
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
print("Haut", "les", "cœurs", "!")
|
||||
----
|
||||
```
|
||||
@ -1,57 +1,51 @@
|
||||
= Exercices
|
||||
# Exercices
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
prenom = "Paul"
|
||||
temperature = 24.8
|
||||
paul_age = 30
|
||||
print(prenom, temperature, paul_age)
|
||||
----
|
||||
```
|
||||
|
||||
== Exercice 2
|
||||
## Exercice 2
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
saisie = input("Saisissez du texte :")
|
||||
print(saisie)
|
||||
----
|
||||
```
|
||||
|
||||
== Exercice 3
|
||||
## Exercice 3
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
val1 = 53 * 46 + 13
|
||||
val2 = 99 > 13
|
||||
val3 = "Bonjour " + "chef"
|
||||
val4 = (59 * 62 + 13) / 6.5
|
||||
print(val1, val2, val3, val4)
|
||||
----
|
||||
```
|
||||
|
||||
== Exercice A1
|
||||
## Exercice A1
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
distance = 42195
|
||||
print(distance // 1000) # nombre de kilomètres
|
||||
print(distance % 1000) # nombre de mètres restants
|
||||
----
|
||||
```
|
||||
|
||||
== Exercice A2
|
||||
## Exercice A2
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
weight = 4_502_177
|
||||
print(weight // 1000000, "tonnes") # combien de groupes de 1000000 de grammes
|
||||
print((weight // 1000) % 1000) # combien de kilos restants, sans compter les tonnes
|
||||
print(weight % 1000) # combien de grammes restants
|
||||
----
|
||||
```
|
||||
|
||||
== Exercice A3
|
||||
## Exercice A3
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
saisie1 = input("Premier nombre :") # attention, je vais récupérer du texte
|
||||
saisie2 = input("Second nombre :")
|
||||
saisie1 = float(saisie1) # convertir en flottant
|
||||
@ -62,4 +56,4 @@ else:
|
||||
print(saisie2)
|
||||
# Autre possibilité intéressante
|
||||
print(max(saisie1, saisie2))
|
||||
----
|
||||
```
|
||||
@ -1,38 +1,34 @@
|
||||
= Exercices
|
||||
# Exercices
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
roll = 5
|
||||
if roll > 4:
|
||||
print("Lancer réussi !")
|
||||
----
|
||||
```
|
||||
|
||||
== Exercice 2
|
||||
## Exercice 2
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
text = "Bonjour"
|
||||
if text == "bonjouR":
|
||||
print("Bien le bonjour")
|
||||
----
|
||||
```
|
||||
|
||||
== Exercice 2B
|
||||
## Exercice 2B
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
text = "Bonjour"
|
||||
if text == "Bonjour":
|
||||
print("Bien le bonjour")
|
||||
else:
|
||||
print("Je ne comprends pas !")
|
||||
----
|
||||
```
|
||||
|
||||
== Exercice 3
|
||||
## Exercice 3
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
value = 7
|
||||
if value >= 9:
|
||||
print("Élevé")
|
||||
@ -42,36 +38,33 @@ elif value >= 4:
|
||||
print("Standard")
|
||||
else:
|
||||
print("Bas")
|
||||
----
|
||||
```
|
||||
|
||||
== Exercice A1
|
||||
## Exercice A1
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
a1 = 4
|
||||
a2 = 7
|
||||
if a1 > 5 and a2 < 6:
|
||||
print("OK")
|
||||
else:
|
||||
print("Valeurs incorrectes")
|
||||
----
|
||||
```
|
||||
|
||||
== Exercice A2
|
||||
## Exercice A2
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
a1 = 5
|
||||
a2 = 5
|
||||
if a1 > 5 or a2 < 6:
|
||||
print("Conditions suffisantes")
|
||||
else:
|
||||
print("Valeurs incorrectes")
|
||||
----
|
||||
```
|
||||
|
||||
== Exercice A3
|
||||
## Exercice A3
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
is_on = True
|
||||
saisie = input("Saisissez une commande (Marche ou Arrêt) :")
|
||||
if saisie == "Marche":
|
||||
@ -84,5 +77,4 @@ elif saisie == "Arrêt":
|
||||
print("Extinction…")
|
||||
else:
|
||||
print("Déjà éteint !")
|
||||
----
|
||||
|
||||
```
|
||||
@ -1,27 +1,24 @@
|
||||
= Exercices
|
||||
# Exercices
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
for number in range(10):
|
||||
print(number)
|
||||
----
|
||||
```
|
||||
|
||||
== Exercice 2
|
||||
## Exercice 2
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
for number in range(10):
|
||||
if number % 2 == 0: # Est pair / reste 0 quand on fait la division entière
|
||||
print(number)
|
||||
----
|
||||
```
|
||||
|
||||
== Exercice A1
|
||||
## Exercice A1
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
for item1 in range(10):
|
||||
for item2 in range(item1):
|
||||
print(item1, item2)
|
||||
----
|
||||
```
|
||||
@ -1,14 +1,10 @@
|
||||
= Exercices sur les dictionnaires
|
||||
# Exercices sur les dictionnaires
|
||||
|
||||
'''
|
||||
## Exercice A1 : compréhension de dictionnaire
|
||||
|
||||
== Exercice A1 : compréhension de dictionnaire
|
||||
*Rappel* : Convertir un dictionnaire en gardant les clés originales, mais y associer comme valeurs uniquement les températures.
|
||||
|
||||
*Rappel* : Convertir un dictionnaire en gardant les clés originales,
|
||||
mais y associer comme valeurs uniquement les températures.
|
||||
|
||||
[source,python]
|
||||
----
|
||||
```python
|
||||
# Dictionnaire original
|
||||
meteo = {
|
||||
"Pau": (21.0, "Nuageux", 1015),
|
||||
@ -23,4 +19,4 @@ meteo = {
|
||||
converted = {key: meteo[key][0] for key in meteo}
|
||||
# On affiche le résultat pour le vérifier
|
||||
print(converted)
|
||||
----
|
||||
```
|
||||
@ -1,6 +1,6 @@
|
||||
= Exercices sur la fonction `print()`
|
||||
# Exercices sur la fonction `print()`
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
Affichez dans la console le texte suivant :
|
||||
|
||||
@ -8,19 +8,19 @@ Affichez dans la console le texte suivant :
|
||||
- `3 espaces` se trouve au
|
||||
- Feu à droite
|
||||
|
||||
== Exercice 2
|
||||
## Exercice 2
|
||||
|
||||
La fonction `print()` accepte plusieurs arguments, dont les valeurs sont affichées sur la même ligne, et par défaut séparés par un espace.
|
||||
|
||||
*La syntaxe est la suivante* : `print("a", "b", "c", 19)`
|
||||
**La syntaxe est la suivante** : `print("a", "b", "c", 19)`
|
||||
|
||||
Affichez, en imitant cette syntaxe, le texte suivant :
|
||||
|
||||
* Hauts les cœurs !
|
||||
- Hauts les cœurs !
|
||||
|
||||
(sous Linux, le e dans l'o s'obtient avec la combinaison de touches `Alt Gr + O`. Sous Windows, `Alt + 339` devrait donner le même résultat)
|
||||
(sous Linux, le e dans l'o s'obtient avec la combinaison de touches `Alt Gr + O`. Sous Windows, `Alt + 339` devrait donner le même résultat)
|
||||
|
||||
== Exercice A1
|
||||
## Exercice A1
|
||||
|
||||
La fonction `print()` accepte des arguments avec des noms spécifiques, dont `sep` et `end`. `sep` permet de désigner quelle chaîne sépare les arguments à afficher, et `end` permet de préciser par quelle chaîne terminer le `print`.
|
||||
Par défaut, `sep=" "` et `end="\n"`. La fonction s'utiliserait ainsi :
|
||||
@ -29,4 +29,4 @@ Par défaut, `sep=" "` et `end="\n"`. La fonction s'utiliserait ainsi :
|
||||
# Ne sépare pas les éléments via un espace et passe deux fois
|
||||
# à la ligne à la fin du print.
|
||||
print("1", "2", "3", sep="", end="\n\n")
|
||||
```
|
||||
```
|
||||
@ -1,18 +1,18 @@
|
||||
= Variables
|
||||
# Variables
|
||||
|
||||
---
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
- Déclarez trois variables, avec des noms corrects, contenant :
|
||||
* Le nom d'une personne, ex. "Paul"
|
||||
* La température courante en °C, ex. 25.3
|
||||
* L'âge d'une personne, ex. 30
|
||||
- Le nom d'une personne, ex. "Paul"
|
||||
- La température courante en °C, ex. 25.3
|
||||
- L'âge d'une personne, ex. 30
|
||||
- Affichez dans la console les valeurs de ces trois variables.
|
||||
|
||||
---
|
||||
|
||||
== Exercice 2
|
||||
## Exercice 2
|
||||
|
||||
- Demandez à l'utilisateur de saisir du texte, et mettez-le dans une variable
|
||||
- Affichez le contenu de la variable.
|
||||
@ -21,18 +21,18 @@
|
||||
|
||||
---
|
||||
|
||||
== Exercice 3 : Expressions
|
||||
## Exercice 3 : Expressions
|
||||
|
||||
- Déclarez plusieurs variables, contenant le résultats de :
|
||||
* Une opération arithmétique entre nombres
|
||||
* Une comparaison entre nombres
|
||||
* Une opération d'addition entre deux chaînes
|
||||
* L'expression `(59 * 62 + 13) / 6.5`
|
||||
- Une opération arithmétique entre nombres
|
||||
- Une comparaison entre nombres
|
||||
- Une opération d'addition entre deux chaînes
|
||||
- L'expression `(59 * 62 + 13) / 6.5`
|
||||
- Affichez leur contenu dans la console.
|
||||
|
||||
---
|
||||
|
||||
== Exercice A1 : Conversion en ordres de grandeur
|
||||
## Exercice A1 : Conversion en ordres de grandeur
|
||||
|
||||
- Déclarez une variable contenant une distance en mètres (au moins 1001, ex 4210)
|
||||
- Affichez le nombre de kilomètres dans cette valeur (nombre entier, ex. 4)
|
||||
@ -50,7 +50,7 @@ print(kilometers, "kilomètres et", meters, "mètres.")
|
||||
|
||||
---
|
||||
|
||||
== Exercice A2 : Deux ordres de grandeur
|
||||
## Exercice A2 : Deux ordres de grandeur
|
||||
|
||||
- Déclarez une variable contenant une masse en grammes (au moins 1 000 000)
|
||||
- Affichez le nombre de tonnes, de kilogrammes et de grammes dans cette masse.
|
||||
@ -60,11 +60,11 @@ y a deux ordres de grandeur à prendre en compte !
|
||||
|
||||
---
|
||||
|
||||
== Exercice A3 : Saisie de nombres
|
||||
## Exercice A3 : Saisie de nombres
|
||||
|
||||
- Demandez à l'utilisateur de saisir deux nombres (en deux fois).
|
||||
- Indiquez quel est le nombre le plus grand qui a été saisi.
|
||||
|
||||
Sachant que la saisie récupérée est toujours une chaîne de caractères vous devez récupérer une version de la saisie qui est un nombre pour pouvoir faire des comparaisons intéressantes.
|
||||
|
||||
*Rappel* : pour récupérer un entier depuis une chaîne, utilisez `int(valeur)`
|
||||
*Rappel* : pour récupérer un entier depuis une chaîne, utilisez `int(valeur)`
|
||||
@ -1,8 +1,8 @@
|
||||
= Conditions
|
||||
# Conditions
|
||||
|
||||
---
|
||||
|
||||
== Exercice 1 : `if` seul
|
||||
## Exercice 1 : `if` seul
|
||||
|
||||
- Déclarez une variable avec une valeur entière entre 1 et 6 (lancer de dé).
|
||||
- Affichez `"Lancer réussi !"` si la valeur est supérieure strictement à 4
|
||||
@ -10,7 +10,7 @@
|
||||
|
||||
---
|
||||
|
||||
== Exercice 2 : `if` seul, comparer du texte
|
||||
## Exercice 2 : `if` seul, comparer du texte
|
||||
|
||||
- Déclarez une variable avec le texte `"Bonjour"`;
|
||||
- Affichez `"Bien le bonjour"` si votre variable est égale à `"bonjouR"`.
|
||||
@ -19,7 +19,7 @@
|
||||
|
||||
---
|
||||
|
||||
== Exercice 2B : `if…else`
|
||||
## Exercice 2B : `if…else`
|
||||
|
||||
- Assignez à une variable le texte `"Bonjour"`;
|
||||
- Affichez `"Bien le bonjour"` si votre variable est égale à `"Bonjour"`;
|
||||
@ -27,7 +27,7 @@
|
||||
|
||||
---
|
||||
|
||||
== Exercice 3 : `if…elif…else`
|
||||
## Exercice 3 : `if…elif…else`
|
||||
|
||||
- Assignez à une variable un entier arbitraire entre 0 et 10 inclus;
|
||||
- Si cette valeur est d'au moins 9, afficher `"Élevé"`;
|
||||
@ -37,7 +37,7 @@
|
||||
|
||||
---
|
||||
|
||||
== Exercice A1 : Multiples conditions
|
||||
## Exercice A1 : Multiples conditions
|
||||
|
||||
- Assignez à deux variables `a1` et `a2` des nombres entiers entre 0 et 10
|
||||
- Si `a1` est supérieur à 5 *et* `a2` est inférieur à 6, afficher `"OK"`
|
||||
@ -45,7 +45,7 @@
|
||||
|
||||
---
|
||||
|
||||
== Exercice A2 (conditions avec `and` et `or`)
|
||||
## Exercice A2 (conditions avec `and` et `or`)
|
||||
|
||||
- Assignez à deux variables `a1` *et* `a2` des nombres entre 0 et 10
|
||||
- Si `a1` est supérieur à 5 *ou* `a2` est inférieur à 6, afficher `"Conditions suffisantes"`
|
||||
@ -53,20 +53,20 @@
|
||||
|
||||
---
|
||||
|
||||
== Exercice A3
|
||||
## Exercice A3
|
||||
|
||||
- Déclarez une variable de statut `is_on` contenant un booléen (`True` ou `False`)
|
||||
- Demandez à l'utilisateur de *saisir un texte*, et assignez-le à une variable `saisie`
|
||||
- Si `saisie` vaut "Marche" :
|
||||
* Si `is_on` est `False`, alors afficher "Allumage en cours..."
|
||||
* Sinon, afficher "Déjà allumé !"
|
||||
- Si `is_on` est `False`, alors afficher "Allumage en cours..."
|
||||
- Sinon, afficher "Déjà allumé !"
|
||||
- Sinon, si `saisie` vaut "Arrêt" :
|
||||
* Si `is_on` est `True`, afficher "Extinction..."
|
||||
* Sinon, afficher "Déjà éteint !"
|
||||
- Si `is_on` est `True`, afficher "Extinction..."
|
||||
- Sinon, afficher "Déjà éteint !"
|
||||
|
||||
Exemple de rappel :
|
||||
|
||||
```python
|
||||
# Demander de saisir un texte et récupérer le résultat dans une variable
|
||||
saisie = input("Saisissez du texte :")
|
||||
```
|
||||
```
|
||||
@ -1,6 +1,6 @@
|
||||
= Exercices sur les blocs vides
|
||||
# Exercices sur les blocs vides
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
- Écrivez un bloc `if` dont le code, lorsqu'il est exécuté, ne fait rien.
|
||||
- *Outils* : `pass`
|
||||
- *Outils* : `pass`
|
||||
@ -1,17 +1,17 @@
|
||||
= Exercices sur les boucles `for`
|
||||
# Exercices sur les boucles `for`
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
- Écrivez une boucle `for` sur les nombres de 0 à 9.
|
||||
- Affichez la valeur du nombre parcouru.
|
||||
|
||||
== Exercice 2
|
||||
## Exercice 2
|
||||
|
||||
- Écrivez une boucle `for` sur les nombres de 0 à 9.
|
||||
- Affichez la valeur du nombre s'il est pair (`nombre % 2 == 0`)
|
||||
|
||||
== Exercice A1
|
||||
## Exercice A1
|
||||
|
||||
- Écrivez une boucle `for` sur les nombres de 0 à 9 (variable nommée `item1`).
|
||||
- Dans cette boucle, écrivez une autre boucle sur les nombres de 0 à `item1` (variable `item2`)
|
||||
- Dans cette sous-boucle, affichez sur la même ligne `item1` et `item2`.
|
||||
- Dans cette sous-boucle, affichez sur la même ligne `item1` et `item2`.
|
||||
@ -1,22 +1,22 @@
|
||||
= Exercices sur les boucles `while`
|
||||
# Exercices sur les boucles `while`
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
- Déclarer une variable `number` égale à 10
|
||||
- Écrivez une boucle `while` tournant tant que `number` est supérieur ou égal à 0.
|
||||
- Dans la boucle, afficher `number`, et retirer `1` à `number`.
|
||||
|
||||
== Exercice 2
|
||||
## Exercice 2
|
||||
|
||||
- Écrire une boucle `while` qui tourne indéfiniment (condition `True`, ou soyez créatif)
|
||||
|
||||
== Exercice 3
|
||||
## Exercice 3
|
||||
|
||||
- Écrire une boucle `while` qui ne se lance jamais (condition `False`, ou soyez créatif)
|
||||
- (il suffit que la condition soit fausse dès le départ)
|
||||
|
||||
== Exercice A1 : Fibonacci
|
||||
## Exercice A1 : Fibonacci
|
||||
|
||||
- Écrire du code, affichant dans la console, les éléments successifs de la suite de Fibonacci jusqu'à 10 000 :
|
||||
* Utiliser deux variables, `left` and `right` qui vont, au départ, contenir les deux premiers éléments de la suite.
|
||||
* Dans la boucle, modifier `left` and `right` pour ne garder que les deux derniers éléments de la suite.
|
||||
- Utiliser deux variables, `left` and `right` qui vont, au départ, contenir les deux premiers éléments de la suite.
|
||||
- Dans la boucle, modifier `left` and `right` pour ne garder que les deux derniers éléments de la suite.
|
||||
@ -1,6 +1,6 @@
|
||||
= Exercices sur les listes
|
||||
# Exercices sur les listes
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
- Écrivez une liste contenant les nombres entiers pairs de 0 à 10 inclus
|
||||
- Assignez la longueur de la liste à une variable (`len()`)
|
||||
@ -8,53 +8,51 @@
|
||||
- Ajoutez un élément à la fin de la liste
|
||||
- Affichez le nouveau contenu de la liste
|
||||
|
||||
== Exercice 2
|
||||
## Exercice 2
|
||||
|
||||
- Écrivez une liste contenant les nombres 1, 2, 4, 8, 16, 32, 64
|
||||
- Supprimez de la liste le nombre 8
|
||||
- Ajoutez à la fin de la liste le nombre 128
|
||||
- Affichez le contenu de la liste dans la console.
|
||||
|
||||
== Exercice 3 (indices négatifs)
|
||||
## Exercice 3 (indices négatifs)
|
||||
|
||||
- Écrivez une liste contenant 3 éléments
|
||||
- Affichez le *dernier* élément en utilisant un indice négatif
|
||||
- Affichez le *premier* élément en utilisant un indice négatif
|
||||
|
||||
== Pré-Exercice 4 (slicing)
|
||||
## Pré-Exercice 4 (slicing)
|
||||
|
||||
[source,python]
|
||||
----
|
||||
```python
|
||||
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
b = a[0:5] # Index 0 à 5 non inclus. Marche aussi sur les chaînes.
|
||||
c = a[5:0] # L'index de fin est inférieur au départ, renvoie une liste vide
|
||||
f = a[:] # Renvoie toute la liste
|
||||
d = a[::-1] # Tout parcourir à l'envers
|
||||
e = a[::2] # Tout parcourir 2 par 2
|
||||
----
|
||||
```
|
||||
|
||||
|
||||
== Exercice 4 (slicing)
|
||||
## Exercice 4 (slicing)
|
||||
|
||||
- Écrivez une liste de 6 nombres
|
||||
- Affichez la liste comprenant les 3 premiers éléments
|
||||
- Affichez la liste comprenant tout sauf le premier élément
|
||||
|
||||
== Exercice 5 (slicing avancé)
|
||||
## Exercice 5 (slicing avancé)
|
||||
|
||||
- Réutilisez la liste de l'exercice 4
|
||||
- Affichez toute la liste, mais à l'envers
|
||||
- Affichez une liste comprenant les éléments aux indices pairs
|
||||
|
||||
== Exercice A1
|
||||
## Exercice A1
|
||||
|
||||
- Écrivez une liste contenant les nombres multiples de 3 de 0 à 15.
|
||||
- Faites une boucle `for` sur cette liste,
|
||||
* et affichez uniquement les nombres pairs de cette liste (`valeur % 2 == 0`)
|
||||
- et affichez uniquement les nombres pairs de cette liste (`valeur % 2 == 0`)
|
||||
|
||||
== Exercice A2
|
||||
## Exercice A2
|
||||
|
||||
- Consultez la https://docs.python.org/3/tutorial/datastructures.html#more-on-lists[référence des fonctions de listes]
|
||||
- Consultez la [référence des fonctions de listes](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists)
|
||||
- Déclarez une liste de nombres flottants
|
||||
- Utilisez la méthode qui sert à renvoyer le dernier élément et le supprimer de la liste
|
||||
- Affichez cet élément, puis la liste
|
||||
- Affichez cet élément, puis la liste
|
||||
@ -1,6 +1,6 @@
|
||||
= Exercices sur les ensembles
|
||||
# Exercices sur les ensembles
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
- Écrivez un `set` contenant 5 valeurs
|
||||
- Déclarez un second `set` contenant au moins 2 valeurs du premier set
|
||||
@ -8,14 +8,14 @@
|
||||
- Affichez les valeurs communes aux deux sets (`intersection()`)
|
||||
- Affichez un set contenant toutes les valeurs des 2 sets (`union()`)
|
||||
|
||||
== Exercice 2 (conversion)
|
||||
## Exercice 2 (conversion)
|
||||
|
||||
- Écrivez une *liste* contenant des valeurs en doublons
|
||||
- Affichez le contenu de la liste
|
||||
- Assignez à une variable la conversion de la liste en set (`set(x)`)
|
||||
- Affichez la valeur du set obtenu
|
||||
|
||||
== Exercice 3
|
||||
## Exercice 3
|
||||
|
||||
Al et Kim sont inscrits sur un réseau social. Al a les amis suivants :
|
||||
|
||||
@ -33,10 +33,10 @@ Kim a les amis suivants :
|
||||
|
||||
Quels sont leurs amis en commun ? Écrivez un code qui représente et résout cet énoncé.
|
||||
|
||||
== Exercice 4
|
||||
## Exercice 4
|
||||
|
||||
Partant du tuple suivant :
|
||||
|
||||
`(1, 4, 6, 9, 1, 3, 6, 12, 2, 5, 7, 10, 3, 5, 2, 6, 4, 6, 1, 8, 5, 2, 3, 6)`
|
||||
|
||||
- Affichez le nombre de valeurs différentes présentes dans le tuple.
|
||||
- Affichez le nombre de valeurs différentes présentes dans le tuple.
|
||||
@ -1,40 +1,40 @@
|
||||
= Exercices sur les dictionnaires
|
||||
# Exercices sur les dictionnaires
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
- Écrivez un simple dictionnaire associant des noms à des âges :
|
||||
* Paul → 30
|
||||
* Karim → 22
|
||||
* Gina → 41
|
||||
* Anna → 25
|
||||
- Paul → 30
|
||||
- Karim → 22
|
||||
- Gina → 41
|
||||
- Anna → 25
|
||||
- Affichez l'âge de Gina
|
||||
- Ajoutez les associations suivantes :
|
||||
* Alina → 33
|
||||
* Victor → 55
|
||||
- Alina → 33
|
||||
- Victor → 55
|
||||
- Affichez le contenu du dictionnaire
|
||||
|
||||
== Exercice 2 (parcours)
|
||||
## Exercice 2 (parcours)
|
||||
|
||||
- Réutilisez votre dictionnaire
|
||||
- Utilisez une boucle `for` normale pour :
|
||||
* Afficher les clés du dictionnaire
|
||||
* Afficher la valeur associée à chaque clé
|
||||
- Afficher les clés du dictionnaire
|
||||
- Afficher la valeur associée à chaque clé
|
||||
|
||||
== Exercice 3 (parcours + `.items()`)
|
||||
## Exercice 3 (parcours + `.items()`)
|
||||
|
||||
- Réutilisez votre dictionnaire
|
||||
- Utilisez une boucle `for` sur `.items()` avec deux variables :
|
||||
* Affichez clé et valeur associée
|
||||
- Affichez clé et valeur associée
|
||||
|
||||
== Exercice A1 (compréhension)
|
||||
## Exercice A1 (compréhension)
|
||||
|
||||
- Déclarez un dictionnaire de conditions météo (°C, condition, pression)
|
||||
* `meteo = {"Pau": (21.0, "Nuageux", 1015), "Gap": (20.3, "Dégagé", 1019), "Osny": (19.1, "Brouillard", 1015)}`
|
||||
- `meteo = {"Pau": (21.0, "Nuageux", 1015), "Gap": (20.3, "Dégagé", 1019), "Osny": (19.1, "Brouillard", 1015)}`
|
||||
- À l'aide d'une compréhension de dictionnaire, récupérer un dictionnaire :
|
||||
* Dont les clés sont les mêmes noms de villes
|
||||
* Dont les valeurs sont uniquement la température associée
|
||||
- Dont les clés sont les mêmes noms de villes
|
||||
- Dont les valeurs sont uniquement la température associée
|
||||
|
||||
== Exercice A2 (compréhensions)
|
||||
## Exercice A2 (compréhensions)
|
||||
|
||||
- Déclarez une liste via une compréhension, qui contient les nombres pairs de 0 à 98, sauf ceux divisibles par 5. (comprendre, uniquement ceux non divisibles par 5).
|
||||
- Déclarez une liste de mots manuellement. Puis déclarez un générateur (compréhension de tuple) qui contient uniquement les mots de plus de 4 lettres. (`len()`).
|
||||
- Déclarez une liste de mots manuellement. Puis déclarez un générateur (compréhension de tuple) qui contient uniquement les mots de plus de 4 lettres. (`len()`).
|
||||
@ -1,48 +1,46 @@
|
||||
= Exercices sur les manipulations de chaînes
|
||||
# Exercices sur les manipulations de chaînes
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
- Consultez https://docs.python.org/3/library/stdtypes.html#string-methods[les méthodes disponibles sur les chaînes]
|
||||
- Consultez [les méthodes disponibles sur les chaînes](https://docs.python.org/3/library/stdtypes.html#string-methods)
|
||||
- Déclarez une chaîne de caractères avec plusieurs mots
|
||||
- Affichez la version tout en majuscules (`upper`)
|
||||
- Affichez la version tout en minuscules (`lower`)
|
||||
- Découpez la autour des espaces (`split`)
|
||||
|
||||
== Exercice 2 (joindre les deux bouts)
|
||||
## Exercice 2 (joindre les deux bouts)
|
||||
|
||||
- Partant de cette liste de mots :
|
||||
|
||||
[source,python]
|
||||
----
|
||||
```python
|
||||
word_list = ("mon", "vieux", "tonton", "m'a", "jeté", "sur", "une", "nouvelle", "planète")
|
||||
----
|
||||
```
|
||||
|
||||
Utiliser la méthode `join()` sur une chaîne de séparation pour reconstituer la phrase entière.
|
||||
(N'utilisez pas de boucle `for`).
|
||||
|
||||
== Exercice 3 (slicing)
|
||||
## Exercice 3 (slicing)
|
||||
|
||||
- Déclarez une chaîne de caractères quelconque
|
||||
- En utilisant le _slicing_, affichez-la à l'envers
|
||||
- De la même façon, affichez uniquement les 5 premiers caractères
|
||||
- Affichez le texte, mais uniquement un caractère sur deux
|
||||
|
||||
== Exercice 4 (f-strings)
|
||||
## Exercice 4 (f-strings)
|
||||
|
||||
- Déclarez plusieurs variables :
|
||||
* `number = 14`
|
||||
* `base_list = [1, 2, 3]`
|
||||
- `number = 14`
|
||||
- `base_list = [1, 2, 3]`
|
||||
- Affichez une *f-string* incluant le contenu de `number` et `base_list` :
|
||||
* Il est *14* heures. La liste est *[1, 2, 3]*.
|
||||
- Il est *14* heures. La liste est *[1, 2, 3]*.
|
||||
|
||||
== Exercice A1 (`join` + conversion)
|
||||
## Exercice A1 (`join` + conversion)
|
||||
|
||||
Partant de cette liste :
|
||||
|
||||
[source, python]
|
||||
----
|
||||
```python
|
||||
items = ["Hello, it's", True, "that", 40, "people have", None]
|
||||
----
|
||||
```
|
||||
|
||||
- Confectionner une phrase avec `" ".join()`.
|
||||
- La fonction `join` nécessitant une liste de chaînes pour fonctionner, utilisez une compréhension de liste pour convertir cette liste en liste de chaînes (utilisez `str(x)`).
|
||||
- La fonction `join` nécessitant une liste de chaînes pour fonctionner, utilisez une compréhension de liste pour convertir cette liste en liste de chaînes (utilisez `str(x)`).
|
||||
@ -1,37 +1,36 @@
|
||||
= Exercices sur les exceptions
|
||||
# Exercices sur les exceptions
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
- Écrivez un bloc `try/except`
|
||||
- Dans le bloc `try`, provoquez une division par zéro (`ZeroDivisionError`)
|
||||
- Dans le bloc `except`, affichez "Division impossible !"
|
||||
|
||||
== Exercice A1
|
||||
## Exercice A1
|
||||
|
||||
- Générez un nombre entier aléatoire entre 0 et 1 :
|
||||
|
||||
[source,python]
|
||||
----
|
||||
```python
|
||||
from random import randint
|
||||
number = randint(0, 1)
|
||||
----
|
||||
```
|
||||
|
||||
- Écrivez un bloc `try/except`
|
||||
- Dans le bloc `try` :
|
||||
* Si `number` vaut `0`, afficher `[1, 2, 3][4]` (`IndexError`)
|
||||
* Si `number` vaut `1`, afficher `{}[0]` (`KeyError`)
|
||||
- Si `number` vaut `0`, afficher `[1, 2, 3][4]` (`IndexError`)
|
||||
- Si `number` vaut `1`, afficher `{}[0]` (`KeyError`)
|
||||
- Écrire un bloc `except` pour `IndexError`, qui affiche "Erreur d'index"
|
||||
- Écrire un bloc `except` pour `KeyError`, qui affiche "Erreur de clé"
|
||||
|
||||
== Exercice A2 (variante)
|
||||
## Exercice A2 (variante)
|
||||
|
||||
- Reprenez une copie de l'exercice 1
|
||||
- Mais cette fois, ayez un seul bloc `except` qui gère à la fois `IndexError` et `KeyError`, et qui affiche "Erreur d'accès".
|
||||
|
||||
== Exercice A3
|
||||
## Exercice A3
|
||||
|
||||
- Écrivez un bloc `try/except`
|
||||
- Provoquez une erreur dans le bloc `try` (pas une erreur de syntaxe !)
|
||||
- Écrivez un bloc `except` qui ne gère pas la bonne erreur (ex. `IOError`)
|
||||
- Écrivez un bloc `finally` qui affiche du texte
|
||||
- Exécutez votre code et voyez que le bloc `finally` est bien honoré.
|
||||
- Exécutez votre code et voyez que le bloc `finally` est bien honoré.
|
||||
@ -1,12 +1,12 @@
|
||||
= Exercices sur les fonctions
|
||||
# Exercices sur les fonctions
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
- Écrivez une fonction nommée `show_something` qui ne prend pas d'argument
|
||||
- Cette fonction doit afficher dans la console "Something"
|
||||
- Appelez cette fonction
|
||||
|
||||
== Exercice 2
|
||||
## Exercice 2
|
||||
|
||||
- Écrivez une fonction nommée `return_constant` qui ne prend pas d'argument
|
||||
- Cette fonction affiche dans la console "99"
|
||||
@ -14,24 +14,24 @@
|
||||
- Appeler la fonction et assigner sa valeur de retour à une variable
|
||||
- Afficher le contenu de la variable
|
||||
|
||||
== Exercice 3
|
||||
## Exercice 3
|
||||
|
||||
- Écrivez une fonction nommée `product` qui prend deux arguments positionnels `x` et `y`
|
||||
- Cette fonction renvoie le produit de `x` et `y`
|
||||
- Affichez le résultat de cette fonction lorsque vous l'appelez avec les valeurs :
|
||||
* `10, 10`
|
||||
* `15, -15`
|
||||
* `"hello ", 3`
|
||||
* `[1, 2, 3], 2`
|
||||
- `10, 10`
|
||||
- `15, -15`
|
||||
- `"hello ", 3`
|
||||
- `[1, 2, 3], 2`
|
||||
|
||||
== Exercice 4
|
||||
## Exercice 4
|
||||
|
||||
- Écrivez une fonction nommée `quotient` qui prend un argument positionnel `numerator` et un argument par défaut `denominator`, qui prend la valeur `1` par défaut.
|
||||
- La fonction renvoie le quotient de `numerator` et `denominator`.
|
||||
- La fonction gère l'exception de `ZeroDivisionError` en renvoyant la valeur `None`.
|
||||
- Affichez le résultat de cette fonction lorsque vous l'appelez avec les valeurs :
|
||||
* `10, 4`
|
||||
* `10, -1`
|
||||
* `1, 0`
|
||||
* `10`
|
||||
- Variez les appels en passant les arguments positionnellement, par nom, etc.
|
||||
- `10, 4`
|
||||
- `10, -1`
|
||||
- `1, 0`
|
||||
- `10`
|
||||
- Variez les appels en passant les arguments positionnellement, par nom, etc.
|
||||
@ -1,19 +1,19 @@
|
||||
= Exercices sur les fonctions
|
||||
# Exercices sur les fonctions
|
||||
|
||||
== Exercice A1
|
||||
## Exercice A1
|
||||
|
||||
- Écrivez une fonction `print_lines` qui prend un argument étoile `*lines`
|
||||
- La fonction utilise une boucle `for` pour afficher les éléments de `lines` dans la console
|
||||
- Appelez la fonction avec des arguments différents :
|
||||
* `"ligne 1", "ligne 2", 13, 14, 15`
|
||||
* _aucun argument_
|
||||
* `"matin", "midi", "soir", "nuit"`
|
||||
- `"ligne 1", "ligne 2", 13, 14, 15`
|
||||
- _aucun argument_
|
||||
- `"matin", "midi", "soir", "nuit"`
|
||||
|
||||
== Exercice A2
|
||||
## Exercice A2
|
||||
|
||||
- Écrivez une fonction `mappings` qui prend un argument double-étoile `**prices`
|
||||
- La fonction parcourt le dictionnaire dans `prices` et affiche pour chaque clé `key` :
|
||||
* `f"Produit : {key:<16} - Prix : {value:.2f}€"`
|
||||
- `f"Produit : {key:<16} - Prix : {value:.2f}€"`
|
||||
- Testez l'appel de cette fonction avec des arguments suivants :
|
||||
* `pomme=0.8, cassis=1.5, ananas=2.8, raisin=4.99`
|
||||
* `perrier=1.2, badoit=0.95, san_pellegrino=1.1, vichy=40`
|
||||
- `pomme=0.8, cassis=1.5, ananas=2.8, raisin=4.99`
|
||||
- `perrier=1.2, badoit=0.95, san_pellegrino=1.1, vichy=40`
|
||||
@ -1,30 +1,30 @@
|
||||
= Exercices sur les dates et heures
|
||||
# Exercices sur les dates et heures
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
- Déclarez trois objets `datetime` :
|
||||
* `now` : là, tout de suite
|
||||
* `forty_ago` : le 12 février 1981 à 22h31
|
||||
* `fifteen_ago` : le 3 mars 2006 à 16h10 et 14 secondes
|
||||
- `now` : là, tout de suite
|
||||
- `forty_ago` : le 12 février 1981 à 22h31
|
||||
- `fifteen_ago` : le 3 mars 2006 à 16h10 et 14 secondes
|
||||
- Affichez chacun de ces objets dans la console
|
||||
- Affichez le mois de `forty_ago` (`.month`)
|
||||
- Affichez les minutes et secondes de `fifteen_ago`
|
||||
|
||||
== Exercice 2
|
||||
## Exercice 2
|
||||
|
||||
- Conservez les variables du dessus
|
||||
- Assignez la différence entre `now` et `forty_ago` dans une variable `interval_40`
|
||||
- Affichez le nombre de jours contenus dans `interval_40` (`.days`)
|
||||
- Affichez la date qu'il sera dans `interval_40` (`now + interval_40`)
|
||||
|
||||
== Exercice 3 (conversion vers chaîne)
|
||||
## Exercice 3 (conversion vers chaîne)
|
||||
|
||||
- Conservez les variables du dessus
|
||||
- Affichez `fifteen_ago` sous la forme suivante :
|
||||
* `"03 mars 2006, 16:10:14"`
|
||||
- `"03 mars 2006, 16:10:14"`
|
||||
- (utilisez `fifteen_ago.strftime(format 8563.3.3.)`)
|
||||
|
||||
== Exercice 4 (conversion depuis chaîne)
|
||||
## Exercice 4 (conversion depuis chaîne)
|
||||
|
||||
- Convertissez la chaîne `"31-01-2019 16:48"` vers un objet `datetime`
|
||||
- (utilisez `datetime.strptime(chaine, format)`)
|
||||
- (utilisez `datetime.strptime(chaine, format)`)
|
||||
@ -1,6 +1,6 @@
|
||||
= Exercices sur les classes (basique)
|
||||
# Exercices sur les classes (basique)
|
||||
|
||||
== Exercice 1
|
||||
## Exercice 1
|
||||
|
||||
(Thème *bibliothèque*)
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
- Instanciez deux nouveaux objets de cette classe (différenciez noms de variables et de classes)
|
||||
- Affichez la valeur de l'attribut `name` de l'un des objets
|
||||
|
||||
== Exercice 2
|
||||
## Exercice 2
|
||||
|
||||
- Déclarez une classe `Book`
|
||||
- Avec des attributs `title` (`None`), `author` (`None`), `year` (`None`)
|
||||
@ -18,40 +18,40 @@
|
||||
- Modifiez les attributs `title` et `author`
|
||||
- Affichez la valeur de ces attributs
|
||||
|
||||
== Exercice 3 (méthodes)
|
||||
## Exercice 3 (méthodes)
|
||||
|
||||
- Réutilisez la classe `Library`
|
||||
- Ajoutez-y un attribut `is_open` (`True`)
|
||||
- Ajoutez une méthode `open(value=True)` qui change l'attribut `is_open`
|
||||
- Ajoutez une méthode `show_status()` qui affiche l'état de la bibliothèque :
|
||||
* `"Bibliothèque <nom> :"`
|
||||
* `"État : Ouverte"` (ou `"fermée"`)
|
||||
- `"Bibliothèque <nom> :"`
|
||||
- `"État : Ouverte"` (ou `"fermée"`)
|
||||
|
||||
== Exercice 4 (Redéfinition de l'instanciation)
|
||||
## Exercice 4 (Redéfinition de l'instanciation)
|
||||
|
||||
- Réutilisez la classe `Library`
|
||||
- Définissez la méthode `_ _ init _ _()`, qui accepte des arguments `name` et `address` :
|
||||
* `name` est un argument à valeur par défaut, à `None`
|
||||
* `address` possède une valeur par défaut à `None`
|
||||
* La méthode utilise ces arguments pour initialiser les attributs de `self`.
|
||||
- Définissez la méthode `__init__()`, qui accepte des arguments `name` et `address` :
|
||||
- `name` est un argument à valeur par défaut, à `None`
|
||||
- `address` possède une valeur par défaut à `None`
|
||||
- La méthode utilise ces arguments pour initialiser les attributs de `self`.
|
||||
- Instanciez deux nouveaux objets de cette classe
|
||||
- Exécutez la méthode `show_status()` sur ces deux objets
|
||||
|
||||
== Exercice 5 (Héritage)
|
||||
## Exercice 5 (Héritage)
|
||||
|
||||
- Définissez une classe `ComicBook` héritant de `Book`
|
||||
- Cette classe contient en plus un attribut `is_color` (`True`)
|
||||
- Instanciez un objet de chacune des deux classes `Book` et `ComicBook`
|
||||
- Vérifiez que l'objet de type `ComicBook` est bien un `Book` :
|
||||
* en utilisant la fonction `isinstance(object, class)`
|
||||
- en utilisant la fonction `isinstance(object, class)`
|
||||
|
||||
== Exercice 6 (Polymorphisme)
|
||||
## Exercice 6 (Polymorphisme)
|
||||
|
||||
- Ajoutez un attribut `is_published` sur la classe `Book`
|
||||
- Ajoutez une méthode `publish(value)` sur `Book`, qui change l'attribut `is_published`
|
||||
- Redéfinissez la méthode `publish(value)` sur `ComicBook`, qui fait la même chose que dans `Book` (fonction `super()`), puis affiche `"Comic book mis à jour"`
|
||||
- Testez les méthodes sur deux objets, de type `Book` et `ComicBook`.
|
||||
|
||||
== Exercice B1 (staticmethod)
|
||||
## Exercice B1 (staticmethod)
|
||||
|
||||
- Écrivez une méthode statique dont la syntaxe est correcte.
|
||||
- Écrivez une méthode statique dont la syntaxe est correcte.
|
||||
@ -1,34 +0,0 @@
|
||||
= Exercices sur les fichiers texte
|
||||
|
||||
== Exercice 1
|
||||
|
||||
- Écrivez un fichier texte, dans lequel vous écrivez les lignes suivantes :
|
||||
* `Il est un feu discret qui se cache en ton âme,`
|
||||
* `Mais qui tremble et palpite à tous les coups du sort :`
|
||||
* `C'est l'espoir ! Défends bien cette petite flamme ;`
|
||||
* `Si la flamme s'éteint, ami, ton cœur est mort.`
|
||||
- Pensez bien aux `"\n"` pour passer à la ligne !
|
||||
|
||||
== Exercice 2
|
||||
|
||||
- Ouvrez à nouveau votre fichier texte, mais en lecture
|
||||
- Pour relire et afficher les lignes du fichier une à une
|
||||
- Utilisez une boucle `while` :
|
||||
* `line = <lire une ligne>`
|
||||
* `while line != "":`
|
||||
* `<afficher la ligne>`
|
||||
* `<lire la ligne suivante>`
|
||||
|
||||
ou
|
||||
|
||||
- Variante de boucle avec la syntaxe de `Python 3.8`
|
||||
* `while line := <lire une ligne>:`
|
||||
* <afficher la ligne>
|
||||
|
||||
== Exercice 3 (ouverture avec `with`)
|
||||
|
||||
- Remplacez le code des deux exercices précédents pour utiliser un gestionnaire de contexte.
|
||||
|
||||
|
||||
|
||||
|
||||
30
training/exercices/08-text-files/01-text.md
Normal file
30
training/exercices/08-text-files/01-text.md
Normal file
@ -0,0 +1,30 @@
|
||||
# Exercices sur les fichiers texte
|
||||
|
||||
## Exercice 1
|
||||
|
||||
- Écrivez un fichier texte, dans lequel vous écrivez les lignes suivantes :
|
||||
- `Il est un feu discret qui se cache en ton âme,`
|
||||
- `Mais qui tremble et palpite à tous les coups du sort :`
|
||||
- `C'est l'espoir ! Défends bien cette petite flamme ;`
|
||||
- `Si la flamme s'éteint, ami, ton cœur est mort.`
|
||||
- Pensez bien aux `"\n"` pour passer à la ligne !
|
||||
|
||||
## Exercice 2
|
||||
|
||||
- Ouvrez à nouveau votre fichier texte, mais en lecture
|
||||
- Pour relire et afficher les lignes du fichier une à une
|
||||
- Utilisez une boucle `while` :
|
||||
- `line = <lire une ligne>`
|
||||
- `while line != "":`
|
||||
- `<afficher la ligne>`
|
||||
- `<lire la ligne suivante>`
|
||||
|
||||
ou
|
||||
|
||||
- Variante de boucle avec la syntaxe de `Python 3.8`
|
||||
- `while line := <lire une ligne>:`
|
||||
- <afficher la ligne>
|
||||
|
||||
## Exercice 3 (ouverture avec `with`)
|
||||
|
||||
- Remplacez le code des deux exercices précédents pour utiliser un gestionnaire de contexte.
|
||||
@ -1,39 +1,35 @@
|
||||
= Exercices sur les fichiers texte JSON, CSV etc.
|
||||
# Exercices sur les fichiers texte JSON, CSV etc.
|
||||
|
||||
== Exercice 1 (JSON)
|
||||
## Exercice 1 (JSON)
|
||||
|
||||
- Convertissez le contenu du fichier JSON proposé sur le dépôt Git en structure Python
|
||||
- La donnée lue depuis le fichier JSON contient un dictionnaire
|
||||
* Quelle notation d'accès aux données du dictionnaire allez-vous utiliser pour récupérer la valeur suivante ?
|
||||
* `"New York Bulls"`
|
||||
- Quelle notation d'accès aux données du dictionnaire allez-vous utiliser pour récupérer la valeur suivante ?
|
||||
- `"New York Bulls"`
|
||||
- Indice : `data["quiz"]["sport"]...`
|
||||
|
||||
== Exercice 2 (JSON, écriture)
|
||||
## Exercice 2 (JSON, écriture)
|
||||
|
||||
- Créez une structure Python étant une liste ou un dictionnaire
|
||||
- Écrivez un fichier JSON valide depuis cette structure
|
||||
- Le fichier doit être indenté (`json.dumps(data, indent=4)`)
|
||||
|
||||
== Exercice 3 (CSV)
|
||||
## Exercice 3 (CSV)
|
||||
|
||||
- Ouvrez à nouveau votre fichier texte, mais en lecture
|
||||
- Pour relire et afficher les lignes du fichier une à une
|
||||
- Utilisez une boucle `while` :
|
||||
* `line = <lire une ligne>`
|
||||
* `while line != "":`
|
||||
* `<afficher la ligne>`
|
||||
* `<lire la ligne suivante>`
|
||||
- `line = <lire une ligne>`
|
||||
- `while line != "":`
|
||||
- `<afficher la ligne>`
|
||||
- `<lire la ligne suivante>`
|
||||
|
||||
ou
|
||||
|
||||
- Variante de boucle avec la syntaxe de `Python 3.8`
|
||||
* `while line := <lire une ligne>:`
|
||||
* <afficher la ligne>
|
||||
|
||||
== Exercice 3 (ouverture avec `with`)
|
||||
|
||||
- Remplacez le code des deux exercices précédents pour utiliser un gestionnaire de contexte.
|
||||
|
||||
|
||||
- `while line := <lire une ligne>:`
|
||||
- <afficher la ligne>
|
||||
|
||||
## Exercice 3 (ouverture avec `with`)
|
||||
|
||||
- Remplacez le code des deux exercices précédents pour utiliser un gestionnaire de contexte.
|
||||
@ -1,81 +0,0 @@
|
||||
= Atelier sur la première partie
|
||||
|
||||
L'atelier suivant vous fait construire une structure où vous pouvez :
|
||||
|
||||
- créer des bibliothèques
|
||||
- créer des livres
|
||||
- créer des utilisateurs
|
||||
|
||||
Et avec ces objets, vous pouvez :
|
||||
|
||||
- ajouter des livres à vos bibliothèques
|
||||
- emprunter et rendre des livres
|
||||
- voir les informations sur les emprunts
|
||||
- voir les informations sur les livres présents dans une bibliothèque
|
||||
- etc.
|
||||
|
||||
L'exercice, qui peut vous prendre un peu de temps, vous permet de :
|
||||
|
||||
- manipuler des objets, listes, dictionnaires
|
||||
- utiliser des f-strings pour afficher des informations en console
|
||||
- utiliser des méthodes et même découvrir la méthode `_ _ str _ _` (faites une recherche Google)
|
||||
- structurer un peu votre code (concept limité par la taille de l'exercice)
|
||||
|
||||
== Organisation
|
||||
|
||||
- un package `entities` contenant
|
||||
* un module `library` pour y mettre la classe `Library`
|
||||
* un module `book` pour y mettre la classe `Book`
|
||||
* un module `user` pour y mettre la classe `User`
|
||||
- un module `application` vous servant de point d'entrée
|
||||
|
||||
l'organisation est simple, ceci dû à la taille du projet. Des projets grandissants impliquent souvent des réorganisations.
|
||||
|
||||
== Des bibliothèques
|
||||
|
||||
. Créez une classe `Library`
|
||||
. Avec des attributs
|
||||
- `name` (`None`)
|
||||
- `is_open` (`True`)
|
||||
- `books` (`None`)
|
||||
. Avec des méthodes
|
||||
. `_ _ init _ _(self, name=None, is_open=True)` qui initialise les attributs du nouvel objet.
|
||||
. `open(self, value=True)` pour changer l'état d'ouverture :
|
||||
- Ne fait rien si `value` a déjà la même valeur que `self.is_open`
|
||||
. `register_book(self, book)` qui ajoute un livre à l'attribut `.books` (le transforme d'abord en liste s'il est à `None`, puis ajoute le livre)
|
||||
. `show_books()` qui affiche la liste des livres enregistrés
|
||||
. `_ _ str _ _(self)` qui renvoie le texte affiché si on fait `print()` sur l'objet
|
||||
. `get_book_avg_prices()` qui renvoie le prix moyen des livres de la bibliothèque
|
||||
|
||||
== Des livres
|
||||
|
||||
. Créez une classe `Book`
|
||||
. Avec des attributs
|
||||
- `title` (`None`)
|
||||
- `author` (`None`)
|
||||
- `is_borrowed` (`False`) : le livre est-il emprunté
|
||||
- `borrower` (`None`) : personne qui a emprunté
|
||||
- `history` (`None`) : liste des opérations d'emprunt du livre
|
||||
- `price` (`0`) : prix de base
|
||||
. Avec des méthodes
|
||||
. `_ _ init _ _(self, ...)` pour initialiser les attributs `title`, `price` et `author`
|
||||
. `borrow(self, user)` qui marque le livre comme emprunté, et modifie `borrower` :
|
||||
- Ne fait rien si le livre est déjà marqué emprunté, sinon :
|
||||
- `is_borrowed` devient `True`
|
||||
- `borrower` prend la référence de l'objet de la classe `User`
|
||||
- `history` *devient* une liste à laquelle on ajoute le dictionnaire `{"user": user, "when": datetime.now()}`
|
||||
. `return_borrow(self)` qui marque le livre comme rendu (non emprunté)
|
||||
- Ne fait rien si le livre est déjà marqué comme non emprunté, sinon :
|
||||
- `borrower` prend la valeur `None`
|
||||
. `show_history(self)` qui affiche l'historique formaté des emprunts
|
||||
. `show_status(self)` qui affiche le statut du livre : titre, emprunté etc.
|
||||
|
||||
|
||||
== Des utilisateurs
|
||||
|
||||
. Créez une classe `User`
|
||||
. Avec des attributs
|
||||
- `name` (`None`)
|
||||
. Avec des méthodes
|
||||
. `_ _ init _ _(self, name=None)` qui initialise l'attribut de l'objet
|
||||
. `_ _ str _ _ (self)` qui renvoie une chaîne `f"Utilisateur : {self.name}"`
|
||||
80
training/exercices/extra-initiation/library.md
Normal file
80
training/exercices/extra-initiation/library.md
Normal file
@ -0,0 +1,80 @@
|
||||
# Atelier sur la première partie
|
||||
|
||||
L'atelier suivant vous fait construire une structure où vous pouvez :
|
||||
|
||||
- créer des bibliothèques
|
||||
- créer des livres
|
||||
- créer des utilisateurs
|
||||
|
||||
Et avec ces objets, vous pouvez :
|
||||
|
||||
- ajouter des livres à vos bibliothèques
|
||||
- emprunter et rendre des livres
|
||||
- voir les informations sur les emprunts
|
||||
- voir les informations sur les livres présents dans une bibliothèque
|
||||
- etc.
|
||||
|
||||
L'exercice, qui peut vous prendre un peu de temps, vous permet de :
|
||||
|
||||
- manipuler des objets, listes, dictionnaires
|
||||
- utiliser des f-strings pour afficher des informations en console
|
||||
- utiliser des méthodes et même découvrir la méthode `__str__` (faites une recherche Google)
|
||||
- structurer un peu votre code (concept limité par la taille de l'exercice)
|
||||
|
||||
## Organisation
|
||||
|
||||
- un package `entities` contenant
|
||||
- un module `library` pour y mettre la classe `Library`
|
||||
- un module `book` pour y mettre la classe `Book`
|
||||
- un module `user` pour y mettre la classe `User`
|
||||
- un module `application` vous servant de point d'entrée
|
||||
|
||||
L'organisation est simple, ceci dû à la taille du projet. Des projets grandissants impliquent souvent des réorganisations.
|
||||
|
||||
## Des bibliothèques
|
||||
|
||||
1. Créez une classe `Library`
|
||||
- Avec des attributs
|
||||
- `name` (`None`)
|
||||
- `is_open` (`True`)
|
||||
- `books` (`None`)
|
||||
- Avec des méthodes
|
||||
- `__init__(self, name=None, is_open=True)` qui initialise les attributs du nouvel objet.
|
||||
- `open(self, value=True)` pour changer l'état d'ouverture :
|
||||
- Ne fait rien si `value` a déjà la même valeur que `self.is_open`
|
||||
- `register_book(self, book)` qui ajoute un livre à l'attribut `.books` (le transforme d'abord en liste s'il est à `None`, puis ajoute le livre)
|
||||
- `show_books()` qui affiche la liste des livres enregistrés
|
||||
- `__str__(self)` qui renvoie le texte affiché si on fait `print()` sur l'objet
|
||||
- `get_book_avg_prices()` qui renvoie le prix moyen des livres de la bibliothèque
|
||||
|
||||
## Des livres
|
||||
|
||||
1. Créez une classe `Book`
|
||||
- Avec des attributs
|
||||
- `title` (`None`)
|
||||
- `author` (`None`)
|
||||
- `is_borrowed` (`False`) : le livre est-il emprunté
|
||||
- `borrower` (`None`) : personne qui a emprunté
|
||||
- `history` (`None`) : liste des opérations d'emprunt du livre
|
||||
- `price` (`0`) : prix de base
|
||||
- Avec des méthodes
|
||||
- `__init__(self, ...)` pour initialiser les attributs `title`, `price` et `author`
|
||||
- `borrow(self, user)` qui marque le livre comme emprunté, et modifie `borrower` :
|
||||
- Ne fait rien si le livre est déjà marqué emprunté, sinon :
|
||||
- `is_borrowed` devient `True`
|
||||
- `borrower` prend la référence de l'objet de la classe `User`
|
||||
- `history` *devient* une liste à laquelle on ajoute le dictionnaire `{"user": user, "when": datetime.now()}`
|
||||
- `return_borrow(self)` qui marque le livre comme rendu (non emprunté)
|
||||
- Ne fait rien si le livre est déjà marqué comme non emprunté, sinon :
|
||||
- `borrower` prend la valeur `None`
|
||||
- `show_history(self)` qui affiche l'historique formaté des emprunts
|
||||
- `show_status(self)` qui affiche le statut du livre : titre, emprunté etc.
|
||||
|
||||
## Des utilisateurs
|
||||
|
||||
1. Créez une classe `User`
|
||||
- Avec des attributs
|
||||
- `name` (`None`)
|
||||
- Avec des méthodes
|
||||
- `__init__(self, name=None)` qui initialise l'attribut de l'objet
|
||||
- `__str__ (self)` qui renvoie une chaîne `f"Utilisateur : {self.name}"`
|
||||
Reference in New Issue
Block a user