Ajout de marqueurs et calques

  • folium.Marker()

    La fonction folium.Marker() permet d'ajouter un marqueur (un point d'intérêt) sur une carte Folium à une position géographique donnée. Ce marqueur peut être personnalisé avec des icônes, des popups, et d'autres propriétés, permettant ainsi d'afficher des informations sur des lieux ou des événements particuliers sur la carte.

    Importation :
    import folium
    Attributs :
    Paramètre Type Description Valeur par défaut
    location tuple (lat, lon) Les coordonnées géographiques (latitude et longitude) où le marqueur sera placé. None
    popup str ou folium.Popup Un texte ou un objet Popup à afficher lorsqu’un utilisateur clique sur le marqueur. None
    icon folium.Icon Icône à utiliser pour le marqueur (par exemple, une icône personnalisée ou une icône standard comme ‘cloud’ ou ‘info’). None
    tooltip str Texte qui apparaît lorsque l’utilisateur survole le marqueur. None
    Exemple de code :
    import folium

# Création de la carte centrée sur Paris
m = folium.Map(location=[48.8566, 2.3522], zoom_start=12)

# Ajout d'un marqueur avec un popup
folium.Marker(
    location=[48.8566, 2.3522],
    popup="C'est Paris !",
    icon=folium.Icon(icon='cloud', color='blue'),
    tooltip="Cliquez pour plus d'infos"
).add_to(m)

# Affichage de la carte
m
    Explication du code :

    1. Création de la carte : La carte est centrée sur Paris avec un niveau de zoom de 12.

    2. Ajout du marqueur : Un marqueur est ajouté à la position géographique de Paris. Ce marqueur affiche un texte (« C’est Paris ! ») dans un popup lorsqu’il est cliqué. Il utilise une icône « cloud » bleue, et un texte (« Cliquez pour plus d’infos ») apparaît lorsque l’utilisateur survole le marqueur.

    3. Affichage de la carte : La carte est affichée avec le marqueur et le popup.

    Remarque importante :

    • Personnalisation de l’icône : La fonction Marker() vous permet d’ajouter des icônes personnalisées grâce à la classe folium.Icon. Vous pouvez choisir parmi plusieurs icônes prédéfinies ou utiliser une image personnalisée. Cela permet d’améliorer l’apparence de vos cartes en fonction des besoins spécifiques de votre projet.

    • Interactivité avec le Popup et Tooltip : Les marqueurs peuvent afficher des informations supplémentaires en utilisant des popups et tooltips, ce qui est très utile pour fournir des détails sur les lieux ou les événements que vous souhaitez mettre en avant sur la carte.

    • Utilisation des événements de survol et de clic : Le marqueur peut être rendu interactif, ce qui permet d’afficher des informations supplémentaires lors du survol (tooltip) ou du clic (popup). Ces interactions ajoutent de la valeur à la carte en améliorant l’expérience utilisateur.

  • folium.CircleMarker()

    La fonction folium.CircleMarker() permet d'ajouter un cercle sur une carte Folium. Contrairement aux folium.Marker(), qui utilisent une icône pour représenter un emplacement, CircleMarker crée des cercles colorés et personnalisables qui peuvent être utilisés pour marquer des points d'intérêt sur la carte. Ces cercles peuvent être stylisés en fonction de leur taille, couleur, opacité, etc.

    Importation :
    import folium
    Attributs :
    Paramètre Type Description Valeur par défaut
    location tuple (lat, lon) Les coordonnées géographiques où le cercle sera affiché (latitude et longitude). None
    radius int ou float Le rayon du cercle, en pixels. Par défaut, il est de 10 pixels. 10
    color str La couleur du bord du cercle (ex : 'blue', 'red', 'green'). 'blue'
    fill_color str La couleur de remplissage du cercle (ex : 'blue', 'red', 'green'). 'blue'
    fill_opacity float Le niveau d’opacité du remplissage (entre 0 et 1). 0.2
    popup str ou folium.Popup Un popup à afficher lorsqu’un utilisateur clique sur le cercle. None
    Exemple de code :
    import folium

# Création de la carte centrée sur Paris
m = folium.Map(location=[48.8566, 2.3522], zoom_start=12)

# Ajout d'un CircleMarker
folium.CircleMarker(
    location=[48.8566, 2.3522],
    radius=20,
    color='blue',
    fill=True,
    fill_color='blue',
    fill_opacity=0.4,
    popup="Cercle à Paris"
).add_to(m)

# Affichage de la carte
m
    Explication du code :

    1. Création de la carte : La carte est centrée sur Paris avec un niveau de zoom de 12.

    2. Ajout du CircleMarker : Un cercle est ajouté à la carte avec une position géographique sur Paris. Le rayon du cercle est de 20 pixels, et il est rempli d’une couleur bleue avec une opacité de 0.4. Un popup est également ajouté au cercle.

    3. Affichage de la carte : La carte est affichée avec le cercle et le popup.

    Remarque importante :

    • Personnalisation de l’apparence : La fonction CircleMarker permet de personnaliser facilement les cercles en jouant sur les paramètres color, fill_color, fill_opacity, et radius. Cela permet de créer des visualisations de données attractives et de mettre en valeur certains points d’intérêt sur une carte.

    • Comparaison avec Marker : Contrairement aux folium.Marker(), qui sont basés sur des icônes, les CircleMarker() sont plus simples à utiliser et peuvent être plus adaptés si vous souhaitez créer des marqueurs homogènes pour chaque point géographique.

    • Interactivité : Comme avec d’autres objets Folium, les cercles peuvent être rendus interactifs en ajoutant des popups. Cela permet d’afficher des informations supplémentaires lorsque l’utilisateur clique sur un cercle.

  • folium.GeoJson()

    La fonction folium.GeoJson() permet d'ajouter un objet GeoJSON à une carte Folium. GeoJSON est un format standard pour représenter des données géospatiales, permettant de décrire des objets géométriques tels que des points, des lignes, des polygones, etc. Cette fonction permet d'intégrer facilement des données géospatiales sous forme de GeoJSON à une carte interactive.

    Importation :
    import folium
    Attributs :
    Paramètre Type Description Valeur par défaut
    geojson dict ou str Les données GeoJSON à afficher sur la carte. Cela peut être un dictionnaire Python ou une chaîne JSON. None
    name str Nom de la couche GeoJSON pour identifier cette couche dans le contrôle des calques. ''
    popup str ou folium.Popup Popup à afficher lorsque l’utilisateur clique sur un élément de la couche GeoJSON. None
    style_function function Fonction utilisée pour définir le style des éléments GeoJSON (par exemple, la couleur des polygones). None
    Exemple de code :
    import folium

# Création de la carte centrée sur Paris
m = folium.Map(location=[48.8566, 2.3522], zoom_start=12)

# Exemple de données GeoJSON (un simple polygone représentant un carré)
geojson_data = {
    "type": "FeatureCollection",
    "features": [
        {
            "type": "Feature",
            "geometry": {
                "type": "Polygon",
                "coordinates": [
                    [
                        [2.3522, 48.8566],
                        [2.3572, 48.8566],
                        [2.3572, 48.8606],
                        [2.3522, 48.8606],
                        [2.3522, 48.8566]
                    ]
                ]
            },
            "properties": {
                "name": "Square in Paris"
            }
        }
    ]
}

# Ajout du GeoJSON à la carte
folium.GeoJson(geojson_data, name="Mon GeoJSON", popup="Cliquez ici pour plus d'infos").add_to(m)

# Affichage de la carte
m
    Explication du code :

    1. Création de la carte : La carte est centrée sur Paris avec un niveau de zoom de 12.

    2. Données GeoJSON : Un objet GeoJSON est créé, représentant un simple polygone (un carré) avec des coordonnées spécifiques dans Paris.

    3. Ajout du GeoJSON à la carte : La fonction folium.GeoJson() est utilisée pour ajouter le GeoJSON à la carte, avec un popup personnalisé.

    4. Affichage de la carte : La carte est affichée avec le polygone et le popup.

    Remarque importante :

    • Personnalisation avec style_function : Le paramètre style_function permet de personnaliser l’apparence des objets géométriques du GeoJSON (par exemple, la couleur, l’épaisseur de la ligne, etc.). Cela peut être très utile pour visualiser différents types d’objets géospatiaux avec des styles distincts.

    • Utilisation des Popups : L’option popup permet d’ajouter des informations supplémentaires à afficher lorsque l’utilisateur clique sur un élément du GeoJSON. Cela peut être utile pour afficher des détails sur une zone géographique, par exemple, une description ou des informations sur la population d’un pays.

    • GeoJSON interactif : En ajoutant un fichier GeoJSON à une carte Folium, vous pouvez facilement visualiser des données géospatiales dans un format interactif. Il est possible de travailler avec des couches multiples et d’appliquer des filtres pour interagir avec des sous-ensembles spécifiques des données.

  • folium.TileLayer()

    La fonction folium.TileLayer() permet d'ajouter une couche de tuiles à une carte Folium. Une tuile est une petite image carrée qui représente une portion d'une carte. Cette fonction permet d'utiliser différents types de tuiles, tels que celles provenant de services comme OpenStreetMap, Stamen, ou des tuiles personnalisées.

    Importation :
    import folium
    Attributs :
    Paramètre Type Description Valeur par défaut
    tiles str Le type de tuiles à utiliser (ex : ‘OpenStreetMap’, ‘Stamen Terrain’, ‘cartodb positron’). 'OpenStreetMap'
    attr str Attribution pour les tuiles. Cette chaîne de caractères est généralement fournie par le fournisseur de tuiles. ''
    control bool Si True, le contrôle des tuiles sera ajouté à la carte (permet à l’utilisateur de changer de couche de tuiles). True
    Exemple de code :
    import folium

# Création de la carte centrée sur Paris
m = folium.Map(location=[48.8566, 2.3522], zoom_start=5)

# Ajout de la couche de tuiles 'Stamen Terrain'
tile_layer = folium.TileLayer('Stamen Terrain', attr='Map data © OpenStreetMap contributors').add_to(m)

# Ajout d'une autre couche de tuiles 'CartoDB positron'
folium.TileLayer('cartodb positron').add_to(m)

# Affichage de la carte
m
    Explication du code :

    1. Création de la carte : La carte est centrée sur Paris avec un niveau de zoom de 5.

    2. Ajout des couches de tuiles :

      • Stamen Terrain : Une première couche de tuiles est ajoutée avec le type ‘Stamen Terrain’.

      • CartoDB positron : Une deuxième couche de tuiles est ajoutée avec le type ‘CartoDB positron’.

    3. Affichage de la carte : La carte est affichée avec les deux couches de tuiles. L’utilisateur pourra changer entre ces couches en fonction des options définies.

    Remarque importante :

    • Attribution des tuiles : Il est important d’inclure l’attribution appropriée dans le paramètre attr pour respecter les conditions d’utilisation des services de tuiles.

    • Utilisation de control : En définissant control=True, l’utilisateur peut activer un contrôle pour alterner entre les différentes couches de tuiles ajoutées à la carte.

    • Disponibilité de tuiles : Folium supporte une variété de services de tuiles, ce qui permet de personnaliser l’apparence de la carte en fonction des besoins du projet.

  • folium.FeatureGroup()

    La fonction folium.FeatureGroup() permet de regrouper plusieurs objets géospatiaux sur une carte Folium sous un même groupe. Cela facilite la gestion de calques multiples, notamment pour l'affichage ou la suppression en masse d'éléments sur la carte.

    Importation :
    import folium
    Attributs :
    Paramètre Type Description Valeur par défaut
    name str Le nom du groupe. Ce nom peut être utilisé dans un contrôle de calques pour identifier ce groupe. ''
    Exemple de code :
    import folium

# Création de la carte centrée sur Paris
m = folium.Map(location=[48.8566, 2.3522], zoom_start=5)

# Création d'un groupe de fonctionnalités
feature_group = folium.FeatureGroup(name="Groupe de marqueurs")

# Ajout de plusieurs marqueurs au groupe
folium.Marker([48.8566, 2.3522], popup="Paris").add_to(feature_group)
folium.Marker([48.8648, 2.3800], popup="Saint-Germain-des-Prés").add_to(feature_group)

# Ajout du groupe de fonctionnalités à la carte
feature_group.add_to(m)

# Ajout du contrôle de calques
folium.LayerControl().add_to(m)

# Affichage de la carte
m
    Explication du code :

    1. Création de la carte : La carte est centrée sur Paris avec un niveau de zoom de 5.

    2. Création du groupe de fonctionnalités : Un objet FeatureGroup est créé pour regrouper plusieurs marqueurs sous un même nom (« Groupe de marqueurs »).

    3. Ajout des marqueurs au groupe : Deux marqueurs sont ajoutés au groupe feature_group (un pour Paris et un pour Saint-Germain-des-Prés).

    4. Ajout du groupe à la carte : Le groupe de fonctionnalités est ajouté à la carte.

    5. Contrôle des calques : Le contrôle des calques permet à l’utilisateur de masquer ou afficher le groupe de marqueurs.

    Remarque importante :

    • Utilisation avec LayerControl() : Le nom du groupe (défini avec name) apparaît dans le contrôle des calques (LayerControl()). Cela permet à l’utilisateur de choisir d’afficher ou de masquer ce groupe d’éléments.

    • Gestion de plusieurs éléments : FeatureGroup() est utile pour gérer plusieurs objets géospatiaux (comme des marqueurs, des lignes ou des polygones) ensemble. Il permet de simplifier la gestion des calques lorsque plusieurs éléments doivent être contrôlés en même temps.

  • folium.LayerControl()

    La fonction folium.LayerControl() permet d'ajouter un contrôle de calques à une carte Folium. Cela permet à l'utilisateur d'afficher ou de masquer différents types de données sur la carte, tels que des marqueurs, des polygones, des couches de tuiles, etc.

    Importation :
    import folium
    Attributs :
    Paramètre Type Description Valeur par défaut
    position str Position du contrôle des couches sur la carte. Les options disponibles sont : ‘topright’, ‘topleft’, ‘bottomright’, ‘bottomleft’. 'topright'
    collapsed bool Détermine si le contrôle des couches est réduit ou non par défaut. True
    Exemple de code :
    import folium

# Création de la carte centrée sur Paris
m = folium.Map(location=[48.8566, 2.3522], zoom_start=5)

# Ajout de deux couches différentes
tile_layer = folium.TileLayer('Stamen Terrain').add_to(m)
marker_layer = folium.Marker([48.8566, 2.3522], popup='Paris').add_to(m)

# Ajout du contrôle des calques pour permettre à l'utilisateur de sélectionner les couches à afficher
folium.LayerControl().add_to(m)

# Affichage de la carte
m
    Explication du code :

    1. Création de la carte : La carte est centrée sur Paris avec un niveau de zoom de 5.

    2. Ajout de couches :

      • Couches de tuiles : On ajoute une couche de tuiles (ici, « Stamen Terrain ») avec la fonction folium.TileLayer().

      • Marqueur : On ajoute un marqueur à Paris avec un popup.

    3. Contrôle des calques : La fonction folium.LayerControl() est ajoutée à la carte pour permettre à l’utilisateur de choisir quelles couches afficher ou masquer (ici, la couche de tuiles et le marqueur).

    4. Affichage de la carte : La carte interactive est affichée avec les éléments ajoutés et le contrôle des calques.

    Remarque importante :

    • Position du contrôle : Le contrôle des calques peut être déplacé en modifiant l’attribut position. Par exemple, pour le mettre en bas à gauche, vous pouvez utiliser position='bottomleft'.

    • Fonctionnalité : Le contrôle des calques peut gérer à la fois les couches de tuiles (comme celles de folium.TileLayer()) et les autres éléments ajoutés à la carte, comme les marqueurs et les polygones.

  • folium.Polygon()

    La fonction folium.Polygon() permet de dessiner un polygone sur une carte interactive. Un polygone est une figure géométrique fermée délimitée par une série de points connectés, souvent utilisée pour délimiter des zones géographiques.

    Importation :
    import folium
    Attributs :
    Paramètre Type Description Valeur par défaut
    locations list Liste de tuples ou de listes représentant les coordonnées GPS des points formant le polygone (par exemple, [(lat1, lon1), (lat2, lon2), …]). None
    color str Couleur de la bordure du polygone (par exemple, ‘blue’, ‘red’). 'blue'
    weight int Épaisseur de la bordure en pixels. 3
    fill_color str Couleur de remplissage du polygone. 'blue'
    fill_opacity float Opacité de la couleur de remplissage (valeur entre 0 et 1). 0.2
    popup str ou folium.Popup Texte ou objet `Popup` à afficher lorsque l’utilisateur clique sur le polygone. None
    Exemple de code :
    import folium

# Coordonnées GPS de plusieurs points formant un polygone
locations = [
    [48.8566, 2.3522],  # Paris
    [51.5074, -0.1278],  # Londres
    [52.5200, 13.4050],  # Berlin
    [48.8566, 2.3522],  # Retour à Paris pour fermer le polygone
]

# Création de la carte centrée sur Paris
m = folium.Map(location=[48.8566, 2.3522], zoom_start=5)

# Création du polygone reliant les points
polygon = folium.Polygon(
    locations,
    color='green',
    weight=3,
    fill_color='yellow',
    fill_opacity=0.4,
    popup='Zone de Paris, Londres et Berlin'
).add_to(m)

# Affichage de la carte
m
    Explication du code :

    1. Coordonnées GPS : La variable locations contient les points géographiques qui forment le polygone. Le dernier point doit être identique au premier pour fermer la forme.

    2. Création de la carte : La carte est centrée sur Paris, avec un zoom de niveau 5.

    3. Création du polygone : La fonction folium.Polygon() est utilisée pour dessiner un polygone en connectant les points définis dans locations.

      • color définit la couleur de la bordure du polygone (ici, vert).

      • fill_color définit la couleur de remplissage du polygone (ici, jaune).

      • fill_opacity contrôle l’opacité du remplissage (ici, 0.4).

    4. Popup : Lorsque l’utilisateur clique sur le polygone, un popup apparaît avec le texte « Zone de Paris, Londres et Berlin ».

    5. Affichage de la carte : La carte interactive est affichée avec le polygone dessiné dessus.

    Remarque importante :

    • Comme pour la fonction PolyLine, les coordonnées doivent être fournies sous forme de liste de tuples ou de listes représentant chaque point du polygone.

    • Le polygone peut avoir un remplissage transparent ou coloré selon les besoins en ajustant le paramètre fill_opacity.

  • folium.PolyLine()

    La fonction folium.PolyLine() permet de tracer une ligne polyligne (une série de segments de lignes connectés) sur une carte interactive. Elle est utilisée pour visualiser des trajectoires, des itinéraires ou des zones délimitées par une série de coordonnées géographiques.

    Importation :
    import folium
    Attributs :
    Paramètre Type Description Valeur par défaut
    locations list Liste de tuples ou de listes représentant les coordonnées GPS des points formant la ligne (par exemple, [(lat1, lon1), (lat2, lon2), …]). None
    color str Couleur de la ligne (par exemple, ‘blue’, ‘red’). 'blue'
    weight int Épaisseur de la ligne en pixels. 3
    opacity float Opacité de la ligne (valeur entre 0 et 1). 1.0
    popup str ou folium.Popup Texte ou objet `Popup` à afficher lorsque l’utilisateur clique sur la ligne. None
    Exemple de code :
    import folium

# Coordonnées GPS de quelques points (latitude, longitude)
locations = [
    [48.8566, 2.3522],  # Paris
    [51.5074, -0.1278],  # Londres
    [52.5200, 13.4050],  # Berlin
]

# Création de la carte centrée sur Paris
m = folium.Map(location=[48.8566, 2.3522], zoom_start=5)

# Création de la polyline (ligne connectant les trois points)
polyline = folium.PolyLine(
    locations,
    color='blue',
    weight=3,
    opacity=1.0,
    popup='Trajet entre Paris, Londres et Berlin'
).add_to(m)

# Affichage de la carte
m
    Explication du code :

    1. Coordonnées GPS : La variable locations contient une liste de tuples représentant les coordonnées GPS de plusieurs points. Ces points seront connectés pour former une ligne.

    2. Création de la carte : La carte est centrée sur Paris avec un zoom de niveau 5.

    3. Création de la polyline : La fonction folium.PolyLine() est utilisée pour créer une ligne reliant les différents points dans la liste locations. Vous pouvez personnaliser la couleur, l’épaisseur et l’opacité de la ligne.

    4. Popup : Lorsque vous cliquez sur la ligne, un popup avec le texte « Trajet entre Paris, Londres et Berlin » apparaîtra.

    5. Affichage de la carte : La carte interactive est ensuite affichée.

    Remarque importante :

    • Les points de la polyline doivent être fournis sous forme de liste de coordonnées [latitude, longitude].

    • Le paramètre color accepte des couleurs sous forme de chaînes de caractères (par exemple, 'blue', 'green', etc.) ou des codes hexadécimaux comme '#ff5733'.

    • Le paramètre popup peut être un simple texte ou un objet Popup Folium pour une interaction plus avancée (comme l’ajout d’HTML ou d’autres éléments interactifs).

  • folium.Choropleth()

    La fonction folium.Choropleth() est utilisée pour créer une carte choroplèthe (ou carte de densité) dans une carte interactive Folium. Elle permet de visualiser des données géospatiales sous forme de couleurs variant en fonction des valeurs associées à chaque zone géographique (par exemple, des régions, des pays, ou des départements).

    Importation :
    import folium
    Attributs :
    Paramètre Type Description Valeur par défaut
    geo_data dict Données géospatiales sous forme de GeoJSON (par exemple, les frontières des pays ou des départements). None
    data pandas.Series Série contenant les valeurs numériques à visualiser sur la carte (par exemple, population, densité, etc.). None
    columns list Liste des noms de colonnes du dataframe pour les valeurs associées aux zones géographiques. None
    key_on str Clé utilisée pour associer les valeurs aux zones géographiques (par exemple, ‘feature.id’ ou ‘properties.name’). None
    fill_color str Couleur de remplissage utilisée pour la choroplèthe (par exemple, ‘YlGn’, ‘BuPu’). 'YlGnBu'
    fill_opacity float Opacité de la couleur de remplissage (de 0 à 1). 0.6
    line_opacity float Opacité des bordures des zones géographiques (de 0 à 1). 0.2
    Exemple de code :
    import folium
import pandas as pd

# Exemple de données géospatiales (GeoJSON)
geo_data = 'https://raw.githubusercontent.com/codeforamerica/click_that_hood/master/public/data/france-regions.geojson'

# Exemple de données numériques à associer aux régions
data = pd.Series({
    'Île-de-France': 12,
    'Provence-Alpes-Côte d\'Azur': 7,
    'Auvergne-Rhône-Alpes': 8,
    'Normandie': 6,
    'Bretagne': 5,
    # Ajoutez plus de régions et de valeurs ici
})

# Création de la carte centrée sur la France
m = folium.Map(location=[46.603354, 1.888334], zoom_start=6)

# Création de la carte choroplèthe
choropleth = folium.Choropleth(
    geo_data=geo_data,
    data=data,
    columns=['Région', 'Valeur'],  # Assurez-vous que vos données sont structurées de manière appropriée
    key_on='feature.properties.nom',  # Associe les valeurs aux régions géographiques
    fill_color='YlGnBu',
    fill_opacity=0.6,
    line_opacity=0.2,
    legend_name='Valeur des régions'
).add_to(m)

# Affichage de la carte
m
    Explication du code :

    1. Données géospatiales (GeoJSON) : Les données géospatiales sont chargées à partir d’un fichier GeoJSON contenant les frontières des régions françaises.

    2. Données numériques : Une série de valeurs numériques (ici des chiffres fictifs représentant des données par région) est associée à chaque zone géographique. Ces valeurs seront utilisées pour colorier la carte.

    3. Création de la carte choroplèthe : La fonction folium.Choropleth() est utilisée pour appliquer les couleurs sur la carte en fonction des valeurs associées à chaque région. Le paramètre key_on permet de lier les données géographiques aux valeurs dans le jeu de données, tandis que fill_color détermine les couleurs utilisées sur la carte.

    4. Affichage de la carte : La carte interactive est affichée.

    Remarque importante :

    • Assurez-vous que la clé utilisée dans key_on correspond bien aux propriétés des objets géospatiaux dans votre fichier GeoJSON.

    • Les données doivent être fournies sous forme de série Pandas où l’index correspond à la clé utilisée dans le fichier GeoJSON.

    • Vous pouvez personnaliser davantage la carte choroplèthe en jouant avec les paramètres comme fill_color et line_opacity pour affiner l’apparence.

  • folium.Popup()

    La fonction folium.Popup() permet de créer une fenêtre contextuelle (popup) dans une carte interactive Folium. Cette fenêtre peut afficher du texte, des images, des liens, ou d'autres éléments HTML. Les popups sont souvent utilisés pour fournir des informations supplémentaires lorsque l'utilisateur clique sur des marqueurs ou autres objets de la carte.

    Importation :
    import folium
    Attributs :
    Paramètre Type Description Valeur par défaut
    html str Le contenu HTML à afficher dans la popup. ''
    max_width int La largeur maximale de la popup (en pixels). 300
    min_width int La largeur minimale de la popup (en pixels). 50
    sticky bool Détermine si la popup reste ouverte lorsqu’on déplace la carte. False
    Exemple de code :
    import folium

# Création de la carte centrée sur Paris
m = folium.Map(location=[48.8566, 2.3522], zoom_start=13)

# Création d'un Popup avec du texte HTML
popup = folium.Popup("Bienvenue à Paris!", max_width=200)

# Ajout d'un marqueur avec le popup
folium.Marker([48.8566, 2.3522], popup=popup).add_to(m)

# Affichage de la carte
m
    Explication du code :

    1. Création de la carte : Une carte est créée et centrée sur Paris (latitude: 48.8566, longitude: 2.3522) avec folium.Map().

    2. Création de la popup : La popup est créée avec le texte "Bienvenue à Paris!" et une largeur maximale de 200 pixels grâce à folium.Popup().

    3. Ajout du marqueur : Un marqueur est placé sur la carte à la position de Paris et le popup est associé au marqueur.

    4. Affichage de la carte : La carte est rendue visible avec la méthode m, ce qui permet d’afficher l’interactivité dans un environnement Jupyter ou un navigateur.

    Remarque importante :

    • Le contenu de la popup peut être enrichi avec du HTML, par exemple, vous pouvez ajouter des liens, des images, ou des tableaux. Cela permet d’afficher des informations complexes dans une fenêtre contextuelle simple.

    • Vous pouvez personnaliser davantage la popup, notamment en contrôlant sa taille avec les paramètres max_width et min_width.

    • Le paramètre sticky permet de définir si la popup doit rester ouverte même lorsque l’utilisateur déplace la carte, ce qui peut être utile dans certaines situations.