Summary  
This chapter explains how to access and assign list elements using zero-based and negative indexing in Python, including retrieving items from nested lists through multi-level indices.

General domain of usage  
Structured data handling (e.g., working with matrices)

Em Python, listas permitem acessar elementos individuais usando seus índices. A indexação começa em `0`, ou seja, o primeiro elemento de uma lista está no índice `0`, o segundo elemento está no índice `1` e assim por diante. Isso é chamado de **indexação baseada em zero**. Para acessar um elemento, utilize colchetes com o índice do item desejado.


cities = ["Rome", "London", "New York", "Brasilia", "Kioto"]

# Getting the first element
print(cities[0])

# Getting the third element
print(cities[2])

No exemplo a seguir, o índice `0` retorna o primeiro elemento, 'Rome', enquanto o índice `2` retorna o terceiro elemento, que é 'New York'. Lembre-se de que o índice corresponde à posição menos um (n - 1).

### Indexação Negativa
Python também suporta **indexação negativa**: isso permite acessar elementos a partir do final da lista. Aqui, `-1` representa o último item, `-2` representa o penúltimo item e assim por diante. A indexação negativa pode ser muito útil quando se deseja trabalhar com uma lista a partir do final sem saber seu comprimento.

cities = ["Rome", "London", "New York", "Brasilia", "Kioto"]

# Getting the last element
print(cities[-1])

# Getting the fourth element
print(cities[3], cities[-2])

Explicação:
1. `-1` recupera o último elemento 'Kioto';
2. `3` e `-2` ambos se referem ao quarto elemento 'Brasilia', um utilizando indexação positiva e o outro utilizando indexação negativa. Isso demonstra como a indexação percorre a lista.

A indexação positiva e negativa adiciona versatilidade ao acesso de elementos em listas, seja a partir do início ou do final.

### Indexação em listas aninhadas
O acesso a elementos em uma lista aninhada requer múltiplos índices: o primeiro índice seleciona a sublista e o segundo índice acessa o item específico dentro dessa sublista.

cities = [
    ["Paris", "France", 2000], 
    ["Tokyo", "Japan", 3000], 
    ["New York", "USA", 2500]
]

# Accessing the first sublist
print(cities[0])  # Output: ['Paris', 'France', 2000]

# Accessing the city name in the second sublist
print(cities[1][0])  # Output: Tokyo

# Accessing the cost of the trip in the third sublist
print(cities[2][2])  # Output: 2500

Aplicações do indexamento de listas aninhadas incluem, mas não se limitam a, dados estruturados como **planilhas**, **matrizes** ou **bancos de dados**. Exemplos práticos podem ser o acesso a linhas e colunas em uma matriz 2D, a recuperação de detalhes em listas de registros de funcionários ou a extração de informações específicas, como nomes de cidades ou custos em roteiros de viagem ou estruturas aninhadas semelhantes a JSON.

import unittest
from contextlib import redirect_stdout
import io
import importlib
import user_code
import re

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)

class TestUserCode(unittest.TestCase):
    def test_cities_is_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'cities'),
            "The `cities` list is declared.",
            "Expected the `cities` list to be declared."
        )

    def test_second_variable_correctly_assigned(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'second') and user_code.second == user_code.cities[1],
            "The `second` variable is correctly assigned as the second element of the list.",
            f"Expected `second` to be assigned to 'Tokyo', but got '{getattr(user_code, 'first', None)}'."
        )

    def test_last_variable_correctly_assigned(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'last') and user_code.last == user_code.cities[-1],
            "The `last` variable is correctly assigned as the last element of the list.",
            f"Expected `last` to be assigned to 'Berlin', but got '{getattr(user_code, 'last', None)}'."
        )
    def test_indexing_is_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        actual = re.search(r'cities\s*\[', user_code_source)
        _dynamic_test(
          self,
          actual,
          "The indexing is used to find the elements.",
          "Expected using indexing to find the elements."
        )

if __name__ == '__main__':
    unittest.main()

test_main.py

Explore as estruturas de dados fundamentais da linguagem de programação Python, incluindo listas, dicionários, tuplas e conjuntos, e aprenda a aplicá-las de forma eficaz para resolver desafios de programação do mundo real.

O que é uma lista? Uma lista é uma coleção ordenada que pode ser modificada. Ela também permite elementos duplicados.

O que é um dicionário? Um dicionário é uma coleção ordenada que pode ser modificada, mas não permite entradas duplicadas. Ele consiste em pares chave:valor, que são utilizados para otimizar sua estrutura.

O que é uma tupla? Uma tupla é uma coleção ordenada que não pode ser alterada. Ela pode conter elementos duplicados. Embora seja semelhante a uma lista, os valores em uma tupla podem ser de qualquer tipo e são indexados por inteiros. Embora não seja obrigatório, é comum envolver os valores de uma tupla entre parênteses, tornando-os mais fáceis de compreender em Python.

O que é um set? Em Python, um set é uma coleção não ordenada que é iterável e mutável, sem elementos repetidos. Embora a ordem dos itens em um set não seja fixa, ele pode incluir uma variedade de elementos. Um benefício importante do uso de sets em relação a listas é seu método altamente eficiente para determinar se um elemento existe no set.

Indexação de Listas em Python: Acesso Eficiente aos Elementos

Indexação Negativa

Indexação em listas aninhadas

Solução