I denna utmaning kommer du att tillämpa din förståelse av **geospatial dataanalys** med Python genom att arbeta med verkliga dataset och visualisera resultaten. Du kommer att använda biblioteken `geopandas` och `matplotlib` för att ladda, filtrera och plotta rumsliga data för en vald kontinent. Denna process stärker dina färdigheter i att komma åt geografiska dataset, manipulera dem baserat på attributdata och skapa tydliga, informativa kartor.

Börja med att överväga hur ett världskartdataset kan användas som baslager för din analys. **Geospatiala dataset** innehåller ofta globala gränser, vilka du kan filtrera för att fokusera på specifika regioner eller kontinenter. Natural Earth-datasetet är en vanlig källa för sådan information och innehåller praktiskt nog ett **kontinentattribut** för varje land.

För att illustrera detta arbetsflöde kommer du att se hur man laddar världens länderdataset, filtrerar det för en viss kontinent och skapar en visualisering som framhäver ditt intresseområde. Följande kodexempel visar hur man extraherar och plottar Afrikas länder, med metoder liknande de som beskrivs för 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()


Denna metod kan anpassas till vilken kontinent som helst genom att ändra filtervärdet i datasetet. **Filtrering på kolumnen `CONTINENT`** gör det möjligt att fokusera på en specifik region, medan överlagring av de filtrerade data ovanpå baskartan gör att ditt intresseområde framträder. Du kan ytterligare anpassa din karta genom att justera färger, etiketter och andra inställningar för plottningen.

Du kan utforska hela listan över kontinentnamn som finns i datasettet genom att kontrollera de unika värdena i kolumnen `CONTINENT`. Använd `print(world['CONTINENT'].unique())` för att se alla alternativ, såsom **"Asia"**, **"Europe"**, **"Oceania"** och andra.

Notering


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

Fördjupa dig i grunderna för geospatial dataanalys med Python. Denna kurs på mellannivå introducerar dig till kärnkoncept och praktiska tillämpningar av geospatial analys, med fokus på verkliga dataset och praktiska projekt. Du lär dig att manipulera, visualisera och analysera rumsliga data med Python och populära bibliotek, med särskild tonvikt på geopandas. Kursen är utformad för att vara engagerande och innehåller interaktiva rutnät, videor och quiz för att förstärka ditt lärande.

Utforska grunderna i geospatial data, koordinatsystem och de viktigaste verktygen för rumslig analys i Python. Denna sektion lägger grunden för arbete med rumsliga dataset och introducerar geopandas i detalj, inklusive dess centrala datastrukturer, läs- och skrivfunktioner samt integration med pandas och matplotlib.

Fördjupa dig i centrala tekniker för rumslig analys, inklusive rumsliga joins, överlägg och aggregeringar, med hjälp av geopandas och visualiseringsbibliotek. Detta avsnitt täcker avancerade geopandas-metoder för att kombinera, jämföra och sammanfatta rumsliga dataset, samt bästa praxis för visualisering av rumsliga data.

Få en gedigen förståelse för verkliga geospatiala dataset och scenarier, med fokus på praktiska analys- och visualiseringsutmaningar. Detta avsnitt betonar projektbaserat lärande och syntes av geospatiala analystekniker.

Challenge: Analyzing the Geospatial Data

Lösning