Python Listas

Até aqui, cada variável guardou um valor: um nome, um preço, uma nota. Mas a vida da Ana está cheia de coisas que vêm em grupo: os itens da lista de compras, os alunos da turma, as notas de uma prova. Criar uma variável para cada item (item1, item2, item3…) não dá certo: e se amanhã forem 30 itens? Para isso o Python tem a lista (em inglês, list): uma variável que guarda vários valores, em ordem.

Você vai aprender

O que é uma lista e para que ela serve.
A criar uma lista com colchetes [ ] e vírgulas, e a mostrá-la com print().
A contar os itens com len() e a reconhecer o tipo list.
Listas vazias, listas de números, itens repetidos e listas escritas em várias linhas.
A perguntar se um item está na lista com in e not in.
A criar listas com list().
Os erros reais: a vírgula esquecida (que não dá erro nenhum!), o colchete sem fechar, o texto sem aspas e a variável chamada list.

A ideia: a lista de compras no papel

Pense na lista de compras que a Ana prende na geladeira. É uma folha de papel, com um título ("compras") e vários itens escritos um embaixo do outro: arroz, feijão, café, leite. Ela não precisa de uma folha para cada item. E a folha tem algumas características que você vai reconhecer nas listas do Python:

Os itens têm ordem. O arroz é o primeiro, o leite é o último. Se a Ana reescrever a folha, a ordem continua a mesma.
Dá para contar os itens. São 4.
Um item pode aparecer duas vezes. Se ela escrever "pão" duas vezes, a folha não reclama.
A folha muda. Dá para riscar um item, acrescentar outro no fim, trocar o "café" por "café sem açúcar". (Isso fica para as próximas aulas: Alterando, Adicionando e Removendo Itens.)

No Python, a folha é a variável, o título é o nome da variável, e os itens ficam entre colchetes, separados por vírgulas.

1. A primeira lista

compras = ["arroz", "feijão", "café", "leite"]
print(compras)
print(len(compras))
print(type(compras))

compras: O nome da variável, como em qualquer variável (aula Variáveis). Para listas, o costume é um nome no plural: compras, alunos, notas. Assim, quem lê já sabe que ali dentro há vários valores.
=: Guarda o que está à direita na variável.
[: O colchete de abrir: "aqui começa uma lista".
"arroz", "feijão", "café", "leite": Os itens (também chamados de elementos). Cada um é um valor comum, aqui um texto entre aspas. Entre um item e outro vai uma vírgula; o espaço depois da vírgula é só para ficar fácil de ler.
]: O colchete de fechar: "aqui termina a lista".
len(compras): len vem de length, "comprimento". É a mesma função que conta as letras de um texto (aula Strings); numa lista, ela conta os itens.
type(compras): Mostra o tipo do valor (aula Descobrindo o Tipo).

$ python3 compras.py
['arroz', 'feijão', 'café', 'leite']
4
<class 'list'>

Três coisas para reparar na saída:

O print mostra a lista do jeito que se escreve uma lista em Python: com os colchetes, as vírgulas e as aspas. Repare que as aspas saíram simples ('arroz'), embora o programa use aspas duplas. Para o Python, "arroz" e 'arroz' são o mesmo texto; ao mostrar uma lista, ele sempre escolhe as simples.
len(compras) deu 4: quatro itens. Não importa quantas letras cada item tem; cada item conta como um.
O tipo é list, "lista". Ela é um tipo de dado, como int, float e str; a diferença é que ela guarda outros valores dentro. Por isso se diz que a lista é uma coleção.

Mostrando a lista "bonita"

Os colchetes e as aspas são ótimos para você, que está programando, ver exatamente o que tem na lista. Mas, numa mensagem para alguém ler, ficam estranhos. Dois jeitos de mostrar os itens sem eles:

compras = ["arroz", "feijão", "café", "leite"]
print(compras)
print(", ".join(compras))
for item in compras:
    print("-", item)

$ python3 bonito.py
['arroz', 'feijão', 'café', 'leite']
arroz, feijão, café, leite
- arroz
- feijão
- café
- leite

O ", ".join(compras) junta os itens num texto só, com ", " entre eles (é um método de texto: aula Métodos de Texto; só funciona se todos os itens forem textos). O for passa por cada item, um de cada vez (aula for); percorrer listas tem aula própria: Percorrendo uma Lista.

Missão: a lista de frutas da Ana está vazia. Coloque dentro dos colchetes, nesta ordem, "banana", "maçã" e "uva", e clique em Rodar.

frutas = []
print(frutas)

frutas = ["banana", "maçã", "uva"]
print(frutas)

2. Que tipos de lista existem

Uma lista pode guardar qualquer tipo de valor. Veja no modo interativo (aula O Modo Interativo):

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> notas = [8.5, 7.0, 9.5]
>>> notas
[8.5, 7.0, 9.5]
>>> vazia = []
>>> vazia
[]
>>> len(vazia)
0
>>> ficha = ["Ana", 17, 9.5, True]
>>> ficha
['Ana', 17, 9.5, True]
>>> repetidos = ["pão", "pão", "leite"]
>>> len(repetidos)
3

Lista	O que mostra
`[8.5, 7.0, 9.5]`	Uma lista de números: sem aspas, como qualquer número. As notas da Ana na prova.
`[]`	A lista vazia: colchetes sem nada dentro. Tem 0 itens. É muito usada como ponto de partida: começa vazia e vai recebendo itens (aula Adicionando Itens).
`["Ana", 17, 9.5, True]`	Uma lista com tipos misturados: um texto, um inteiro, um decimal e um booleano. O Python aceita.
`["pão", "pão", "leite"]`	Itens repetidos são permitidos, e cada um conta: são 3 itens, não 2.

Misturar tipos: pode, mas não é o costume

Uma lista como ["Ana", 17, 9.5, True] funciona, mas é difícil de usar: para saber o que é cada item, você precisa lembrar a posição de cada um. No dia a dia, uma lista guarda coisas do mesmo tipo: todos os itens de compras, todas as notas, todos os nomes. Para guardar a ficha de uma pessoa (nome, idade, nota), existem estruturas melhores, que você vai conhecer nas aulas Tuplas e Dicionários.

3. Listas compridas: uma linha para cada item

Quando a lista tem muitos itens, ou itens compridos, ela não cabe bem numa linha só. O Python deixa você quebrar a lista em várias linhas, um item em cada:

turma = [
    "Ana",
    "Bruno",
    "Carla",
    "Davi",
]
print(turma)
print(f"A turma tem {len(turma)} alunos.")

$ python3 turma.py
['Ana', 'Bruno', 'Carla', 'Davi']
A turma tem 4 alunos.

turma = [: O colchete fica aberto no fim da primeira linha. Enquanto ele não for fechado, o Python sabe que a lista continua na linha de baixo.
"Ana",: Cada item numa linha, com 4 espaços na frente. Aqui os espaços não são obrigatórios (não é um bloco, como o do if), mas deixam claro o que está dentro da lista.
"Davi",: Repare na vírgula depois do último item. Ela é permitida e é um bom costume em listas de várias linhas: para acrescentar um item no fim, basta escrever uma linha nova, sem precisar lembrar de pôr a vírgula na linha de cima.
]: O colchete de fechar, sozinho, na altura do começo de turma.
{len(turma)}: Dentro de uma f-string (aula f-strings), o len entra no texto.

O resultado é exatamente o mesmo que escrever turma = ["Ana", "Bruno", "Carla", "Davi"] numa linha só. A diferença é só para quem lê o código.

4. Perguntando se um item está na lista: `in`

A Ana está no mercado e quer saber: "o café está na minha lista?". Em Python, a pergunta se escreve com in ("em", "dentro de"), o mesmo operador da aula is e in. A resposta é True (verdadeiro) ou False (falso):

>>> compras = ["arroz", "feijão", "café", "leite"]
>>> "café" in compras
True
>>> "açúcar" in compras
False
>>> "Café" in compras
False
>>> "açúcar" not in compras
True

"café" in compras: o café está lá, True.
"açúcar" in compras: não está, False.
"Café" in compras: False! O in procura um item igual, letra por letra. "Café", com C maiúsculo, não é igual a "café". Acentos e espaços também contam.
not in é a pergunta ao contrário: "o açúcar não está na lista?". Sim, não está: True.

Como a resposta é um booleano, o in combina com o if (aula if):

compras = ["arroz", "feijão", "café", "leite"]
if "açúcar" not in compras:
    print("Não esqueça: o açúcar não está na lista!")

$ python3 mercado.py
Não esqueça: o açúcar não está na lista!

5. Duas listas são iguais?

O == (aula Comparações) também funciona com listas. Duas listas são iguais quando têm os mesmos itens, na mesma ordem:

>>> [1, 2, 3] == [3, 2, 1]
False
>>> [1, 2, 3] == [1, 2, 3]
True

Os mesmos números em outra ordem dão False: na lista, a ordem faz parte do conteúdo.

6. Criando listas com `list()`

Além dos colchetes, existe a função list(). Ela cria uma lista a partir de outra coisa que tenha vários valores dentro, como um texto ou um range (aula range()):

>>> list("Ana")
['A', 'n', 'a']
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list()
[]

list("Ana"): um texto é uma sequência de letras, e o list põe cada letra num item.
list(range(5)): o range(5) produz os números de 0 a 4, e o list os guarda numa lista.
list(), sem nada: uma lista vazia, igual a [].

Formas diferentes de criar uma lista

Forma	Resultado	Quando usar
`compras = ["arroz", "café"]`	`['arroz', 'café']`	Quase sempre: quando você já sabe os itens
`compras = []`	`[]`	Para começar vazia e ir enchendo depois. É a forma mais comum de lista vazia
`compras = list()`	`[]`	Também cria a lista vazia; funciona, mas `[]` é mais curto e mais usado
`letras = list("Ana")`	`['A', 'n', 'a']`	Para transformar outra sequência em lista
Uma linha para cada item, com vírgula no último	A mesma lista	Quando a lista é comprida

Mais adiante você vai ver mais um jeito, muito poderoso, de criar listas a partir de outras: a List Comprehension.

Quando dá errado

A vírgula esquecida: nenhum erro, e a lista fica errada

Este é o erro mais traiçoeiro desta aula, porque o Python não reclama. A Ana esqueceu a vírgula entre o arroz e o feijão:

compras = ["arroz" "feijão", "café"]
print(compras)
print(len(compras))

$ python3 virgula.py
['arrozfeijão', 'café']
2

Em vez de três itens, vieram dois, e o primeiro virou 'arrozfeijão'. Por quê? Em Python, dois textos escritos lado a lado, sem nada entre eles, são colados num texto só: "arroz" "feijão" é o mesmo que "arrozfeijão". Isso existe para quebrar textos compridos em pedaços, mas, dentro de uma lista, quase sempre é uma vírgula que faltou.

Como perceber: o len() deu menos do que você esperava, ou um item saiu grudado no outro. Como consertar: ponha a vírgula: ["arroz", "feijão", "café"]. Com números, a vírgula esquecida dá erro, e o Python até dá a dica:

>>> numeros = [1 2]
  File "<python-input-0>", line 1
    numeros = [1 2]
               ^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?

"Sintaxe inválida. Será que você esqueceu uma vírgula?" Com textos, não há dica nenhuma: eles simplesmente se colam.

O colchete que não foi fechado

compras = ["arroz", "feijão", "café"
print(compras)

$ python3 colchete.py
  File "/home/ana/colchete.py", line 1
    compras = ["arroz", "feijão", "café"
              ^
SyntaxError: '[' was never closed

Linha por linha:

File "/home/ana/colchete.py", line 1: o problema está no arquivo colchete.py, na linha 1.
A linha de código e, embaixo, o ^ apontando para o colchete de abrir.
SyntaxError: '[' was never closed: "erro de sintaxe: o [ nunca foi fechado". O Python leu o arquivo até o fim procurando o ] e não achou.

Repare que não aparece Traceback: um SyntaxError acontece antes de o programa começar, e nenhuma linha roda, nem o print. Como consertar: feche o colchete depois do último item: "café"].

Textos sem aspas

compras = [arroz, feijão, café]
print(compras)

$ python3 aspas.py
Traceback (most recent call last):
  File "/home/ana/aspas.py", line 1, in <module>
    compras = [arroz, feijão, café]
               ^^^^^
NameError: name 'arroz' is not defined

Sem aspas, arroz não é um texto: é o nome de uma variável, e nenhuma variável chamada arroz foi criada. O Python para no primeiro item que não conhece (os ^^^^^ marcam o arroz) e diz name 'arroz' is not defined, "o nome 'arroz' não está definido". Como consertar: textos sempre entre aspas: ["arroz", "feijão", "café"].

Uma variável chamada list

Parece uma boa ideia chamar a lista de list. Não é:

list = ["arroz", "feijão"]
letras = list("Ana")
print(letras)

$ python3 nome_list.py
Traceback (most recent call last):
  File "/home/ana/nome_list.py", line 2, in <module>
    letras = list("Ana")
TypeError: 'list' object is not callable

A linha 1 não deu erro: o Python deixou você usar o nome list para a sua variável. Só que, a partir dali, list deixou de ser a função e passou a ser a sua lista de compras. Na linha 2, list("Ana") tenta "chamar" (executar, com os parênteses) a lista de compras, e uma lista não é uma função: 'list' object is not callable, "um objeto do tipo lista não pode ser chamado". Como consertar: use um nome que diga o que a lista guarda (compras, itens) e nunca list, str, len, print, que são nomes que o Python já usa.

compras.len() no lugar de len(compras)

>>> compras = ["arroz", "feijão", "café", "leite"]
>>> compras.len()
Traceback (most recent call last):
  File "<python-input-1>", line 1, in <module>
    compras.len()
    ^^^^^^^^^^^
AttributeError: 'list' object has no attribute 'len'

"O objeto lista não tem o atributo len". O len é uma função que recebe a lista entre parênteses, len(compras), e não um método escrito depois do ponto. (Listas têm métodos com ponto, como compras.append(…), que você vai ver nas próximas aulas, mas len não é um deles.) No modo interativo, no lugar do nome do arquivo aparece <python-input-1>: é o que a Ana digitou na sessão (a contagem começa em 0, então o 1 é a segunda linha).

Missão: a Ana escreveu três itens, mas o programa diz que a lista tem 2. Encontre o erro e conserte, para o programa mostrar 3.

compras = ["arroz" "feijão", "café"]
print(compras)
print(len(compras))

compras = ["arroz", "feijão", "café"]
print(compras)
print(len(compras))

Referência rápida

Escrita	O que faz	Exemplo de resultado
`[a, b, c]`	Cria uma lista com os itens `a`, `b` e `c`, nessa ordem	`['arroz', 'café']`
`[]` ou `list()`	Cria uma lista vazia	`[]`
`list(sequência)`	Cria uma lista com os itens de um texto, `range` etc.	`list("Ana")` → `['A', 'n', 'a']`
`len(lista)`	Quantos itens a lista tem	`4`
`x in lista`	`True` se algum item é igual a `x`	`"café" in compras` → `True`
`x not in lista`	`True` se nenhum item é igual a `x`	`"açúcar" not in compras` → `True`
`lista1 == lista2`	Mesmos itens, na mesma ordem?	`[1, 2] == [2, 1]` → `False`
`type(lista)`	O tipo	`<class 'list'>`

Sintoma	Causa provável
Dois itens grudados (`'arrozfeijão'`) e o `len` menor que o esperado	Faltou a vírgula entre dois textos
`SyntaxError: '[' was never closed`	Faltou o `]` no fim da lista
`NameError: name 'arroz' is not defined`	Texto sem aspas
`TypeError: 'list' object is not callable`	Uma variável chamada `list` tomou o lugar da função
`AttributeError: 'list' object has no attribute 'len'`	Escreveu `lista.len()`; o certo é `len(lista)`

Exercícios

1. Os sinais da lista

Complete com os sinais que abrem e fecham uma lista:

notas = 7.5, 8.0, 10

2. Quantos itens?

Quanto vale len(["pão", "pão", "leite", "manteiga"])?

3. Está na lista?

Com compras = ["arroz", "feijão", "café"], o que o Python responde para "Arroz" in compras?

4. O que mostra print(len(["Ana" "Bruno", "Carla"]))?

3 Um SyntaxError, porque falta uma vírgula 2, porque "Ana" "Bruno" vira um texto só, 'AnaBruno' 13, o total de letras

5. Qual destes é o melhor nome para uma lista com os alunos da turma?

list alunos Aluno1 len

6. O que print(["café", "leite"]) mostra?

['café', 'leite'] café leite ["café", "leite"] café, leite

Missão final: a turma da Ana

Missão: a professora matriculou mais uma aluna, a Eva. Acrescente "Eva" numa linha nova no fim da lista e troque o número escrito à mão (4) por {len(turma)}, para o programa contar sozinho. A saída tem de dizer A turma tem 5 alunos.

turma = [
    "Ana",
    "Bruno",
    "Carla",
    "Davi",
]
print(turma)
print(f"A turma tem 4 alunos.")
print("Bruno está na turma?", "Bruno" in turma)

turma = [
    "Ana",
    "Bruno",
    "Carla",
    "Davi",
    "Eva",
]
print(turma)
print(f"A turma tem {len(turma)} alunos.")
print("Bruno está na turma?", "Bruno" in turma)

Graças à vírgula depois de "Davi", acrescentar a Eva foi só escrever uma linha nova. E, com o len, a frase continua certa quando entrar mais alguém.

Resumo

Uma lista guarda vários valores, em ordem, numa variável só: compras = ["arroz", "feijão", "café"].
Colchetes [ ] em volta, vírgula entre os itens. A lista vazia é [].
len(lista) conta os itens; type(lista) mostra <class 'list'>.
Itens podem se repetir e podem ser de qualquer tipo; o costume é uma lista com coisas do mesmo tipo e nome no plural.
Listas compridas ficam melhor com um item por linha e uma vírgula também depois do último.
x in lista e x not in lista perguntam se o item está lá (comparação exata, com maiúsculas e acentos).
list() cria uma lista a partir de um texto, de um range etc.
Vírgula esquecida entre textos não dá erro: os dois textos se colam. Desconfie quando o len não bater.
Nunca chame uma variável de list: ela esconde a função list().