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.
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.
