I denne utfordringen skal du anvende din forståelse av **geospatiale dataanalyser** med Python ved å arbeide med virkelige datasett og visualisere resultatene. Du skal bruke bibliotekene `geopandas` og `matplotlib` for å laste inn, filtrere og plotte romlige data for et valgt kontinent. Denne prosessen vil styrke dine ferdigheter i å få tilgang til geografiske datasett, manipulere dem basert på attributtdata, og lage tydelige, informative kart.

Start med å vurdere hvordan et verdenskartdatasett kan brukes som et grunnlag for analysen din. **Geospatiale datasett** inkluderer ofte globale grenser, som du kan filtrere for å fokusere på bestemte regioner eller kontinenter. Natural Earth-datasettet er en vanlig kilde for slik informasjon, og det inkluderer praktisk nok et **kontinentattributt** for hvert land.

For å illustrere denne arbeidsflyten vil du se hvordan du laster inn verdensland-datasettet, filtrerer det for et bestemt kontinent, og lager en visualisering som fremhever ditt interesseområde. Eksempelkoden nedenfor viser hvordan du kan hente ut og plotte landene i Afrika, ved å bruke metoder som ligner på de som er beskrevet for Sør-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()


Denne tilnærmingen kan tilpasses ethvert kontinent ved å endre filterverdien i datasettet. **Filtrering etter `CONTINENT`-kolonnen** gjør det mulig å fokusere på en bestemt region, mens overlegg av de filtrerte dataene på basiskartet får interesseområdet ditt til å skille seg ut. Du kan tilpasse kartet ytterligere ved å justere farger, etiketter og andre innstillinger for plottet.

Du kan utforske hele listen over kontinentnavn som er tilgjengelige i datasettet ved å sjekke unike verdier i kolonnen `CONTINENT`. Bruk `print(world['CONTINENT'].unique())` for å se alle alternativer, som **"Asia"**, **"Europe"**, **"Oceania"** og andre.

Merknad


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

Fordyp deg i grunnleggende geodataanalyse med Python. Dette mellomnivåkurset introduserer deg for kjernebegreper og praktiske anvendelser av geospatial analyse, med fokus på virkelige datasett og praktiske prosjekter. Du lærer å manipulere, visualisere og analysere romlige data ved hjelp av Python og populære biblioteker, med særlig vekt på geopandas. Kurset er utformet for å være engasjerende, med interaktive rutenett, videoer og quizer for å styrke læringen.

Utforsk det grunnleggende innen geodata, koordinatsystemer og de viktigste verktøyene for romlig analyse i Python. Denne delen legger grunnlaget for arbeid med romlige datasett og introduserer geopandas i detalj, inkludert dets kjerne datastrukturer, lese- og skrivefunksjoner, samt integrasjon med pandas og matplotlib.

Fordyp deg i sentrale romlige analyseteknikker, inkludert romlige sammenføyninger, overlegg og aggregeringer, ved bruk av geopandas og visualiseringsbiblioteker. Denne delen dekker avanserte geopandas-metoder for å kombinere, sammenligne og oppsummere romlige datasett, samt beste praksis for visualisering av romlige data.

Få en solid forståelse av geospatiale datasett og scenarier fra virkeligheten, med fokus på praktiske analyse- og visualiseringsutfordringer. Denne delen legger vekt på prosjektbasert læring og syntese av geospatiale analyseteknikker.

Challenge: Analyzing the Geospatial Data

Løsning