Fundamentos de Estruturas de Dados em Python

Introdução

Neste laboratório, aprenderemos sobre estruturas de dados em Python. Os principais conteúdos das estruturas de dados com as quais trabalharemos são: listas, tuplas, dicionários e conjuntos (sets).

Conquistas

• Listas (Lists)
• Compreensões de Lista (List Comprehensions)
• Tuplas (Tuples)
• Dicionários (Dictionaries)
• Conjuntos (Sets)

Listas

Em Python, as listas servem como contêineres versáteis capazes de armazenar vários tipos de objetos. Aqui, exploraremos operações fundamentais de listas, como criação, acesso a valores, atualização de valores, adição de valores e exclusão de valores.

Criar lista (Create list)

As listas são definidas com valores separados por vírgulas, dentro de colchetes. Os itens de dados em uma lista não precisam ser do mesmo tipo.

>>> l1 = [1, 2, 3, 'a', 'hello']
>>> l1
[1, 2, 3, 'a', 'hello']

>>> l2 = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday']
>>> l2
['monday', 'tuesday', 'wednesday', 'thursday', 'friday']

Acessar valor (Access value)

Use o índice de subscrito para acessar os valores na lista.

>>> print("l1[0] = ", l1[0])
l1[0] =  1

Você pode usar a forma com colchetes para interceptar caracteres da seguinte forma, o que é chamado de fatia (slice). Fatiar é uma maneira de extrair um intervalo de itens de uma lista.

nome_da_lista[Início:Fim:Passo] (list_name[Start:End:Step])

O primeiro índice (Início/Start) é o índice inicial e o segundo índice (Fim/End) é o índice final. O terceiro índice (Passo/Step) é o passo, onde passo é o incremento (padrão 1).

>>> print("l2[1:3] = ", l2[1:3])
l2[1:3] =  ['tuesday', 'wednesday']

Atualizar valor (Update value)

Você pode atualizar o valor usando o índice de subscrito para acessar o valor e, em seguida, atribuir um novo valor a ele:

>>> l1[0] = 10
>>> l1
[10, 2, 3, 'a', 'hello']

Adicionar valor (Append value)

Você pode adicionar valores à lista usando o método append().

nome_da_lista.append(valor) (list_name.append(value))

>>> l1.append('b')
>>> l1
[10, 2, 3, 'a', 'hello', 'b']

>>> l2.append('statuday')
>>> l2
['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'statuday']

Excluir valor (Delete value)

Você pode excluir valores da lista usando a palavra-chave del. Este método exclui o elemento no índice especificado da lista.

del nome_da_lista[índice] (del list_name[index])

>>> del l1[0]
>>> l1
[2, 3, 'a', 'hello', 'b']

E você também pode usar o método remove() para excluir o valor especificado da lista.

nome_da_lista.remove(valor) (list_name.remove(value))

>>> l1.remove('a')
>>> l1
[2, 3, 'hello', 'b']

Outras funções de lista (Other list functions)

Você pode usar a função len() para obter o comprimento de uma lista.

>>> print("Length of l1 = ", len(l1))
Length of l1 =  5

E a função sorted() para ordenar a lista.

>>> print("Sorted of l2 = ", sorted(l2))
Sorted of l2 =  ['friday', 'monday', 'thursday', 'tuesday', 'wednesday']

List Comprehensions

A compreensão de lista é uma maneira concisa e poderosa de criar listas em Python, iterando sobre um iterável existente, como uma lista, e aplicando uma expressão a cada item para criar uma nova lista.

O formato de uma compreensão de lista pode ser entendido como um loop for. E a sintaxe de uma compreensão de lista é:

nova_lista = [expressão for item in lista_antiga]
nova_lista = [expressão for item in lista_antiga if condição]

• nova_lista: A lista resultante gerada a partir da expressão para cada item na lista antiga.
• expressão: A operação ou transformação aplicada a cada item da lista antiga para gerar a nova lista.
• item: A variável que representa cada item na lista antiga.
• lista_antiga: A lista existente usada para gerar a nova lista.
• condição (opcional): Uma condição de filtro que pode ser aplicada para incluir apenas certos itens da lista antiga com base em um critério especificado.

Prática de compreensão de lista (List comprehension practise)

Vamos praticar a compreensão de lista no shell do Python:

>>> ls = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> even_list = [item for item in ls if item % 2 == 0]
>>> even_list
[2, 4, 6, 8, 10]

Neste exemplo, even_list conterá apenas os números pares da lista ls.

As compreensões de lista fornecem uma maneira concisa e legível de manipular listas, tornando o código Python mais expressivo e eficiente.

Tuplas

As tuplas são semelhantes às listas em Python, exceto que os elementos de uma tupla são imutáveis, o que significa que não podem ser alterados após a criação. Os elementos das tuplas são colocados entre () e separados por ,.

Criar tupla (Create tuple)

Crie uma tupla com os seguintes elementos:

>>> tup1 = ('Google', 'Run', 'Python')
>>> tup2 = (1, 2, 3, 4, 5)
>>> empty_tup = ()

>>> tup1
('Google', 'Run', 'Python')
>>> tup2
(1, 2, 3, 4, 5)
>>> empty_tup
()

Acessar elementos da tupla (Access tuple elements)

Acesse elementos de tuplas usando indexação:

>>> print(tup1[0])
Google

>>> print(tup2[1:3])
(2, 3)

>>> print(empty_tup[0])
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
IndexError: tuple index out of range      ## Error occurs, because tuple is empty.

Mesclando tuplas (Merging tuples)

Embora as tuplas não possam ser modificadas, elas podem ser mescladas:

>>> tup3 = tup1 + tup2
>>> print(tup3)
('Google', 'Run', 'Python', 1, 2, 3, 4, 5)

As tuplas oferecem uma maneira confiável de armazenar dados que não devem ser modificados, fornecendo estabilidade e integridade aos seus programas Python.

Dicionários

Os dicionários em Python são estruturas de dados versáteis e mutáveis que armazenam pares chave-valor.

Cada par chave-valor é separado por dois pontos, e cada par é separado por uma vírgula, com todo o dicionário entre chaves {}.

d = {chave1 : valor1, chave2 : valor2, chave3 : valor3 }

As chaves em um dicionário devem ser únicas, mas os valores podem ser duplicados.

Criar dicionário (Create dictionary)

Crie dicionários com pares chave-valor:

>>> dict1 = {'name': 'James', "age": 23, "phone": "12345"}
>>> dict2 = {}

>>> dict1
{'name': 'James', 'age': 23, 'phone': '12345'}
>>> dict2
{}

Acessar elementos do dicionário (Access dictionary elements)

Acesse pares chave-valor usando a chave entre colchetes [] ou a função get():

>>> print(dict1["name"])
James

>>> print(dict2["name"])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'name'

>>> print(dict2.get("name"))
None

Usar dict[chave] para acessar uma chave que não existe no dicionário levanta uma exceção KeyError. No entanto, dict.get(chave) retorna None se a chave não for encontrada no dicionário.

Modificar dicionário (Modify dictionary)

Adicione ou modifique entradas em um dicionário atribuindo valores às chaves:

>>> dict2["name"] = "Lily"
>>> dict1["name"] = "Bob"

>>> dict2["name"]
'Lily'
>>> dict1["name"]
'Bob'

Excluir elementos do dicionário (Delete dictionary elements)

Exclua pares chave-valor usando del dict[chave] ou limpe todo o dicionário usando dict.clear():

>>> del dict1["name"]
>>> print(dict1)

{'age': 23, 'phone': '12345'}

>>> dict2.clear()
>>> print(dict2)

{}

Os dicionários oferecem uma maneira flexível de armazenar e manipular dados, tornando-os essenciais para várias tarefas na programação Python.

Conjuntos

Conjuntos em Python são coleções desordenadas de elementos únicos. Eles podem ser criados usando chaves {} ou a função set().

Criar conjunto (Create set)

Para criar um conjunto vazio, você deve usar set() em vez de {}, pois {} é usado para criar um dicionário vazio. Crie conjuntos usando diferentes métodos:

>>> set1 = set()
>>> print(set1)
set()

>>> set2 = {'apple', 'orange', 'banana'}
>>> print(set2)
{'banana', 'apple', 'orange'}

>>> set3 = set("Hello World!")
>>> print(set3)
{'o', 'H', 'W', ' ', 'd', 'r', '!', 'e', 'l'}

Adicionar elemento (Add element)

Adicione elementos a um conjunto usando os métodos add() ou update():

>>> set1.add('apple')
>>> print(set1)
{'apple'}

>>> set2.update({'orange', 'pear'})
>>> print(set2)
{'apple', 'orange', 'banana', 'pear'}

Remover elemento (Remove element)

Remova elementos de um conjunto usando os métodos discard() ou remove().
O método discard() não levanta um erro se o elemento não estiver presente no conjunto, enquanto o método remove() levanta.

>>> set1.remove('apple')
>>> print(set1)
set()

>>> set1.discard('banana')
>>> print(set1)
set()

Os conjuntos fornecem uma maneira conveniente de trabalhar com coleções de elementos únicos em Python, tornando-os úteis para várias tarefas, como remover duplicatas ou testar a pertinência (membership).

Resumo

Parabéns! Você concluiu o laboratório (Lab) de estruturas de dados.

Neste laboratório, você aprendeu as estruturas de dados básicas do Python e quando e como usar essas estruturas de dados na resolução de problemas.