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
|
1 2 3 4 5 6 7 8 |
for num in range(11): print(num, end = ' ') """ Resultado: 0 1 2 3 4 5 6 7 8 9 10 """ |
10 a 1
|
1 2 3 4 5 6 7 8 |
for num in range(10,0,-1): print(num, end = ' ') """ Resultado: 10 9 8 7 6 5 4 3 2 1 """ |
3 a 10
|
1 2 3 4 5 6 7 8 |
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
|
1 2 3 4 5 6 7 |
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
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 """ |
Adicionando item a uma Lista
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
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()
|
1 2 3 4 5 6 7 8 9 |
import random # Sorteia número entre 1 e 60 numero_sorteado = random.randint(1,60) print(numero_sorteado) """ Possível Resultado: 22 """ |
Sorteio de uma opção de uma lista
|
1 2 3 4 5 6 7 8 9 |
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
|
1 2 3 4 5 6 7 8 9 10 11 |
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
|
1 2 3 4 5 6 7 8 9 |
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. |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
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( ).
|
1 2 3 4 5 6 7 8 9 10 11 12 |
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 """ |
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. |
|
1 2 3 4 5 6 7 8 |
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
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 """ |
Adicionando item a um Conjunto
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
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. |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
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 """ |
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
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 """ |
Adicionando item a um Dicionário
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
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. |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
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>. |
Convertendo
| Convertendo Lista em Conjunto | ||
|---|---|---|
|
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 | ||
|---|---|---|
|
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( ).
