Estruturas de Dados em Python: o que você precisa saber para concursos

Fala aí, Padawan! Hoje vamos mergulhar em um dos assuntos mais importantes de Python para quem estuda programação e, principalmente, para quem está se preparando para concursos públicos: estruturas de dados. Listas, tuplas, conjuntos e dicionários aparecem o tempo inteiro em códigos, questões teóricas e problemas envolvendo algoritmos. Entender como cada estrutura funciona ajuda não apenas a acertar questões, mas também a escrever programas mais eficientes e organizados.

O que são estruturas de dados?

Uma estrutura de dados é uma forma organizada de armazenar informações na memória do computador para que elas possam ser acessadas e manipuladas. Pense em uma gaveta: dependendo do tipo de objeto que você pretende guardar, pode fazer sentido utilizar divisórias, caixas ou simplesmente colocar tudo em sequência. Na programação acontece algo parecido. Cada estrutura possui características próprias que tornam determinadas operações mais fáceis ou eficientes.

Python oferece várias estruturas de dados prontas. Entre as mais importantes estão list, tuple, set e dict. Além delas, a biblioteca padrão oferece estruturas especializadas, como deque, encontrada no módulo collections. Para concursos, é fundamental conhecer principalmente as quatro estruturas básicas e saber diferenciá-las.

Listas: a estrutura mais versátil

A lista, representada pelo tipo list, é uma coleção ordenada e mutável. Quando dizemos que uma coleção é ordenada, significa que os elementos possuem uma posição definida. Quando dizemos que ela é mutável, significa que seu conteúdo pode ser alterado depois da criação.

Veja um exemplo:

linguagens = ["Python", "Java", "C++"]

print(linguagens[0])

linguagens.append("Go")

print(linguagens)

Na primeira linha, criamos uma lista chamada linguagens contendo três strings. Na segunda instrução, linguagens[0] acessa o primeiro elemento da lista. Atenção, Padawan: em Python, os índices começam em zero. Portanto, o índice 0 representa o primeiro elemento, o índice 1 representa o segundo e assim por diante.

O método append() adiciona um elemento ao final da lista. Depois da execução de linguagens.append(“Go”), teremos:

["Python", "Java", "C++", "Go"]

Outro detalhe bastante cobrado é que uma lista pode possuir elementos repetidos. O código abaixo é perfeitamente válido:

numeros = [10, 20, 20, 30]

A lista também pode armazenar diferentes tipos de dados ao mesmo tempo:

dados = ["Júlio", 40, True, 1.75]

Embora isso seja permitido pela linguagem, na prática costuma ser interessante manter elementos semanticamente relacionados dentro de uma mesma coleção.

Acessando elementos de uma lista

Os elementos de uma lista podem ser acessados utilizando índices positivos ou negativos. Os índices positivos começam da esquerda para a direita, enquanto os negativos começam do final da lista.

frutas = ["maçã", "banana", "uva", "laranja"]

print(frutas[0])
print(frutas[-1])

A expressão frutas[0] retorna “maçã”, enquanto frutas[-1] retorna “laranja”. Esse comportamento dos índices negativos costuma aparecer em questões que apresentam pequenos trechos de código e perguntam qual será a saída.

Fatiamento de listas

Python também permite utilizar uma técnica chamada slicing, ou fatiamento. Ela permite selecionar uma parte de uma sequência.

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

print(numeros[1:4])
O resultado será:
[20, 30, 40]

A sintaxe [1:4] significa: comece no índice 1 e vá até antes do índice 4. O limite final não é incluído. Esse detalhe é uma pegadinha clássica de prova.

Principais operações com listas

Python possui diversos métodos para manipular listas. Alguns dos mais importantes são append(), insert(), remove(), pop(), sort() e reverse().

Veja:

numeros = [30, 10, 20]

numeros.append(40)
numeros.insert(0, 5)
numeros.remove(20)
numeros.sort()

print(numeros)

O append(40) adiciona 40 ao final. O insert(0, 5) adiciona 5 na posição zero. O remove(20) procura o valor 20 e remove sua primeira ocorrência. Já sort() reorganiza os elementos em ordem crescente.

Depois dessas operações, teremos:

[5, 10, 30, 40]

Tuplas: parecidas com listas, mas imutáveis

A tupla, representada pelo tipo tuple, também é uma sequência ordenada. A grande diferença é que a tupla é imutável. Isso significa que, depois que ela é criada, não podemos adicionar, remover ou substituir diretamente seus elementos.

coordenada = (10, 20)

print(coordenada[0])
print(coordenada[1])

Nesse exemplo, temos uma tupla contendo dois valores. Podemos consultar os elementos normalmente. Porém, tentar fazer isso:

coordenada[0] = 50

provocará um erro do tipo TypeError.

Padawan, cuidado com uma sutileza: dizer que uma tupla é imutável significa que a estrutura da tupla não pode ser modificada. Entretanto, uma tupla pode conter internamente um objeto mutável, como uma lista, e esse objeto pode ser alterado.

dados = ([1, 2], "Python")

dados[0].append(3)

print(dados)

O resultado será:

([1, 2, 3], 'Python')

A referência armazenada na tupla continua sendo a mesma lista. O que mudou foi o conteúdo da lista.

Desempacotamento de tuplas

Um recurso muito utilizado em Python é o desempacotamento, também chamado de unpacking.

nome, idade = ("Ana", 30)

print(nome)
print(idade)

Python associa “Ana” à variável nome e 30 à variável idade. Esse recurso também aparece quando trabalhamos com funções que retornam múltiplos valores.

Por exemplo:

def calcular(a, b):
    return a + b, a * b

soma, produto = calcular(3, 4)

print(soma)
print(produto)

A função retorna dois valores, que são agrupados em uma tupla. Depois, o desempacotamento coloca cada valor em uma variável.

Sets: conjuntos sem elementos duplicados

O set é a implementação de conjunto em Python. Sua principal característica é não permitir elementos duplicados.

numeros = {1, 2, 2, 3, 3, 3}

print(numeros)

O conjunto terá apenas os valores 1, 2 e 3. Isso acontece porque elementos repetidos são automaticamente eliminados.

Outra característica importante é que sets não devem ser tratados como sequências indexadas. Portanto, isso não funciona:

numeros[0]

Um set não oferece acesso aos elementos por posição como uma lista ou uma tupla.

Operações matemáticas com conjuntos

Uma característica muito interessante dos sets é a possibilidade de executar operações da teoria dos conjuntos, como união, interseção e diferença.

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a | b)
print(a & b)
print(a - b)

O operador | representa a união. Portanto:

{1, 2, 3, 4, 5, 6}

O operador & representa a interseção:

{3, 4}

Já a – b representa os elementos existentes em a que não estão em b:

{1, 2}

Essas operações podem aparecer em questões envolvendo tanto Python quanto conceitos matemáticos de conjuntos.

Um detalhe perigoso: conjunto vazio

Esta aqui é uma pegadinha que merece destaque, Padawan!

Observe:

x = {}

Apesar das chaves, x não é um conjunto vazio. Ele é um dicionário vazio.

Para criar um conjunto vazio, precisamos utilizar:

x = set()

Essa diferença é excelente candidata para questão de concurso.

Dicionários: trabalhando com chave e valor

O dicionário, representado pelo tipo dict, armazena informações utilizando pares de chave e valor. Em vez de procurar uma informação utilizando uma posição numérica, normalmente utilizamos uma chave.

servidor = {
    "nome": "Carlos",
    "cargo": "Analista",
    "idade": 35
}

print(servidor["nome"])

Nesse exemplo, “nome”, “cargo” e “idade” são as chaves. “Carlos”, “Analista” e 35 são os respectivos valores.

Ao executar:

servidor["nome"]

Python procura a chave “nome” e retorna:

Carlos

As chaves de um dicionário precisam ser hashable, ou seja, devem possuir um valor de hash estável durante sua existência. Por isso, tipos imutáveis como strings, números e determinadas tuplas podem ser utilizados como chaves. Uma lista, por ser mutável, não pode ser utilizada diretamente como chave de um dicionário.

Alterando e adicionando informações em dicionários

Dicionários são mutáveis. Portanto, podemos modificar valores existentes ou adicionar novas chaves.

aluno = {
    "nome": "Lucas",
    "nota": 7
}

aluno["nota"] = 9
aluno["aprovado"] = True

print(aluno)

Primeiro, a nota passa de 7 para 9. Depois, uma nova chave chamada “aprovado” é criada.

O resultado será semelhante a:

{‘nome’: ‘Lucas’, ‘nota’: 9, ‘aprovado’: True}

Nas versões modernas do Python, os dicionários preservam a ordem de inserção dos elementos. Porém, é importante não confundir essa característica com acesso por índice: normalmente consultamos os valores pelas respectivas chaves.

Métodos importantes dos dicionários

Três métodos aparecem bastante no cotidiano e merecem sua atenção: keys(), values() e items().

pessoa = {
    "nome": "Maria",
    "idade": 28
}

print(pessoa.keys())
print(pessoa.values())
print(pessoa.items())

keys() fornece uma visão das chaves do dicionário. values() fornece os valores. Já items() fornece os pares chave-valor.

O método items() é especialmente interessante para percorrer um dicionário:

pessoa = {
    "nome": "Maria",
    "idade": 28
}

for chave, valor in pessoa.items():

    print(chave, valor)

A cada repetição, o Python desempacota um par formado pela chave e pelo valor correspondente.

O método get()

Imagine que tentamos acessar uma chave inexistente desta maneira:

pessoa["cidade"]

Caso “cidade” não exista, ocorrerá um KeyError.

Uma alternativa é utilizar o método get():

cidade = pessoa.get("cidade", "Não informado")

print(cidade)

Nesse caso, se a chave não existir, o programa retorna “Não informado” em vez de provocar um KeyError. É uma diferença pequena, mas conceitualmente importante.

List comprehension

Python possui uma sintaxe muito utilizada para construir listas chamada list comprehension, ou compreensão de listas.

Observe:

quadrados = [x * x for x in range(5)]

print(quadrados)

O range(5) gera os valores de 0 até 4. Para cada valor, x * x calcula seu quadrado. O resultado será:

[0, 1, 4, 9, 16]

Podemos ainda colocar uma condição:

pares = [x for x in range(10) if x % 2 == 0]

print(pares)

O trecho if x % 2 == 0 seleciona somente os números pares.

O resultado será:

[0, 2, 4, 6, 8]

Estruturas aninhadas

Uma estrutura de dados também pode conter outras estruturas. Podemos, por exemplo, ter uma lista de dicionários.

alunos = [

    {"nome": "Ana", "nota": 9},

    {"nome": "Bruno", "nota": 7},

    {"nome": "Carla", "nota": 10}

]

print(alunos[1]["nome"])

Primeiro, alunos[1] acessa o segundo dicionário da lista:

{"nome": "Bruno", "nota": 7}

Depois, [“nome”] acessa o valor associado à chave “nome”. Portanto, o resultado será:

Bruno

Esse tipo de estrutura aparece com frequência em aplicações reais porque permite representar registros semelhantes a dados vindos de APIs, bancos de dados e arquivos JSON.

Pilhas utilizando listas

Uma pilha segue o princípio LIFO, sigla para Last In, First Out: o último elemento que entra é o primeiro que sai.

Imagine uma pilha de pratos. O último prato colocado no topo normalmente será o primeiro retirado.

Em Python, podemos utilizar uma lista:

pilha = []

pilha.append("A")

pilha.append("B")

pilha.append("C")

print(pilha.pop())

append() adiciona elementos ao final da lista. Já pop() sem argumentos remove e retorna o último elemento.

Portanto, o resultado será:

C

Filas e deque

Uma fila normalmente segue o princípio FIFO, ou First In, First Out: o primeiro elemento que entra é o primeiro a sair.

Apesar de ser possível implementar uma fila com listas, remover repetidamente o primeiro elemento de uma lista pode ser ineficiente, pois os elementos restantes precisam ser deslocados. Uma solução mais adequada é deque, disponível em collections.

from collections import deque

fila = deque()

fila.append("Ana")

fila.append("Bruno")

fila.append("Carla")

print(fila.popleft())

A primeira linha importa deque. Em seguida, criamos a fila. Os elementos são inseridos com append() e o primeiro elemento é retirado com popleft().

A saída será:

Ana

Esse comportamento caracteriza uma fila FIFO.

Complexidade das principais operações

Concursos podem misturar Python com complexidade de algoritmos. Portanto, vale conhecer algumas características gerais.

Em uma lista, acessar um elemento diretamente pelo índice, como lista[5], possui complexidade O(1). Isso significa que o tempo de acesso não cresce proporcionalmente ao tamanho da lista.

Por outro lado, procurar um determinado valor usando:

valor in lista

pode exigir percorrer vários elementos. No pior caso, temos uma operação O(n).

Sets e dicionários são baseados em estruturas de hashing. Por isso, operações como verificar se uma chave está presente geralmente possuem complexidade média O(1).

Observe:

usuarios = {"ana", "bruno", "carlos"}

if "bruno" in usuarios:

    print("Usuário encontrado")

Quando a aplicação precisa realizar muitas verificações de pertinência, um set pode ser muito mais adequado do que uma lista.

Lista, tupla, set ou dicionário?

Vamos organizar as diferenças mais importantes:

Uma maneira simples de pensar é a seguinte: use lista quando precisar de uma sequência modificável; use tupla quando desejar uma sequência cuja estrutura não deverá mudar; use set quando valores únicos e operações de conjunto forem importantes; e utilize dict quando precisar associar uma chave a um valor.

Igualdade e identidade

Outra diferença importante em Python aparece entre os operadores == e is.

a = [1, 2, 3]

b = [1, 2, 3]

print(a == b)

print(a is b)

a == b verifica se os valores são equivalentes. Nesse caso, o resultado será True.

Já a is b verifica se as duas variáveis fazem referência ao mesmo objeto. Como criamos duas listas diferentes, o resultado normalmente será False.

Essa diferença é muito importante porque questões podem tentar confundir igualdade de conteúdo com identidade de objetos.

Cuidado ao copiar listas

Observe este código:

a = [1, 2, 3]

b = a

b.append(4)

print(a)

A saída será:

[1, 2, 3, 4]

Isso acontece porque b = a não cria outra lista. As duas variáveis passam a fazer referência ao mesmo objeto.

Para criar uma cópia superficial da lista, podemos utilizar:

b = a.copy()

ou:

b = a[:]

Essa diferença entre atribuição e cópia é outro assunto clássico em questões que apresentam pequenos programas e pedem sua saída.

Agora chegou a hora de colocar esse conhecimento em prática, Padawan. Que a força esteja com você!

(2024) CEBRASPE – CODEVASF – Analista em Desenvolvimento Regional – Área: Tecnologia da Informação

Acerca da linguagem de programação Python, julgue o item que se segue. 

A linguagem Python possui três tipos de sequências — list, tuple e range —, que são imutáveis, ou seja, não podem ser alteradas depois de sua criação. 

Gabarito: ERRADO.
Justificativa: tuple e range são imutáveis, mas list é mutável, permitindo inclusão, remoção e alteração de elementos.

(2025) CEBRASPE – BDMG – Analista de Desenvolvimento – Gestão, Finanças e Controladoria

Acerca de ciência de dados, análise exploratória de dados, ferramentas de data science e utilização de bibliotecas e ferramentas, julgue o item seguinte. 

Em Python, listas e tuplas possuem as mesmas propriedades, podendo ser aumentadas ou diminuídas após sua criação. 

Gabarito: ERRADO.
Justificativa: listas são mutáveis e podem ter elementos adicionados ou removidos. Tuplas são imutáveis e não podem ser alteradas após a criação.

(2025) CEBRASPE – 2025 – Polícia Federal – Agente de Polícia Federal

Julgue o próximo item, relativos aos modos de transmissão de dados, ao modelo OSI, à linguagem Python e aos conceitos de falso positivo (FPIR) e falso negativo (FNIR) dos testes de acurácia do NIST.GOV. 

Em Python, listas são estruturas de dados imutáveis, o que as torna ideais para serem usadas como chaves de dicionários (dict). 

Gabarito: ERRADO.
Justificativa: listas são mutáveis e não são hashable, portanto não podem ser usadas como chaves de um dict. Tuplas, se contiverem apenas elementos hashable, podem ser usadas como chaves.

(2024) CEBRASPE- SEPLAG-CE – Analista de Gestão Pública – Área de Atuação: Ciência da Computação

Considerando linguagens de programação, julgue o item que se segue.   

Considere o código Python a seguir.

x = ("laranja","lima","taiti")

y = ["laranja","lima","taiti"]

print (type(x))

print (type(y))

Esse código, após executado, apresentará o seguinte resultado. 

<class 'list'>

<class 'array'>

Gabarito: ERRADO.

Justificativa: x foi criado com parênteses, portanto é uma tupla (tuple). Já y foi criado com colchetes, sendo uma lista (list).

A saída correta será:

<class 'tuple'>

<class 'list'>

Resumo: ( ) → tuple | [ ] → list.

(2024) VUNESP – Câmara de Campinas – SP – Analista Legislativo – TI

Considere uma lista armazenada em uma variável a na linguagem Python. Assinale a alternativa que apresenta uma maneira de imprimir os elementos desta lista de maneira inversa (começando pelo último elemento). 

1. print(a[-1])
2. print(a[::])
3. print(a[::-1])
4. print(a[-1::])
5. print(a[:-1:])

Gabarito: C) print(a[::-1])

Justificativa: O fatiamento [::-1] percorre a lista com passo -1, invertendo a ordem dos elementos.

• A) a[-1] → imprime apenas o último elemento. 
• B) a[::] → imprime a lista na ordem original. 
• C) a[::-1] → inverte a lista. Correta. 
• D) a[-1::] → retorna apenas o último elemento em uma lista. 
• E) a[:-1:] → retorna todos os elementos, exceto o último.

(2023) FGV- PGM – Niterói – Analista de Tecnologia da Informação

Considere o código Python a seguir. 

L=[0, 1, 1, 2, 3, 5, 8, 13, 21] print (L[2:4][-1])

O resultado exibido na execução desse script é: 

1. 0
2. 1
3. 2
4. 3
5. 21

Gabarito: C) 2

Justificativa: L[2:4] retorna os elementos dos índices 2 e 3:

[1, 2]

Depois, [-1] pega o último elemento dessa nova lista, que é 2.

• A) 0 — errado. 
• B) 1 — errado; é o primeiro elemento do recorte. 
• C) 2 — correta. 
• D) 3 — errado; está no índice 4 da lista original. 
• E) 21 — errado; é o último elemento da lista original.