Tässä haasteessa sovelletaan **paikkatietoanalyysin** osaamista Pythonilla käyttämällä oikean maailman aineistoja ja visualisoimalla tulokset. Käytössä ovat `geopandas`- ja `matplotlib`-kirjastot paikkatietoaineistojen lataamiseen, suodattamiseen ja piirtämiseen valitulle mantereelle. Tämä prosessi vahvistaa taitoja maantieteellisten aineistojen hakemisessa, niiden muokkaamisessa attribuuttitietojen perusteella sekä selkeiden ja informatiivisten karttojen luomisessa.

Aloita pohtimalla, miten maailman kartta -aineistoa voidaan käyttää analyysin pohjakerroksena. **Paikkatietoaineistot** sisältävät usein globaalit rajat, joita voidaan suodattaa keskittymään tiettyihin alueisiin tai maanosiin. Natural Earth -aineisto on yleinen lähde tällaiselle tiedolle, ja se sisältää kätevästi **continent-attribuutin** jokaiselle maalle.

Tämän työnkulun havainnollistamiseksi näytetään, miten maailman maiden aineisto ladataan, suodatetaan tietylle mantereelle ja luodaan visualisointi, joka korostaa kiinnostuksen kohteena olevaa aluetta. Seuraava koodiesimerkki näyttää, miten Afrikan maat poimitaan ja piirretään käyttäen samanlaisia menetelmiä kuin Etelä-Amerikan tapauksessa.




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


Tätä lähestymistapaa voidaan soveltaa mihin tahansa mantereeseen muuttamalla suodattimen arvoa aineistossa. **Suodattamalla `CONTINENT`-sarakkeen perusteella** voidaan keskittyä tiettyyn alueeseen, ja suodatetun datan asettaminen pohjakartan päälle korostaa kiinnostuksen kohteena olevaa aluetta. Karttaa voi lisäksi mukauttaa säätämällä värejä, nimiöitä ja muita piirtoasetuksia.

Voit tarkastella tietoaineistossa olevien maanosien täydellistä luetteloa tarkistamalla `CONTINENT`-sarakkeen uniikit arvot. Käytä komentoa `print(world['CONTINENT'].unique())` nähdäksesi kaikki vaihtoehdot, kuten **"Asia"**, **"Europe"**, **"Oceania"** ja muut.

Huomio


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

Sukella paikkatietoanalyysin perusteisiin Pythonilla. Tämä keskitason kurssi esittelee paikkatietoanalyysin ydinkäsitteet ja käytännön sovellukset, keskittyen todellisiin aineistoihin ja käytännön projekteihin. Opit käsittelemään, visualisoimaan ja analysoimaan paikkatietoa Pythonilla ja suosituilla kirjastoilla, erityisesti geopandasilla. Kurssi on suunniteltu mukaansatempaavaksi, sisältäen interaktiivisia taulukoita, videoita ja tietovisoja oppimisen tukemiseksi.

Tutustu paikkatietoaineistojen perusteisiin, koordinaattijärjestelmiin ja keskeisiin työkaluihin spatiaalisen analyysin toteuttamiseksi Pythonilla. Tämä osio luo perustan paikkatietoaineistojen käsittelylle ja esittelee geopandas-kirjaston yksityiskohtaisesti, mukaan lukien sen ydintietorakenteet, luku- ja kirjoitusominaisuudet sekä integraation pandas- ja matplotlib-kirjastojen kanssa.

Syvenny keskeisiin spatiaalisen analyysin tekniikoihin, kuten spatiaalisiin liitoksiin, päällekkäisyyksiin ja aggregointeihin, hyödyntäen geopandasia ja visualisointikirjastoja. Tässä osiossa käsitellään edistyneitä geopandas-menetelmiä spatiaalisten aineistojen yhdistämiseen, vertailuun ja tiivistämiseen sekä parhaisiin käytäntöihin spatiaalisen datan visualisoinnissa.

Hanki vankka ymmärrys todellisten paikkatietoaineistojen ja -tilanteiden käsittelystä, keskittyen käytännön analyysi- ja visualisointihaasteisiin. Tässä osiossa painotetaan projektipohjaista oppimista ja paikkatietoanalyyttisten menetelmien yhdistämistä.

Challenge: Analyzing the Geospatial Data

Ratkaisu