Python Índices e Fatias

Na aula Strings você viu que um texto é uma fileira de caracteres, em ordem. Como cada caractere tem o seu lugar na fileira, dá para pedir ao Python "me dá o primeiro", "me dá o último" ou "me dá do terceiro ao quinto". O lugar de cada caractere é o seu índice, e um pedaço do texto é uma fatia (em inglês, slice). Com isso você vai tirar o ano de uma data, o DDD de um telefone, e até escrever uma palavra ao contrário.

Você vai aprender

A pegar um caractere pela posição, com texto[0], e por que a contagem começa no zero.
Os índices negativos, que contam do fim: texto[-1] é o último.
A pegar um pedaço com texto[início:fim], e por que o fim não entra.
O passo: texto[::2] pula de dois em dois, e texto[::-1] vira o texto ao contrário.
A recortar uma data e um telefone em pedaços.
Os erros reais: IndexError: string index out of range e TypeError: string indices must be integers.

A ideia: as casas de uma rua

Pense numa rua com uma casa para cada letra da palavra "Brasil". Cada casa tem um número na porta. Só que, nesta rua, a primeira casa é a de número 0, e não a de número 1. É como os andares de um prédio no Brasil: o térreo é o andar 0, o primeiro andar fica acima dele. E a rua tem uma segunda numeração, pintada do outro lado, que conta a partir do fim, com números negativos:

Caractere	`B`	`r`	`a`	`s`	`i`	`l`
Índice (do começo)	0	1	2	3	4	5
Índice (do fim)	-6	-5	-4	-3	-2	-1

A palavra tem 6 letras, então os índices do começo vão de 0 a 5 (sempre um a menos que o tamanho). Os do fim vão de -1 (o último) a -6 (o primeiro).

1. Um caractere: `texto[índice]`

pais = "Brasil"

print(pais[0])
print(pais[1])
print(pais[5])
print(pais[-1])
print(pais[-2])
print(len(pais))

pais: O texto de onde você quer tirar o caractere.
[ ]: Os colchetes, colados no nome, querem dizer "a posição…".
0: O índice: qual posição. Precisa ser um número inteiro.
-1: Índice negativo: conta do fim. -1 é sempre o último caractere, seja qual for o tamanho do texto.

$ python3 indices.py
B
r
l
l
i
6

pais[0] é o B, o primeiro; pais[1] é o r, o segundo. O último é pais[5], e também pais[-1]: duas maneiras de chegar à mesma casa. O -1 é o mais usado, porque você não precisa saber o tamanho do texto para pegar o último.

Por que começa no zero?

O índice diz quantos passos você anda desde o começo do texto. Para chegar no primeiro caractere, você anda zero passos; no segundo, um passo. Quase todas as linguagens de programação contam assim. Estranha no começo, vira costume rápido.

2. Um pedaço: `texto[início:fim]`

Para pegar mais de um caractere, ponha dois índices separados por dois-pontos. Isso é uma fatia:

pais = "Brasil"

print(pais[0:3])
print(pais[2:5])
print(pais[:3])
print(pais[3:])
print(pais[-3:])
print(pais[:])

pais[0:3]: Do índice 0 até antes do 3: as posições 0, 1 e 2.
início: O primeiro índice: entra na fatia.
:: Os dois-pontos separam o início do fim.
fim: O segundo índice: não entra. A fatia para logo antes dele.
pais[:3]: Sem o início: começa do começo.
pais[3:]: Sem o fim: vai até o fim do texto.
pais[:]: Sem os dois: o texto inteiro.

$ python3 fatias.py
Bra
asi
Bra
sil
sil
Brasil

pais[0:3] e pais[:3] dão Bra: os 3 primeiros.
pais[2:5] dá asi: as posições 2, 3 e 4 (a 5, o l, ficou de fora).
pais[3:] dá sil: da posição 3 até o fim.
pais[-3:] também dá sil: os 3 últimos.

Por que o fim não entra? Porque assim a conta fica fácil: texto[:3] são os 3 primeiros, e o tamanho de texto[2:5] é 5 - 2, isto é, 3. E texto[:3] mais texto[3:] dá o texto inteiro, sem repetir nem perder nada: um termina exatamente onde o outro começa.

Um uso de verdade: recortando uma data

As datas costumam ser guardadas no formato ano-mês-dia, como "2026-10-18". Sabendo as posições, a Ana tira cada parte com uma fatia e monta a data do jeito brasileiro:

data = "2026-10-18"

ano = data[:4]
mes = data[5:7]
dia = data[8:]

print("Ano:", ano)
print("Mês:", mes)
print("Dia:", dia)
print(dia + "/" + mes + "/" + ano)

$ python3 data.py
Ano: 2026
Mês: 10
Dia: 18
18/10/2026

As posições 0 a 3 são o ano; a 4 é o traço; 5 e 6, o mês; a 7 é outro traço; 8 e 9, o dia. Os pedaços continuam sendo textos ("2026", não 2026), e o + emenda textos (aula Juntar e Repetir Textos). Para trabalhar com datas de verdade, com contas de dias, existe um módulo próprio: datetime.

Missão: o programa já mostra o ano. Acrescente uma linha que mostre o mês, tirado da variável data com uma fatia: Mês: 10.

data = "2026-10-18"
print("Ano:", data[:4])

data = "2026-10-18"
print("Ano:", data[:4])
print("Mês:", data[5:7])

3. O passo: de dois em dois, e ao contrário

A fatia aceita um terceiro número, depois de mais um dois-pontos: o passo, que diz de quanto em quanto pular. Com os algarismos de 0 a 9 fica fácil de ver:

numeros = "0123456789"

print(numeros[::2])
print(numeros[1::2])
print(numeros[::3])
print(numeros[2:8:2])
print(numeros[::-1])
print(numeros[8:2:-2])

$ python3 passo.py
02468
13579
0369
246
9876543210
864

[::2]: Início e fim vazios (o texto todo), passo 2: um sim, um não. Pegou os pares.
[1::2]: Começa no índice 1, passo 2: os ímpares.
[::3]: De três em três.
[2:8:2]: Do 2 até antes do 8, de dois em dois: 2, 4, 6.
[::-1]: Passo negativo: anda para trás. Com início e fim vazios, vai do último ao primeiro: o texto ao contrário.
[8:2:-2]: Para trás, do 8 até antes do 2, de dois em dois: 8, 6, 4. Com passo negativo, o início é o lado direito.

Dos passos, o [::-1] é de longe o mais usado. Com ele, a Ana descobre se uma palavra é um palíndromo (lida igual nos dois sentidos):

palavra = "arara"
print(palavra[::-1])
print(palavra == palavra[::-1])

palavra = "banana"
print(palavra[::-1])
print(palavra == palavra[::-1])

$ python3 palindromo.py
arara
True
ananab
False

Missão: mostre o nome da cidade ao contrário, usando uma fatia com passo -1.

cidade = "Roma"
print(cidade)

cidade = "Roma"
print(cidade[::-1])

4. Fatias e a imutabilidade

Lembra que um texto não pode ser alterado (nome[0] = "B" dá TypeError, aula Strings)? A fatia não muda o texto original: ela fabrica um texto novo, com uma cópia do pedaço. Então, para "trocar" a primeira letra, você monta um texto novo, com a letra nova mais o resto do antigo:

nome = "Ana"
nome = "B" + nome[1:]
print(nome)

$ python3 trocar.py
Bna

nome[1:] é "na" (do índice 1 até o fim); "B" + "na" dá o texto novo "Bna", que é guardado de volta em nome.

5. Fatias que passam do fim não dão erro

Uma diferença importante entre um índice e uma fatia: a fatia é tolerante. Se o fim passar do tamanho do texto, ela simplesmente para no último caractere:

pais = "Brasil"
print(pais[2:100])
print(pais[10:20])
print(len(pais[10:20]))

$ python3 fora-fatia.py
asil

0

pais[2:100] deu asil: do 2 até o fim, sem reclamar do 100. E pais[10:20], que começa depois do fim, deu o texto vazio (a linha em branco), de tamanho 0. Já um índice sozinho fora do texto dá erro, como você vai ver em Quando dá errado.

Formas diferentes de pegar o mesmo pedaço

Você quer…	Prefira	Também funciona	Por quê
o último caractere	`texto[-1]`	`texto[len(texto) - 1]`	Mais curto, e não precisa saber o tamanho
os 3 primeiros	`texto[:3]`	`texto[0:3]`	O 0 no início é desnecessário
os 3 últimos	`texto[-3:]`	`texto[len(texto) - 3:]`	Mais curto e claro
tudo menos o primeiro	`texto[1:]`	`texto[1:len(texto)]`	Sem o fim, vai até o fim
tudo menos o último	`texto[:-1]`	`texto[:len(texto) - 1]`	Mais curto
o texto ao contrário	`texto[::-1]`	(um laço `for`, aula for)	Uma linha só

Quando dá errado

Índice fora do texto: IndexError

"Brasil" tem 6 letras, então a Ana pediu a de número 6, achando que era a última:

pais = "Brasil"
print(pais[6])

$ python3 fora.py
Traceback (most recent call last):
  File "/home/ana/fora.py", line 2, in <module>
    print(pais[6])
          ~~~~^^^
IndexError: string index out of range

File "/home/ana/fora.py", line 2: O erro está na linha 2.
~~~~^^^: Os ~ sublinham o texto (pais), e os ^, o índice que deu problema ([6]).
IndexError:: "Erro de índice".
string index out of range: "Índice do texto fora do intervalo": não existe a posição 6. Os índices de "Brasil" vão de 0 a 5.

Com índice negativo, o limite é o mesmo do outro lado: -6 é o primeiro, -7 já não existe.

$ 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.
>>> pais = "Brasil"
>>> pais[-7]
Traceback (most recent call last):
  File "<python-input-1>", line 1, in <module>
    pais[-7]
    ~~~~^^^^
IndexError: string index out of range
>>> exit()

Como consertar: o último caractere é pais[5] (o tamanho menos um) ou, melhor, pais[-1]. Lembre: num texto de tamanho N, o maior índice é N - 1.

Índice que é um texto: TypeError

pais = "Brasil"
posicao = "2"
print(pais[posicao])

$ python3 indice-texto.py
Traceback (most recent call last):
  File "/home/ana/indice-texto.py", line 3, in <module>
    print(pais[posicao])
          ~~~~^^^^^^^^^
TypeError: string indices must be integers, not 'str'

string indices must be integers, not 'str': "os índices de um texto precisam ser números inteiros, não str". O "2" entre aspas é um texto. Isso acontece muito quando a posição vem do teclado, porque o input() sempre devolve texto. Como consertar: converta, pais[int(posicao)] (aula Conversão de Tipos).

Índice com casas decimais: TypeError

A Ana quer a letra do meio e dividiu o tamanho por 2:

pais = "Brasil"
meio = len(pais) / 2
print(pais[meio])

$ python3 indice-float.py
Traceback (most recent call last):
  File "/home/ana/indice-float.py", line 3, in <module>
    print(pais[meio])
          ~~~~^^^^^^
TypeError: string indices must be integers, not 'float'

A divisão / sempre dá um float (6 / 2 é 3.0, e não 3), e 3.0 não serve de índice, mesmo sem nada depois da vírgula. Como consertar: use a divisão inteira // (aula Operadores Aritméticos):

pais = "Brasil"
meio = len(pais) // 2
print(pais[meio])
print(pais[:meio])
print(pais[meio:])

$ python3 indice-meio.py
s
Bra
sil

Querer mudar o texto pelo índice

$ 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.
>>> pais = "Brasil"
>>> pais[0] = "b"
Traceback (most recent call last):
  File "<python-input-1>", line 1, in <module>
    pais[0] = "b"
    ~~~~^^^
TypeError: 'str' object does not support item assignment
>>> exit()

Com índices você lê, mas não escreve: textos são imutáveis. Como consertar: monte um texto novo, pais = "b" + pais[1:] (seção 4), ou use o replace() da aula Métodos de Texto.

Referência rápida

Com t = "Brasil":

Escrita	O que pega	Resultado
`t[0]`	O primeiro caractere	`'B'`
`t[-1]`	O último	`'l'`
`t[2:5]`	Do 2 até antes do 5	`'asi'`
`t[:3]`	Os 3 primeiros	`'Bra'`
`t[3:]`	Do 3 até o fim	`'sil'`
`t[-3:]`	Os 3 últimos	`'sil'`
`t[:]`	Tudo	`'Brasil'`
`t[::2]`	De dois em dois	`'Bai'`
`t[::-1]`	Ao contrário	`'lisarB'`
`t[6]`	Não existe	`IndexError`
`t[2:100]`	Fatia que passa do fim: para no fim	`'asil'`

Exercícios

Use p = "Teresina" em todos.

1. A primeira e a última

Complete os índices para pegar o T e o a do fim:

print(p[], p[])

2. O começo

Complete a fatia que pega Tere:

print(p[:])

3. O fim

Complete a fatia que pega sina, contando do fim:

print(p[:])

4. O que p[1:3] mostra?

Ter er ere e

5. O que acontece com p[8]?

Mostra a, a última letra Mostra o texto vazio Dá IndexError: os índices vão de 0 a 7 Mostra T: volta para o começo

6. O que p[::-1] mostra?

anisereT a Teresin Dá erro: índice negativo

Missão final: o telefone formatado

Missão: o telefone da Ana está guardado só com os algarismos. Mostre-o formatado, assim: (86) 98888-7777. Os 2 primeiros algarismos são o DDD, os 5 seguintes são a primeira parte do número, e o resto é a segunda parte.

telefone = "86988887777"
print("DDD:", telefone[:2])

telefone = "86988887777"
print("(" + telefone[:2] + ") " + telefone[2:7] + "-" + telefone[7:])

Dica: telefone[2:7] são as posições 2, 3, 4, 5 e 6. Quando você conhecer as f-strings, vai escrever isso de um jeito bem mais limpo.

Resumo

Cada caractere tem um índice, a partir do 0. Num texto de tamanho N, o último é o N - 1.
Índices negativos contam do fim: texto[-1] é o último.
texto[início:fim] é uma fatia: o início entra, o fim não. Sem o início, começa do começo; sem o fim, vai até o fim.
O terceiro número é o passo: [::2] pula de dois em dois, [::-1] dá o texto ao contrário.
A fatia não muda o texto: ela cria um texto novo. Fatia que passa do fim não dá erro; índice fora do texto dá IndexError: string index out of range.
O índice precisa ser um int: "2" e 3.0 dão TypeError: string indices must be integers.