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.
