Introdução
Neste laboratório, você explorará as técnicas fundamentais para manipular strings (cadeias de caracteres) em Python. As strings são um dos tipos de dados mais comuns, e saber como trabalhar com elas de forma eficaz é uma habilidade crucial para qualquer programador Python. Cobriremos desde definições básicas, o uso de caracteres especiais e a criação de strings de múltiplas linhas, até operações mais avançadas como acesso a substrings, verificação de conteúdo, alteração de caixa (case), pesquisa, divisão (splitting) e formatação de texto. Ao final deste laboratório, você terá uma base sólida para lidar com dados textuais em seus programas Python.
Caracteres de Escape e Strings de Múltiplas Linhas
Nesta etapa, você aprenderá como lidar com caracteres especiais dentro de strings, criar strings que ignoram esses caracteres especiais e definir strings que se estendem por várias linhas.
Primeiro, vamos explorar os caracteres de escape. Um caractere de escape é uma barra invertida (\) seguida por um caractere que você deseja inserir. Por exemplo, \n representa uma nova linha, e \' representa uma aspa simples.
Nota: Se você não está familiarizado com o uso do WebIDE (semelhante ao VS Code), aprenda primeiro neste laboratório.
Abra o arquivo main.py no explorador de arquivos à esquerda. Adicione o seguinte código a ele:
## Caracteres de escape: use barra invertida para inserir caracteres especiais
## \n = nova linha, \' = aspa simples
print("Hello there!\nHow are you?\nI\'m doing fine.")
Agora, execute o script abrindo um terminal e executando o comando abaixo. Você pode abrir um novo terminal clicando no ícone + no painel do terminal.
python3 main.py
Você verá a saída com novas linhas e uma aspa simples inseridas corretamente.
Hello there!
How are you?
I'm doing fine.
Em seguida, vamos ver as strings brutas (raw strings). Uma string bruta, prefixada com um r, ignora todos os caracteres de escape e imprime qualquer barra invertida que apareça na string. Isso é particularmente útil para expressões regulares ou caminhos de arquivo.
Substitua o conteúdo de main.py pelo seguinte código:
## String bruta (prefixo r): trata barras invertidas como caracteres literais
print(r"Hello there!\nHow are you?\nI\'m doing fine.")
Execute o script novamente:
python3 main.py
Observe como \n e \' são agora tratados como caracteres literais na saída.
Hello there!\nHow are you?\nI\'m doing fine.
Finalmente, você pode criar strings multilinhas usando aspas triplas (""" ou '''). Esta é uma maneira conveniente de definir strings que se estendem por várias linhas, preservando a formatação.
Substitua o conteúdo de main.py por este exemplo:
print(
"""Dear Alice,
Eve's cat has been arrested for catnapping,
cat burglary, and extortion.
Sincerely,
Bob"""
)
Execute o script:
python3 main.py
A saída será uma mensagem formatada e multilinhas.
Dear Alice,
Eve's cat has been arrested for catnapping,
cat burglary, and extortion.
Sincerely,
Bob
Indexação e Fatiamento de Strings
Nesta etapa, você aprenderá como acessar caracteres individuais e extrair substrings usando indexação e fatiamento.
Strings em Python são sequências, o que significa que você pode acessar suas partes usando um índice. A indexação começa em 0 para o primeiro caractere.
H e l l o w o r l d !
0 1 2 3 4 5 6 7 8 9 10 11
Limpe o arquivo main.py e adicione o seguinte código para definir uma string:
spam = 'Hello world!'
Para acessar o primeiro caractere ('H'), você usa o índice 0. Para acessar o quinto caractere ('o'), você usa o índice 4. Você também pode usar índices negativos para contar a partir do final da string; -1 refere-se ao último caractere.
Adicione estas instruções print em main.py para ver a indexação em ação:
spam = 'Hello world!'
## String indexing: access characters by position (0-based)
print(spam[0]) ## Returns first character
print(spam[4]) ## Returns fifth character
print(spam[-1]) ## Returns last character
Execute o script:
python3 main.py
A saída mostrará os caracteres individuais que você acessou.
H
o
!
O fatiamento (slicing) permite que você extraia uma porção de uma string, chamada de substring. A sintaxe é [start:end], que extrai caracteres do índice start até, mas não incluindo, o índice end.
Vamos praticar o fatiamento. Substitua o conteúdo de main.py pelo seguinte código. Exploraremos algumas maneiras diferentes de fatiar a string.
spam = 'Hello world!'
## String slicing: extract substring using [start:end] syntax
print(spam[0:5]) ## Returns characters from index 0 to 4
print(spam[:5]) ## Omitting start index defaults to 0
print(spam[6:]) ## Omitting end index defaults to the end of the string
print(spam[::-1]) ## A step of -1 reverses the string
Execute o script:
python3 main.py
Observe as diferentes substrings criadas pelo fatiamento.
Hello
Hello
world!
!dlrow olleH
Membros de String e Métodos de Caixa (Case Methods)
Nesta etapa, você aprenderá como verificar se uma substring existe dentro de uma string e como alterar e validar a caixa (case) de uma string.
Os operadores in e not in são usados para verificar a associação de strings. Eles retornam um valor booleano: True ou False.
Limpe o arquivo main.py e adicione o seguinte código para testar esses operadores. Observe que a comparação diferencia maiúsculas de minúsculas (case-sensitive).
## The 'in' and 'not in' operators
print('Hello' in 'Hello World')
print('HELLO' in 'Hello World')
print('cats' not in 'cats and dogs')
Execute o script para ver os resultados booleanos:
python3 main.py
True
False
False
Python também fornece vários métodos para alterar a caixa de uma string. Os métodos upper(), lower() e title() retornam uma nova string em letras maiúsculas, minúsculas ou em caixa de título (title case - onde cada palavra é capitalizada), respectivamente.
Substitua o conteúdo de main.py pelo seguinte:
greet = 'Hello world!'
print(greet.upper())
print(greet.lower())
print(greet.title())
Execute o script:
python3 main.py
Você verá as strings transformadas.
HELLO WORLD!
hello world!
Hello World!
Para verificar se uma string já está em uma caixa específica, você pode usar os métodos isupper() e islower(). Esses métodos retornam True se todos os caracteres com caixa na string estiverem na caixa especificada e houver pelo menos um caractere com caixa.
Substitua o conteúdo de main.py por estes exemplos:
spam = 'Hello world!'
print(spam.islower())
print('HELLO'.isupper())
## This is true because non-letter characters are ignored
print('abc12345'.islower())
## This is false because there are no cased characters
print('12345'.islower())
Execute o script para verificar a caixa de cada string.
python3 main.py
False
True
True
False
Busca e Divisão de Strings (Searching and Splitting Strings)
Nesta etapa, você aprenderá como verificar se uma string começa ou termina com uma substring específica, como juntar uma lista de strings em uma única string e como dividir uma string em uma lista de substrings.
Os métodos startswith() e endswith() são úteis para verificar o início ou o fim de uma string. Eles retornam True ou False.
Limpe o main.py e adicione o seguinte código:
print('Hello world!'.startswith('Hello'))
print('Hello world!'.endswith('world!'))
print('abc123'.startswith('abcdef'))
Execute o script para ver os resultados:
python3 main.py
True
True
False
O método join() é chamado em uma string separadora e aceita um iterável (como uma lista) como argumento. Ele combina os elementos do iterável em uma única string, com o separador colocado entre cada elemento.
Substitua o conteúdo de main.py por estes exemplos para ver como join() funciona:
## Join with a comma and space separator
print(', '.join(['cats', 'rats', 'bats']))
## Join with a space separator
print(' '.join(['My', 'name', 'is', 'Simon']))
Execute o script:
python3 main.py
cats, rats, bats
My name is Simon
O método split() faz o oposto de join(). Ele é chamado em uma string e a divide em uma lista de substrings. Por padrão, ele divide por espaços em branco (whitespace), mas você pode fornecer um delimitador específico.
Substitua o conteúdo de main.py pelo seguinte código para praticar a divisão de strings:
## Split by default whitespace
print('My name is Simon'.split())
## Split by a specific delimiter 'ABC'
print('MyABCnameABCisABCSimon'.split('ABC'))
Execute o script para ver as listas resultantes:
python3 main.py
['My', 'name', 'is', 'Simon']
['My', 'name', 'is', 'Simon']
Justificação e Limpeza de Strings (Justifying and Cleaning Strings)
Nesta etapa, você aprenderá como formatar o alinhamento de strings e como remover caracteres indesejados, como espaços em branco (whitespace), do início ou do fim de uma string.
Python fornece métodos para justificar texto dentro de uma largura (width) definida: rjust() (justificar à direita), ljust() (justificar à esquerda) e center(). Esses métodos retornam uma nova string preenchida (padded string).
Limpe o arquivo main.py e adicione o seguinte código:
print('Hello'.rjust(10))
print('Hello'.ljust(10))
print('Hello'.center(20))
Execute o script para ver o texto alinhado. As aspas simples na saída ajudam a visualizar o preenchimento (padding).
python3 main.py
Hello
Hello
Hello
Você também pode fornecer um segundo argumento opcional para especificar um caractere de preenchimento diferente de um espaço. Substitua o conteúdo de main.py por isto:
print('Hello'.rjust(20, '*'))
print('Hello'.center(20, '='))
Execute o script novamente:
python3 main.py
***************Hello
=======Hello========
Para limpar strings, você pode usar os métodos strip(), rstrip() e lstrip(). Eles são usados para remover caracteres das extremidades de uma string. Por padrão, eles removem caracteres de espaço em branco (whitespace - espaços, tabulações, novas linhas).
Substitua o conteúdo de main.py por este exemplo:
spam = ' Hello World '
print(spam.strip()) ## Removes from both ends
print(spam.lstrip()) ## Removes from the left side
print(spam.rstrip()) ## Removes from the right side
Execute o script para ver as strings limpas:
python3 main.py
Hello World
Hello World
Hello World
Você também pode passar um argumento de string para esses métodos para especificar quais caracteres remover. O método removerá todos os caracteres do argumento que estiverem nas extremidades da string.
Substitua o conteúdo de main.py pela última vez:
spam = 'SpamSpamBaconSpamEggsSpamSpam'
## Removes all characters 'S', 'p', 'a', 'm' from the ends
print(spam.strip('ampS'))
Execute o script:
python3 main.py
A saída mostra que as partes externas "Spam" foram removidas, restando a parte central da string.
BaconSpamEggs
Resumo
Neste laboratório, você dominou as técnicas essenciais para manipulação de strings em Python. Você aprendeu a usar caracteres de escape (escape characters) e a criar strings de múltiplas linhas (multiline strings) para uma melhor representação de texto. Você praticou o acesso a partes de uma string usando indexação (indexing) e fatiamento (slicing). Você também explorou métodos poderosos de string para verificar pertinência (in, not in), alterar caixa (upper(), lower()), validar caixa (isupper(), islower()), pesquisa (startswith(), endswith()), junção e divisão (joining and splitting), e, finalmente, formatação e limpeza de texto (rjust(), strip()). Essas habilidades são fundamentais para qualquer tarefa que envolva processamento de texto em Python.
