Nas próximas aulas vamos aprender sobre listas, tuplas e ranges, que são três tipos básicos de sequência usados em Python. O tipo de dado lista é uma sequência ordenada de elementos que podem ser compostos por strings, números ou até outras listas. Listas são mutáveis e usam indexação baseada em zero, o que significa que o primeiro elemento da lista está no índice zero. Aqui está a sintaxe básica para uma lista:

cities = ['Los Angeles', 'London', 'Tokyo']

Para acessar um elemento da lista cities, você pode referenciar seu número de índice na sequência. Aqui está um exemplo de como acessar o primeiro elemento da lista cities:

cities = ['Los Angeles', 'London', 'Tokyo']
cities[0] # 'Los Angeles'

A indexação negativa é usada para acessar elementos começando do final da lista em vez do início no índice 0. Para acessar o último elemento de qualquer lista, você pode usar -1 assim:

cities = ['Los Angeles', 'London', 'Tokyo']
cities[-1] # 'Tokyo'

Outra forma de criar uma lista é usar o construtor list(). O construtor list() é usado para converter um iterável em uma lista assim:

developer = 'Jessica'
list(developer) # ['J', 'e', 's', 's', 'i', 'c', 'a']

Um iterável é um tipo especial de objeto que pode ser percorrido um item por vez. Você aprenderá mais sobre loops em Python mais adiante. Para obter o número total de elementos em uma lista, você pode usar a função len() assim:

numbers = [1, 2, 3, 4, 5]
len(numbers) # 5

Se você quiser atualizar um valor em um índice específico, pode fazer algo assim:

programming_languages = ['Python', 'Java', 'C++', 'Rust']
programming_languages[0] = 'JavaScript'
print(programming_languages) # ['JavaScript', 'Java', 'C++', 'Rust']

Como as listas são mutáveis, você pode atualizar qualquer elemento na lista desde que forneça um número de índice válido. Se você passar um índice (positivo ou negativo) que esteja fora dos limites da lista, então você receberá um IndexError:

programming_languages = ['Python', 'Java', 'C++', 'Rust']
programming_languages[10] = 'JavaScript'

"""
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
IndexError: list assignment index out of range
"""

Se você quiser remover um elemento de uma lista, pode usar a palavra-chave del assim:

developer = ['Jane Doe', 23, 'Python Developer']
del developer[1]
print(developer) # ['Jane Doe', 'Python Developer']

Às vezes é útil verificar se um elemento está dentro da lista. Para fazer isso, você pode usar a palavra-chave in assim:

programming_languages = ['Python', 'Java', 'C++', 'Rust']

'Rust' in programming_languages # True
'JavaScript' in programming_languages # False

Às vezes é comum ter listas aninhadas dentro de outras listas assim:

developer = ['Alice', 25, ['Python', 'Rust', 'C++']]

Neste exemplo, temos uma lista aninhada contendo três linguagens de programação populares. Para acessar a lista aninhada, você precisará acessá-la usando o índice 2 já que as listas são indexadas a partir do zero:

developer = ['Alice', 25, ['Python', 'Rust', 'C++']]
developer[2] # ['Python', 'Rust', 'C++']

Então, para acessar o segundo idioma daquela lista aninhada, você precisará acessá-lo usando o índice 1 assim:

developer = ['Alice', 25, ['Python', 'Rust', 'C++']]
developer[2][1] # 'Rust'

Outra técnica comum usada com listas é desempacotar valores. Desempacotar valores de uma lista é uma técnica usada para atribuir valores de uma lista a novas variáveis. Aqui está um exemplo de desempacotamento de uma lista developer em novas variáveis chamadas name, age e job.

developer = ['Alice', 34, 'Rust Developer']
name, age, job = developer

print(name) # 'Alice'
print(age) # 34
print(job) # 'Rust Developer'

Aqui, name tem o valor 'Alice', age tem o valor 34 e job tem o valor 'Rust Developer'. Se você precisar coletar quaisquer elementos restantes de uma lista, pode usar o operador asterisco (*) assim:

developer = ['Alice', 34, 'Rust Developer']
name, *rest = developer

print(name) # 'Alice'
print(rest) # [34, 'Rust Developer']

Neste exemplo, name ainda terá o valor 'Alice' e rest é uma lista de dois itens: o número 34 e a string 'Rust Developer'. Se o número de variáveis do lado esquerdo do operador de atribuição não corresponder ao número total de itens na lista, você receberá um ValueError:

developer = ['Alice', 34, 'Rust Developer']
name, age, job, city = developer

"""
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
ValueError: not enough values to unpack (expected 4, got 3)
"""

O último conceito que vamos analisar é o operador slice (:). Semelhante às strings, você pode acessar partes de uma lista usando o operador de slice assim:

desserts = ['Cake', 'Cookies', 'Ice Cream', 'Pie', 'Brownies']
desserts[1:4] # ['Cookies', 'Ice Cream', 'Pie']

Neste exemplo, o índice inicial é 1 já que isso aponta para o segundo item na lista. Então usamos o operador slice seguido por um índice final de 4, que inclui tudo até (mas não incluindo) o item nesse índice. Outra coisa que você pode fazer com o operador de slice : é especificar um intervalo de passo que determina o quanto incrementar entre os índices. Vamos supor que você tenha uma lista de números assim:

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

Se você quiser extrair uma lista apenas com números pares, pode usar o operador de slicing assim:

numbers = [1, 2, 3, 4, 5, 6]
numbers[1::2] # [2, 4, 6]

O primeiro número par está no índice 1, então esse será o índice inicial. Como queremos percorrer até o final da lista, então omitimos o índice final. Por fim, especificamos 2 para o intervalo opcional de passos para que ele incremente apenas de 2 em vez do padrão 1. Listas são uma estrutura de dados útil e flexível que você usará muito em seus programas Python. Na próxima lição, você aprenderá sobre métodos comuns que pode usar com listas.