Listas em Python

A lista (list) é uma estrutura de dados que armazena uma sequência de elementos. Em muitos outros linguagens, essa estrutura é conhecida como array.

Criando uma Lista

Para criar uma lista, utilizamos colchetes [], onde os elementos são separados por vírgulas. Por exemplo, vamos definir uma lista de números:

numbers = [1, 2, 3, 4, 5]

Da mesma forma, podemos criar listas com outros tipos de dados, como strings:

people = ["Tom", "Sam", "Bob"]

Também é possível utilizar a função construtora list() para criar uma lista:

numbers1 = []
numbers2 = list()

Essas duas definições criam listas vazias.

Uma lista não precisa conter apenas objetos de um único tipo. É possível incluir strings, números e outros tipos de dados em uma mesma lista:

objects = [1, 2.6, "Hello", True]

Para verificar o conteúdo da lista, podemos utilizar a função print, que exibe o conteúdo de maneira legível:

numbers = [1, 2, 3, 4, 5]
people = ["Tom", "Sam", "Bob"]

print(numbers)  # [1, 2, 3, 4, 5]
print(people)   # ["Tom", "Sam", "Bob"]

A função list() também pode receber valores que servirão para criar uma nova lista:

numbers1 = [1, 2, 3, 4, 5]
numbers2 = list(numbers1)
print(numbers2)  # [1, 2, 3, 4, 5]

letters = list("Hello")
print(letters)   # ['H', 'e', 'l', 'l', 'o']

Caso seja necessário criar uma lista com um mesmo valor repetido, podemos utilizar o operador *:

numbers = [5] * 6   # Repete o valor 5 seis vezes
print(numbers)      # [5, 5, 5, 5, 5, 5]

people = ["Tom"] * 3   # Repete "Tom" três vezes
print(people)          # ["Tom", "Tom", "Tom"]

students = ["Bob", "Sam"] * 2   # Repete "Bob", "Sam" duas vezes
print(students)                 # ["Bob", "Sam", "Bob", "Sam"]

Acessando Elementos de uma Lista

Para acessar os elementos de uma lista, utilizamos índices, que indicam a posição do elemento na lista. Os índices começam em zero. Portanto, o primeiro elemento possui índice 0, o segundo índice 1, e assim por diante. Para acessar elementos de trás para frente, podemos usar índices negativos, começando em -1 para o último elemento.

people = ["Tom", "Sam", "Bob"]
# Acessando elementos do início
print(people[0])   # Tom
print(people[1])   # Sam
print(people[2])   # Bob

# Acessando elementos a partir do final
print(people[-2])   # Sam
print(people[-1])   # Bob
print(people[-3])   # Tom

Para modificar um elemento da lista, basta atribuir a ele um novo valor:

people = ["Tom", "Sam", "Bob"]

people[1] = "Mike"  # Modificando o segundo elemento
print(people[1])    # Mike
print(people)       # ["Tom", "Mike", "Bob"]

Desempacotamento de Lista

O Python permite que uma lista seja desempacotada em variáveis individuais:

people = ["Tom", "Bob", "Sam"]

tom, bob, sam = people

print(tom)  # Tom
print(bob)  # Bob
print(sam)  # Sam

Nesse exemplo, as variáveis tom, bob e sam recebem os valores correspondentes da lista people. No entanto, o número de variáveis deve corresponder ao número de elementos da lista.

Iterando sobre Elementos

Para iterar sobre os elementos de uma lista, podemos usar tanto o loop for quanto o while.

Exemplo com for:

people = ["Tom", "Sam", "Bob"]
for person in people:
    print(person)

Aqui, cada elemento da lista people é atribuído à variável person em cada iteração.

Exemplo com while:

people = ["Tom", "Sam", "Bob"]
i = 0
while i < len(people):
    print(people[i])  # Usamos o índice para acessar o elemento
    i += 1

Usamos a função len() para obter o tamanho da lista e, com o índice i, acessamos cada elemento até que o índice seja igual ao tamanho da lista.

Comparação de Listas

Duas listas são consideradas iguais se contêm o mesmo conjunto de elementos:

numbers1 = [1, 2, 3, 4, 5]
numbers2 = list([1, 2, 3, 4, 5])
print(numbers1 == numbers2)  # True

people1 = ["Tom", "Sam", "Bob"]
people2 = ["Sam", "Bob", "Tom"]

print(people1 == people2)  # False

Obtendo uma Parte da Lista

Para obter uma parte específica de uma lista, usamos uma sintaxe especial com três parâmetros opcionais: end, start e step.

• list[:end]: Retorna os elementos da lista do início até o índice end (exclusivo).
• list[start:end]: Retorna os elementos da lista do índice start até o índice end (exclusivo).
• list[start:end:step]: Retorna os elementos da lista do índice start até o índice end (exclusivo), com um passo de step.

É possível também utilizar índices negativos para a seleção de partes da lista, contando a partir do final.

people = ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"]

slice_people1 = people[:-1]   # Da primeira posição até o penúltimo
print(slice_people1)   # ["Tom", "Bob", "Alice", "Sam", "Tim"]

slice_people2 = people[-3:-1]  # Da terceira posição a partir do final até o penúltimo
print(slice_people2)   # ["Sam", "Tim"]

Métodos e Funções para Manipulação de Listas

As listas em Python oferecem diversos métodos para manipular seus elementos. Aqui estão alguns dos principais:

• append(item): adiciona o elemento item ao final da lista.
• insert(index, item): insere o elemento item no índice especificado.
• extend(items): adiciona todos os elementos do conjunto items ao final da lista.
• remove(item): remove o primeiro elemento encontrado que corresponda a item. Se o elemento não for encontrado, lança uma exceção ValueError.
• clear(): remove todos os elementos da lista.
• index(item): retorna o índice do elemento item. Se não encontrado, lança ValueError.
• pop([index]): remove e retorna o elemento no índice especificado. Sem índice, remove o último elemento.
• count(item): retorna o número de vezes que item aparece na lista.
• sort([key]): ordena a lista em ordem crescente. Com o parâmetro key, é possível definir uma função de ordenação.
• reverse(): inverte a ordem dos elementos na lista.
• copy(): cria uma cópia da lista.

Além disso, Python fornece várias funções para uso com listas:

• len(list): retorna o tamanho da lista.
• sorted(list, [key]): retorna uma lista ordenada.
• min(list): retorna o menor elemento.
• max(list): retorna o maior elemento.

Adição e Remoção de Elementos

Para adicionar elementos, utilizamos append(), extend() e insert(). Para remover, usamos remove(), pop() e clear().

Exemplo de uso:

people = ["Tom", "Bob"]

# Adiciona ao final da lista
people.append("Alice")  # ["Tom", "Bob", "Alice"]
# Insere na segunda posição
people.insert(1, "Bill")  # ["Tom", "Bill", "Bob", "Alice"]
# Adiciona os elementos de uma nova lista
people.extend(["Mike", "Sam"])  # ["Tom", "Bill", "Bob", "Alice", "Mike", "Sam"]

# Obtemos o índice de um elemento
index_of_tom = people.index("Tom")
# Removemos pelo índice
removed_item = people.pop(index_of_tom)  # ["Bill", "Bob", "Alice", "Mike", "Sam"]
# Removemos o último elemento
last_item = people.pop()  # ["Bill", "Bob", "Alice", "Mike"]
# Removemos o elemento "Alice"
people.remove("Alice")  # ["Bill", "Bob", "Mike"]

# Limpamos a lista
people.clear()
print(people)  # []

Verificação de Elementos

Os métodos remove e index lançam exceção se o elemento não for encontrado. Para evitar isso, é possível verificar a presença de um elemento com o operador in:

people = ["Tom", "Bob", "Alice", "Sam"]

if "Alice" in people:
    people.remove("Alice")
print(people)  # ["Tom", "Bob", "Sam"]

Remoção com del

Python permite a remoção de elementos também pelo operador del, onde passamos o índice ou intervalo dos elementos a serem removidos:

people = ["Tom", "Bob", "Alice", "Sam", "Bill", "Kate", "Mike"]

del people[1]   # Remove o segundo elemento
print(people)   # ["Tom", "Alice", "Sam", "Bill", "Kate", "Mike"]

del people[:3]  # Remove até o quarto elemento, sem incluí-lo
print(people)   # ["Bill", "Kate", "Mike"]

del people[1:]  # Remove a partir do segundo elemento
print(people)   # ["Bill"]

Alteração de Subconjunto de Elementos

Para alterar um subconjunto de elementos, podemos utilizar o mesmo método de fatiamento:

nums = [10, 20, 30, 40, 50]
nums[1:4] = [11, 22]
print(nums)  # [10, 11, 22, 50]

Aqui, nums[1:4] referencia [20, 30, 40] e, ao substituir esse subconjunto, obtemos [10, 11, 22, 50].

Contagem de Ocorrências

Para contar a presença de um elemento específico, usamos o método count():

people = ["Tom", "Bob", "Alice", "Tom", "Bill", "Tom"]

people_count = people.count("Tom")
print(people_count)  # 3

Ordenação

Para ordenar uma lista em ordem crescente, usamos sort():

people = ["Tom", "Bob", "Alice", "Sam", "Bill"]
people.sort()
print(people)  # ["Alice", "Bill", "Bob", "Sam", "Tom"]

Para ordenar em ordem decrescente, combinamos sort() com reverse():

people.sort()
people.reverse()
print(people)  # ["Tom", "Sam", "Bob", "Bill", "Alice"]

A ordenação compara elementos de acordo com regras de menor e maior, onde strings, por exemplo, são comparadas pelo valor de cada caractere. Para ordenar ignorando maiúsculas e minúsculas, utilizamos uma função auxiliar com o parâmetro key:

Além de sort(), podemos usar sorted(), que não altera a lista original:

people = ["Tom", "bob", "alice", "Sam", "Bill"]

sorted_people = sorted(people, key=str.lower)
print(sorted_people)  # ["alice", "Bill", "bob", "Sam", "Tom"]

Filtrando Lista

Para filtrar uma lista, usamos a função filter(), que recebe uma função condicional e a lista a ser filtrada:

numbers = [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]

def condition(number):
    return number > 1

result = filter(condition, numbers)

for n in result:
    print(n, end=" ")  # 2 3 4 5

A função filter() retorna uma lista contendo apenas os elementos que atendem à condição.

Alternativamente, podemos utilizar uma expressão lambda para simplificar o código:

numbers = [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]

result = filter(lambda n: n > 1, numbers)

for n in result:
    print(n, end=" ")  # 2 3 4 5

Da mesma forma, podemos filtrar listas de objetos mais complexos:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

people = [
    Person("Tom", 38), Person("Kate", 31), Person("Bob", 42),
    Person("Alice", 34), Person("Sam", 25)
]

# Filtrando pessoas com idade superior a 33
view = filter(lambda p: p.age > 33, people)

for person in view:
    print(f"Name: {person.name} Age: {person.age}")

Nesse caso, filtramos a lista de objetos Person, onde cada objeto representa uma pessoa com nome e idade. Aqui selecionamos aqueles cuja idade é maior que 33.

Mapeamento de Lista

Para aplicar transformações em cada elemento de uma lista, usamos a função map(), que recebe uma função e a lista a ser projetada:

map(fun, iter)

A função fun é aplicada a cada elemento de iter, retornando uma nova lista com os resultados.

O map() retorna uma lista de valores obtidos após aplicar a função a cada elemento. Por exemplo, vamos transformar uma lista de números em uma lista com seus quadrados:

numbers = [1, 2, 3, 4, 5]

def square(number):
    return number * number

result = map(square, numbers)

for n in result:
    print(n, end=" ")  # 1 4 9 16 25

Também podemos usar expressões lambda como função de transformação:

numbers = [1, 2, 3, 4, 5]
result = map(lambda n: n * n, numbers)

for n in result:
    print(n, end=" ")  # 1 4 9 16 25

Da mesma forma, podemos projetar listas de objetos mais complexos:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

people = [Person("Tom", 38), Person("Kate", 31), Person("Bob", 42), Person("Alice", 34), Person("Sam", 25)]

view = map(lambda p: p.name, people)

for person in view:
    print(person)

Aqui, cada objeto Person é transformado para exibir apenas o atributo name, resultando em uma lista de nomes.

Tom
Kate
Bob
Alice
Sam

Valores Mínimos e Máximos

As funções min() e max() em Python permitem obter o valor mínimo e máximo de uma lista:

numbers = [9, 21, 12, 1, 3, 15, 18]
print(min(numbers))  # 1
print(max(numbers))  # 21

Cópia de Listas

Como listas são mutáveis, é importante considerar que, ao copiar uma lista de forma superficial (shallow copy), tanto a original quanto a cópia referenciam o mesmo objeto:

people1 = ["Tom", "Bob", "Alice"]
people2 = people1
people2.append("Sam")

print(people1)  # ["Tom", "Bob", "Alice", "Sam"]
print(people2)  # ["Tom", "Bob", "Alice", "Sam"]

Para evitar esse comportamento, podemos fazer uma cópia profunda usando o método copy():

people1 = ["Tom", "Bob", "Alice"]
people2 = people1.copy()
people2.append("Sam")

print(people1)  # ["Tom", "Bob", "Alice"]
print(people2)  # ["Tom", "Bob", "Alice", "Sam"]

Concatenação de Listas

Para concatenar duas listas, usamos o operador +:

people1 = ["Tom", "Bob", "Alice"]
people2 = ["Tom", "Sam", "Tim", "Bill"]
people3 = people1 + people2

print(people3)  # ["Tom", "Bob", "Alice", "Tom", "Sam", "Tim", "Bill"]

Listas Aninhadas

Em Python, Listas podem conter outras listas, o que permite a criação de estruturas semelhantes a tabelas, onde cada lista aninhada representa uma linha:

people = [
    ["Tom", 29],
    ["Alice", 33],
    ["Bob", 27]
]

print(people[0])        # ["Tom", 29]
print(people[0][0])     # Tom
print(people[0][1])     # 29

Podemos manipular listas aninhadas da mesma forma que listas regulares:

people = [
    ["Tom", 29],
    ["Alice", 33],
    ["Bob", 27]
]

# Criando uma nova lista aninhada
person = list()
person.append("Bill")
person.append(41)
people.append(person)

print(people[-1])  # ["Bill", 41]

# Adicionando um elemento a uma lista aninhada
people[-1].append("+99876543210")
print(people[-1])  # ["Bill", 41, "+99876543210"]

# Removendo o último elemento da lista aninhada
people[-1].pop()
print(people[-1])  # ["Bill", 41]

# Removendo a lista aninhada inteira
people.pop(-1)

# Alterando o primeiro elemento
people[0] = ["Sam", 18]
print(people)  # [["Sam", 18], ["Alice", 33], ["Bob", 27]]

Iterando sobre Listas Aninhadas

Para percorrer todos os elementos em listas aninhadas, utilizamos loops aninhados:

people = [
    ["Tom", 29],
    ["Alice", 33],
    ["Bob", 27]
]

for person in people:
    for item in person:
        print(item, end=" | ")

Saída:

Tom | 29 | Alice | 33 | Bob | 27 |

Documentação oficial:

• Métodos de listas