Lista Tupla Conjunto e Dicionário

Veremos a seguir estruturas de dados nativas do Python: lista, tupla, conjunto e dicionário.

Compreenda as Diferenças Essenciais

Em Python, compreender as principais coleções de dados é essencial para desenvolver soluções eficientes.

1 – Lista

Para começar, as listas são estruturas dinâmicas que permitem armazenar elementos em uma ordem específica. Dessa forma, elas são ideais para situações onde a sequência dos dados precisa ser mantida. Além disso, as listas aceitam elementos duplicados, o que garante maior flexibilidade no gerenciamento das informações.

Tipo	Características
List	Cada elemento possi um indice iniciado em 0. Após sua declaração podemos adicionar, remover ou modifica-lo.

Criando listas com Range

0 a 10

for num in range(11):
  print(num, end = ' ')

"""
Resultado:

0 1 2 3 4 5 6 7 8 9 10
"""

for num in range(11):

print(num, end = ' ')

"""

Resultado:

0 1 2 3 4 5 6 7 8 9 10

"""

10 a 1

for num in range(10,0,-1):
  print(num, end = ' ')

"""
Resultado:

10 9 8 7 6 5 4 3 2 1 
"""

for num in range(10,0,-1):

print(num, end = ' ')

"""

Resultado:

10 9 8 7 6 5 4 3 2 1

"""

3 a 10

for num in range(3,11):
  print(num, end = ' ')

"""
Resultado:

3 4 5 6 7 8 9 10
"""

for num in range(3,11):

print(num, end = ' ')

"""

Resultado:

3 4 5 6 7 8 9 10

"""

5 a 100 com saltos de 5 em 5

for num in range(5,100,5):
  print(num, end = ' ')
"""
Resultado:

5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95
"""

for num in range(5,100,5):

print(num, end = ' ')

"""

Resultado:

5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95

"""

Acessando dados de uma Lista

print("====")
print("Lista")
print("====")
# criando uma lista e imprimindo seus itens
minha_lista = list(range(5))
for item in minha_lista:
    print(item)

"""
Resultado:

====
Lista
====
0
1
2
3
4
"""

print("====")

print("Lista")

print("====")

# criando uma lista e imprimindo seus itens

minha_lista = list(range(5))

for item in minha_lista:

print(item)

"""

Resultado:

====

Lista

====

"""

Adicionando item a uma Lista

print("====")
print("Lista")
print("====")
# criando uma lista e imprimindo seus itens
minha_lista = list(range(5))
print("Valor Inicial:",minha_lista)
minha_lista.append(10)
print("Valor Final:",minha_lista)

"""
Resultado:

====
Lista
====
Valor Inicial: [0, 1, 2, 3, 4]
Valor Final: [0, 1, 2, 3, 4, 10]
"""

print("====")

print("Lista")

print("====")

# criando uma lista e imprimindo seus itens

minha_lista = list(range(5))

print("Valor Inicial:",minha_lista)

minha_lista.append(10)

print("Valor Final:",minha_lista)

"""

Resultado:

====

Lista

====

Valor Inicial: [0, 1, 2, 3, 4]

Valor Final: [0, 1, 2, 3, 4, 10]

"""

Sorteio de um número inteiro entre 1 e 60 com randint()

import random
# Sorteia número entre 1 e 60
numero_sorteado = random.randint(1,60)
print(numero_sorteado)
"""
Possível Resultado:

22
"""

import random

# Sorteia número entre 1 e 60

numero_sorteado = random.randint(1,60)

print(numero_sorteado)

"""

Possível Resultado:

"""

Sorteio de uma opção de uma lista

import random
lista = ["segunda","terça","quarta","quinta","sexta","sábado","domingo"]
selecionado = random.choice(lista)
print(selecionado)
"""
Possível Resultado:

domingo
"""

import random

lista = ["segunda","terça","quarta","quinta","sexta","sábado","domingo"]

selecionado = random.choice(lista)

print(selecionado)

"""

Possível Resultado:

domingo

"""

Embaralhar uma lista

import random
deck = 'ace two three four'.split()
print(deck)
random.shuffle(deck)  
print(deck)
"""
Possível Resultado:

['ace', 'two', 'three', 'four']
['ace', 'four', 'two', 'three']
"""

import random

deck = 'ace two three four'.split()

print(deck)

random.shuffle(deck)

print(deck)

"""

Possível Resultado:

['ace', 'two', 'three', 'four']

['ace', 'four', 'two', 'three']

"""

Selecionando quatro amostras aleatórias sem reposição

import random
universo = [10, 20, 30, 40, 50]
resultado = random.sample(universo, k=4)
print(resultado)
"""
Possível Resultado:

[40, 10, 30, 20]
"""

import random

universo = [10, 20, 30, 40, 50]

resultado = random.sample(universo, k=4)

print(resultado)

"""

Possível Resultado:

[40, 10, 30, 20]

"""

Removendo dados de uma Lista

Estrutura	Método	Descrição
Lista	`remove()`	Remove pelo valor (primeira ocorrência).
Lista	`pop()`	Remove pelo índice e retorna o valor.
Lista	`del`	Remove pelo índice ou toda a lista.

print("====")
print("Lista")
print("====")
# criando uma lista e imprimindo seus itens
minha_lista = list(range(5))
print("Valor Inicial:",minha_lista)
minha_lista.pop(0)
print("Valor Final:",minha_lista)
"""
Resultado:

====
Lista
====
Valor Inicial: [0, 1, 2, 3, 4]
Valor Final: [1, 2, 3, 4]
"""

print("====")

print("Lista")

print("====")

# criando uma lista e imprimindo seus itens

minha_lista = list(range(5))

print("Valor Inicial:",minha_lista)

minha_lista.pop(0)

print("Valor Final:",minha_lista)

"""

Resultado:

====

Lista

====

Valor Inicial: [0, 1, 2, 3, 4]

Valor Final: [1, 2, 3, 4]

"""

Comprimento (o número de itens) de um objeto com len( ).

print(len("Área de Trampo")) # número de caracteres
print(len(["amora","banana","melancia"])) # número de itens de uma lista
print(len({"amora","banana","melancia"})) # número de itens de um conjunto
print(len(["amora","banana","melancia"][1:2])) #intervalo entre 1 e 2
"""
Resultado:

14
3
3
1
"""

print(len("Área de Trampo")) # número de caracteres

print(len(["amora","banana","melancia"])) # número de itens de uma lista

print(len({"amora","banana","melancia"})) # número de itens de um conjunto

print(len(["amora","banana","melancia"][1:2])) #intervalo entre 1 e 2

"""

Resultado:

"""

2 – Tupla

As tuplas são semelhantes às listas, mas possuem uma diferença crucial: elas são imutáveis. Como resultado, os dados contidos em uma tupla não podem ser alterados após a sua criação. Assim, as tuplas são frequentemente utilizadas quando se deseja proteger a integridade das informações. Além disso, a imutabilidade também contribui para a eficiência do código, especialmente em operações que envolvem grandes volumes de dados.

Tipo	Características
Tupla	Cada elemento possi um indice iniciado em 0. Após sua declaração não podemos modifica-lo.

dias_semana = ('segunda','terça','quarta',
'quinta','sexta','sábado','domingo')
print(dias_semana)
"""
Resultado:

('segunda', 'terça', 'quarta', 'quinta', 'sexta', 'sábado', 'domingo')
"""

dias_semana = ('segunda','terça','quarta',

'quinta','sexta','sábado','domingo')

print(dias_semana)

"""

Resultado:

('segunda', 'terça', 'quarta', 'quinta', 'sexta', 'sábado', 'domingo')

"""

Atenção: Tupla tem a finalidade de ser uma constante, portanto, depois da declaração ela não pode ser alterada !

3 – Conjunto

Quando a necessidade envolve dados únicos, os conjuntos se destacam. Primeiramente, essa coleção não mantém uma ordem específica, mas elimina automaticamente os elementos duplicados. Portanto, os conjuntos são perfeitos para operações como união, interseção e diferença entre coleções. Apesar disso, eles não possuem índices, mas são altamente otimizados para buscas rápidas.

Tipo	Características
Conjunto	A ordem não é garantida. Podemos adicionar ou remover elementos. Cada elemento aprarece uma única vez. Entre conjuntos podemos verificar a interseção, diferença e a união

Acessando dados de um Conjunto

print("====")
print("Conjunto")
print("====")
# criando um conjunto e imprimindo seus itens
meu_conjunto = set(range(5))
for item in meu_conjunto:
    print(item)

"""
Resultado:

====
Conjunto
====
0
1
2
3
4
"""

print("====")

print("Conjunto")

print("====")

# criando um conjunto e imprimindo seus itens

meu_conjunto = set(range(5))

for item in meu_conjunto:

print(item)

"""

Resultado:

====

Conjunto

====

"""

Adicionando item a um Conjunto

print("====")
print("Conjunto")
print("====")
# criando um conjunto e imprimindo seus itens
meu_conjunto = set(range(5))
print("Valor Inicial:",meu_conjunto)
meu_conjunto.add(10)
print("Valor Final:",meu_conjunto)
"""
Resultado:

====
Conjunto
====
Valor Inicial: {0, 1, 2, 3, 4}
Valor Final: {0, 1, 10, 2, 3, 4}
"""

print("====")

print("Conjunto")

print("====")

# criando um conjunto e imprimindo seus itens

meu_conjunto = set(range(5))

print("Valor Inicial:",meu_conjunto)

meu_conjunto.add(10)

print("Valor Final:",meu_conjunto)

"""

Resultado:

====

Conjunto

====

Valor Inicial: {0, 1, 2, 3, 4}

Valor Final: {0, 1, 10, 2, 3, 4}

"""

Removendo itens de Conjunto

Estrutura	Método	Descrição
Conjunto	`remove()`	Remove o elemento; erro se não existir.
Conjunto	`discard()`	Remove o elemento; sem erro se não existir.
Conjunto	`pop()`	Remove um elemento arbitrário.

print("====")
print("Conjunto")
print("====")
# criando um conjunto e imprimindo seus itens
meu_conjunto = set(range(5))
print("Valor Inicial:",meu_conjunto)
meu_conjunto.remove(0)
print("Valor Final:",meu_conjunto)

"""
Resultado:

====
Conjunto
====
Valor Inicial: {0, 1, 2, 3, 4}
Valor Final: {1, 2, 3, 4}
"""

print("====")

print("Conjunto")

print("====")

# criando um conjunto e imprimindo seus itens

meu_conjunto = set(range(5))

print("Valor Inicial:",meu_conjunto)

meu_conjunto.remove(0)

print("Valor Final:",meu_conjunto)

"""

Resultado:

====

Conjunto

====

Valor Inicial: {0, 1, 2, 3, 4}

Valor Final: {1, 2, 3, 4}

"""

Subtração, união e interseção com Conjuntos

hortifruti = {"banana","abacate", "laranja", "pera", "limão", "goiaba", "melão"}
# Perceba que vamos tentar adicionar 'acerola' 3 vezes ma o tipo conjunto não permite itens duplicados
hortifruti.add("acerola")
hortifruti.add("acerola")
hortifruti.add("acerola")
print(f'Hortifruti tem: {hortifruti}n')
lista_de_compras_minha_mae = {"mamão","banana","pera"}
minha_lista_de_compras = {"laranja","goiaba","mamão"}
# DIFERENÇA entre minha_lista_de_compras e lista_de_compras_minha_mae
print(f'minha lista - lista da minha mãe = \n{minha_lista_de_compras - lista_de_compras_minha_mae}n ')
# UNION - unir a minha lista e a da minha mãe para fazer todas as compras da casa
lista_de_casa = minha_lista_de_compras | lista_de_compras_minha_mae
print(f'LISTA_DE_CASA = minha lista + lista da minha mãe : \n{lista_de_casa}n ')
# INTERSEÇÃO - verificar dentre os itens desejados o que tem no hortifruti
o_que_achei_da_lista_no_hortifruti = hortifruti & lista_de_casa
print(f'Da LISTA DE CASA encontramos apenas {o_que_achei_da_lista_no_hortifruti} no hortifruti') 
"""
Resultado:

Hortifruti tem: {'acerola', 'abacate', 'goiaba', 'banana', 'laranja', 'limão', 'melão', 'pera'}n
minha lista - lista da minha mãe = 
{'goiaba', 'laranja'}n 
LISTA_DE_CASA = minha lista + lista da minha mãe : 
{'goiaba', 'banana', 'laranja', 'mamão', 'pera'}n 
Da LISTA DE CASA encontramos apenas {'goiaba', 'banana', 'laranja', 'pera'} no hortifruti
"""

hortifruti = {"banana","abacate", "laranja", "pera", "limão", "goiaba", "melão"}

# Perceba que vamos tentar adicionar 'acerola' 3 vezes ma o tipo conjunto não permite itens duplicados

hortifruti.add("acerola")

print(f'Hortifruti tem: {hortifruti}n')

lista_de_compras_minha_mae = {"mamão","banana","pera"}

minha_lista_de_compras = {"laranja","goiaba","mamão"}

# DIFERENÇA entre minha_lista_de_compras e lista_de_compras_minha_mae

print(f'minha lista - lista da minha mãe = \n{minha_lista_de_compras - lista_de_compras_minha_mae}n ')

# UNION - unir a minha lista e a da minha mãe para fazer todas as compras da casa

lista_de_casa = minha_lista_de_compras | lista_de_compras_minha_mae

print(f'LISTA_DE_CASA = minha lista + lista da minha mãe : \n{lista_de_casa}n ')

# INTERSEÇÃO - verificar dentre os itens desejados o que tem no hortifruti

o_que_achei_da_lista_no_hortifruti = hortifruti & lista_de_casa

print(f'Da LISTA DE CASA encontramos apenas {o_que_achei_da_lista_no_hortifruti} no hortifruti')

"""

Resultado:

Hortifruti tem: {'acerola', 'abacate', 'goiaba', 'banana', 'laranja', 'limão', 'melão', 'pera'}n

minha lista - lista da minha mãe =

{'goiaba', 'laranja'}n

LISTA_DE_CASA = minha lista + lista da minha mãe :

{'goiaba', 'banana', 'laranja', 'mamão', 'pera'}n

Da LISTA DE CASA encontramos apenas {'goiaba', 'banana', 'laranja', 'pera'} no hortifruti

"""

4 – Dicionário

Por fim, os dicionários oferecem uma forma de armazenar pares de chave e valor, permitindo acesso direto aos valores por meio das suas respectivas chaves. Por essa razão, os dicionários são indispensáveis quando se trabalha com dados estruturados. Além do mais, a flexibilidade para utilizar diferentes tipos de dados como chaves ou valores amplia ainda mais sua aplicabilidade em diversos contextos.

No Dicionário cada elemento é um par chave: valor, onde a chave é única. Você pode adicionar, remover ou modificar elementos. Use um dicionário para acessar diretamente o valor por sua chave, evitando fazer For e While desnescessários.

Acessando dados de um Dicionário

print("====")
print("Acessando um Dicionário")
print("====")
meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}
print(meu_dicionario["Maria"])
"""
Resultado:

====
Acessando um Dicionário
====
Minha mãe
"""

print("====")

print("Acessando um Dicionário")

print("====")

meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}

print(meu_dicionario["Maria"])

"""

Resultado:

====

Acessando um Dicionário

====

Minha mãe

"""

Veja que no exemplo acima o VALOR do item do Dicionário é acessado com sua CHAVE “Maria”. A chave deve ser única no Dicionário de dados. Perceba que um dicionário não é adequado para a iteração com For e While, a ideia é o acesso direto pela chave.

Alterando item do Dicionário

print("====")
print("====")
print("Alterando item do Dicionário")
print("====")
meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}
meu_dicionario["Maria"] = "Minha sogra"
print(meu_dicionario["Maria"])
"""
Resultado:

====
Alterando item do Dicionário
====
Minha sogra
"""

print("====")

print("Alterando item do Dicionário")

print("====")

meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}

meu_dicionario["Maria"] = "Minha sogra"

print(meu_dicionario["Maria"])

"""

Resultado:

====

Alterando item do Dicionário

====

Minha sogra

"""

Adicionando item a um Dicionário

print("====")
print("Adicionando um item a um Dicionário")
print("====")
meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}
print("Valor Inicial:",meu_dicionario)
meu_dicionario["Silvio"] = "Colega de faculdade"
print("Valor Final:",meu_dicionario)
"""
Resultado:

====
Adicionando um item a um Dicionário
====
Valor Inicial: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe', 'José': 'Meu tio'}
Valor Final: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe', 'José': 'Meu tio', 'Silvio': 'Colega de faculdade'}
"""

print("====")

print("Adicionando um item a um Dicionário")

print("====")

meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}

print("Valor Inicial:",meu_dicionario)

meu_dicionario["Silvio"] = "Colega de faculdade"

print("Valor Final:",meu_dicionario)

"""

Resultado:

====

Adicionando um item a um Dicionário

====

Valor Inicial: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe', 'José': 'Meu tio'}

Valor Final: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe', 'José': 'Meu tio', 'Silvio': 'Colega de faculdade'}

"""

Removendo item de um Dicionário

Estrutura	Método	Descrição
Dicionário	`pop()`	Remove pela chave e retorna o valor.
Dicionário	`del`	Remove pela chave ou todo o dicionário.
Dicionário	`clear()`	Remove todos os itens do dicionário.

print("====")
print("Removendo item Dicionário")
print("====")
meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}
print("Valor Inicial:",meu_dicionario)
meu_dicionario.pop("José")
print("Valor Final:",meu_dicionario)
"""
Resultado:

====
Removendo item Dicionário
====
Valor Inicial: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe', 'José': 'Meu tio'}
Valor Final: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe'}
"""

Observação:

Lista usa <strong>[ ] </strong><strong>'colchetes'</strong> , tupla <strong>( ) 'parênteses'</strong>, Conjunto e Dicionário <strong>{ } 'chaves'</strong> mas diferente do Conjunto apenas o Dicionário tem <strong>chave : valor</strong>.

print("====")

print("Removendo item Dicionário")

print("====")

meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}

print("Valor Inicial:",meu_dicionario)

meu_dicionario.pop("José")

print("Valor Final:",meu_dicionario)

"""

Resultado:

====

Removendo item Dicionário

====

Valor Inicial: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe', 'José': 'Meu tio'}

Valor Final: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe'}

"""

Observação:

Lista usa [ ] 'colchetes' , tupla ( ) 'parênteses', Conjunto e Dicionário { } 'chaves' mas diferente do Conjunto apenas o Dicionário tem chave : valor.

Convertendo

Convertendo Lista em Conjunto

lista = ['banana', 'maça','maça','maça','maça','maça','maça']
conjunto = set(lista)
print(conjunto)
"""
Resultado:

{'banana', 'maça'}
"""

lista = ['banana', 'maça','maça','maça','maça','maça','maça']

conjunto = set(lista)

print(conjunto)

"""

Resultado:

{'banana', 'maça'}

"""

Perceba que, ao transformar em conjunto, os itens repetidos foram automaticamente descartados. Isso acontece porque, por definição, conjuntos não permitem repetições em seus itens. Portanto, essa característica os torna ideais para eliminar duplicatas de forma eficiente.

Convertendo Conjunto em Lista

adicionar = ["abacate","morango","Abacate","abacaxi","ABACATE"]
hortifruti = {"amora"}
for fruta in adicionar:
    hortifruti.add(fruta.lower())
    
resultado = list(hortifruti)
print(resultado)
"""
Resultado:

['abacaxi', 'abacate', 'morango', 'amora']
"""

adicionar = ["abacate","morango","Abacate","abacaxi","ABACATE"]

hortifruti = {"amora"}

for fruta in adicionar:

hortifruti.add(fruta.lower())

resultado = list(hortifruti)

print(resultado)

"""

Resultado:

['abacaxi', 'abacate', 'morango', 'amora']

"""

Observação: Perceba que, no código anterior, ao usar um conjunto quando adicionávamos novos dados, conseguimos evitar a adição de elementos repetidos. No entanto, se não utilizarmos a função .lower() para transformar tudo em letras minúsculas, o conjunto interpretará que “abacate”, “Abacate” e “ABACATE” são diferentes, uma vez que Python é case-sensitive. Em resumo, ao escolher entre listas, tuplas, conjuntos e dicionários, é essencial considerar as necessidades específicas do projeto. Dessa forma, a escolha adequada impactará diretamente a eficiência, a clareza e a manutenção do código. Assim, compreender as vantagens de cada coleção contribui para o desenvolvimento de soluções mais robustas e organizadas. Portanto, optar pela estrutura correta é fundamental para resolver problemas de forma eficiente em qualquer situação de programação. Portanto, escolher a estrutura correta é essencial para resolver problemas de maneira eficiente e organizada em qualquer contexto de programação. Dessa forma, hoje vimos o que são, suas principais características e além disso, aprendemos como tirar o melhor proveito de Lista, Tupla, Conjunto e Dicionário. Ao final, trasformamos o conjunto em uma lista utilizando list( ).

Referências:

Documentação Python