Listas em Python - #09
Tags: beginners, programming, python, tutorial
Published: 2022-05-12 10:05:07

{% youtube https://youtu.be/-ybKy4yjIAY %}
{% youtube https://youtu.be/DHP5BtLs7U8 %}

## Introdução

**_Listas_** são tipos de dados em _Python_ semelhantes a vetores ou **_arrays_**, no mundo da programação.

Um **_array_** é uma estrutura de dados capaz de armazenar um conjunto de dados e que possui acesso randômico através do uso de índices.

O que é acesso randômico? Quando um tipo de dado possui acesso randômico, significa que posso acessar qualquer elemento de forma direta, sem ser necessário ler os elementos anteriores, por exemplo (leitura sequencial).

E os índices? Índices representam números que identificam a posição de um determinado elemento em uma lista. Por exemplo, quando você faz uma lista de compras, facilmente é identificável qual é o quinto elemento da lista.

Além de conhecer este tipo de dado, você deve saber como inserir, ler, remover elementos, além de percorrer uma lista.

## Sintaxe

### Criando uma lista

Para criar uma lista, basta utilizarmos colchetes (“[” e “]”) entre os valores. Os valores de uma lista devem ser separados por vírgula (“,”).

```python
#Criando listas
>>> lista_vazia = []
>>> lista_inteiros = [6, -1, 12, 8, 10]
>>> lista_strings = ["alguma", "qualquer", "Python", "lista"]

>>> print(lista_vazia)                   
[]                                       

>>> print(lista_inteiros)                
[6, -1, 12, 8, 10]                       

>>> print(lista_strings)                 
['alguma', 'qualquer', 'Python', 'lista']
```

No exemplo anterior criamos 3 variáveis do tipo lista (lista_vazia, lista_inteiros, lista_strings), recebendo uma lista vazia, uma lista de inteiros e uma lista de _strings_.

Também é possível misturarmos tipos de dados em uma lista:

```python
#Criando lista com dados misturados
>>> lista_mista = [1, "texto", True, 1.0]
>>> print(lista_mista)
[1, 'texto', True, 1.0]
```

### Tamanho de uma lista - **_len()_**

A função **_len()_** retorna a quantidade de elementos de uma lista.

```python
#Usando a função len()
>>> lista_vazia = []
>>> len(lista_vazia)
0

>>> lista_nomes = ["Lara", "Joao", "Igor", "Eduardo", "Alan"]
>>> len(lista_nomes)
5
```

### Verificando se a lista não está vazia

Além do uso do **_len()_**, podemos verificar se uma lista está vazia através do laço **_if_**.

```python
#Verificando com if se a lista está vazia
>>> lista = []
>>> if lista :
...     print("Lista nao esta vazia")
... else:
...     print("Lista vazia")
...
Lista vazia
```

O laço **_if_** será executado se a lista não estiver vazia e o **_else_** caso esteja vazia.

Se você utilizar um **_not_** na instrução **_if_**, como `if not lista :`, implica que a condição será verdadeira se a lista estiver vazia.


### Acessando elementos da lista

O acesso aos elementos de uma lista é feito através de índices, e se iniciam no valor ZERO. Os índices são valores inteiros que indicam a posição do elemento na lista.

Por exemplo, se você deseja acessar o primeiro elemento da _lista_inteiros_, do exemplo anterior, você deve utilizar o nome da lista e entre colchetes a posição desejada, neste caso ZERO:

```python
#Acessando a primeira posição de uma lista
>>> lista_inteiros = [6, -1, 12, 8, 10]
>>> print(lista_inteiros[0])
6

>>> lista_nomes = ['casa', 'comida']
>>> print(lista_nomes[0].title())
Casa
```

Aplicando o raciocínio que o primeiro elemento possui índice ZERO, temos que, do exemplo anterior:
* lista_inteiros[0] == 6
* lista_inteiros[1] == -1
* lista_inteiros[2] == 12
* lista_inteiros[3] == 8
* lista_inteiros[4] == 10

Também podemos aplicar índices negativos, quando utilizado o valor negativo, a lista será lida ao contrário. Usando o exemplo anteior:
* lista_inteiros[-1] == 10
* lista_inteiros[-2] == 8
* lista_inteiros[-3] == 12
* lista_inteiros[-4] == -1
* lista_inteiros[-5] == 6

```python
#Uso de índices positivos e negativos
>>> lista_cores = ["verde", "amarelo", "azul", "branco", "preto"]

>>> lista_cores[3]
'branco'

>>> lista_cores[-3]
'azul'

>>> lista_cores[0]
'verde'

>>> lista_cores[-5]
'verde'
```

### Alterando os valores de uma lista

Também através do uso dos índices, podemos  alterar os valores de uma lista. Você pode interpretar uma posição da lista como se fosse uma variável:

```python
#Alterando valores em uma lista, substituindo o quarto elemento
>>> lista_pares = [2, 4, 6, 7, 10]
>>> print(lista_pares)
[2, 4, 6, 7, 10]

>>> lista_pares[3] = 8
>>> print(lista_pares)
[2, 4, 6, 8, 10]
```

No algoritmo anterior, estamos substituindo o quarto elemento da lista (_lista_pares[3]_) pelo valor 8.

### Inserindo elementos na lista - **_append( )_**

Através do método **_append( )_** podemos adicionar elementos no final da lista. É um método porque precisamos da variável lista e um ponto (“.”) como prefixo na execução do **_append( )_**.

```python
#Inserindo elementos na lista - append()
>>> lista_pares = []
>>> print(lista_pares)
[]

>>> lista_pares.append(2)
>>> print(lista_pares)
[2]

>>> lista_pares.append(4)
>>> print(lista_pares)
[2, 4]

>>> lista_pares.append(6)
>>> print(lista_pares)
[2, 4, 6]
```

Do exemplo anterior, inserimos 3 valores em uma lista vazia (_lista_pares_) com a execução do método **_append()_**: <code>lista_pares.append(2)</code></em>, <code>lista_pares.append(4), lista_pares.append(6).</code></strong>

### Inserindo elementos na lista - **_insert()_**

O método **_insert()_** permite inserir elementos na lista em uma posição específica, através do uso do índice. Veja o exemplo:

```python
#Inserindo elementos na lista - insert()
>>> lista_frutas = ["caju", "castanha"]
>>> print(lista_frutas)
['caju', 'castanha']

>>> lista_frutas.insert(0, "abacaxi")
>>> print(lista_frutas)
['abacaxi', 'caju', 'castanha']

>>> lista_frutas.insert(2, "caqui")
>>> print(lista_frutas)
['abacaxi', 'caju', 'caqui', 'castanha']
```

Observe que ao inserir um elemento em uma determinada posição, os outros elementos são **empurrados**. No jargão de programação, dizemos que é feito um **_shift_** nos elementos.

### Removendo elementos da lista - **_del_**

Para se remover um elemento da lista utilizamos o **_comando del_**. Um comando diferente de uma função, não utiliza parênteses e também diferente de um método, não precisa de um prefixo com variável.

Se quisermos remover um elemento de uma lista, usamos a sintaxe **_del nome_lista[indice]_**. Observe o exemplo removendo o quarto elemento da lista:

```python
#Removendo elementos na lista - comando del
>>> lista_pares = [2, 4, 6, 7, 8, 10]
>>> print(lista_pares)
[2, 4, 6, 7, 8, 10]

>>> del lista_pares[3]
>>> print(lista_pares)
[2, 4, 6, 8, 10]
```

### Removendo elementos da lista - **_pop()_**

O método **_pop()_** permite remover o último elemento da lista. Diferente do **_del_**, o **_pop()_** quando executado, retorna o elemento removido.

```python
#Removendo elementos na lista - comando pop()
>>> lista_prioridades = []
>>> lista_prioridades.append("acordar")
>>> lista_prioridades.append("escovar dentes")
>>> lista_prioridades.append("tomar cafe")
>>> print(lista_prioridades)
['acordar', 'escovar dentes', 'tomar cafe']

>>> print(lista_prioridades.pop())
tomar cafe
>>> print(lista_prioridades.pop())
escovar dentes
>>> print(lista_prioridades.pop())
acordar
>>> print(lista_prioridades)
[]
```

Quando um método possui mais de uma forma de ser executado, dizemos que ele é um **método sobrecarregado**, um método que possui mais de uma **_<span style="text-decoration:underline;">assinatura</span>_**. (Iremos explorar **_assinatura_** de métodos ou funções em outra oportunidade)

O método **_pop()_** é sobrecarregado, isto significa que podemos executá-lo de outra forma: **_é possível indicar a posição do item que queremos remover da lista_**. Veja o exemplo.

```python
#Removendo elemento específico na lista
>>> lista = ["elemento 1", "elemento 2", "elemento 3"]
>>> print(lista)
['elemento 1', 'elemento 2', 'elemento 3']

>>> lista.pop(1)
'elemento 2'

>>> print(lista)
['elemento 1', 'elemento 3']
```

### Removendo elementos da lista - **_remove()_**

O método **_remove()_** permite remover elementos da lista, recebendo como argumento o **valor** que queremos remover.

Se a lista possuir mais de um elemento com o mesmo valor que queremos remover, somente a primeira ocorrência será removida.

```python
#Removendo elemento na lista com remove
>>> lista = [4.5, -2, 3.4, 55, -2]
>>> print(lista)
[4.5, -2, 3.4, 55, -2]

>>> lista.remove(-2)
>>> print(lista)
[4.5, 3.4, 55, -2]
```

### Verificando se um elemento pertence à lista

Através do uso da palavra reservada “_in_” e da expressão “_not in_” podemos verificar se um elemento pertence ou não pertence à lista, respectivamente.

```python
#Usando in e not in
>>> lista = [1, 3, 5, 7, 9]

>>> 2 in lista
False

>>> 5 in lista
True

>>> if 4 not in lista:
...     print("4 nao pertence a lista")
...
4 nao pertence a lista
```

### Sublistas

É possível usar somente partes da lista através do operador dois pontos (:) dentro dos colchetes.

```python
#Sintaxe sublista
<lista>[<inicio>:<fim>:<incremento>]
```

Por exemplo, escrevendo _&lt;lista>[3:7]_, vamos ler os elementos começando do índice 3 até o índice 6, por definição o limite superior é não inclusivo.

```python
#Escrevendo um subconjunto da lista
>>> lista = [1, 3, 5, 7, 9]

>>> print(lista[1:4])
[3, 5, 7]

>>> print(lista[0:10])
[1, 3, 5, 7, 9]

>>> print(lista[:10])
[1, 3, 5, 7, 9]

>>> print(lista[1:])
[3, 5, 7, 9]

>>> print(lista[0:5:2])
[1, 5, 9]
```

Observe no exemplo anterior, se você utilizar um índice maior que o tamanho da lista, o código não irá gerar um erro e todos os elementos serão impressos. 

Podemos suprimir o índice inicial, como em `lista[:10]`,  e _Python_ usará o começo da lista. Da mesma forma, se suprimirmos o índice final (`lista[1:]`), a linguagem lerá até o último elemento.

Também podemos usar índices negativos, para ler os índices em ordem inversa, por exemplo como imprimir os 3 últimos elementos de uma lista?

```python
#Lendo os 3 últimos de uma lista
>>> lista = [1, 3, 5, 7, 9]
>>> print(lista[-3:])
[5, 7, 9]
```

### Substrings

Utilizando a sintaxe de sublistas, podemos ler substrings de **_strings_**. Analogamente, uma **_string_** é uma lista de caracteres, com o índice do primeiro caractere começando na posição ZERO.

Repita os exemplos abaixo no seu **_shell_**.

```python
#Sintaxe substring
<string>[<inicio>:<fim>:<incremento>]
```

```python
#Experimentando substrings
>>> string = "Aprendendo Python"

>>> print(string[0:5])
Apren

>>> print(string[2:6])
rend

>>> print(string[-1])
n

>>> print(string[-6:])
Python

>>> print(string[1:-4])
prendendo Py

>>> print(string[::2])
Arned yhn
```

## Outras operações com listas

### Copiando uma lista

Vimos que o operador de atribuição (“=”) é utilizado para associar um valor a uma variável.

Quando fazemos a atribuição entre variáveis utilizando tipos de dados simples como os inteiros, **_float_** e **_strings_**, o valor é copiado entre as variáveis.

Observe:

```python
#Copiando valores entre variáveis
>>> num = 10
>>> copia_num = num
>>> num
10
>>> copia_num
10
>>> copia_num = 5
>>> num
10
>>> copia_num
5

>>> num = 10.11
>>> copia_num = num
>>> copia_num
10.11
>>> copia_num = 5.55
>>> num
10.11
>>> copia_num
5.55

>>> nome = "banana"
>>> copia_nome = nome
>>> nome
'banana'
>>> copia_nome
'banana'
>>> copia_nome = "abacaxi"
>>> nome
'banana'
>>> copia_nome
'abacaxi'
```

Veja nos casos acima, em cada caso, fizemos a cópia de uma variável em uma variável cópia e qualquer alteração em uma das variáveis não afeta o valor da outra.

No caso de listas é diferente, quando atribuímos uma lista entre duas variáveis, ambas vão referenciar a mesma lista e qualquer alteração em uma variável afetará a outra.

```python
#Atribuindo listas entre variáveis
>>> lista = ["banana", "abacaxi"]
>>> copia_lista = lista

>>> lista
['banana', 'abacaxi']
>>> copia_lista
['banana', 'abacaxi']

>>> copia_lista.append("limao")
>>> lista
['banana', 'abacaxi', 'limao']
>>> copia_lista
['banana', 'abacaxi', 'limao']
```

Para fazermos a cópia de listas, podemos adicionar elemento por elemento na nova variável ou utilizar sublistas.

```python
#Atribuindo listas entre variáveis
>>> lista = ["banana", "abacaxi"]
>>> copia_lista = lista[:]

>>> lista
['banana', 'abacaxi']
>>> copia_lista
['banana', 'abacaxi']

>>> copia_lista.append("limao")
>>> lista
['banana', 'abacaxi']
>>> copia_lista
['banana', 'abacaxi', 'limao']
```

### Concatenação (+) e replicação (*)

As listas possuem similaridade com **_strings_** através das operações de concatenação (“+”) e replicação (“*”).

Veja os exemplos:

```python
#Concatenação e replicação de listas
>> lista_frutas = ["banana", "uva"] + ["morango", "abacaxi"]
>>> print(lista_frutas)
['banana', 'uva', 'morango', 'abacaxi']

>>> lista_cores = ["preto", "branco"]
>>> print(3 * lista_cores)
['preto', 'branco', 'preto', 'branco', 'preto', 'branco']
```

### Ordenação - **_sort()_**

O método **_sort()_** é usado para ordenar listas. Se a lista contiver **_strings_** será ordenada em ordem alfabética e se for numérica em ordem crescente.

É possível ordernar a lista em ordem inversa, utilizando a sintaxe **_sort(reverse=True)_**.

```python
#Ordenando listas - sort()
>>> lista_nomes = ["Lara", "Joao", "Igor", "Eduardo", "Alan"]

>>> lista_nomes.sort()
>>> print(lista_nomes)
['Alan', 'Eduardo', 'Igor', 'Joao', 'Lara']

>>> lista_nomes.sort(reverse=True)
>>> print(lista_nomes)
['Lara', 'Joao', 'Igor', 'Eduardo', 'Alan']
```

Atenção, quando usamos o **_sort()_**, a posição dos items é alterada na lista original.

### Ordenação - **_sorted()_**

A função **_sorted()_** é usado para ordenar uma lista, **sem alterar a lista original**. Uma nova lista é gerada com o método **_sorted()_**.

```python
#Ordenando lista - sorted()
>>> lista_nomes = ["Lara", "Joao", "Igor", "Eduardo", "Alan"]

>>> print(sorted(lista_nomes))
['Alan', 'Eduardo', 'Igor', 'Joao', 'Lara']
>>> print(lista_nomes)
['Lara', 'Joao', 'Igor', 'Eduardo', 'Alan']

>>> lista_ordenada = sorted(lista_nomes)
>>> print(lista_ordenada)
['Alan', 'Eduardo', 'Igor', 'Joao', 'Lara']
>>> print(lista_nomes)
['Lara', 'Joao', 'Igor', 'Eduardo', 'Alan']
```

A sintaxe da função **_sorted()_** é diferente do método **_sort()_**. Enquanto a primeira recebe como argumento a lista a ser ordenada - **_sorted(lista_nomes)_** - o método **_sort( )_** precisa da variável com o ponto **(“.”)** - **_lista_nomes.sort()_**.

### Encontrando elementos - **_index()_**

O médodo **_index()_** retorna a posição ou o índice de um elemento presente na lista. Se o elemento não pertence à lista, um erro será gerado.

```python
#Executando o index()
>>> lista_nomes = ["Lara", "Joao", "Igor", "Eduardo", "Alan"]
>>> lista_nomes.index("Igor")
2
```

### Invertendo uma lista - **_reverse()_**

O método **_reverse()_** é usado para inverter a ordem dos elementos de uma lista.

```python
#Invertendo lista - reverse()
>>> lista_nomes = ["Lara", "Joao", "Igor", "Eduardo", "Alan"]
>>> print(lista_nomes)
['Lara', 'Joao', 'Igor', 'Eduardo', 'Alan']

>>> lista_nomes.reverse()
>>> print(lista_nomes)
['Alan', 'Eduardo', 'Igor', 'Joao', 'Lara']
```

### Removendo elementos repetidos - **_set()_**

A função **_set()_** é usado para remover elementos repetidos de uma lista.

```python
#Removendo elementos duplicados da lista - set()
>>> lista_cor = ["preto", "branco", "vermelho", "branco", "azul", "vermelho"]
>>> set(lista_cor)
{'azul', 'branco', 'vermelho', 'preto'}
>>> lista_cor
['preto', 'branco', 'vermelho', 'branco', 'azul', 'vermelho']
```

Da mesma forma que o **_sorted()_**, a função **_set()_** não altera a lista original.

### Atribuição múltipla

Podemos fazer uma atribuição múltipla dos valores de uma lista para uma lista de variáveis.

Observe o exemplo abaixo e aprenda a usá-lo.

```python
#Atribuição múltipla com listas
>>> lista_cor = ["preto", "branco", "vermelho"]
>>> cor_primaria = lista_cor[0]
>>> cor_secundaria = lista_cor[1]
>>> cor_reserva = lista_cor[2]
>>> print(cor_primaria, cor_secundaria, cor_reserva, sep = " , ")
preto , branco , vermelho

>>> cor_primaria, cor_secundaria, cor_reserva = lista_cor
>>> print(cor_primaria, cor_secundaria, cor_reserva, sep = " , ")
preto , branco , vermelho
```

Na atribuição múltipla o número de variáveis deve ser igual à quantidade de elementos da lista.

## Strings e listas

Diversas funções aplicadas em listas podem ser aplicadas nas **_strings_**, incluindo o operador “in” e “not in”.

Refaça os casos abaixo no seu **_shell_**.

```python
#Funções aplicadas em strings
>>> string = "Alguma string"

>>> sorted(string)
[' ', 'A', 'a', 'g', 'g', 'i', 'l', 'm', 'n', 'r', 's', 't', 'u']

>>> set(string)
{'i', 'n', 't', 'a', 's', 'l', 'g', 'A', 'u', ' ', 'r', 'm'}

>>> string
'Alguma string'

>>> "x" in string
False

>>> "t" in string
True

>>> "y" not in string
True

>>> "string" in string
True

>>> "teste" not in string
True

>>> for s in string:
...     print(s)
A
l
g
u
m
a

s
t
r
i
n
g
```

### Métodos **_join( ), split( )_**

O método **_join( )_** é usado para fazer a junção de uma lista de **_strings_** em uma única **_string_**. Observe atentamente que a **_string_** que invoca o método **_join_** é utilizada como separador.

```python
#Métodos join()
>>> ", ".join(["banana", "melao", "uva"])
'banana, melao, uva'

>>> "# ".join(["banana", "melao", "uva"])
'banana# melao# uva'

>>> " ".join(["banana", "melao", "uva"])
'banana melao uva'
```

O método **_split( )_** é o inverso do método **_join( )_**, dada uma **_string_** ela é transformada em uma lista de **_strings_**. Por padrão o espaço em branco é tomado como separador, mas você pode fornecer a **_string_** de separação.

```python
#Métodos split()
>>> "Estou aprendendo Python".split()
['Estou', 'aprendendo', 'Python']

>>> "casa, comida, carro, praia, sol, mar".split(", ")
['casa', 'comida', 'carro', 'praia', 'sol', 'mar']
```

Você vai usar muito o método **_split( )_**, principalmente para ler as linhas de **_strings_** com múltiplas linhas.

```python
#Métodos split() lendo linhas
>>> texto = ''' Este eh um exemplo
... Envolvendo multiplas linhas
... Simulando um arquivo
... E aplicando o split()'''

>>> texto.split("\n")
[' Este eh um exemplo', 'Envolvendo multiplas linhas', 'Simulando um arquivo', 'E aplicando o split()']
```

## Listas de listas

As listas podem armazenar todos os tipos de dados da linguagem, inclusive outras listas.

No jargão computacional, quando criamos listas de listas, estamos criando matrizes. 

Todas as discussões das seções anteriores são aplicados nas listas de listas:

```python
#Algumas operações com listas de listas
>>> lista_cores = ["verde", "preto", "branco"]
>>> lista_frutas = ["coco", "banana", "uva", "morango"]
>>> lista_de_listas = [lista_cores, lista_frutas]

>>> print(lista_de_listas)
[['verde', 'preto', 'branco'], ['coco', 'banana', 'uva', 'morango']]

>>> print("Primeiro elemento da lista de listas: " + str(lista_de_listas[0]))
Primeiro elemento da lista de listas: ['verde', 'preto', 'branco']

>>> print("Acessando o 2o elemento da 2a lista: " + lista_de_listas[1][3])
Acessando o 2o elemento da 2a lista: morango
```

Você consegue entender o código anterior?

Como estamos definindo uma variável _lista_de_listas_ que armazena uma lista em que cada elemento é outra lista, se quisermos acessar um elemento particular de dentro de alguma lista, é necessário usar dois índices. Como por exemplo _lista_de_listas[1][3]_ que representa o quarto elemento (índice 3) da segunda lista (índice 1).

Qual o índice do valor _branco_ ? Será _lista_de_listas[0][2]_

## Erros comuns

O programa gerará um erro se você tentar acessar uma posição inexistente na lista.

```python
#Cuidado com os índices de uma lista
>>> lista = []
>>> print(lista[0])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

>>> lista = [0, 1, 2]
>>> print(lista[3])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

>>> print(lista[-4])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

>>> lista_pares = [2, 4, 6, 8, 10]
>>> del lista_pares[7]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
```

Os índices são números inteiros, não utilize casas decimais ou outro tipo de dado.
```python
#Índices são números inteiros
>>> lista = [1,2,3,4]

>>> lista[1.0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: list indices must be integers or slices, not float

>>> lista["1"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: list indices must be integers or slices, not str
```

Não é possível remover elementos de uma lista vazia.
```python
#Cuidado ao tentar remover elementos de uma lista vazia
>>> lista = []
>>> lista.pop()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: pop from empty list
```

Cuidado ao tentar usar o método **_remove()_** com um valor inexistente.

```python
#Não use o remove() utilizando um valor inexistente
>>> lista = [4.5, -2, 3.4, 55, -2]
>>> print(lista)
[4.5, -2, 3.4, 55, -2]

>>> lista.remove(10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
```

Não é possível ordenar listas com tipos de dados diferentes.

```python
#Não se ordena listas com tipos de dados diferentes
>>> list = [3, "Ze", 2, "Alan"]

>>> list.sort()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'
```

Na atribuição múltipla se usarmos uma quantidade diferente entre variáveis e elementos da lista, ocorrerá um erro.

```python
#Múltipla atribuição com erro
>>> lista_cor = ["preto", "branco", "vermelho"]

>>> cor_1, cor_2 = lista_cor
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)

>>> cor_1, cor_2, cor_3, cor_4 = lista_cor
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 4, got 3)
```

Usar o método **_index()_** com um elemento que não pertence à lista retornará um erro.

```python
#index() gerando erro
>>> lista_cor = ["preto", "branco", "vermelho"]
>>> lista_cor.index("azul")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'azul' is not in list
```