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

ajout representation construits

Browse Source
This commit is contained in:
Florian Mathieu
2021-11-15 16:41:55 +01:00
parent 2d8c726977
commit 779024ea47
58 changed files with 7068 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
representation_construits/chapitre_2/exercices/CORRECTION.md Normal file
View File

@@ -0,0 +1,166 @@
## Exercice
### Itérer sur les éléments d'un dictionnaire
Au zoo de Beauval, il y a 5 éléphants d'Asie, 17 écureuils d'Asie, 7 hippopotames d'Afrique...
On représente cet inventaire à l'aide d'un dictionnaire, de la façon suivante:
```python
zoo_Beauval = {
'elephant' : ('Asie', 5),
'ecureuil' : ('Asie', 17),
'panda' : ('Asie', 2),
'hippopotame' : ('Afrique', 7),
'girafe' : ('Afrique', 4)
}
```
De la même manière, on peut représenter le zoo de La Flèche :
```python
zoo_LaFleche = {
'ours' : ('Europe', 4),
'tigre' : ('Asie', 7),
'girafe' : ('Afrique', 11),
'hippopotame' : ('Afrique', 3)
}
```
#### Question n°1
On souhaite créer une fonction *plus_grand_nombre* ( ) qui prend un zoo en paramètre et renvoie le nom de l'animal le plus présent au sein du zoo.
Exemples :
```python
>> plus_grand_nombre(zoo_LaFleche)
>> 'girafe'
```
```python
>> plus_grand_nombre(zoo_Beauval)
>> 'ecureuil'
```
On aura besoin d'une boucle utilisant
```python
for (cle, valeur) in dico.items()
```
À votre avis, pourquoi ?
**Nous avons besoin à la fois des clés ainsi que des valeurs**
Écrire la fonction :
```python
def plus_grand_nombre(zoo):
"""
:param: zoo est un dictionnaire dont les clés sont des str (noms des animaux)
:param: les valeurs de ces clés sont des tuples (origine, nombre) avec origine : str et nombre : int
:return: le nom de l'animal le plus représenté dans le zoo, sous la forme d'une chaîne de caractères
"""
nom_max = 0
nombre_max = 0
for (nom, (x, nombre)) in zoo.items():
if nombre > nombre_max:
nom_max = nom
nombre_max = nombre
return nom_max
```
Note : ici, la variable **x** fait référence à une donnée que nous n'utilisons pas.
#### Question n°2
On souhaite se doter d'une fonction *nombre_total* ( ) qui prend un zoo ainsi que le nom d'un continent en paramètre, et qui renvoie le nombre d'animaux originaires de ce continent dans le zoo.
Exemples :
```python
>> nombre_total(zoo_LaFleche, 'Afrique')
>> 14
```
```python
>> nombre_total(zoo_Beauval, 'Asie')
>> 24
```
On utilisera une boucle
```python
for valeur in dico.values()
```
Pourquoi ?
**Parce que l'on a uniquement besoin des valeurs, l'espèce animal n'est pas importante**
Écrire la fonction :
```python
def nombre_total(zoo, continent):
"""
:param: zoo est un dictionnaire dont les clés sont des chaines, correspondantes aux noms des animaux
:param: et dont les valeurs sont des tuples (origine, nombre), origine étant une chaine, nombre un int
:param: continent est une chaine comprenant le nom d'un continent d'où sont originaires les animaux
:return: la fonction renvoie le nombre d'animaux originaires de 'continent' dans ce zoo
"""
total = 0
for (origine, nombre) in zoo.values():
if continent == origine:
total = total + nombre
return total
```
#### Question n°3
Enfin, on souhaite écrire une fonction nombre, qui prendun zoo ainsi qu'un nom d'animal en paramètre, et qui renvoie le nombre de représentants de cet animal dans le zoo.
Exemples :
````python
>> nombre(zoo_LaFleche, 'panda')
>> 0
````
```python
>> nombre(zoo_Beauval, 'panda')
>> 2
```
Quel type de boucle va t-on utiliser ici ?
**Aucune, car nous n'avons uniquement besoin que de la clé, qui est un paramètre de la fonction.**
Écrire la fonction
```python
def nombre(zoo, animal):
"""
:param: zoo est un dictionnaire dont les clés sont des chaines, correspondantes aux noms des animaux
:param: et dont les valeurs sont des tuples (origine, nombre), origine étant une chaine, nombre un int
:param: animal est une chaine comprenant le nom d'un animal
:return: la fonction renvoie le nombre de représentants du paramètre 'animal' dans ce zoo
"""
if animal not in zoo.keys():
return 0
else:
return zoo[animal][1]
```

80
representation_construits/chapitre_2/exercices/CORRECTION_2.md Normal file
View File

@@ -0,0 +1,80 @@
## Exercice n°2
Pour remplir le pokedex de Sacha, on modélise les informations sur les Pokemons de la façon suivante :
```python
liste_pokemons = {
'Bulbizarre' : (70, 7),
'Herbizarre' : (100,13),
'Abo' : (200, 7),
'Pikachu' : (40, 6)
}
```
Les tuples représentent la taille en centimètres, ainsi que le poids en kilogramme du Pokemon.
#### Questions :
- Quel est le type de *liste_pokemons* ?
- **Il s'agit d'un dictionnaire, dont les clés sont des chaines de caractères représentant les nomsdes Pokemons, et les valeurs des tuples de deux entiers correspondant à la taille en cm et au poids en kg**
- Quelle instruction permet d'ajouter à cette structure de données le Pokemon Goupil qui mesure 60 cm et pèse 10 kg ?
- **liste_pokemons["Goupix"] = (60, 10)**
On donne le code suivant :
```python
def le_plus_grand(pokemons):
grand = None
taille_max = None
for (nom,(taille, poids)) in pokemons.items():
taille_max = taille
grand = nom
return(grand,taille_max)
```
- Quelle est la valeur de *le_plus_grand(liste_pokemons)* ?
- **Il s'agira du nom et de la taille du Pokemon le plus grand rencontré dans le dictionnaire (en cas d'égalité, il s'agira du premier Pokémon rencontré) sous la forme d'un tuple**
- Écrire le code d'une fonction *le_plus_leger(liste_pokemons)* qui prend des Pokémons en paramètre et renvoie un tuple correspondant au nom ainsi qu'au poids de Pokémon le plus léger.
```python
>> le_plus_leger(liste_pokemons)
>> ('Pikachu', 6)
```
```python
def le_plus_leger(liste_pokemons):
leger = None
poids_min = None
for (nom, (taille, poids)) in liste_pokemons.items():
if poids_min > poids
poids_min = poids
leger = nom
return (leger, poids_min)
```
- Écrire une fonction *taille* qui prend en paramère un dictionnaire de Pokémons ainsi que le nom d'un Pokémon, et qui renvoie la taille de ce Pokémon.
```python
>> taille(liste_pokemons, 'Abo')
>> 200
```
```python
>> taille(liste_pokemons, 'Dracaufeu')
>> None
```
```python
def taille(liste_pokemons, nom):
if noms in liste_pokemons:
return pokemon[nom][0]
else:
return None
```

148
representation_construits/chapitre_2/exercices/README.md Normal file
View File

@@ -0,0 +1,148 @@
## Exercice
### Itérer sur les éléments d'un dictionnaire
Au zoo de Beauval, il y a 5 éléphants d'Asie, 17 écureuils d'Asie, 7 hippopotames d'Afrique...
On représente cet inventaire à l'aide d'un dictionnaire, de la façon suivante:
```python
zoo_Beauval = {
'elephant' : ('Asie', 5),
'ecureuil' : ('Asie', 17),
'panda' : ('Asie', 2),
'hippopotame' : ('Afrique', 7),
'girafe' : ('Afrique', 4)
}
```
De la même manière, on peut représenter le zoo de La Flèche :
```python
zoo_LaFleche = {
'ours' : ('Europe', 4),
'tigre' : ('Asie', 7),
'girafe' : ('Afrique', 11),
'hippopotame' : ('Afrique', 3)
}
```
#### Question n°1
On souhaite créer une fonction *plus_grand_nombre* ( ) qui prend un zoo en paramètre et renvoie le nom de l'animal le plus présent au sein du zoo.
Exemples :
```python
>> plus_grand_nombre(zoo_LaFleche)
>> 'girafe'
```
```python
>> plus_grand_nombre(zoo_Beauval)
>> 'ecureuil'
```
On aura besoin d'une boucle utilisant
```python
for (cle, valeur) in dico.items()
```
À votre avis, pourquoi ?
Écrire la fonction :
```python
def plus_grand_nombre(zoo):
"""
:param: zoo est un dictionnaire dont les clés sont des str (noms des animaux)
:param: les valeurs de ces clés sont des tuples (origine, nombre) avec origine : str et nombre : int
:return: le nom de l'animal le plus représenté dans le zoo, sous la forme d'une chaîne de caractères
"""
pass
```
#### Question n°2
On souhaite se doter d'une fonction *nombre_total* ( ) qui prend un zoo ainsi que le nom d'un continent en paramètre, et qui renvoie le nombre d'animaux originaires de ce continent dans le zoo.
Exemples :
```python
>> nombre_total(zoo_LaFleche, 'Afrique')
>> 14
```
```python
>> nombre_total(zoo_Beauval, 'Asie')
>> 24
```
On utilisera une boucle
```python
for valeur in dico.values()
```
Pourquoi ?
Écrire la fonction :
```python
def nombre_total(zoo, continent):
"""
:param: zoo est un dictionnaire dont les clés sont des chaines, correspondantes aux noms des animaux
:param: et dont les valeurs sont des tuples (origine, nombre), origine étant une chaine, nombre un int
:param: continent est une chaine comprenant le nom d'un continent d'où sont originaires les animaux
:return: la fonction renvoie le nombre d'animaux originaires de 'continent' dans ce zoo
"""
pass
```
#### Question n°3
Enfin, on souhaite écrire une fonction nombre, qui prendun zoo ainsi qu'un nom d'animal en paramètre, et qui renvoie le nombre de représentants de cet animal dans le zoo.
Exemples :
````python
>> nombre(zoo_LaFleche, 'panda')
>> 0
````
```python
>> nombre(zoo_Beauval, 'panda')
>> 2
```
Quel type de boucle va t-on utiliser ici ?
Écrire la fonction
```python
def nombre(zoo, animal):
"""
:param: zoo est un dictionnaire dont les clés sont des chaines, correspondantes aux noms des animaux
:param: et dont les valeurs sont des tuples (origine, nombre), origine étant une chaine, nombre un int
:param: animal est une chaine comprenant le nom d'un animal
:return: la fonction renvoie le nombre de représentants du paramètre 'animal' dans ce zoo
"""
pass
```

58
representation_construits/chapitre_2/exercices/README_2.md Normal file
View File

@@ -0,0 +1,58 @@
## Exercice n°2
Pour remplir le pokedex de Sacha, on modélise les informations sur les Pokemons de la façon suivante :
```python
liste_pokemons = {
'Bulbizarre' : (70, 7),
'Herbizarre' : (100,13),
'Abo' : (200, 7),
'Pikachu' : (40, 6)
}
```
Les tuples représentent la taille en centimètres, ainsi que le poids en kilogramme du Pokemon.
#### Questions :
- Quel est le type de *liste_pokemons* ?
- Quelle instruction permet d'ajouter à cette structure de données le Pokemon Goupil qui mesure 60 cm et pèse 10 kg ?
On donne le code suivant :
```python
def le_plus_grand(pokemons):
grand = None
taille_max = None
for (nom,(taille, poids)) in pokemons.items():
taille_max = taille
grand = nom
return(grand,taille_max)
```
- Quelle est la valeur de *le_plus_grand(liste_pokemons)* ?
- Écrire le code d'une fonction *le_plus_leger(liste_pokemons)* qui prend des Pokémons en paramètre et renvoie un tuple correspondant au nom ainsi qu'au poids de Pokémon le plus léger.
```python
>> le_plus_leger(liste_pokemons)
>> ('Pikachu', 6)
```
- Écrire une fonction *taille* qui prend en paramère un dictionnaire de Pokémons ainsi que le nom d'un Pokémon, et qui renvoie la taille de ce Pokémon.
```python
>> taille(liste_pokemons, 'Abo')
>> 200
```
```python
>> taille(liste_pokemons, 'Dracaufeu')
>> None
```