I denne udfordring skal du anvende din forståelse af **geospatiel dataanalyse** med Python ved at arbejde med virkelige datasæt og visualisere resultaterne. Du skal bruge bibliotekerne `geopandas` og `matplotlib` til at indlæse, filtrere og plotte rumlige data for et udvalgt kontinent. Denne proces styrker dine færdigheder i at tilgå geografiske datasæt, manipulere dem baseret på attributdata og skabe tydelige, informative kort.

Start med at overveje, hvordan et verdenskortdatasæt kan bruges som baggrundslag for din analyse. **Geospatiale datasæt** indeholder ofte globale grænser, som du kan filtrere for at fokusere på bestemte regioner eller kontinenter. Natural Earth-datasættet er en almindelig kilde til sådanne oplysninger, og det indeholder praktisk en **kontinentattribut** for hvert land.

For at illustrere denne arbejdsgang vil du se, hvordan man indlæser verdenslandenes datasæt, filtrerer det for et bestemt kontinent og skaber en visualisering, der fremhæver dit interesseområde. Følgende kodeeksempel viser, hvordan man udtrækker og plotter Afrikas lande ved hjælp af metoder, der ligner dem, der er beskrevet for Sydamerika.




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()


Denne tilgang kan tilpasses til ethvert kontinent ved at ændre filterværdien i datasættet. **Filtrering efter `CONTINENT`-kolonnen** gør det muligt at fokusere på en bestemt region, mens overlejring af de filtrerede data oven på baggrundskortet får dit interesseområde til at træde tydeligt frem. Du kan yderligere tilpasse dit kort ved at justere farver, etiketter og andre plotindstillinger.

Du kan udforske den fulde liste over kontinentnavne, der er tilgængelige i datasættet, ved at tjekke de unikke værdier i kolonnen `CONTINENT`. Brug `print(world['CONTINENT'].unique())` for at se alle muligheder, såsom **"Asia"**, **"Europe"**, **"Oceania"** og andre.

Bemærk


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

Dyk ned i grundlæggende geospatiel dataanalyse med Python. Dette mellemniveaukursus introducerer dig til kernekoncepter og praktiske anvendelser af geospatiel analyse med fokus på virkelige datasæt og praktiske projekter. Du lærer at manipulere, visualisere og analysere spatiale data ved hjælp af Python og populære biblioteker, med særlig vægt på geopandas. Kurset er designet til at være engagerende og indeholder interaktive gittere, videoer og quizzer for at styrke din læring.

Udforsk det grundlæggende inden for geospatiale data, koordinatsystemer og de væsentlige værktøjer til rumlig analyse i Python. Dette afsnit danner grundlaget for at arbejde med spatiale datasæt og introducerer geopandas i detaljer, herunder dets kerne-datastrukturer, læse-/skrivefunktioner og integration med pandas og matplotlib.

Dyk ned i centrale rumlige analyseteknikker, herunder rumlige joins, overlays og aggregeringer, ved brug af geopandas og visualiseringsbiblioteker. Dette afsnit dækker avancerede geopandas-metoder til at kombinere, sammenligne og opsummere rumlige datasæt samt bedste praksis for visualisering af rumlige data.

Opnå en solid forståelse af geospatiale datasæt og scenarier fra den virkelige verden med fokus på praktiske analyse- og visualiseringsudfordringer. Dette afsnit lægger vægt på projektbaseret læring og syntese af geospatiale analyseteknikker.

Challenge: Analyzing the Geospatial Data

Løsning