Représentation graphique

Dans cette leçon nous allons créer un graphique pour observer certaines propriétés des entiers inférieurs à 100.

Nous avons déjà utilisé plusieurs modules, et Python en possède par défaut un certain nombre, comme les modules math et random. Il est également possible de créer ses propres modules pour étendre les fonctionnalités de base. Un ensemble de modules autour d'une fonctionnalité centrale forment une librairie.

Par exemple matplotlib est une librairie qui apporte tout ce qu'il faut pour faire des graphiques en Python. En temps normal les librairies doivent être installées avant d'être utilisées, mais ici l'environnement est conçu pour faire ça automatiquement.

1
Sur la première ligne de l'éditeur il y a un nouveau mot clé as. Il permet de donner un nom (plus court) à ce que l'on importe, un alias.

Par exemple je peux faire import random as r pour donner l'alias r au module random. Je peux alors appeler la fonction randint de ce module en faisant r.randint(1,6) pour générer un entier aléatoire entre 1 et 6.

La notation avec un point ressemble beaucoup aux méthodes. Normal, du point de vue de Python, c'est pareil ! randint est une fonction du module random et comme j'ai importé l'ensemble du module sous l'alias r, pour utiliser cette fonction je dois faire r.randint

La première ligne de l'éditeur importe le module pyplot de la librairie matplotlib et lui donne l'alias plt. On utilise couramment cet alias. Pour utiliser un sous-module spécifique d'une librairie on utilise un point entre les deux comme dans matplotlib.pyplot puisque pyplot existe à l'intérieur de matplotlib.

Faisons un premier exemple de graphique avec un nuage de points. Pour représenter un nuage de points, il nous faut la liste de leurs abscisses et la liste de leurs ordonnées. Par exemple
```
X = [1, 2, 3] # les abscisses
Y = [-1, 10, 5] # les ordonnées
```
Ensuite il faut demander à matplotlib de générer un graphique, et de l'afficher. Tu as l'habitude que l'affichage ne soit pas automatique. Ici c'est pareil il nous faut deux instructions :
```
plt.plot(X, Y, 'ro')
plt.show()
```
La fonction plot du module pyplot construit le graphique des Y en fonction de X. L'option 'ro' contient deux lettres, la première pour la couleur red et la seconde pour la forme des points. Donc on a des ronds rouges.

Ajoute le code précédent dans l'éditeur pour représenter un nuage de points, puis exécute le code. Lorsque c'est fait tu peux observer ton graphique en cliquant sur le bouton
Solution

Il nous faut une liste d'abscisses, une liste d'ordonnées, et les instructions pour construire le graphique et l'afficher :
```
import matplotlib.pyplot as plt

X = [1, 2, 3]
Y = [-1, 10, 5]

plt.plot(X, Y, 'ro')
plt.show()
```
2
À présent voyons une nouvelle opération en Python, le modulo. Cette opération nous permet de déterminer le reste d'une division euclidienne. Son symbole est %

Par exemple le reste de la division euclidienne de 16 par 5 est 1 car $16 = 3\times 5 + 1$ . Vérifions dans la console :
```
>>> 16 % 5
1
```
Le calcul précédent se lit "16 modulo 5 égale 1".

Quel est le reste de la division euclidienne de 23 par 5 ? Vérifie dans la console en faisant un calcul
Solution

Le reste de la division euclidienne de 23 par 5 est 3 car $23 = 4 \times 5 + 3$ . Vérifions dans la console :
```
>>> 23 % 5
3
```
3
On souhaite déterminer le nombre de diviseurs d'un entier. Pour t'aider, j'ai ajouté le début du code d'une fonction nb_diviseurs. Elle prend un entier n en argument, et initialise un compteur à zéro. On veut incrémenter ce compteur pour chaque diviseur de n

Pour ce faire une boucle for parcourt tous les nombres de 1 à n. Mais cette boucle ne fait rien. Tu peux observer le mot clé pass.

Supprime le mot clé pass et fini de coder la fonction nb_diviseurs en ajoutant une instruction conditionnelle : si n est divisible par i alors incrémente le compteur de 1. Indice : tu peux utiliser le modulo pour tester la divisibilité.
Solution

n est divisible par i lorsque le reste de la division euclidienne de n par i est 0. Donc la condition à vérifier estn % i == 0

Si la condition est vraie on incrémente compteur de 1. Sinon on ne fait rien
```
import matplotlib.pyplot as plt

def nb_diviseurs(n):
	compteur = 0
	for i in range(1, n+1):
		if n % i == 0:
			compteur = compteur + 1
	return compteur
```
4
Combien de diviseurs possède un nombre premier ? Vérifie que ta fonction nb_diviseurs fonctionne bien en l'appelant dans la console sur de petits nombres premiers.
Solution

Par exemple :
```
>>> nb_diviseurs(5)
2
```
5
On va représenter graphiquement le nombre de diviseurs des entiers inférieurs à 100.

Il nous faut deux listes. Pour les abscisses on prend les entiers de 1 à 100. Pour les ordonnées, on prend la liste de leurs images par nb_diviseurs.

Pour la liste des abscisses on pourrait faire X = [i for i in range(1,101)] mais il y a plus simple. La fonction list permet de convertir une séquence obtenue avec range en une liste. Par exemple :
```
>>> list(range(3))
[0, 1, 2]
```
Essaie dans la console pour t'en convaincre. Ensuite défini de cette manière une variable X dans l'éditeur qui contient tous les entiers de 1 à 100 inclus.

Pour les ordonnées, il nous faut les images des entiers de la liste X par la fonction nb_diviseurs. Défini une liste Y en compréhension qui contient le nombre de diviseurs de chaque élément de X
Solution

La liste X s'obtient en convertissant la séquence range(1,101) à l'aide de la fonction list.

La liste Y s'obtient en compréhension : on applique nb_diviseurs à chaque élément de X :
```
import matplotlib.pyplot as plt

def nb_diviseurs(n):
	compteur = 0
	for i in range(1, n+1):
		if n % i == 0:
			compteur = compteur + 1
	return compteur

X = list(range(1, 101))
Y = [nb_diviseurs(x) for x in X]
```
6
Il ne reste plus qu'à représenter ce nuage de point !

Ajoute le code nécessaire pour générer le graphique des Y en fonction des X à l'aide du module pyplot
Solution

Comme à la question 1 il nous reste à appeler les fonctions plot et show du module pyplot. Utilisons l'option 'b.' pour avoir des points bleus :
```
import matplotlib.pyplot as plt

def nb_diviseurs(n):
	compteur = 0
	for i in range(1, n+1):
		if n % i == 0:
			compteur = compteur + 1
	return compteur

X = list(range(1, 101))
Y = [nb_diviseurs(x) for x in X]

plt.plot(X, Y, 'b.')
plt.show()
```

Cette leçon t'as fait découvrir la librairie matplotlib, nous avons vu comment représenter un nuage de points avec le module pyplot, comment faire un calcul de modulo, et comment utiliser la fonction list pour convertir !