In deze uitdaging pas je je kennis van **geospatiale data-analyse** met Python toe door te werken met realistische datasets en het visualiseren van de resultaten. Je gebruikt de bibliotheken `geopandas` en `matplotlib` om ruimtelijke data te laden, te filteren en te plotten voor een geselecteerd continent. Dit proces versterkt je vaardigheden in het benaderen van geografische datasets, het manipuleren ervan op basis van attribuutgegevens en het maken van duidelijke, informatieve kaarten.

Begin met het overwegen hoe een wereldkaartdataset kan dienen als basislaag voor je analyse. **Geospatiale datasets** bevatten vaak wereldwijde grenzen, die je kunt filteren om je te richten op specifieke regio's of continenten. De Natural Earth dataset is een veelgebruikte bron voor dergelijke informatie en bevat handig een **continentattribuut** voor elk land.

Om deze workflow te illustreren, zie je hoe je de wereldlanden-dataset laadt, filtert op een bepaald continent en een visualisatie maakt die je interessegebied benadrukt. De volgende codevoorbeeld toont hoe je de landen van Afrika extraheert en plot, met methoden die vergelijkbaar zijn met die voor Zuid-Amerika.




import geopandas as gpd
import matplotlib.pyplot as plt

# Load the world countries dataset from Natural Earth (GeoJSON format)
world_url = "https://raw.githubusercontent.com/nvkelso/natural-earth-vector/master/geojson/ne_110m_admin_0_countries.geojson"
world = gpd.read_file(world_url)

# Filter for African countries using the 'CONTINENT' column
africa = world[world['CONTINENT'] == 'Africa']

# Plot all world countries in light gray
ax = world.plot(color='lightgray', edgecolor='white', figsize=(10, 6))

# Overlay African countries in green
africa.plot(ax=ax, color='mediumseagreen', edgecolor='black', label='Africa')

# Add a title and legend
plt.title("Countries of Africa")
plt.legend()
plt.show()


Deze aanpak kan worden aangepast aan elk continent door de filterwaarde in de dataset te wijzigen. **Filteren op de `CONTINENT`-kolom** maakt het mogelijk om je te richten op een specifieke regio, terwijl het overlayen van de gefilterde data op de basiskaart je interessegebied laat opvallen. Je kunt je kaart verder aanpassen door kleuren, labels en andere plotinstellingen te wijzigen.

Je kunt de volledige lijst van continentnamen die beschikbaar zijn in de dataset verkennen door de unieke waarden in de kolom `CONTINENT` te controleren. Gebruik `print(world['CONTINENT'].unique())` om alle opties te bekijken, zoals **"Asia"**, **"Europe"**, **"Oceania"** en anderen.

Opmerking


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import ast
import re

class TestTask(unittest.TestCase):
    def setUp(self):
        self.module_name = "user_code"
        if self.module_name in sys.modules:
            del sys.modules[self.module_name]

    def test_libraries_imported(self):
        with open("user_code.py", "r") as f:
            code = f.read()
        _dynamic_test(
            self,
            "import geopandas" in code and ("import matplotlib.pyplot" in code or "from matplotlib import pyplot" in code),
            "Both geopandas and matplotlib.pyplot are imported.",
            "Missing import for geopandas or matplotlib.pyplot.",
        )

    def test_world_dataset_loaded(self):
        import importlib
        user_code = importlib.import_module("user_code")
        importlib.reload(user_code)
        world = getattr(user_code, 'world', None)
        _dynamic_test(
            self,
            world is not None,
            "World dataset loaded into 'world' variable.",
            "World dataset not loaded into 'world' variable.",
        )
        if world is not None:
            _dynamic_test(
                self,
                hasattr(world, 'columns') and 'CONTINENT' in world.columns,
                "World dataset has CONTINENT column.",
                "World dataset missing CONTINENT column.",
            )

    def test_continent_filtering(self):
        import importlib
        user_code = importlib.import_module("user_code")
        importlib.reload(user_code)
        world = getattr(user_code, 'world', None)
        found = False
        filtered_varname = None
        for var in dir(user_code):
            if var.lower() in ["world", "africa", "south_america"]:
                continue
            val = getattr(user_code, var)
            # Check if it's a GeoDataFrame and not empty
            if hasattr(val, "__class__") and val.__class__.__name__ == "GeoDataFrame":
                if ('CONTINENT' in val.columns and not val.empty 
                    and all(c not in ["South America", "Africa"] for c in val['CONTINENT'].unique())):
                    found = True
                    filtered_varname = var
        _dynamic_test(
            self,
            found,
            "A continent other than South America or Africa was filtered.",
            "No continent other than South America or Africa was filtered.",
        )
        # Store the variable name for use in the next test
        self._filtered_varname = filtered_varname

    def test_distinct_color(self):
        with open("user_code.py", "r") as f:
            code = f.read().lower()
        forbidden_colors = ["blue", "royalblue", "mediumseagreen", "green"]
        color_lines = [line for line in code.splitlines() if ".plot(" in line and "color=" in line]
        used_ok_color = False
        for line in color_lines:
            if not any(c in line for c in forbidden_colors):
                used_ok_color = True
        _dynamic_test(
            self,
            used_ok_color,
            "A distinct color (not blue or green) is used for the overlay.",
            "Overlay color is not distinct (blue or green found).",
        )

    def test_title_and_legend(self):
        with open("user_code.py", "r") as f:
            code = f.read().lower()
        _dynamic_test(
            self,
            "plt.title" in code and "plt.legend" in code,
            "Title and legend are added to the map.",
            "Missing title or legend in the plot.",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str):
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Verdiep je in de basisprincipes van georuimtelijke data-analyse met Python. Deze cursus op gemiddeld niveau introduceert de kernconcepten en praktische toepassingen van georuimtelijke analyse, met de nadruk op datasets uit de praktijk en praktijkgerichte projecten. Je leert ruimtelijke data te manipuleren, visualiseren en analyseren met Python en populaire libraries, met speciale aandacht voor geopandas. De cursus is ontworpen om boeiend te zijn, met interactieve rasters, video's en quizzen ter versterking van het leerproces.

Verken de basisprincipes van geospatiale data, coördinatensystemen en de essentiële tools voor ruimtelijke analyse in Python. Deze sectie legt de basis voor het werken met ruimtelijke datasets en introduceert geopandas in detail, inclusief de kern datastructuren, lees- en schrijfmogelijkheden, en integratie met pandas en matplotlib.

Verdiep u in kerntechnieken voor ruimtelijke analyse, waaronder ruimtelijke joins, overlays en aggregaties, met gebruik van geopandas en visualisatielibraries. Deze sectie behandelt geavanceerde geopandas-methoden voor het combineren, vergelijken en samenvatten van ruimtelijke datasets, evenals best practices voor de visualisatie van ruimtelijke data.

Verkrijg een grondig begrip van echte georuimtelijke datasets en scenario's, met de nadruk op praktische analyse- en visualisatie-uitdagingen. Deze sectie legt de nadruk op projectmatig leren en het samenbrengen van georuimtelijke analysetechnieken.

Challenge: Het Analyseren van Geospatiale Gegevens

Oplossing