fiche mémo : 1.5. Introduction aux listes.¶

Organisez vos données pour pouvoir les utiliser efficacement.¶

Vincent GODARD - V2.1 - 03/03/2025¶

Cours Introduction à la programmation¶

Département de géographie - L3 - Université de Paris 8¶

Traduction librement (largement) inspirée de : https://www.kaggle.com/code/alexisbcook/intro-to-lists

Sources :

Kaggle : https://www.kaggle.com/learn

Python Tutorial : https://www.w3schools.com/python/default.asp

Cours de Python : https://python.sdv.u-paris.fr/00_avant_propos/

Téléchargement des documents nécessaires :

Dossier compressé à télécharger => (pas utile ici).

1. Introduction¶¶

Lorsque vous faites de la science des données, vous avez besoin d'un moyen d'organiser vos données afin de pouvoir les utiliser efficacement. Python dispose de nombreuses structures de données disponibles pour contenir vos données, telles que des listes, des ensembles, des dictionnaires et des tuples. Dans ce didacticiel, vous apprendrez à travailler avec des listes Python.

2. Motivation¶¶

Dans le cadre du concours Petal to the Metal competition (https://www.kaggle.com/c/tpu-getting-started), votre objectif est de classer les espèces d'une fleur en fonction uniquement de son image. (Il s'agit d'une tâche courante en vision par ordinateur, appelée classification d'images.) Pour atteindre cet objectif, disons que vous organisez les noms des espèces de fleurs dans les données.

Une façon de procéder consiste à organiser les noms dans une chaîne Python.

In [ ]:
# Traduction des noms des fleurs de l'exemple :
# primevère rose, orchidée de poche à feuilles dures, clochettes de Canterbury, pois de senteur, souci anglais, lys tigré, orchidée de lune, oiseau de paradis, aconit, chardon globe
flowers = "pink primrose,hard-leaved pocket orchid,canterbury bells,sweet pea,english marigold,tiger lily,moon orchid,bird of paradise,monkshood,globe thistle"

print(type(flowers))
print(flowers)

Il est encore mieux de représenter les mêmes données dans une liste Python. Pour créer une liste, vous devez utiliser des crochets ([ , ]) et séparer chaque élément par une virgule. Chaque élément de la liste est une chaîne Python, donc chacun est placé entre guillemets.

In [ ]:
# Création d'une liste
flowers_list = ["pink primrose", "hard-leaved pocket orchid", "canterbury bells", "sweet pea", "english marigold", "tiger lily", "moon orchid", "bird of paradise", "monkshood", "globe thistle"]

print(type(flowers_list))
print(flowers_list)

À première vue, cela ne semble pas très différent, que vous représentiez les informations dans une chaîne Python ou dans une liste. Mais comme vous le verrez, il existe de nombreuses tâches que vous pouvez effectuer plus facilement avec une liste. Par exemple, une liste facilitera les opérations suivantes :

○ obtenir un élément à une position spécifiée (première, deuxième, troisième, etc.),
○ vérifier le nombre d'éléments, et
○ ajouter et supprimer des éléments.

3. Listes (Lists)¶

3.1. Longueur (Length)¶

Nous pouvons compter le nombre d'entrées dans n'importe quelle liste avec len(), qui est l'abréviation de "length". Il vous suffit de fournir le nom de la liste entre parenthèses.

In [ ]:
# La liste comporte dix entrées
print(len(flowers_list))
In [ ]:
## À quoi correspond :
print(len(flowers))

3.2. Indexation (indexing)¶¶

Nous pouvons faire référence à n'importe quel élément de la liste en fonction de sa position dans la liste (premier, deuxième, troisième, etc.). C'est ce qu'on appelle l'indexation.

Notez que Python utilise une indexation basée sur zéro, ce qui signifie que :

○ pour extraire la première entrée de la liste, vous utilisez 0,
○ pour extraire la deuxième entrée de la liste, vous utilisez 1, et
○ pour extraire la dernière entrée de la liste, vous utilisez un de moins que la longueur de la liste.
In [ ]:
# Affichez les première et deuxième entrées
print("Première entrée:", flowers_list[0])
print("Seconde entrée:", flowers_list[1])

# La liste a une longueur de dix, nous nous référons donc à l'entrée finale avec 9
print("Dernière entrée:", flowers_list[9])

Remarque : vous avez peut-être remarqué que dans la cellule de code ci-dessus, nous utilisons une seule fonction print() pour imprimer plusieurs éléments (à la fois une chaîne Python (comme « Première entrée : ») et une valeur de la liste (comme flowers_list[0]). Pour imprimer plusieurs éléments en Python avec une seule commande, il suffit de les séparer par une virgule.

3.3. Découpage (slicing)¶¶

Vous pouvez également extraire un segment d'une liste (par exemple, les trois premières entrées ou les deux dernières entrées). C'est ce qu'on appelle le découpage. Par exemple :

○ pour extraire les x premières entrées, vous utilisez [:x], et
○ pour extraire les y dernières entrées, vous utilisez [-y:].
In [ ]:
# Sélectionnez et affichez des entrées dans la liste
print("Les trois premières entrées:", flowers_list[:3])
print("Les deux dernières entrées:", flowers_list[-2:])

Comme vous pouvez le voir ci-dessus, lorsque nous découpons une liste, elle renvoie une nouvelle liste raccourcie.

3.4. Supprimer des éléments¶

Supprimez un élément d'une liste avec .remove() en plaçant l'élément que vous souhaitez supprimer entre parenthèses.

In [ ]:
# Supprimez une entrée dans la liste et affichez celles qui restent
flowers_list.remove("globe thistle")
print(flowers_list)

3.5. Ajout d'éléments¶¶

Ajoutez un élément à une liste avec .append() en plaçant l'élément que vous souhaitez ajouter entre parenthèses.

In [ ]:
# Ajoutez une entrée (le muflier ou gueule de loup) dans la liste et affichez celle-ci
flowers_list.append("snapdragon")
print(flowers_list)

3.6. Les listes ne sont pas uniquement destinées aux chaînes de caractères¶¶

Jusqu'à présent, nous n'avons travaillé qu'avec des listes où chaque élément de la liste est une chaîne de caractères. Mais les listes peuvent contenir des éléments avec n'importe quel type de données, y compris des booléens, des entiers et des nombres à virgule flottante.

À titre d'exemple, considérons les températures moyennes mensuelles (station météo de Paris-Montsouris - moyennes 1981-2010, https://www.meteo-paris.com/ile-de-france/climat.html).

In [ ]:
# Liste des températures moyennes mensuelles à Paris-Montsouris
temp_mens = [4.9, 5.6, 8.8, 11.5, 15.2, 18.3, 20.5, 20.3, 16.9, 13.0, 8.3, 5.5]

Ici, temp_mens est une liste d'entiers. Comme lorsque vous travaillez avec des chaînes, vous pouvez toujours faire des choses comme obtenir la longueur, extraire des entrées individuelles et étendre la liste.

In [ ]:
# Indiquez le nombre d'enregistrements (ici les mois) et affichez des entrées dans la liste
print("Length of the list:", len(temp_mens))
print("Entry at index 2:", temp_mens[2]) # Le troisième de la liste, soit mars !

Vous pouvez également obtenir le minimum avec min() et le maximum avec max().

In [ ]:
# Température moyenne mensuelle minimale et maximale à Paris-Montsouris
print("Minimum:", min(temp_mens))
print("Maximum:", max(temp_mens))

Pour ajouter chaque élément de la liste, utilisez sum().

In [ ]:
# Somme des températures moyennes mensuelles à Paris-Montsouris (est-ce que cela a du sens ?)
print("Somme des températures annuelle (", sum(temp_mens), "°C) à Paris-Montsouris")

Nous pouvons également effectuer des calculs similaires avec des tranches de la liste. Dans la cellule de code suivante, nous prenons la somme des cinq premiers mois (sum(temp_mens[:5])), puis nous la divisons par cinq pour obtenir le nombre moyen de degrés au cours des cinq premiers mois de l'année moyenne.

In [ ]:
# Moyenne des températures moyennes des cinq premiers mois à Paris-Montsouris (est-ce la bonne méthode ?)
print("Température moyenne des 5 premiers mois (", sum(temp_mens[:5])/5, "°C ) à Paris-Montsouris")
À vous de jouer !¶
In [ ]:
# Sauriez-vous calculer la moyenne annuelle (ici aussi une moyenne de moyennes !) ?
print("Température moyenne sur 12 mois (",  ????????, "°C ) à Paris-Montsouris")
In [ ]:
# Sauriez-vous calculer la moyenne des températures moyennes des cinq derniers mois à Paris-Montsouris (est-ce la bonne méthode ?)
print("Température moyenne des 5 derniers mois (",  ??????, "°C) à Paris-Montsouris")
In [ ]:
# Sauriez-vous calculer la moyenne des températures moyennes du premier et du dernier mois à Paris-Montsouris (est-ce la bonne méthode ?)
print("Température moyenne des 1er et dernier mois (",  ??????, "°C) à Paris-Montsouris")

4. Compléments¶

Quelques compléments sont proposés ici pour jouer avec les listes.

4.1. Modifier et compléter une liste¶

Dans une liste de cours de l'UE Informatique de base, du 1er semestre du master de géomatique, G2M, un cours du second semestre s'est glissé. Vous allez l'enlever et le remplacer par un cours du premier semestre qui avait été oublié.

Vous utiliserez .append() pour ajouter un élément et .remove() pour supprimer un élément.

In [ ]:
## Voici la proposition originale d'emploi du temps : 

edt_UE1 = ['Algorithmique et programmation', 'Système', 'Programmation Objet 2']


## Supprimez 'Programmation Objet 2' et remplacez le par 'Programmation Objet 1' à la fin de l'EduT

edt_UE1.remove('Programmation Objet 2')
edt_UE1.append('Programmation Objet 1')

# Vérifiez :

print("Emploi du temps de l'UE1 corrigé",  edt_UE1, "pour le premier semestre")

4.2. Faire quelques calculs¶

Voici le nombre d'étudiants qui ont fréquenté le DESU puis le master 2 de géomatique (G2M) de Paris 8 de 1999 à 2022.

DESU : 1999-2000, 2000-2001, 2001-2002, 2002-2003, 2003-2004, 2004-2005 (6 ans)

Master G2M M2

LMD1 : 2005-2006, 2006-2007, 2007-2008, 2008-2009 (4 ans)

LMD2 : 2009-2010, 2010-2011, 2011-2012, 2012-2013, 2013-2014, 2014-2015 (6 ans)

LMD3 : 2015-2016, 2016-2017, 2017-2018, 2018-2019, 2019-2020 (5 ans)

LMD4 : 2020-2021, 2021-2022.... (2 ans...)

In [ ]:
# Création de la liste du nombre d'étudiants annuels de DESU puis de M2 de 1999 à 2022
num_studiants = [10, 11, 16, 14, 10, 7,
                 10, 12, 15, 10,
                 14, 9, 8, 12, 15, 11,
                 14, 14, 18, 15, 17,
                 15, 20]

Voilà ce qu'il faudrait calculer comme statistiques :

  1. La somme des étudiants qui ont fréquenté le DESU de 1999 à 2005, soit six ans (six rentrées)

    sum_six_first_years = sum(num_studiants[:6])

  2. La moyenne du nombre d'étudiants qui ont fréquenté le DESU de 1999 à 2005, pendant six ans (six rentrées)

    avg_six_first_years = sum(num_studiants[:6])/6

  3. La moyenne du nombre d'étudiants qui ont fréquenté le G2M de 2020 à 2022, le début du LMD4, pendant deux ans (deux rentrées)

    avg_last_two_years = sum(num_studiants[-2:])/2

  4. La moyenne du nombre d'étudiants qui ont fréquenté le G2M de 2015 à 2020, le LMD3, pendant cinq ans (cinq rentrées), mais les indices commencent à 0

    avg_LMD3 = sum(num_studiants[16:21])/5

  5. Quelle a été l'année avec le maximum d'étudiants

    max_year = max(num_studiants)

  6. Quelle a été l'année avec le minimum d'étudiants

    min_year = min(num_studiants)

4.2.1 Vérification du rang d'une valeur¶

In [ ]:
## Vérification du rang de la première valeur dans une liste (0 ou 1 ?), de la troisième et des trois premières années
## Pour "jongler" avec la syntaxe

# Résultats :
print("Nb d'étudiants de la première année du DESU :", num_studiants[0]) # Le premier de la liste, soit 1999-2000 !
print("Nb d'étudiants de la troisième année du DESU :", num_studiants[2]) # Le troisième de la liste, soit 2001-2002 !
print("Nb d'étudiants de la troisième année du DESU :", num_studiants[2:3]) # Le troisième de la liste, soit 2001-2002 !
print("Nb d'étudiants de trois premières années :", num_studiants[0:3]) # Les trois premiers de la liste, soit de 1999-2000 à 2001-2002 !

# [0:3] => 0 = le premier (inclus), 3 = le quatrième (exclus) !
# Faites des essais !

4.2.2. Faire une somme¶

In [ ]:
## La somme des étudiants qui ont fréquenté le DESU de 1999 à 2005, soit six ans (six rentrées)
sum_six_first_years = sum(num_studiants[:6]) # le [0:6] est optionnel

# Résultat :
print("Somme des étudiants qui ont fréquenté le DESU de 1999 à 2005 =", sum_six_first_years, "étudiants")
In [ ]:
## La somme des étudiants qui ont fréquenté le DESU de 2002 à 2005, soit les trois dernières années (trois rentrées)
sum_three_last_years = sum(num_studiants[3:6])

# Résultat :
print("Somme des étudiants qui ont fréquenté le DESU de 2002 à 2005 =", sum_three_last_years, "étudiants")

4.2.3. Faire une moyenne (sur les premiers)¶

Jouer avec le début de la liste.

In [ ]:
## La moyenne du nombre d'étudiants qui ont fréquenté le DESU de 1999 à 2005, pendant six ans (six rentrées)
## Sans modifier le nombre de décimales
avg_six_first_years = sum(num_studiants[:6])/6  # le [0:6] est optionnel

# Résultat avec trop de décimales :
print("Moyenne du nombre d'étudiants qui ont fréquenté le DESU de 1999 à 2005 =", avg_six_first_years, " étudiants")
In [ ]:
## La moyenne du nombre d'étudiants qui ont fréquenté le DESU de 1999 à 2005, pendant six ans (six rentrées)
## En modifiant le nombre de décimales
avg_six_first_years = sum(num_studiants[:6])/6

# Résultat avec nombre de décimales choisi (une ici) :
print(f"Moyenne du nombre d'étudiants qui ont fréquenté le DESU de 1999 à 2005 = {avg_six_first_years:.1f} étudiants")

4.2.4. Faire une moyenne (sur les derniers)¶

Partir de la fin.

In [ ]:
## La moyenne du nombre d'étudiants qui ont fréquenté le G2M de 2020 à 2022, le début du LMD4, pendant deux ans (deux rentrées)
avg_last_two_years = sum(num_studiants[-2:])/2

# Résultat :
print("Moyenne du nombre d'étudiants qui ont fréquenté le G2M de 2020 à 2022 au début du LMD4 =", avg_last_two_years, " étudiants")

4.2.5. Faire une moyenne (au milieu)¶

Sur une portion centrale de la liste.

In [ ]:
## La moyenne du nombre d'étudiants qui ont fréquenté le G2M de 2015 à 2020, le LMD3, pendant cinq ans (cinq rentrées), mais les indices commencent à 0
avg_LMD3 = sum(num_studiants[16:21])/5

# Résultat :
print("Moyenne du nombre d'étudiants qui ont fréquenté le G2M de 2015 à 2020 pendant le LMD3 =", avg_LMD3, " étudiants")

4.2.6. Min et max¶

In [ ]:
## Quelle a été l'année avec le maximum d'étudiants
max_year = max(num_studiants)

# Résultat :
print("Quelle a été le nombre maximum d'étudiants en M2 =", max_year, " étudiants")
In [ ]:
## Quelle a été l'année avec le minimum d'étudiants
min_year = min(num_studiants)

# Résultat :
print("Quelle a été le nombre minimum d'étudiants en M2 =", min_year, " étudiants")

4.2.7. À vous de jouer¶

J'ai retrouvé deux années supplémentaires d'étudiants du G2M, dans le LMD4 :

○ 2022-2023 => 16 étudiants
○ 2023-2024 => 16 étudiants

Pourriez-vous les intégrer et faire les calculs suivants (cf. infra) ?

Pour l'intégration à la liste, je vous conseille d'utiliser .append(), déjà vu au 3.5 et au 4.1, deux fois de suite [attention de ne pas le faire plus, sinon il faudra utiliser remove()].

Utilisez len(num_studiants), ensuite, pour vérifier que vous avez 25 valeurs.

In [ ]:
## Complétement de la liste des promotions du G2M
num_studiants.append(16)
num_studiants.append(16)

# Résultat :
print("Liste des étudiants par année",  num_studiants, "pendant 25 ans")
In [ ]:
## Vérification du nombre d'années
len(num_studiants)

Quel LMD a la moyenne la plus élevée ?¶

In [ ]:
# Moyenne du LMD1
avg_lmd1 = 
# Moyenne du LMD2
avg_lmd2 = 
# Moyenne du LMD3
avg_lmd3 = 
# Moyenne du LMD4
avg_lmd4 = 

# Résultats :
print(f"Moyenne du nombre d'étudiants inscrits en G2M pendant le LMD1 = {avg_lmd1:.1f} étudiants")
print
print
print
In [ ]:
 

4.3. Jouer avec une liste¶

Dans le didacticiel, nous avons donné un exemple d'une chaîne Python avec des informations qui étaient meilleures sous forme de liste.

In [ ]:
## Succession de fleurs
flowers = "pink primrose,hard-leaved pocket orchid,canterbury bells,sweet pea,english marigold,tiger lily,moon orchid,bird of paradise,monkshood,globe thistle"

Vous pouvez en fait utiliser Python pour transformer rapidement cette chaîne en liste avec .split(). Dans les parenthèses, nous devons fournir le caractère qui doit être utilisé pour marquer la fin d'un élément de la liste et le début d'un autre, et le placer entre guillemets. Dans ce cas, ce caractère est une virgule.

In [ ]:
# Diviser, scinder
print(flowers.split(","))

C'est maintenant à votre tour d'essayer ! Créez deux listes Python :¶

  1. Vous venez de recopier sur le site de Géoconfluence (https://geoconfluences.ens-lyon.fr/glossaire) le glossaire qui est une succession de lettres séparées par des espaces et souhaitez en faire une liste Python pour initier des traitements. Les lettres doivent être une liste Python dans laquelle chaque entrée est une lettre majuscule de l'alphabet. Par exemple, les deux premières entrées doivent être « A » et « B », et les deux dernières entrées doivent être « Y » et « Z ». Utilisez la chaîne "glossaire" pour créer cette liste.
In [ ]:
# Copié-collé du glossaire entre deux doubles guillemets (") pour produire une liste alphabétique
glossaire = "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
letters = glossaire.split(" ")
print(letters)
  1. Vous avez extrait un certain nombre de références relatives à la ville de Beaune (http://geographie.ipt.univ-paris8.fr/rubriks/carto/cartorub/recherchebouquetcartes2.php?debut=12&saisie=beaune&res=33&tri=Titre) depuis le site de la cartothèque de Paris 8 (https://geographie.univ-paris8.fr/-cartotheque-) et ces références sont séparées par un ";". Vous souhaitez en faire une liste pour un traitement ultérieur.
In [ ]:
# Copié-collé d'un extrait de la liste de titres des cartes correspondant à Beaune
# entre deux doubles guillemets (") et le tout sur la même ligne pour produire une liste alphabétique
titres = "Beaune et environs;Carte de France type 1889. Beaune;Carte géologique détaillée de la France. Beaune;Carte géologique détaillée de la France. Beaune;Carte pédologique de la France. Beaune;Cartes géologiques simplifiées. Beaune;Cartes géologiques simplifiées. Plombiéres-lés-Dijon;Cartes géologiques simplifiées. Epinac-les-Mines - Beaune;Les vins de Bourgogne. Côte et hautes-côtes de Nuits"
cartes = titres.split(";")
print(cartes)

5. Construction d'un test de notation (rating)¶

Dans le cours "2. Initiation à Python", vous apprendrez tout sur les compréhensions de liste, qui permettent de créer une liste basée sur les valeurs d'une autre liste. Dans cette question, vous aurez un bref aperçu de leur fonctionnement.

Supposons que nous travaillions avec la liste ci-dessous.

In [ ]:
# Valeurs prises dans l'évaluation (de 1, le moins, à 5, le plus)
test_ratings = [1, 2, 3, 4, 5]

Nous pouvons ensuite utiliser cette liste (test_ratings) pour créer une nouvelle liste (test_liked) où chaque élément a été transformé en booléen, selon que l'élément est supérieur ou égal à quatre.

In [ ]:
# Test d'appréciation qui renvoie des booléens
test_liked = [i>=4 for i in test_ratings]
print(test_liked)

Dans cette question, vous utiliserez cette compréhension de liste pour définir une fonction percentage_liked() qui prend un argument en entrée :

○ ratings : liste des notes attribuées à un film par des personnes, où chaque note est un nombre compris entre 1 et 5 inclus

On dit que quelqu'un a aimé le film s'il a attribué une note de 4 ou 5. Votre fonction doit renvoyer le pourcentage de personnes qui ont aimé le film.

Par exemple, si nous fournissons une valeur de [1, 2, 3, 4, 5, 4, 5, 1], alors 50 % (4/8) des personnes ont aimé le film et la fonction doit renvoyer 0,5.

In [ ]:
## Construction du test

# 1) Rédaction de la fonction
def percentage_liked(ratings):
    list_liked = [i >= 4 for i in ratings]
    percentage_liked = sum(list_liked)/len(list_liked)
    return percentage_liked

# 2) Résultats de l'enquête sur lequel s'effectue le test (doit retourner 0.5)
percentage_liked([1, 2, 3, 4, 5, 4, 5, 1])

Si vous souhaitez une phrase d'accompagnement :

In [ ]:
## Construction du test

# 1) Rédaction de la fonction
def percentage_liked(ratings):
    list_liked = [i >= 4 for i in ratings]
    percentage_liked = sum(list_liked)/len(list_liked)
    return percentage_liked

# 2) Résultats de l'enquête sur lequel s'effectue le test (doit retourner 0.5)
result = percentage_liked([1, 2, 3, 4, 5, 4, 5, 1])

# 3) Affichage du résultat
print(f"La part des personnes ayant aimé le film est de : {result:.2f}")

Ou en pourcentage :

In [ ]:
## Construction du test

# 1) Rédaction de la fonction
def percentage_liked(ratings):
    list_liked = [i >= 4 for i in ratings]
    percentage_liked = sum(list_liked)/len(list_liked)
    return percentage_liked

# 2) Résultats de l'enquête sur lequel s'effectue le test (doit retourner 50%)
result = percentage_liked([1, 2, 3, 4, 5, 4, 5, 1])

# 3) Affichage du résultat
print(f"Le pourcentage de personnes ayant aimé le film est de : {result * 100:.1f}%")
# ou, sans décimales
print(f"Le pourcentage de personnes ayant aimé le film est de : {round(result * 100)}%")

6. Calcul d'accroissement¶

Vous souhaitez connaître l'accroissement ou la décroissance d'une population sur un lieu donné.

L'INSEE fournit la population de Paris par tranches d'âges (https://www.insee.fr/fr/statistiques/2011101?geo=DEP-75) pour 2010, 2015 et 2021.

La population, en recul, est pour ces années là, de : 2 243 833, 2 206 488, 2 133 111 habitants (Sources : Insee, RP2010, RP2015 et RP2021, exploitations principales, géographie au 01/01/2024). Sur le site wikipédia (https://fr.wikipedia.org/wiki/D%C3%A9mographie_de_Paris), il existe des données depuis l'antiquité.

Astuce : il est correct de soustraire deux nombres de la liste avant de diviser par un élément de la liste. Il vous suffit de modifier les positions des éléments extraits de la liste.

Pour extraire l'entrée finale de la liste "population", le recensement le plus récent, vous devez utiliser population[len(population)-1]. Cela correspond à la population recensée de l'année la plus récente.

Ensuite, pour obtenir la population d'un recensement précédent, vous devez utiliser population[len(population)-2].

Pour obtenir la population recensée d'il y a plusieurs recensements (non fournie ici), utilisez un incrément supérieur dans la liste.

In [ ]:
## Calcul de croissance ou décroissance par rapprt à la dernière année de recensement : 2021

# 1) Rédaction de la fonction
def percentage_accrois(population, ann_recen):
    accrois = (population[len(population)-1] - population[len(population)-ann_recen-1])/population[len(population)-ann_recen-1]
    return accrois

# Poupulation parisienne en 2010, 2015 et 2021
population_test = [2243833, 2206488, 2133111]

# 2) Résultats du calcul entre les recensements 2021 et 2015
result1 = percentage_accrois(population_test, 1)

print(f"Le taux d'accroissement à Paris entre 2021 et 2015 est de : {result1:.1%}")

#  3) Résultats du calcul entre les recensements 2021 et 2010
result2 = percentage_accrois(population_test, 2)

print(f"Le taux d'accroissement à Paris entre 2021 et 2010 est de : {result2:.1%}")
In [ ]:
## Pour calculer la population de la deuxième année la plus récente essayez :
print(population_test[len(population_test)-2])
In [ ]:
## Calcul de croissance ou décroissance par rapprt à l'avant dernière année de recensement : 2015

# 1) Rédaction de la fonction
def percentage_accrois(population, ann_recen):
    accrois = (population[len(population)-2] - population[len(population)-ann_recen-1])/population[len(population)-ann_recen-1]
    return accrois

# Poupulation parisienne en 2010, 2015 et 2021
population_test = [2243833, 2206488, 2133111]

# 2) Résultats du calcul entre les recensements 2015 et 2010
result1 = percentage_accrois(population_test, 2)

print(f"Le taux d'accroissement à Paris entre 2015 et 2010 est de : {result1:.1%}")
Sauriez-vous calculer le dernier taux d'accroissement positif à Paris ? Il remonte à 1954 (https://fr.wikipedia.org/wiki/Mod%C3%A8le:Tableau_D%C3%A9mographie_Paris).¶