Python: Estruturas de dados comuns

Esta documentação faz parte do guia Aprender Python. Consulte o guia completo aqui: Um guia abrangente de Python.

👋 Bem-vindo à documentação do Stackhero!

Stackhero oferece uma solução cloud Python pronta a usar que proporciona uma série de benefícios, incluindo:

• Implemente a sua aplicação em segundos com um simples git push.
• Utilize o seu próprio nome de domínio e beneficie da configuração automática de certificados HTTPS para uma segurança reforçada.
• Desfrute de tranquilidade com backups automáticos, atualizações com um clique, e preços simples, transparentes e previsíveis.
• Obtenha performance ótima e segurança robusta graças a uma VM privada e dedicada.

Poupe tempo e simplifique a sua vida: só leva 5 minutos para experimentar a solução de hospedagem cloud Python do Stackhero!

Python fornece várias estruturas de dados para ajudá-lo a organizar, armazenar e manipular dados de forma eficiente. As mais comumente usadas são listas, tuplos, dicionários e conjuntos. Listas e tuplos mantêm uma sequência ordenada de elementos, dicionários armazenam pares chave-valor, e conjuntos armazenam elementos únicos. Cada estrutura vem com uma gama de métodos adaptados a casos de uso específicos.

• Lista: my_list = [1, 2, 3, 4]
• Tuplo: my_tuple = (1, 2, 3, 4)
• Dicionário: my_dictionary = {'key1': 'value1', 'key2': 'value2'}
• Conjunto: my_set = {1, 2, 3, 4}

Listas

As listas são coleções mutáveis e ordenadas de elementos. Permitem duplicados e podem conter elementos de vários tipos de dados, incluindo outras listas, tuplos, dicionários ou conjuntos. Pode-se facilmente adicionar, atualizar e remover elementos. As listas são definidas entre colchetes [] com elementos separados por vírgulas.

Pontos-chave sobre listas:

1. Mutáveis e ordenadas
2. Permitem elementos duplicados
3. Mantêm a ordem em que os elementos são adicionados
4. Suportam múltiplos tipos de dados
5. Fornecem operações para adicionar, atualizar e excluir elementos

As listas são comumente usadas quando se precisa de uma coleção dinâmica e redimensionável de itens.

Exemplos:

# Criar uma lista
my_list = [1, 2, 3, 4, 5]

# Acessar elementos
print(my_list[0])  # Saída: 1
print(my_list[-1])  # Saída: 5

# Adicionar elementos
my_list.append(6)
print(my_list)  # Saída: [1, 2, 3, 4, 5, 6]

# Atualizar elementos
my_list[0] = 0
print(my_list)  # Saída: [0, 2, 3, 4, 5, 6]

# Excluir elementos
del my_list[0]
print(my_list)  # Saída: [2, 3, 4, 5, 6]

Dicionários

Os dicionários são coleções mutáveis e não ordenadas de pares chave-valor. Cada chave deve ser única, e pode-se usar essas chaves para acessar seus valores associados. Como as listas, os dicionários podem armazenar elementos de vários tipos de dados, incluindo coleções aninhadas. Eles são definidos entre chaves {} com pares chave-valor separados por vírgulas, e chaves e valores separados por dois pontos.

Pontos-chave sobre dicionários:

1. Coleção mutável e não ordenada
2. Composta por pares chave-valor com chaves únicas
3. Acesso aos valores usando chaves
4. Armazenam vários tipos de dados

Os dicionários são ideais para tarefas onde é necessário realizar buscas, como configurações ou contagens de frequência.

Exemplos:

# Criar um dicionário
my_dictionary = {'a': 1, 'b': 2, 'c': 3}

# Acessar elementos
print(my_dictionary['a'])  # Saída: 1

# Adicionar elementos
my_dictionary['d'] = 4
print(my_dictionary)  # Saída: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# Atualizar elementos
my_dictionary['a'] = 0
print(my_dictionary)  # Saída: {'a': 0, 'b': 2, 'c': 3, 'd': 4}

# Excluir elementos
del my_dictionary['a']
print(my_dictionary)  # Saída: {'b': 2, 'c': 3, 'd': 4}

Tuplos

Os tuplos são coleções imutáveis e ordenadas de elementos. Funcionam muito como listas, exceto que uma vez criado um tuplo, seus elementos não podem ser alterados, adicionados ou removidos. Os tuplos são definidos usando parênteses () com elementos separados por vírgulas.

Pontos-chave sobre tuplos:

1. Coleção imutável e ordenada
2. Suportam múltiplos tipos de dados
3. Estrutura de tamanho fixo

Os tuplos são úteis quando se precisa de uma coleção imutável, ou quando se deseja usar a coleção como chave de dicionário.

Exemplo:

# Criar um tuplo
my_tuple = (1, 2, 3, 4, 5)

# Acessar elementos
print(my_tuple[0])  # Saída: 1
print(my_tuple[-1])  # Saída: 5

# Nota: Tuplos são imutáveis

Conjuntos

Os conjuntos são coleções mutáveis e não ordenadas que armazenam elementos únicos. Eles removem automaticamente duplicados e não mantêm uma ordem. Os conjuntos podem conter elementos de vários tipos de dados, excluindo tipos mutáveis como listas e dicionários. Podem ser definidos usando chaves {} ou o construtor set().

Pontos-chave sobre conjuntos:

1. Mutáveis e não ordenados
2. Armazenam apenas elementos únicos, removendo automaticamente duplicados
3. Excluem tipos mutáveis (como listas e dicionários)

Os conjuntos são ideais para testes de pertencimento, deduplicação e realização de operações de conjunto como união, interseção e diferença.

# Criar um conjunto
my_set = {1, 2, 3, 4, 5}

# Verificar pertencimento
print(1 in my_set)  # Saída: True

# Adicionar um elemento
my_set.add(6)
print(my_set)  # Saída: {1, 2, 3, 4, 5, 6}

# Atualizar removendo um elemento e adicionando outro
my_set.remove(1)
my_set.add(0)
print(my_set)  # Saída: {0, 2, 3, 4, 5, 6}

# Excluir um elemento
my_set.remove(0)
print(my_set)  # Saída: {2, 3, 4, 5, 6}