• 6 heures
  • Facile

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 04/02/2019

Calculez l'agréabilité moyenne d'une zone

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

 

Nous y sommes presque ! Comment calcule-t-on la densité de population ? Nous avons la population par zone. Il ne nous manque plus qu'à calculer la surface en kilomètres carrés.

Conversion en kilomètres

Actuellement nous n'avons que la longitude et la latitude en radians. Il nous faut les convertir en kilomètres avant de pouvoir les utiliser pour calculer une surface.

Ne vous inquiétez pas, nous n'allons pas faire de maths très avancés !

En cherchant un peu, j'ai trouvé que nous pouvons calculer la largeur d'une surface à partir de sa longitude (en radians). Il suffit de multiplier un angle, en radian, par le rayon de la Terre (en kilomètres).

Créons une nouvelle méthode  width(). Etant donné que ce sera une valeur qui sera renvoyée et que je ne veux pas particulièrement faire une action, transformons-la en une propriété :

class Zone
    ...
    @property
    def width(self):

Etant donné que le rayon de la Terre ne sera pas amené à changer, je crée un nouvel attribut de classe :

class Zone:
    ...
    EARTH_RADIUS_KILOMETERS = 6371

Et je mets à jour la propriété  width() :

class Zone
...
    @property
    def width(self):
        return (self.corner1.longitude - self.corner2.longitude) * self.EARTH_RADIUS_KILOMETERS

Je vais vérifier que ça fonctionne en ajoutant un print() à ma fonction  main()

C'est plutôt pas mal... sauf que les largeurs sont parfois négatives ! Pourquoi ? Car la longitude de corner1 est inférieure à la longitude de  corner2. Si vous écrivez  "3 - 4", le résultat sera -1 ! Il en est de même ici.

Pour éviter cela, transformons la longitude en valeur absolue.

Une valeur absolue est un nombre qui est soit nul, soit positif. La valeur absolue de -1 est donc... 1.
La librairie standard de Python contient une méthode qui s'appelle abs() et qui prend en paramètre un nombre. Il transforme ce dernier en valeur absolue. Utilisons-la !

class Zone
    ...
    
    @property
    def width(self):
       return abs(self.corner1.longitude - self.corner2.longitude) * self.EARTH_RADIUS_KILOMETERS
       
    @property
    def height(self):
        return abs(self.corner1.latitude - self.corner2.latitude) * self.EARTH_RADIUS_KILOMETERS

Kilomètres carrés

Ajoutons une nouvelle méthode pour calculer la surface d'une zone puis trouvons la densité de population :

class Zone
    ...
    
    @property
    def area(self):
        return self.height * self.width

    def population_density(self):
        return self.population / self.area

Agréabilité moyenne

Maintenant que nous avons la densité de population, il nous manque l'agréabilité moyenne d'une zone. Comment faire ? Nous allons ajouter l'agréabilité de toutes les personnes de la zone et diviser cette somme par le nombre de personnes. Une simple moyenne en fait ! :)

Etant donné que la division par zéro cause l'arrêt du programme, nous allons ajouter une condition : s'il n'y a pas d'habitant dans une zone, l'agréabilité sera de zéro.

class Zone:
    ...
    
    def average_agreeableness(self):
        if not self.inhabitants:
            return 0
        agreeableness = []
        for inhabitant in self.inhabitants:
            agreeableness.append(inhabitant.agreableness)
        return sum(agreeableness) / self.population

List comprehension

Que diriez-vous si je vous disais que vous pouvez condenser les 4 lignes de la boucle et celle de création de liste en une seule ? Vous sauteriez au plafond, n'est-ce pas ?! Hé bien oui ! Nous allons le faire !
Cela porte même le nom super sexy de "list comprehension".

Une list comprehension est une liste dans laquelle vous effectuez une opération pour créer cette même liste. Oui, je sais, nous repartons encore dans Inception... Reprenons notre exemple.

Nous commençons par écrire le résultat de l'action dans la liste. Dans notre cas, nous voulons que la liste contienne l'agréabilité d'un habitant. Puis nous indiquons la condition ou la boucle à effectuer. Dans notre cas, c'est une boucle for : 

[inhabitant.agreeableness for inhabitant in self.inhabitants]

Enfin, nous pouvons nous passer de la création d'une variable. Nous n'en avons pas besoin plus tard ! Nous allons donc effectuer l'opération directement dans la méthode sum() :

class Zone   
    ...
    def average_agreeableness(self):
        if not self.inhabitants:
            return 0
        return sum([inhabitant.agreeableness for inhabitant in self.inhabitants]) / self.population

Et voilà le travail !

Testons ! Je modifie la fonction main() pour afficher l'agréabilité moyenne. Et ça fonctionne ! \o/

Nous avons tous les éléments pour créer nos graphiques désormais ! Youpi ! Voyons comment faire dans le prochain chapitre. 

Code du chapitre

Retrouvez l'intégralité du code de ce chapitre ici : https://github.com/OpenClassrooms-Student-Center/la_poo_avec_python/blob/07_list_comp/model.py

 

Exemple de certificat de réussite
Exemple de certificat de réussite