Summary  
This chapter demonstrates how to use GeoPandas to load and inspect vector spatial data, visualize polygon boundaries, and calculate spatial attributes such as area and density.  

General domain of usage  
Urban area analysis

This video presents a case study involving a real urban area dataset. You will be introduced to the dataset's structure, the main questions guiding the analysis, and the workflow for exploring urban boundaries, land use, and population trends using Python geospatial tools. The video demonstrates the importance of spatial data in uncovering urban patterns and sets the stage for hands-on analysis.

Städtische Gebiete sind dynamische Landschaften, die durch Bevölkerungswachstum, Infrastruktur und sich verändernde Flächennutzung geprägt werden. Bei der Analyse von räumlichen Daten urbaner Räume beginnt man häufig mit der Untersuchung der Grenzen einer Stadt oder Metropolregion. Das Verständnis dieser Grenzen hilft, Muster wie **Dichte**, **Erreichbarkeit** und **Nachbarschaftsstruktur** einzuordnen. Mit Python und der Bibliothek `geopandas` lassen sich Stadtgrenzen einfach laden, inspizieren und visualisieren – ein grundlegender Schritt in der Geodatenanalyse.

import geopandas as gpd
import matplotlib.pyplot as plt

# Load urban area boundaries from a GeoJSON file (example URL)
url = "https://raw.githubusercontent.com/datasets/geo-boundaries-world-110m/master/countries.geojson"
urban_areas = gpd.read_file(url)

# Inspect the first few records and their attributes
print(urban_areas.head())

# Plot the urban area boundaries
fig, ax = plt.subplots(figsize=(10, 6))
urban_areas.plot(ax=ax, edgecolor="black", facecolor="lightgray")
ax.set_title("Urban Area Boundaries")
plt.show()

Nachdem die Stadtgrenzen geladen und visualisiert wurden, können deren räumliche Eigenschaften analysiert werden. Wichtige Kennzahlen wie **Gesamtfläche** und **Bevölkerungsdichte** geben Aufschluss über die Struktur und Herausforderungen urbaner Räume. Durch die Nutzung der räumlichen und tabellarischen Funktionen von `geopandas` lassen sich diese Kennzahlen effizient berechnen und die Ergebnisse für eine weiterführende Interpretation zusammenfassen.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def setUp(self):
        self.url = "https://raw.githubusercontent.com/datasets/geo-boundaries-world-110m/master/countries.geojson"
        self.population_column = "POP_EST"

    def test_loads_geospatial_data(self):
        import user_code
        importlib.reload(user_code)
        # Patch print to capture output
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_urban_area_stats(self.url, population_column=None)
        output = f.getvalue()
        _dynamic_test(
            self,
            "area_sqkm" in output,
            "Function prints summary with area_sqkm column.",
            f"Expected 'area_sqkm' in printed output, got: {output}"
        )

    def test_area_sqkm_calculation(self):
        import user_code
        importlib.reload(user_code)
        # Patch print to capture output
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_urban_area_stats(self.url, population_column=None)
        output = f.getvalue()
        # Check that area_sqkm values are present and numeric
        found_numeric = False
        for line in output.splitlines():
            if "area_sqkm" in line:
                continue
            fields = line.split()
            if len(fields) >= 2:
                try:
                    val = float(fields[1])
                    found_numeric = True
                except Exception:
                    continue
        _dynamic_test(
            self,
            found_numeric,
            "Area in square kilometers is calculated and printed.",
            "Area values are not numeric or missing from output."
        )

    def test_population_density_calculation(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_urban_area_stats(self.url, population_column=self.population_column)
        output = f.getvalue()
        # Look for population_density column header and at least one numeric value below it
        found_density_header = "population_density" in output
        found_numeric_density = False
        for line in output.splitlines():
            if "population_density" in line:
                continue
            fields = line.split()
            if len(fields) >= 3:
                try:
                    val = float(fields[2])
                    found_numeric_density = True
                except Exception:
                    continue
        _dynamic_test(
            self,
            found_density_header and found_numeric_density,
            "Population density column is printed with numeric values.",
            "Population density column or its values are missing or not numeric."
        )

    def test_summary_first_three_areas(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_urban_area_stats(self.url, population_column=self.population_column)
        output = f.getvalue()
        # Count the number of data lines (skip header)
        lines = [l for l in output.splitlines() if l.strip() and not l.startswith("  name") and not l.startswith("name")]
        # Remove header line(s)
        if lines and ("area_sqkm" in lines[0] or "population_density" in lines[0]):
            lines = lines[1:]
        _dynamic_test(
            self,
            2 <= len(lines) <= 3,
            "Function prints summary for first three urban areas.",
            f"Expected 2 or 3 summary rows, got {len(lines)}."
        )

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

Tauchen Sie ein in die Grundlagen der Geodatenanalyse mit Python. Dieser Kurs auf mittlerem Niveau führt Sie in die Kernkonzepte und praktischen Anwendungen der Geodatenanalyse ein, mit Fokus auf reale Datensätze und praxisorientierte Projekte. Sie lernen, räumliche Daten mit Python und beliebten Bibliotheken zu manipulieren, zu visualisieren und zu analysieren, mit besonderem Schwerpunkt auf geopandas. Der Kurs ist ansprechend gestaltet und bietet interaktive Raster, Videos und Quizze zur Vertiefung Ihres Lernens.

Erkunden Sie die Grundlagen von Geodaten, Koordinatensystemen und den wichtigsten Werkzeugen für die räumliche Analyse mit Python. Dieser Abschnitt legt das Fundament für die Arbeit mit räumlichen Datensätzen und führt ausführlich in geopandas ein, einschließlich seiner zentralen Datenstrukturen, Lese- und Schreibfunktionen sowie der Integration mit pandas und matplotlib.

Tauchen Sie ein in zentrale Techniken der räumlichen Analyse, einschließlich räumlicher Joins, Overlays und Aggregationen, unter Verwendung von geopandas und Visualisierungsbibliotheken. Dieser Abschnitt behandelt fortgeschrittene Methoden von geopandas zum Kombinieren, Vergleichen und Zusammenfassen räumlicher Datensätze sowie bewährte Verfahren für die Visualisierung räumlicher Daten.

Erwerben Sie ein fundiertes Verständnis realer geodatenbezogener Datensätze und Szenarien mit Schwerpunkt auf praktischen Analyse- und Visualisierungsherausforderungen. Dieser Abschnitt legt den Fokus auf projektbasiertes Lernen und die Synthese von Methoden der Geodatenanalyse.

Analyse von Städtischen Gebieten

Lösung