Strings em Python: criar, acessar, fatiar e manipular texto

Q: Como juntar strings em Python?

Concatenação significa juntar strings. Em Python, você usa o operador +. É como encaixar duas peças de LEGO para formar algo maior. A repetição usa o operador *. Ele repete uma string um certo número de vezes. Isso é surpreendentemente útil para criar separadores, padrões ou preenchimentos.

Q: Como descobrir o tamanho de uma string?

A função len() informa quantos caracteres há em uma string. Isso inclui letras, números, espaços e caracteres especiais. Todo caractere conta.

Iniciante25 min7 exercícios135 XP

Este tutorial foi traduzido do original em inglês.Read in English Leer en español Читать на русском อ่านภาษาไทย Avisar sobre um erro de tradução

Antes de começar

Números em Python: inteiros, floats e matemática na prática

0/7 exercícios

Pense no seu celular. Quase tudo o que você vê na tela é texto: nomes nos contatos, mensagens de amigos, resultados de busca, notificações. Nos bastidores, todo esse texto é tratado com strings.

Uma string é a forma como o Python guarda e trabalha com texto. Pode ser uma única letra, uma frase inteira ou até um livro inteiro. Se é texto, é uma string.

Neste tutorial, você vai aprender a criar strings, pegar caracteres específicos, fatiar strings, juntá-las e verificar o que há dentro delas. São habilidades que você vai usar em quase todo programa Python que escrever.

O que são strings em Python?

Uma string é uma sequência de caracteres entre aspas. Você pode usar aspas simples, aspas duplas ou aspas triplas. O Python trata todas elas como strings.

Pense numa string como um colar de contas. Cada conta é um caractere. As aspas são o fecho que mantém o colar inteiro.

Três formas de criar strings

# Single quotes

greeting = 'Hello, world!'

print(greeting) # Hello, world!

# Double quotes - exactly the same

greeting = "Hello, world!"

print(greeting) # Hello, world!

# Triple quotes - for multi-line text

poem = """Roses are red,

Violets are blue,

Python is awesome,

And so are you."""

print(poem)

Saída

Hello, world!
Hello, world!
Roses are red,
Violets are blue,
Python is awesome,
And so are you.

Aspas simples e aspas duplas funcionam exatamente do mesmo jeito. O principal motivo de existirem as duas é a praticidade: se o seu texto contém um tipo de aspas, você pode envolvê-lo com o outro.

Misturando tipos de aspas

# Use double quotes when your text has single quotes

message = "It's a beautiful day"

print(message)

# Use single quotes when your text has double quotes

html = '<div class="container">Hello</div>'

print(html)

Saída

It's a beautiful day
<div class="container">Hello</div>

Até um par de aspas vazio cria uma string. Uma string vazia tem zero caracteres, mas continua sendo uma string válida.

Strings vazias e strings com espaços

empty = ""

print(type(empty)) # <class 'str'>

print(len(empty)) # 0

# A string with just a space is NOT empty

space = " "

print(len(space)) # 1

Saída

<class 'str'>
0
1

Como acessar caracteres individuais de uma string?

Cada caractere de uma string tem um número de posição chamado índice. Você pode pegar qualquer caractere colocando o índice dele entre colchetes.

Agora a parte importante: o Python começa a contar do 0, não do 1. O primeiro caractere está no índice 0, o segundo no índice 1, e assim por diante. Isso se chama indexação a partir de zero.

Acessando caracteres com índices positivos

word = "Python"

# Positive indexing (left to right)

# P y t h o n

# 0 1 2 3 4 5

print(word[0]) # P - first character

print(word[1]) # y - second character

print(word[5]) # n - last character

Saída

P
y
n

Pense nos índices de uma string como os números das casas de uma rua. A primeira casa é a de número 0, não a de número 1. Parece estranho no começo, mas você se acostuma rápido.

O que são índices negativos em Python?

O Python também permite contar de trás para frente, a partir do fim, usando índices negativos. O último caractere está no índice -1, o penúltimo no -2, e assim por diante.

Acessando caracteres com índices negativos

word = "Python"

# Negative indexing (right to left)

# P y t h o n

# -6 -5 -4 -3 -2 -1

print(word[-1]) # n - last character

print(word[-2]) # o - second to last

print(word[-6]) # P - first character

Saída

n
o
P

Como funciona o fatiamento de strings em Python?

A indexação pega um caractere. O fatiamento (slicing) pega um pedaço com vários caracteres. É como cortar uma fatia do meio de um pão.

A sintaxe é string[start:stop]. Ela pega os caracteres a partir de start até stop, mas sem incluir a posição de parada. Essa regra do "até, mas sem incluir" é uma das coisas mais importantes para lembrar.

Fatiamento básico de strings

text = "Hello, World!"

# text[start:stop] - includes start, excludes stop

print(text[0:5]) # Hello - characters 0,1,2,3,4

print(text[7:12]) # World - characters 7,8,9,10,11

print(text[0:1]) # H - just one character

Saída

Hello
World
H

Você pode deixar de fora o início ou o fim. Sem o início, o Python começa do primeiro caractere. Sem o fim, ele vai até o final da string.

Atalhos de fatiamento

text = "Hello, World!"

print(text[:5]) # Hello - from the beginning up to (not including) index 5

print(text[7:]) # World! - from index 7 to the end

print(text[:]) # Hello, World! - the whole string

Saída

Hello
World!
Hello, World!

Como funciona o passo (step) no fatiamento?

Existe um terceiro número que você pode acrescentar: string[start:stop:step]. O passo (step) define o tamanho do salto de um caractere para o próximo. Um passo de 2 pega um caractere sim, outro não.

Fatiamento com passo

text = "abcdefghij"

# Every other character

print(text[::2]) # acegi - step of 2

# Every third character

print(text[::3]) # adgj - step of 3

# Slice and step together

print(text[1:8:2]) # bdfh - start at 1, stop before 8, step 2

Saída

acegi
adgj
bdfh

O uso mais famoso do passo é inverter uma string. Um passo de -1 percorre a string inteira de trás para frente.

Invertendo uma string com [::-1]

word = "Python"

# Reverse a string with [::-1]

print(word[::-1]) # nohtyP

# This works on any string

print("racecar"[::-1]) # racecar - a palindrome!

Saída

nohtyP
racecar

Como juntar strings em Python?

Concatenação significa juntar strings. Em Python, você usa o operador +. É como encaixar duas peças de LEGO para formar algo maior.

Juntando strings com +

first_name = "Ada"

last_name = "Lovelace"

# Concatenation with +

full_name = first_name + " " + last_name

print(full_name) # Ada Lovelace

# You can chain as many as you want

greeting = "Hello" + ", " + "world" + "!"

print(greeting) # Hello, world!

Saída

Ada Lovelace
Hello, world!

A repetição usa o operador *. Ele repete uma string um certo número de vezes. Isso é surpreendentemente útil para criar separadores, padrões ou preenchimentos.

Repetindo strings com *

# Repeat a string with *

print("Ha" * 3) # HaHaHa

print("-" * 30) # ------------------------------

print("abc " * 4) # abc abc abc abc

# Great for creating visual separators

title = "My Report"

print(title)

print("=" * len(title)) # =========

Saída

HaHaHa
------------------------------
abc abc abc abc 
My Report
=========

Como descobrir o tamanho de uma string?

A função len() informa quantos caracteres há em uma string. Isso inclui letras, números, espaços e caracteres especiais. Todo caractere conta.

Medindo o tamanho de uma string

message = "Hello, World!"

print(len(message)) # 13

# Spaces count!

print(len("a b c")) # 5 - three letters + two spaces

# Empty string has length 0

print(len("")) # 0

# Common use: get the last index

word = "Python"

last_index = len(word) - 1

print(word[last_index]) # n

Saída

Como verificar se um texto existe dentro de uma string?

O operador in verifica se uma string aparece dentro de outra. Ele retorna True ou False. É como usar Ctrl+F para procurar uma palavra em um documento.

Buscando com o operador in

sentence = "The quick brown fox jumps over the lazy dog"

# Check if a word is in the sentence

print("fox" in sentence) # True

print("cat" in sentence) # False

print("quick" in sentence) # True

# Check if something is NOT in the string

print("cat" not in sentence) # True

Saída

True
False
True
True

Lidando com maiúsculas e minúsculas no in

# Case-sensitive gotcha

text = "Hello World"

print("hello" in text) # False - wrong case!

print("hello" in text.lower()) # True - convert to lowercase first

# Practical example: checking user input

user_answer = "Yes"

if "yes" in user_answer.lower():

print("User said yes!")

Saída

False
True
User said yes!

O que são caracteres de escape em strings Python?

Alguns caracteres não podem ser digitados diretamente dentro de uma string. Como colocar uma quebra de linha numa string? Ou uma tabulação? Você usa caracteres de escape: sequências especiais que começam com uma barra invertida \.

Caracteres de escape comuns

# \n - new line

print("Line 1\nLine 2\nLine 3")

# \t - tab

print("Name\tAge\tCity")

print("Alice\t25\tParis")

print("Bob\t30\tTokyo")

# \\ - literal backslash

print("File path: C:\\Users\\Documents")

# \" or \' - quote inside a string

print("She said \"hello\"")

Saída

Line 1
Line 2
Line 3
Name	Age	City
Alice	25	Paris
Bob	30	Tokyo
File path: C:\Users\Documents
She said "hello"

Aqui está uma referência rápida dos caracteres de escape que você mais vai usar:

Escape	O que faz	Exemplo de saída
`\n`	Nova linha	Texto em uma nova linha
`\t`	Tabulação	Adiciona um espaço de tabulação
`\\`	Barra invertida	Exibe uma única `\`
`\"`	Aspas duplas	Exibe `"` dentro de uma string com `"`
`\'`	Aspas simples	Exibe `'` dentro de uma string com `'`

Por que não dá para mudar um caractere de uma string em Python?

Strings em Python são imutáveis. Isso significa que, depois que uma string é criada, você não pode mudar nenhum dos caracteres dela. Não dá para trocar uma letra nem corrigir um erro de digitação dentro de uma string que já existe.

Pense numa string como um livro impresso. Você pode ler qualquer página, mas não pode apagar uma palavra e escrever outra no lugar. Se quiser mudar algo, precisa imprimir um livro novo.

Strings não podem ser alteradas no lugar

word = "Hello"

# This will CRASH with a TypeError

try:

word[0] = "J" # Can't change individual characters!

except TypeError as e:

print(f"Error: {e}")

Saída

Error: 'str' object does not support item assignment

Então, como "mudar" uma string? Você cria uma string nova com as mudanças que quer. O fatiamento e a concatenação servem exatamente para isso.

Falha: modificar uma string no lugar

word = "Hello"
word[0] = "J"  # TypeError!

Funciona: criar uma string nova

word = "Hello"
new_word = "J" + word[1:]
print(new_word)  # Jello

Exercícios práticos

Hora de praticar! Estes exercícios cobrem tudo o que você viu neste tutorial. Eles começam tranquilos e vão ficando mais desafiadores.

Tente resolver cada um antes de olhar as dicas. Errar e ler as mensagens de erro é como você realmente aprende.

Exercício 1: monte uma saudação com concatenação

Escreva o código

Você recebe duas variáveis: first_name com o valor "Ada" e last_name com o valor "Lovelace". Crie uma variável chamada greeting que junte as duas em uma mensagem e depois exiba essa mensagem.

Saída esperada:

Hello, Ada Lovelace! Welcome to Python.

Use concatenação de strings (+) para montar a saudação.

first_name = "Ada"

last_name = "Lovelace"

# Create the greeting using concatenation (+)

# Print the greeting

Exercício 2: pegue o primeiro e o último caractere

Escreva o código

Você recebe uma variável word com o valor "Programming". Exiba o primeiro e o último caractere, cada um em uma linha.

Saída esperada:

P
g

Use indexação de strings para acessar cada caractere.

word = "Programming"

# Print the first character

# Print the last character

Exercício 3: inverta uma string

Escreva o código

Você recebe uma variável text com o valor "Python". Exiba a string invertida.

Saída esperada:

nohtyP

Use fatiamento para invertê-la em um único passo.

text = "Python"

# Print the reversed string using slicing

Exercício 4: preveja a saída do fatiamento

Preveja a saída

Sem executar o código, preveja o que cada linha vai exibir. Lembre-se: o fatiamento usa [start:stop], e o stop fica de fora.

Escreva suas previsões como comentários e depois execute o código para conferir.

word = "Hello"

print(word[1:4]) # Your prediction:

print(word[:3]) # Your prediction:

print(word[2:]) # Your prediction:

Exercício 5: corrija o bug: modificar uma string

Corrija o erro

Este código tenta corrigir um erro de digitação mudando um caractere diretamente. Mas strings são imutáveis, então ele falha.

Corrija o código para que ele exiba:

Hello World

Crie uma string nova em vez de modificar a antiga.

message = "Hello Wurld"

# Fix the typo: change "u" to "o"

message[7] = "o"

print(message)

Exercício 6: verifique se uma palavra está em uma frase

Escreva o código

Você recebe uma sentence (frase) e uma search_word (palavra buscada). Verifique se a palavra buscada aparece na frase (sem diferenciar maiúsculas de minúsculas) e exiba o resultado.

Saída esperada:

True

Deixe as duas no mesmo formato (tudo em minúsculas, por exemplo) antes de verificar.

sentence = "The quick brown Fox jumps over the lazy Dog"

search_word = "fox"

# Check if search_word is in sentence (case-insensitive)

# Print True or False

Exercício 7: extraia o domínio de um endereço de e-mail

Escreva o código

Você recebe um endereço de e-mail guardado em email. Extraia só o nome do domínio (a parte depois do símbolo @) e exiba-o.

Saída esperada:

gmail.com

Use o método .find() para localizar o símbolo @ e depois use fatiamento para extrair tudo o que vem depois dele.

email = "alice@gmail.com"

# Find the position of the @ symbol

# Slice the string to get the domain

# Print the domain

Resumo: strings em Python

Aqui está uma referência rápida de tudo o que você aprendeu:

Conceito	Sintaxe	Exemplo
Criar uma string	`"text"` ou `'text'`	`name = "Alice"`
Indexação	`string[i]`	`"Hello"[0]` dá `"H"`
Indexação negativa	`string[-i]`	`"Hello"[-1]` dá `"o"`
Fatiamento	`string[start:stop]`	`"Hello"[1:4]` dá `"ell"`
Fatiamento com passo	`string[::step]`	`"Hello"[::-1]` dá `"olleH"`
Concatenação	`+`	`"Hi" + " there"` dá `"Hi there"`
Repetição	`*`	`"Ha" * 3` dá `"HaHaHa"`
Tamanho	`len(string)`	`len("Hello")` dá `5`
Pertinência	`in`	`"fox" in "a fox"` dá `True`
Caracteres de escape	`\n`, `\t`, `\\`	Caracteres especiais em strings

Ponto principal: strings são imutáveis. Você pode ler caracteres, fatiar, buscar e combinar strings, mas nunca pode mudar uma string no lugar. Qualquer "mudança" cria uma string totalmente nova.

O que vem a seguir?

Agora que você sabe criar e fatiar strings, é hora de aprender a transformá-las. No próximo tutorial, Métodos de string em Python, você vai conhecer métodos embutidos como .upper(), .replace(), .split() e .strip(), que deixam o trabalho com texto muito mais tranquilo.

O que são strings em Python?

Como acessar caracteres individuais de uma string?

O que são índices negativos em Python?

Como funciona o fatiamento de strings em Python?

Como funciona o passo (step) no fatiamento?

Como juntar strings em Python?

Como descobrir o tamanho de uma string?

Como verificar se um texto existe dentro de uma string?

O que são caracteres de escape em strings Python?

Por que não dá para mudar um caractere de uma string em Python?

Exercícios práticos

Resumo: strings em Python

O que vem a seguir?

Tutoriais relacionados