Trabalhar com Strings em Python

PythonBeginner
Pratique Agora

Introdução

Neste laboratório, você ganhará experiência prática trabalhando com strings em Python, um tipo de dado fundamental. Você começará entendendo os conceitos básicos de strings, incluindo criação, imutabilidade e acesso a caracteres individuais usando indexação tanto positiva quanto negativa.

Com base nessa fundação, você aprenderá a extrair substrings usando slicing (fatiamento), utilizar vários operadores de string e caracteres de escape para manipulação e formatação especial, e explorará diferentes métodos para formatar strings. Finalmente, você se aprofundará nos métodos comuns de string para realizar operações como busca, substituição e modificação do conteúdo da string.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 97%. Recebeu uma taxa de avaliações positivas de 100% dos estudantes.

Compreender os Fundamentos e a Indexação de Strings

Nesta etapa, você aprenderá os conceitos fundamentais de strings em Python, incluindo como criá-las e acessar caracteres individuais usando indexação. Strings são sequências de caracteres e são um dos tipos de dados mais comuns. Você pode criar strings usando aspas simples ('...') ou aspas duplas ("...").

Uma característica chave das strings em Python é que elas são imutáveis, o que significa que seu conteúdo não pode ser alterado após serem criadas. Qualquer operação que pareça modificar uma string na verdade cria uma nova.

Vamos explorar isso. No WebIDE, abra o arquivo string_basics.py no diretório ~/project no explorador de arquivos à esquerda. Adicione o seguinte código a ele:

## string_basics.py

## Strings são imutáveis. Atribuir uma nova string a uma variável
## cria um novo objeto string com um novo endereço de memória.
a = "hello"
print(f"Value: {a}, ID: {id(a)}")

a = "hi"
print(f"Value: {a}, ID: {id(a)}")

Para executar o script, abra um terminal no WebIDE (Terminal -> New Terminal) e execute o seguinte comando:

python ~/project/string_basics.py

Você verá uma saída semelhante a esta, onde os valores de ID são diferentes, confirmando que um novo objeto string foi criado.

Value: hello, ID: <placeholder>
Value: hi, ID: <placeholder>

Agora, vamos explorar a indexação de strings. Você pode acessar caracteres individuais usando seu índice (posição). Em Python, a indexação começa em 0 para o primeiro caractere.

Modifique o arquivo string_basics.py para incluir a indexação positiva:

## string_basics.py
a = "Hello"

## Indexação positiva (a partir do início)
print("Positive Indexing:")
print(a[0])
print(a[1])
print(a[2])
print(a[3])
print(a[4])

## Acessar um índice que não existe causará um IndexError.
## print(a[5])

Salve o arquivo e execute-o novamente:

python ~/project/string_basics.py
Positive Indexing:
H
e
l
l
o

Python também suporta indexação negativa, que acessa caracteres a partir do final da string. O último caractere está no índice -1, o penúltimo em -2, e assim por diante.

Adicione exemplos de indexação negativa ao string_basics.py:

## string_basics.py
a = "Hello"

## Positive indexing (from the beginning)
print("Positive Indexing:")
print(a[0])
print(a[1])
print(a[2])
print(a[3])
print(a[4])

## Negative indexing (from the end)
print("\nNegative Indexing:")
print(a[-5])
print(a[-4])
print(a[-3])
print(a[-2])
print(a[-1])

## Because strings are immutable, you cannot change a character.
## The following line would cause a TypeError: 'str' object does not support item assignment
## a[0] = "J"

Salve o arquivo e execute-o pela última vez nesta etapa:

python ~/project/string_basics.py
Positive Indexing:
H
e
l
l
o

Negative Indexing:
H
e
l
l
o

Fatiar Strings (Slicing)

Nesta etapa, você aprenderá como extrair substrings de uma string usando slicing (fatiamento). Enquanto a indexação obtém um único caractere, o slicing obtém uma sequência de caracteres.

A sintaxe básica para slicing é string[start:end]. Isso extrai a parte da string do índice start até, mas não incluindo, o índice end.

Abra o arquivo string_slicing.py no diretório ~/project. Adicione o seguinte código para demonstrar o slicing básico:

## string_slicing.py
a = "Hello World"

## Fatiar do índice 0 até (mas não incluindo) o índice 5
print(a[0:5])

## Fatiar do índice 6 até o final da string
print(a[6:])

## Fatiar do início até (mas não incluindo) o índice 5
print(a[:5])

## Usando índices negativos para fatiamento
print(a[-5:-2])

## Obter uma cópia da string inteira
print(a[:])

Salve o arquivo e execute-o no terminal:

python ~/project/string_slicing.py
Hello
World
Hello
Wor
Hello World

O slicing também pode aceitar um terceiro parâmetro, step (passo), com a sintaxe string[start:end:step]. O valor de step determina o intervalo entre os caracteres na fatia.

Modifique string_slicing.py para incluir exemplos com um passo:

## string_slicing.py
a = "Hello World"

## ... (código anterior) ...

b = "0123456789"

## Obter cada segundo caractere do início ao fim
print(b[::2])

## Obter caracteres do índice 1 ao 7, com um passo de 3
print(b[1:7:3])

## Um passo negativo reverte a direção. Isso inverte a string inteira.
print(b[::-1])

## Inverter do índice 7 até (mas não incluindo) o índice 2
print(b[7:2:-1])

Salve o arquivo e execute-o novamente:

python ~/project/string_slicing.py
Hello
World
Hello
Wor
Hello World
02468
14
9876543210
76543

O slicing é tolerante e lida automaticamente com índices fora dos limites, o que evita erros.

Adicione estas linhas finais a string_slicing.py para ver esse comportamento:

## string_slicing.py
a = "Hello World"

## ... (código anterior) ...

b = "0123456789"

## ... (código anterior) ...

## Slicing com índices fora dos limites
c = "Python"
## O índice final é maior que o comprimento da string, mas funciona bem.
print(c[2:100])

## O índice inicial é anterior ao início, mas funciona bem.
print(c[-100:4])

Salve e execute o script:

python ~/project/string_slicing.py
Hello
World
Hello
Wor
Hello World
02468
14
9876543210
76543
thon
Pyth

Usar Operadores de String e Caracteres de Escape

Nesta etapa, você aprenderá sobre os operadores comuns usados com strings e como usar caracteres de escape para representar caracteres especiais.

Python fornece vários operadores para manipulação de strings. Os operadores in e not in verificam a existência de substrings, + concatena strings e * repete uma string.

Abra o arquivo string_operators.py no WebIDE e adicione o seguinte código:

## string_operators.py

## O operador 'in' verifica se uma substring existe dentro de uma string
print('e' in 'Hello')
print('x' in 'Hello')

## O operador 'not in' é o oposto de 'in'
print('e' not in 'Hello')
print('x' not in 'Hello')

## Concatenação (+) une duas strings
print('Hello' + ' ' + 'World')

## Repetição (*) repete uma string um número determinado de vezes
print('=' * 20)
print('Go! ' * 3)

Salve o arquivo e execute-o:

python ~/project/string_operators.py
True
False
False
True
Hello World
====================
Go! Go! Go!

Em seguida, vamos ver os caracteres de escape. Estas são sequências especiais que começam com uma barra invertida (\) e representam caracteres não imprimíveis ou especiais.

Abra o arquivo escape_characters.py e adicione o seguinte código:

## escape_characters.py

## Use \' ou \" para incluir aspas dentro de uma string
print('It\'s a beautiful day.')
print("He said, \"Python is fun!\"")

## \n cria uma nova linha
print("First line\nSecond line")

## \t cria uma tabulação horizontal
print("Column1\tColumn2\tColumn3")

## \\ representa uma barra invertida literal
print("This is a backslash: \\")

## Uma string bruta (*raw string*), prefixada com 'r', trata barras invertidas como caracteres literais.
## Isso é muito útil para caminhos de arquivo e expressões regulares.
print("A normal string: C:\\Users\\new_folder")
print(r"A raw string: C:\Users\new_folder")

Salve o arquivo e execute-o:

python ~/project/escape_characters.py
It's a beautiful day.
He said, "Python is fun!"
First line
Second line
Column1 Column2 Column3
This is a backslash: \
A normal string: C:\Users\new_folder
A raw string: C:\Users\new_folder

Formatação de Strings

Nesta etapa, você aprenderá maneiras modernas e eficazes de formatar strings em Python. Isso é crucial para criar saídas dinâmicas e legíveis, incorporando variáveis e expressões dentro das strings.

Embora você possa usar o operador + para concatenar strings, isso se torna desajeitado ao misturar strings com tipos que não são strings, como números, pois você deve convertê-los manualmente usando str().

Python oferece soluções melhores. O método mais comum e recomendado é usar f-strings (formatted string literals).

Formatação com f-string

As f-strings, introduzidas no Python 3.6, fornecem uma maneira concisa e legível de incorporar expressões dentro das strings. Basta prefixar a string com f ou F e escrever as expressões dentro de chaves {}.

Abra o arquivo string_formatting.py e adicione o seguinte código:

## string_formatting.py

name = "Alice"
age = 30

## Usando uma f-string para incorporar variáveis
greeting = f"Hello, my name is {name} and I am {age} years old."
print(greeting)

## Você também pode incorporar expressões diretamente
print(f"In 5 years, I will be {age + 5} years old.")

Salve e execute o script:

python ~/project/string_formatting.py
Hello, my name is Alice and I am 30 years old.
In 5 years, I will be 35 years old.

Especificadores de Formato (Format Specifiers)

As f-strings também permitem controlar a formatação dos valores incorporados usando especificadores de formato, que seguem dois pontos (:) dentro das chaves.

Adicione os seguintes exemplos a string_formatting.py:

## string_formatting.py

## ... (código anterior) ...

pi = 3.14159265

## Formatar um float para 2 casas decimais
print(f"The value of pi is approximately {pi:.2f}")

## Preencher um número com zeros à esquerda até uma largura de 8
order_id = 45
print(f"Order ID: {order_id:08}")

## Alinhar texto dentro de um espaço definido (largura de 10)
## < (esquerda), ^ (centro), > (direita)
text = "Python"
print(f"'{text:<10}'")
print(f"'{text:^10}'")
print(f"'{text:>10}'")

## Adicionar vírgula como separador de milhar
large_number = 1234567890
print(f"A large number: {large_number:,}")

Salve e execute o script novamente:

python ~/project/string_formatting.py
Hello, my name is Alice and I am 30 years old.
In 5 years, I will be 35 years old.
The value of pi is approximately 3.14
Order ID: 00000045
'Python    '
'  Python  '
'    Python'
A large number: 1,234,567,890

O Método str.format()

Antes das f-strings, o método str.format() era a maneira preferida de formatar strings. Ele funciona colocando chaves de espaço reservado {} na string e, em seguida, passando valores para o método format().

Adicione este exemplo ao final de string_formatting.py:

## string_formatting.py

## ... (código anterior) ...

## Usando o método str.format()
item = "moon"
cost = 99.95
statement = "The {} costs {:.2f} dollars.".format(item, cost)
print(statement)

Salve e execute o arquivo para ver a saída:

python ~/project/string_formatting.py
Hello, my name is Alice and I am 30 years old.
In 5 years, I will be 35 years old.
The value of pi is approximately 3.14
Order ID: 00000045
'Python    '
'  Python  '
'    Python'
A large number: 1,234,567,890
The moon costs 99.95 dollars.

Embora o str.format() ainda seja útil, as f-strings são geralmente mais legíveis e rápidas.

Explorar Métodos Comuns de String

Nesta etapa final, você explorará alguns dos métodos built-in (integrados) mais comuns e úteis para objetos string. Esses métodos executam várias operações, como alteração de caixa, localização e substituição de texto e divisão de strings em listas.

Lembre-se de que as strings são imutáveis, portanto, esses métodos sempre retornam uma nova string e não modificam a original.

Abra o arquivo string_methods.py e adicione o seguinte código para ver esses métodos em ação:

## string_methods.py

## Métodos de conversão de caixa
s1 = "Hello, World!"
print(f"Original: '{s1}'")
print(f"Upper case: '{s1.upper()}'")
print(f"Lower case: '{s1.lower()}'")
print(f"Title case: '{s1.title()}'")
print("-" * 20)

## Busca e substituição
s2 = "The quick brown fox jumps over the lazy dog."
print(f"Original: '{s2}'")
## Verifica se uma string começa ou termina com uma substring
print(f"Starts with 'The': {s2.startswith('The')}")
print(f"Ends with 'dog.': {s2.endswith('dog.')}")
## Encontra o índice de uma substring (-1 se não for encontrada)
print(f"Index of 'fox': {s2.find('fox')}")
## Substitui uma substring por outra
s3 = s2.replace("brown", "red")
print(f"After replace: '{s3}'")
print("-" * 20)

## Remoção de espaços em branco (*Stripping whitespace*)
s4 = "    some whitespace    "
print(f"Original: '{s4}'")
## strip() remove de ambas as extremidades, lstrip() da esquerda, rstrip() da direita
print(f"Stripped: '{s4.strip()}'")
print("-" * 20)

## Divisão (*Splitting*) e Junção (*Joining*)
s5 = "one,two,three,four"
print(f"Original: '{s5}'")
## Divide a string em uma lista de substrings com base em um delimitador
parts = s5.split(',')
print(f"Split list: {parts}")
## Junta os elementos de uma lista em uma única string com um separador
s6 = " ".join(parts)
print(f"Joined string: '{s6}'")

Salve o arquivo e execute-o no terminal:

python ~/project/string_methods.py

Sua saída deve ser parecida com esta:

Original: 'Hello, World!'
Upper case: 'HELLO, WORLD!'
Lower case: 'hello, world!'
Title case: 'Hello, World!'
--------------------
Original: 'The quick brown fox jumps over the lazy dog.'
Starts with 'The': True
Ends with 'dog.': True
Index of 'fox': 16
After replace: 'The quick red fox jumps over the lazy dog.'
--------------------
Original: '    some whitespace    '
Stripped: 'some whitespace'
--------------------
Original: 'one,two,three,four'
Split list: ['one', 'two', 'three', 'four']
Joined string: 'one two three four'

Estes são apenas alguns dos muitos métodos de string disponíveis em Python. Eles fornecem ferramentas poderosas para processar e manipular dados de texto.

Resumo

Neste laboratório, você aprendeu os conceitos fundamentais de como trabalhar com strings em Python. Você começou com o básico, entendendo como criar strings e reconhecendo sua natureza imutável. Você praticou o acesso a caracteres individuais usando indexação positiva e negativa e a extração de substrings usando slicing com os parâmetros de início (start), fim (end) e passo (step).

Em seguida, você explorou os operadores de string para concatenação (+) e repetição (*) e aprendeu a usar caracteres de escape para incluir caracteres especiais em suas strings. Você dominou as técnicas modernas de formatação de strings, focando no poder e na legibilidade das f-strings e seus especificadores de formato (format specifiers), ao mesmo tempo em que viu o método str.format(). Por fim, você praticou o uso de métodos comuns de string, como upper(), lower(), replace(), strip(), split() e join(), para realizar tarefas essenciais de manipulação de texto.