Manipular Listas em Python

Introdução

Neste laboratório, você ganhará experiência prática na manipulação de listas em Python. Listas são uma estrutura de dados fundamental para armazenar coleções ordenadas de itens. Você aprenderá a criar, acessar, adicionar, remover e modificar elementos de listas.

Além disso, este laboratório o guiará por operações mais avançadas, como ordenação, consulta (querying) e aninhamento de listas. Ao final deste laboratório, você terá uma compreensão sólida de como trabalhar eficazmente com listas para gerenciar e processar dados em seus programas Python.

Criar e Acessar Listas

Nesta etapa, você aprenderá a criar listas e acessar seus elementos. Listas são coleções ordenadas e mutáveis de itens e são um dos tipos de dados mais versáteis do Python.

Listas são criadas usando colchetes [], com os itens separados por vírgulas. Vamos começar criando algumas listas.

No explorador de arquivos do WebIDE à esquerda, localize e abra o arquivo list_creation.py localizado no diretório ~/project. Adicione o seguinte código ao arquivo:

## Create an empty list
empty_list = []
print("Empty list:", empty_list)
print("Type of empty_list:", type(empty_list))

## Create a list of numbers
numbers = [10, 20, 30, 40, 50]
print("Numbers list:", numbers)

## Lists can contain elements of different data types
mixed_list = [1, 'hello', 3.14, True]
print("Mixed data type list:", mixed_list)

## You can also create a list from another iterable, like a string
string_list = list("python")
print("List from a string:", string_list)

Após adicionar o código, salve o arquivo. Para executar o script, abra o terminal integrado no WebIDE e execute o seguinte comando:

python ~/project/list_creation.py

Você deverá ver a seguinte saída, demonstrando diferentes maneiras de criar uma lista:

Empty list: []
Type of empty_list: <class 'list'>
Numbers list: [10, 20, 30, 40, 50]
Mixed data type list: [1, 'hello', 3.14, True]
List from a string: ['p', 'y', 't', 'h', 'o', 'n']

Em seguida, vamos explorar como acessar elementos dentro de uma lista. Você pode acessar elementos pelo seu índice (posição). A indexação de listas começa em 0. Você também pode usar índices negativos, onde -1 se refere ao último elemento.

O fatiamento (slicing) permite que você acesse um intervalo de elementos. A sintaxe é list[start:stop:step].

Adicione o seguinte código ao final do seu arquivo list_creation.py:

## Accessing list elements
fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi']
print("\n--- Accessing Elements ---")
print("Fruits list:", fruits)

## Access the first element (index 0)
print("First element:", fruits[0])

## Access the last element (index -1)
print("Last element:", fruits[-1])

## Slicing: get elements from index 1 up to (but not including) index 4
print("Slice [1:4]:", fruits[1:4])

## Slicing: get all elements from the beginning up to index 3
print("Slice [:3]:", fruits[:3])

## Slicing: get all elements from index 2 to the end
print("Slice [2:]:", fruits[2:])

## Slicing: get a copy of the entire list
print("Slice [:] (a copy):", fruits[:])

## Slicing with a step: get every second element
print("Slice [::2]:", fruits[::2])

## Slicing to reverse the list
print("Reversed list [::-1]:", fruits[::-1])

Salve o arquivo e execute o script novamente a partir do terminal:

python ~/project/list_creation.py

Observe a nova saída para entender como funcionam a indexação e o fatiamento:

Empty list: []
Type of empty_list: <class 'list'>
Numbers list: [10, 20, 30, 40, 50]
Mixed data type list: [1, 'hello', 3.14, True]
List from a string: ['p', 'y', 't', 'h', 'o', 'n']

--- Accessing Elements ---
Fruits list: ['orange', 'apple', 'pear', 'banana', 'kiwi']
First element: orange
Last element: kiwi
Slice [1:4]: ['apple', 'pear', 'banana']
Slice [:3]: ['orange', 'apple', 'pear']
Slice [2:]: ['pear', 'banana', 'kiwi']
Slice [:] (a copy): ['orange', 'apple', 'pear', 'banana', 'kiwi']
Slice [::2]: ['orange', 'pear', 'kiwi']
Reversed list [::-1]: ['kiwi', 'banana', 'pear', 'apple', 'orange']

Você aprendeu agora como criar listas e acessar seu conteúdo.

Modificar Listas: Adicionar, Remover e Alterar Elementos

Nesta etapa, você aprenderá a modificar listas. Como as listas são mutáveis, você pode adicionar, remover ou alterar seus elementos após terem sido criadas.

Primeiro, vamos nos concentrar em adicionar elementos. Python fornece vários métodos:

• append(): Adiciona um único elemento ao final da lista.
• extend(): Adiciona todos os elementos de um iterável (como outra lista) ao final.
• insert(): Adiciona um elemento em um índice específico.

Abra o arquivo list_modification.py no explorador de arquivos do WebIDE. Adicione o seguinte código a ele:

## --- Adding Elements ---
my_list = [1, 2, 3]
print("Original list:", my_list)

## Add an element using append()
my_list.append(4)
print("After append(4):", my_list)

## Add multiple elements using extend()
my_list.extend([5, 6])
print("After extend([5, 6]):", my_list)

## Insert an element at a specific position
my_list.insert(1, 1.5) ## Insert 1.5 at index 1
print("After insert(1, 1.5):", my_list)

Salve o arquivo e execute-o a partir do terminal:

python ~/project/list_modification.py

Sua saída deve mostrar a lista crescendo a cada operação:

Original list: [1, 2, 3]
After append(4): [1, 2, 3, 4]
After extend([5, 6]): [1, 2, 3, 4, 5, 6]
After insert(1, 1.5): [1, 1.5, 2, 3, 4, 5, 6]

Em seguida, vamos praticar a remoção de elementos. Os métodos principais incluem:

• remove(): Remove a primeira ocorrência de um valor especificado.
• pop(): Remove e retorna o elemento em um determinado índice (ou o último elemento se nenhum índice for especificado).
• del: Uma instrução para remover um item ou fatia (slice) por índice.
• clear(): Remove todos os elementos da lista.

Adicione o seguinte código ao final de list_modification.py:

## --- Removing Elements ---
fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple']
print("\n--- Removing Elements ---")
print("Original fruits list:", fruits)

## Remove the last element using pop()
popped_item = fruits.pop()
print("After pop():", fruits)
print("Popped item:", popped_item)

## Remove an element by its value using remove()
fruits.remove('pear')
print("After remove('pear'):", fruits)

## Remove an element by its index using del
del fruits[1] ## Deletes 'apple' at index 1
print("After del fruits[1]:", fruits)

## Clear all elements from the list
fruits.clear()
print("After clear():", fruits)

Finalmente, você pode alterar elementos existentes atribuindo um novo valor a um índice ou a uma fatia (slice). Adicione este último bloco de código a list_modification.py:

## --- Changing Elements ---
letters = ['a', 'b', 'c', 'd', 'e']
print("\n--- Changing Elements ---")
print("Original letters list:", letters)

## Change a single element
letters[0] = 'A'
print("After changing index 0:", letters)

## Change a slice of elements
letters[1:3] = ['B', 'C']
print("After changing slice [1:3]:", letters)

Salve o arquivo e execute o script mais uma vez:

python ~/project/list_modification.py

A saída completa demonstrará todas as técnicas de modificação que você aprendeu:

Original list: [1, 2, 3]
After append(4): [1, 2, 3, 4]
After extend([5, 6]): [1, 2, 3, 4, 5, 6]
After insert(1, 1.5): [1, 1.5, 2, 3, 4, 5, 6]

--- Removing Elements ---
Original fruits list: ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple']
After pop(): ['orange', 'apple', 'pear', 'banana', 'kiwi']
Popped item: apple
After remove('pear'): ['orange', 'apple', 'banana', 'kiwi']
After del fruits[1]: ['orange', 'banana', 'kiwi']
After clear(): []

--- Changing Elements ---
Original letters list: ['a', 'b', 'c', 'd', 'e']
After changing index 0: ['A', 'b', 'c', 'd', 'e']
After changing slice [1:3]: ['A', 'B', 'C', 'd', 'e']

Você agora está apto a adicionar, remover e alterar elementos em uma lista Python.

Operações Avançadas com Listas: Ordenação, Consulta e Aninhamento

Nesta etapa final, você explorará operações de lista mais avançadas, incluindo ordenação, consulta de informações e trabalho com listas aninhadas (nested lists).

Vamos começar com a ordenação. O método sort() modifica a lista no local (in-place). Você pode ordenar em ordem crescente ou decrescente.

Abra o arquivo list_operations.py no WebIDE. Adicione o seguinte código para demonstrar a ordenação:

## --- Sorting Lists ---
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print("--- Sorting Lists ---")
print("Original numbers list:", numbers)

## Sort the list in-place (ascending)
numbers.sort()
print("After sort():", numbers)

## Sort the list in descending order
numbers.sort(reverse=True)
print("After sort(reverse=True):", numbers)

## The reverse() method simply reverses the order, it does not sort
letters = ['a', 'b', 'c', 'd']
print("\nOriginal letters list:", letters)
letters.reverse()
print("After reverse():", letters)

Salve o arquivo e execute-o a partir do terminal:

python ~/project/list_operations.py

A saída mostra as listas ordenadas e invertidas:

--- Sorting Lists ---
Original numbers list: [3, 1, 4, 1, 5, 9, 2, 6]
After sort(): [1, 1, 2, 3, 4, 5, 6, 9]
After sort(reverse=True): [9, 6, 5, 4, 3, 2, 1, 1]

Original letters list: ['a', 'b', 'c', 'd']
After reverse(): ['d', 'c', 'b', 'a']

Em seguida, vamos consultar uma lista para encontrar informações.

• count(): Retorna o número de vezes que um valor aparece.
• index(): Retorna o índice da primeira ocorrência de um valor.

Adicione o seguinte código a list_operations.py:

## --- Querying Lists ---
fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
print("\n--- Querying Lists ---")
print("Fruits list:", fruits)

## Count the occurrences of an element
apple_count = fruits.count('apple')
print("Count of 'apple':", apple_count)

## Find the index of the first occurrence of an element
banana_index = fruits.index('banana')
print("Index of first 'banana':", banana_index)

Finalmente, vamos ver as listas aninhadas (nested lists). Uma lista aninhada é uma lista que contém outras listas como seus elementos. Isso é útil para criar estruturas 2D como uma matriz ou uma grade.

Adicione este bloco final de código a list_operations.py:

## --- Nested Lists ---
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print("\n--- Nested Lists ---")
print("Matrix:", matrix)

## Access an entire inner list (a row)
first_row = matrix[0]
print("First row:", first_row)

## Access a specific element in the nested list
## To get the element '6', we access row 1, then column 2
element = matrix[1][2]
print("Element at matrix[1][2]:", element)

Salve o arquivo e execute o script pela última vez:

python ~/project/list_operations.py

A saída completa demonstrará ordenação, consulta e acesso a listas aninhadas:

--- Sorting Lists ---
Original numbers list: [3, 1, 4, 1, 5, 9, 2, 6]
After sort(): [1, 1, 2, 3, 4, 5, 6, 9]
After sort(reverse=True): [9, 6, 5, 4, 3, 2, 1, 1]

Original letters list: ['a', 'b', 'c', 'd']
After reverse(): ['d', 'c', 'b', 'a']

--- Querying Lists ---
Fruits list: ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
Count of 'apple': 2
Index of first 'banana': 3

--- Nested Lists ---
Matrix: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
First row: [1, 2, 3]
Element at matrix[1][2]: 6

Você dominou agora várias técnicas avançadas para trabalhar com listas Python.

Resumo

Neste laboratório, você aprendeu os fundamentos da manipulação de listas em Python. Você começou criando listas usando colchetes [] e o construtor list(). Você praticou o acesso a elementos da lista com indexação (indexing) e fatiamento (slicing), que são essenciais para recuperar itens específicos ou subconjuntos de uma lista.

Em seguida, você explorou como modificar listas adicionando elementos com append(), extend() e insert(), removendo elementos com remove(), pop() e del, e alterando elementos por meio de atribuição de índice e fatia. Por fim, você cobriu operações avançadas, incluindo ordenação no local (in-place) com sort(), inversão com reverse(), consulta com count() e index(), e estruturação de dados com listas aninhadas (nested lists). Agora você está bem equipado para usar listas de forma eficaz em seus projetos Python.