Neste desafio, será aplicada a compreensão sobre **análise de dados geoespaciais** com Python, utilizando conjuntos de dados do mundo real e visualizando os resultados. Serão utilizadas as bibliotecas `geopandas` e `matplotlib` para carregar, filtrar e plotar dados espaciais de um continente selecionado. Esse processo reforça as habilidades de acesso a conjuntos de dados geográficos, manipulação com base em atributos e criação de mapas claros e informativos.

Comece considerando como um conjunto de dados de mapa-múndi pode ser utilizado como camada base para a análise. **Conjuntos de dados geoespaciais** frequentemente incluem limites globais, que podem ser filtrados para focar em regiões ou continentes específicos. O conjunto de dados Natural Earth é uma fonte comum para esse tipo de informação e inclui convenientemente um **atributo de continente** para cada país.

Para ilustrar esse fluxo de trabalho, será mostrado como carregar o conjunto de dados de países do mundo, filtrá-lo para um continente específico e criar uma visualização que destaque a região de interesse. O exemplo de código a seguir demonstra como extrair e plotar os países da África, utilizando métodos semelhantes aos descritos para a América do Sul.




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


Essa abordagem pode ser adaptada para qualquer continente, alterando o valor do filtro no conjunto de dados. **Filtrar pela coluna `CONTINENT`** permite focar em uma região específica, enquanto sobrepor os dados filtrados sobre o mapa base destaca a área de interesse. É possível personalizar ainda mais o mapa ajustando cores, rótulos e outras configurações do gráfico.

Você pode explorar a lista completa de nomes de continentes disponíveis no conjunto de dados verificando os valores únicos na coluna `CONTINENT`. Use `print(world['CONTINENT'].unique())` para ver todas as opções, como **"Asia"**, **"Europe"**, **"Oceania"** e outros.

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

Mergulhe nos fundamentos da análise de dados geoespaciais utilizando Python. Este curso intermediário apresenta os conceitos centrais e aplicações práticas da análise geoespacial, com foco em conjuntos de dados do mundo real e projetos práticos. Você aprenderá a manipular, visualizar e analisar dados espaciais com Python e bibliotecas populares, com ênfase especial em geopandas. O curso foi desenvolvido para ser envolvente, apresentando grades interativas, vídeos e questionários para reforçar o aprendizado.

Explore os conceitos essenciais de dados geoespaciais, sistemas de coordenadas e as ferramentas fundamentais para análise espacial em Python. Esta seção estabelece a base para trabalhar com conjuntos de dados espaciais e apresenta o geopandas em detalhes, incluindo suas principais estruturas de dados, capacidades de leitura/escrita e integração com pandas e matplotlib.

Aprofunde-se nas principais técnicas de análise espacial, incluindo junções espaciais, sobreposições e agregações, utilizando geopandas e bibliotecas de visualização. Esta seção aborda métodos avançados do geopandas para combinar, comparar e resumir conjuntos de dados espaciais, além de melhores práticas para visualização de dados espaciais.

Adquira uma compreensão sólida de conjuntos de dados geoespaciais do mundo real e cenários, com foco em desafios práticos de análise e visualização. Esta seção enfatiza o aprendizado baseado em projetos e a síntese de técnicas de análise geoespacial.

Desafio: Analisando os Dados Geoespaciais

Solução