In questa sfida, applicazione delle conoscenze sull'**analisi dei dati geospaziali** con Python utilizzando dataset reali e visualizzando i risultati. Utilizzo delle librerie `geopandas` e `matplotlib` per caricare, filtrare e rappresentare dati spaziali relativi a un continente selezionato. Questo processo rafforza le competenze nell'accesso a dataset geografici, nella loro manipolazione in base ai dati attributo e nella creazione di mappe chiare e informative.

Considerazione iniziale sull'utilizzo di un dataset della mappa mondiale come layer di base per l'analisi. I **dataset geospaziali** includono spesso i confini globali, che possono essere filtrati per concentrarsi su regioni o continenti specifici. Il dataset Natural Earth è una fonte comune per queste informazioni e include comodamente un **attributo continent** per ogni paese.

Per illustrare questo flusso di lavoro, viene mostrato come caricare il dataset dei paesi del mondo, filtrarlo per un continente specifico e creare una visualizzazione che evidenzi la regione di interesse. Il seguente esempio di codice mostra come estrarre e rappresentare i paesi dell'Africa, utilizzando metodi simili a quelli descritti per il Sud America.




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


Questo approccio può essere adattato a qualsiasi continente modificando il valore del filtro nel dataset. **Il filtraggio tramite la colonna `CONTINENT`** consente di concentrarsi su una regione specifica, mentre la sovrapposizione dei dati filtrati sulla mappa di base mette in evidenza l'area di interesse. Ulteriore personalizzazione della mappa possibile tramite la regolazione di colori, etichette e altre impostazioni del grafico.

È possibile esplorare l'elenco completo dei nomi dei continenti disponibili nel dataset controllando i valori unici nella colonna `CONTINENT`. Utilizzare `print(world['CONTINENT'].unique())` per visualizzare tutte le opzioni, come **"Asia"**, **"Europe"**, **"Oceania"** e altri.

Nota


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

Immergiti nei fondamenti dell'analisi dei dati geospaziali utilizzando Python. Questo corso intermedio ti introduce ai concetti chiave e alle applicazioni pratiche dell'analisi geospaziale, concentrandosi su dataset reali e progetti pratici. Imparerai a manipolare, visualizzare e analizzare dati spaziali con Python e librerie popolari, con un'enfasi particolare su geopandas. Il corso è progettato per essere coinvolgente, con griglie interattive, video e quiz per rafforzare l'apprendimento.

Esplora i fondamenti dei dati geospaziali, dei sistemi di coordinate e degli strumenti essenziali per l'analisi spaziale in Python. Questa sezione fornisce le basi per lavorare con dataset spaziali e introduce in dettaglio geopandas, comprese le sue strutture dati principali, le capacità di lettura/scrittura e l'integrazione con pandas e matplotlib.

Approfondimento delle principali tecniche di analisi spaziale, inclusi join spaziali, overlay e aggregazioni, utilizzando geopandas e librerie di visualizzazione. Questa sezione copre metodi avanzati di geopandas per combinare, confrontare e sintetizzare dataset spaziali, oltre alle migliori pratiche per la visualizzazione dei dati spaziali.

Acquisizione di una solida comprensione dei dataset geospaziali reali e degli scenari, con un focus sulle sfide pratiche di analisi e visualizzazione. Questa sezione enfatizza l'apprendimento basato su progetti e la sintesi delle tecniche di analisi geospaziale.

Sfida: Analisi dei Dati Geospaziali

Soluzione