Capítulo 6: Manipulação de Strings

Capítulo 6: Manipulação de Strings#

Capítulo 6: Strings

Introdução às Strings#

As strings são um dos tipos de dados mais comuns e versáteis na programação. Este capítulo revisará conceitos introdutórios e expandirá o uso de strings em Python, ajudando você a dominá-las para aplicações práticas no desenvolvimento.

Para mais detalhes técnicos sobre strings em Python, você pode consultar a PEP 498 - Literal String Interpolation, que introduz f-strings, uma das formas mais eficientes de formatar strings.

O que são strings?#

Strings são sequências de caracteres usadas para representar texto em programação. Em Python, elas podem conter letras, números, símbolos e espaços. Strings são delimitadas por aspas (simples ou duplas) e podem ter qualquer comprimento, desde uma única letra até textos extensos.

Exemplo de string:

"Olá, Mundo!"

Criando strings#

Existem diversas maneiras de criar strings em Python:

Aspas simples ou duplas: Coloque o texto entre aspas simples (') ou duplas ("). Ambas são equivalentes.
```
string1 = 'Olá, Mundo!'
string2 = "Python é incrível!"
```
Aspas triplas para strings multilinhas: Use três aspas simples (''') ou duplas (""") para criar strings que ocupam várias linhas.
```
mensagem = """Este é um exemplo de string
que ocupa várias linhas. É bastante útil."""
```

Imprimindo strings#

Use a função print() para exibir strings no console:

saudacao = "Olá, Mundo!"
print(saudacao)

Saída do Código:

Olá, Mundo!

Aspas simples vs. duplas#

A escolha entre aspas simples e duplas depende de como você deseja lidar com aspas dentro da string:

Aspas simples: Permitem incluir aspas duplas no texto sem necessidade de escape.

frase1 = 'Ele disse: "Python é incrível!"'
print(frase1)

Saída do Código:

Ele disse: "Python é incrível!"

Aspas duplas: Permitem incluir aspas simples no texto sem necessidade de escape.

frase2 = "Ele disse: 'Python é incrível!'"
print(frase2)

Saída do Código:

Ele disse: 'Python é incrível!'

Indexação e Fatiamento de Strings#

Strings em Python podem ser tratadas como sequências de caracteres, e cada caractere na string tem um índice numérico associado. A indexação e o fatiamento de strings permitem acessar e manipular caracteres individuais ou substrings dentro de uma string.

Acessando caracteres individuais em uma string#

Cada caractere em uma string tem um índice numérico, começando do zero. Você pode acessar um caractere específico em uma string usando colchetes [] e fornecendo o índice do caractere desejado.

Exemplo:

string = "Python"
primeiro_caractere = string[0]
ultimo_caractere = string[5]
print(primeiro_caractere)
print(ultimo_caractere)

Saída do Código:

P
n

Fatiamento de strings#

O fatiamento de strings permite extrair uma substring de uma string maior. Você pode especificar um intervalo de índices para obter uma substring. A sintaxe para fatiamento é [início:fim], onde início é o índice do primeiro caractere da substring e fim é o índice do caractere após o último caractere desejado.

Exemplo:

string = "Python é incrível!"
substring = string[9:17]
print(substring)

Saída do Código:

incrível

Exemplo:

string = "Aprender Python"
substring = string[0:8]
print(substring)

Saída do Código:

Aprender

Indexação negativa#

Python também permite o uso de índices negativos para acessar caracteres a partir do final da string. O índice -1 refere-se ao último caractere, -2 ao penúltimo, e assim por diante.

Exemplo:

string = "Python"
ultimo_caractere = string[-1]
penultimo_caractere = string[-2]
print(ultimo_caractere)
print(penultimo_caractere)

Saída do Código:

n
o

Exemplo:

string = "Indexação negativa"
substring = string[-8:]
print(substring)

Saída do Código:

negativa

Formatação de Strings#

A formatação de strings é uma tarefa comum na programação, especialmente ao exibir informações para os usuários. Com as versões mais recentes do Python, há ferramentas modernas e eficientes que oferecem flexibilidade e legibilidade na formatação de texto. As duas abordagens mais usadas atualmente são as f-strings e o método str.format().

Usando f-strings#

As f-strings (ou strings formatadas) foram introduzidas no Python 3.6 e são uma maneira prática e eficiente de formatar strings. Elas permitem inserir variáveis, expressões ou até mesmo chamadas de funções diretamente dentro da string, com uma sintaxe clara e legível. Para usar uma f-string, basta prefixar a string com a letra f ou F e incluir as expressões dentro de chaves {}.

Exemplo básico:

saudação = "Olá"
nome = "Alana"
resultado = f"{saudação}, {nome}!"
print(resultado)

Saída do Código:

Olá, Alana!

Exemplo com expressões:

a = 5
b = 3
resultado = f"O resultado de {a} + {b} é {a + b}."
print(resultado)

Saída do Código:

O resultado de 5 + 3 é 8.

Exemplo com chamadas de funções:

nome = "Carlos"
resultado = f"O nome em maiúsculas é {nome.upper()}."
print(resultado)

Saída do Código:

O nome em maiúsculas é CARLOS.

As f-strings também permitem especificar formatações avançadas, como precisão de números decimais, alinhamento de texto e preenchimento de espaços.

Exemplo com formatação:

valor = 123.45678
print(f"O valor formatado é {valor:.2f}.")

Saída do Código:

O valor formatado é 123.46.

Trabalhando com expressões#

preco = 99.90
desconto = 0.1
mensagem = f"O preço com desconto é {preco * (1 - desconto):.2f}."
print(mensagem)

Saída do Código:

O preço com desconto é 89.91.

Formatação com :.2f

O formato :.2f em f-strings é usado para formatar números diretamente dentro das chaves {}. Ele funciona assim:

: Inicia a formatação.
.2 Limita o número a duas casas decimais.
f Especifica que o número é um ponto flutuante (float).

Chamadas de funções#

texto = "python"
mensagem = f"O texto em maiúsculas é {texto.upper()}."
print(mensagem)

Saída do Código:

O texto em maiúsculas é PYTHON.

Alinhamento e largura#

nome = "João"
idade = 28
mensagem = f"|{nome:<10}|{idade:^6}|{idade:>5}|"
print(mensagem)

Saída do Código:

|João      |  28  |   28|

<: Alinha à esquerda.
^: Centraliza.
>: Alinha à direita.

Formatando números em diferentes estilos#

valor = 123456789.987654321
mensagem = (
    f"O valor formatado é {valor:,.2f}.\n"
    f"O valor em notação científica é {valor:.2e}.\n"
    f"O número alinhado à direita com zeros é {int(valor):08d}."
)
print(mensagem)

Saída do Código:

O valor formatado é 123,456,789.99.
O valor em notação científica é 1.23e+08.
O número alinhado à direita com zeros é 123456789.

Aqui, combinamos a formatação com separador de milhar, notação científica e preenchimento com zeros para destacar diferentes estilos de exibição.

Método `str.format()`#

Embora menos usado atualmente, o método str.format() ainda é útil em situações específicas. Ele permite inserir valores em uma string usando chaves {} como marcadores, substituídos pelos argumentos passados ao método.

Exemplo básico:

nome = "Carlos"
idade = 25
mensagem = "Meu nome é {} e tenho {} anos.".format(nome, idade)
print(mensagem)

Saída:

Meu nome é Carlos e tenho 25 anos.

Referência posicional ou nomeada:

mensagem = "Meu nome é {0} e tenho {1} anos. Meu nome de novo: {0}.".format("Carlos", 25)
print(mensagem)

Saída:

Meu nome é Carlos e tenho 25 anos. Meu nome de novo: Carlos.

Especificação de formatos:

preco = 1234.56789
mensagem = "O valor formatado é {:,.2f}.".format(preco)
print(mensagem)

Saída:

O valor formatado é 1,234.57.

Comparação: F-strings vs `str.format()`#

Característica	F-strings	`str.format()`
Simplicidade	Mais legível e intuitiva	Moderadamente legível
Suporte a expressões	Sim	Sim
Chamadas de funções	Sim	Sim
Adotada amplamente	Sim	Moderado (menos usado hoje)

Recomendação

Sempre que possível, utilize f-strings para maior legibilidade e eficiência. Elas são mais diretas, suportam formatações avançadas e reduzem a necessidade de escrever código desnecessário. O método str.format() pode ser usado em contextos que ainda exigem compatibilidade com versões mais antigas do Python.

Operações com Strings#

As strings oferecem uma ampla gama de operações que podem ser realizadas para manipulação e análise de texto. Nesta seção, exploraremos algumas operações comuns com strings: concatenação, repetição e comparação.

Concatenando strings#

A concatenação de strings é o processo de unir duas ou mais strings em uma única string. Isso pode ser feito de várias maneiras:

Usando o operador +: O operador + é utilizado para concatenar duas ou mais strings.

string1 = "Olá,"
string2 = "Pessoal!"
resultado = string1 + " " + string2
print(resultado)

Saída do Código:

Olá, Pessoal!

Usando o método join(): O método join() pode ser utilizado para concatenar uma lista de strings com um delimitador específico.

palavras = ["Olá", "Pessoal"]
resultado = " ".join(palavras) # Delimitador de espaço nesse caso
print(resultado)

Saída do Código:

Olá, Pessoal

Repetindo strings#

Repetir strings é um processo simples que pode ser realizado usando o operador *. Este operador multiplica a string pelo número de vezes especificado.

Exemplo:

string = "Oi! "
repetida = string * 3
print(repetida)

Saída do Código:

Oi! Oi! Oi!

Comparando strings#

Comparar strings é uma operação comum e pode ser realizada usando operadores de comparação. Python compara strings lexicograficamente, ou seja, com base na ordem alfabética e na posição dos caracteres.

Igualdade (==) e desigualdade (!=):

string1 = "Python"
string2 = "python"
print(string1 == string2)  # False, diferencia maiúsculas e minúsculas
print(string1 != string2)  # True, diferencia maiúsculas e minúsculas

Saída do Código:

False
True

Comparações lexicográficas (<, >, <=, >=):

string1 = "Abacate"
string2 = "Banana"
print(string1 < string2)  # True, "Abacate" vem antes de "Banana"
print(string1 > string2)  # False, "Abacate" vem antes de "Banana"

Saída do Código:

True
False

Para realizar comparações insensíveis a caso, você pode converter as strings para o mesmo caso (todas minúsculas ou todas maiúsculas) antes da comparação.

Exemplo de comparação insensível a caso:

string1 = "Python"
string2 = "python"
print(string1.lower() == string2.lower())  # True, ignora maiúsculas e minúsculas

Saída do Código:

True

Métodos de String#

Strings em Python possuem vários métodos internos que permitem realizar diversas operações de manipulação de texto. Aqui estão alguns dos métodos de string mais comumente usados, com exemplos de código e a saída esperada:

Método	Descrição	Exemplo	Saída
`upper()`	Converte a string em letras maiúsculas.	`texto = "Olá, Mundo!"; texto_maiusculo = texto.upper();`	OLÁ, MUNDO!
`lower()`	Converte a string em letras minúsculas.	`texto = "OLÁ, MUNDO!"; texto_minusculo = texto.lower();`	olá, mundo!
`capitalize()`	Converte a primeira letra da string em maiúscula e as demais em minúsculas.	`texto = "olá, mundo!"; texto_capitalizado = texto.capitalize();`	Olá, mundo!
`strip()`	Remove espaços em branco (incluindo tabulações, quebras de linha, etc.) do início e do final da string.	`texto = " Olá, Mundo! "; texto_sem_espacos = texto.strip();`	Olá, Mundo!
		`texto = '"Olá, Mundo!"'; texto_sem_aspas = texto.strip('"');`	Olá, Mundo!
`lstrip()`	Remove espaços em branco apenas do início da string.	`texto = " Olá, Mundo!"; texto_sem_espacos_esquerda = texto.lstrip();`	Olá, Mundo!
`rstrip()`	Remove espaços em branco apenas do final da string.	`texto = "Olá, Mundo! "; texto_sem_espacos_direita = texto.rstrip();`	Olá, Mundo!
`split()`	Divide a string em uma lista de substrings, separando-a por um delimitador especificado.	`texto = "Olá, Mundo!"; palavras = texto.split(", ");`	[‘Olá’, ‘Mundo’]
`join()`	Junta os elementos de uma lista em uma única string, usando um delimitador especificado.	`palavras = ["Olá", "Mundo"]; frase = " ".join(palavras);`	Olá Mundo
`replace()`	Substitui todas as ocorrências de um substring específico por outro substring.	`texto = "Eu gosto de maçãs"; texto_substituido = texto.replace("maçãs", "laranjas");`	Eu gosto de laranjas
`format()`	Formata a string inserindo valores nas posições especificadas por chaves {}.	`nome = "Alberto"; idade = 25; frase = "Meu nome é {} e tenho {} anos".format(nome, idade);`	Meu nome é Alberto e tenho 25 anos

Verificação e Conversão de Tipos#

A verificação e conversão de tipos são tarefas importantes ao lidar com strings que representam números. A seguir, exploraremos os principais métodos para verificar se uma string contém apenas números e como realizar conversões entre strings e tipos numéricos.

Verificação de números em strings#

Python oferece métodos nativos para verificar se uma string representa números em diferentes contextos. Aqui estão os principais:

Método	Descrição	Exemplo	Saída
`isdigit()`	Retorna `True` se todos os caracteres na string forem dígitos decimais (0–9).	`"123".isdigit()` `"12.3".isdigit()`	`True` `False`
`isdecimal()`	Retorna `True` se todos os caracteres forem dígitos decimais, incluindo números em outros sistemas.	`"123".isdecimal()` `"١٢٣".isdecimal()` `"12.3".isdecimal()`	`True` `True` `False`
`isnumeric()`	Retorna `True` se a string contém números (dígitos, fracionários, romanos, etc.).	`"123".isnumeric()` `"½".isnumeric()` `"Ⅳ".isnumeric()` `"12.3".isnumeric()`	`True` `True` `True` `False`

Notas importantes:

isdigit(): Funciona apenas para números inteiros positivos.
isdecimal(): Reconhece dígitos decimais de diferentes idiomas (e.g., números árabes).
isnumeric(): É o mais abrangente, reconhecendo frações, números romanos e caracteres numéricos especiais.

Convertendo strings para números#

A conversão de strings para números pode ser feita usando as funções int() e float(). Se a string contiver caracteres inválidos (como letras), será gerado um erro.

Exemplos:

idade_str = "25"
idade_int = int(idade_str)
print(idade_int)  

preco_str = "49.99"
preco_float = float(preco_str)
print(preco_float) 

Saída do Código::

25
49.99

Tratando entradas inválidas#

É uma boa prática verificar a validade da string antes da conversão para evitar erros.

Exemplo:

entrada = "12.34"
if entrada.replace(".", "").isdigit():
    numero = float(entrada)
    print(numero)
else:
    print("Entrada inválida!")

Saída do Código::

12.34

Convertendo números para strings#

Para exibir números como texto, você pode usar as funções str() ou f-strings para obter maior controle sobre a formatação.

Exemplos:

numero = 42
numero_str = str(numero)
print(f"O número como string é: {numero_str}")  # Usando f-string

valor = 3.14159
valor_formatado = f"{valor:.2f}"  # Formata com 2 casas decimais
print(f"Valor formatado: {valor_formatado}")

Saída do Código::

O número como string é: 42
Valor formatado: 3.14

Conversão com formatação avançada Você pode personalizar ainda mais a conversão de números para strings.

Exemplo com separador de milhar:

numero_grande = 123456789
numero_str = f"{numero_grande:,}"  # Usa ',' como separador
print(f"Valor formatado: {numero_str}")

Saída do Código:

Valor formatado: 123,456,789

Importante:

Use os métodos isdigit(), isdecimal() ou isnumeric() para validar strings antes de convertê-las.
Utilize int() e float() para conversões numéricas, garantindo que a string seja válida.
Prefira f-strings para conversões e formatações avançadas, pois são mais modernas e legíveis.

Funções Úteis para Strings#

Python oferece várias funções integradas úteis para manipulação de strings. Estas funções permitem obter informações, verificar conteúdo ou realizar operações específicas. Aqui estão algumas das mais usadas:

Função	Descrição	Exemplo	Saída (print)
`len()`	Retorna o comprimento (número de caracteres) da string.	`texto = "Olá, Mundo!"; comprimento = len(texto)`	`11`
`in` e `not in`	Verifica se um substring está contido ou não na string.	`"Mundo" in "Olá, Mundo!"` `"Mundo" not in "Olá, Universo!"`	`True` `True`
`count()`	Retorna o número de ocorrências de um substring na string.	`texto = "Olá, Mundo, Mundo!"; contagens = texto.count("Mundo")`	`2`
`find()`	Retorna o índice da primeira ocorrência de um substring na string, ou `-1` se não encontrado.	`texto = "Olá, Mundo!"; posicao = texto.find("Mundo")` `texto.find("Planeta")`	`5` `-1`
`index()`	Retorna o índice da primeira ocorrência de um substring na string. Levanta um erro se não encontrado.	`texto = "Olá, Mundo!"; posicao = texto.index("Mundo")`	`5`
		`outro_texto = "Olá, Universo!"; posicao = outro_texto.index("Mundo")`	`ValueError`

Expressões Regulares#

Expressões regulares (regex) são padrões utilizados para buscar e manipular texto de maneira eficiente. Em Python, o módulo re oferece funcionalidades para trabalhar com expressões regulares.

Tabela de Caracteres Especiais em Expressões Regulares#

Caractere	Descrição	Exemplo de Padrão	Resultado do Exemplo
`.`	Qualquer caractere (exceto nova linha)	`".asa"`	Corresponde a “casa”, “vasa”, “basa”, etc.
`*`	Zero ou mais ocorrências do caractere anterior	`"ab*c"`	Corresponde a “ac”, “abc”, “abbbc”, etc.
`+`	Uma ou mais ocorrências do caractere anterior	`"ab+c"`	Corresponde a “abc”, “abbc”, “abbbc”, etc.
`?`	Zero ou uma ocorrência do caractere anterior	`"favor?"`	Corresponde a “favo” ou “favor”.
`^`	Início da linha	`"^olá"`	Corresponde a “olá” somente no início da linha.
`$`	Fim da linha	`"mundo$"`	Corresponde a “mundo” somente no final da linha.
`\A`	Início da string	`\A"olá"`	Corresponde a “olá” apenas no início da string.
`\Z`	Fim da string	`"mundo\Z"`	Corresponde a “mundo” apenas no final da string.
`[]`	Conjunto de caracteres	`"[aeiou]la"`	Corresponde a “ala”, “ela”, “ila”, etc.
`[^]`	Conjunto de caracteres proibidos	`"[^aeiou]la"`	Corresponde a “bla”, “cla”, “fla”, etc.
`\d`	Qualquer dígito decimal	`\d{3}`	Corresponde a três dígitos consecutivos como “123”.
`\w`	Caractere alfanumérico (letras, dígitos e `_`)	`\w+`	Corresponde a “texto”, “123”, “_abc”, etc.
`\s`	Qualquer caractere de espaço (inclui tabulação)	`\s+`	Corresponde a espaços, tabulações, etc.
`\S`	Qualquer caractere que não seja espaço	`\S+`	Corresponde a “texto”, “123”, mas não espaços.
`\b`	Limite de palavra	`\bgato\b`	Corresponde a “gato” como palavra inteira.
`\|`	Alternativa entre padrões	`"gato\|cão"`	Corresponde a “gato” ou “cão”.
`{}`	Número de ocorrências do caractere anterior	`"a{2}"`	Corresponde a “aa”.
`()`	Grupo de captura	`(\d{2})-(\d{4})`	Captura grupos como “12-3456”.

Nota: Os caracteres *, +, e ? podem ser combinados com {} para definir a quantidade de repetições com mais precisão.

Tabela de Funções do Módulo `re`#

Função	Descrição	Exemplo	Resultado
`re.search(pattern, string)`	Encontra o padrão em qualquer parte da string	`re.search(r'gato', 'O gato está aqui')`	Match object para “gato”.
`re.match(pattern, string)`	Encontra o padrão no início da string	`re.match(r'gato', 'gato está aqui')`	Match object para “gato”.
`re.findall(pattern, string)`	Retorna todas as ocorrências do padrão	`re.findall(r'\d+', 'Há 3 gatos e 5 cães')`	`['3', '5']`.
`re.sub(pattern, repl, string)`	Substitui o padrão encontrado	`re.sub(r'[aeiou]', '*', 'olá mundo')`	`'l mnd'`.
`re.split(pattern, string)`	Divide a string pelo padrão	`re.split(r'\s+', 'dividir esta frase')`	`['dividir', 'esta', 'frase']`.
`re.compile(pattern)`	Compila um padrão para uso eficiente	`padrao = re.compile(r'\d+')` `padrao.findall('Há 4 gatos')`	`['4']`.

Explicação detalhada:

re.search: Procura o padrão em qualquer parte da string.
re.match: Limita a busca para o início da string.
re.findall: Retorna uma lista com todas as correspondências.
re.sub: Substitui o padrão por outro texto.
re.split: Divide o texto onde o padrão ocorre.
re.compile: Pré-compila o padrão para repetição eficiente.

Exemplos Práticos#

Sobre o uso de r antes do padrão de expressão regular

O prefixo r em strings de expressões regulares em Python cria uma “string bruta” (raw string). Isso impede que o Python interprete caracteres de escape como \n ou \t de forma especial. É particularmente útil em regex, onde \ é frequentemente usado para indicar caracteres especiais.

Com r, \ é tratado literalmente, simplificando a escrita de padrões complexos. Por exemplo, r"\d+" é interpretado como \d+, enquanto "\d+" seria d+. Isso melhora a legibilidade e evita escapes duplos, sendo recomendado sempre que o padrão contiver \.

Exemplo: Encontrando uma palavra específica em um texto e sua posição

import re

texto = "O rápido cão pulou sobre o coelho lento."
padrao = r"\brápido\b"
correspondencia = re.search(padrao, texto)
if correspondencia:
    print(f"Palavra encontrada: {correspondencia.group()}")
    print(f"Posição inicial: {correspondencia.start()}")
    print(f"Posição final: {correspondencia.end()}")
else:
    print("Palavra não encontrada.")

Saída do Código:

Palavra encontrada: rápido
Posição inicial: 2
Posição final: 8

Explicação da expressão regular:

\b: Limite de palavra, garante que estamos correspondendo à palavra inteira “rápido”.
“rápido”: A palavra que estamos procurando no texto.

Exemplo: Encontrando um número de telefone em um texto

import re

texto = "Por favor, ligue para 123-456-7890 para mais informações."
padrao = r"\d{3}-\d{3}-\d{4}"
correspondencia = re.search(padrao, texto)
if correspondencia:
    numero = correspondencia.group()
    print(numero)
else:
    print("Número de telefone não encontrado.")

Saída do Código:

123-456-7890

Explicação da expressão regular:

\d{3}: Corresponde a exatamente três dígitos.
-: Corresponde ao caractere de hífen.
\d{3}: Novamente, corresponde a exatamente três dígitos.
-: Mais uma vez, corresponde ao caractere de hífen.
\d{4}: Corresponde aos últimos quatro dígitos do número de telefone.

re.match():

Exemplo: Verificando se uma string começa com um prefixo específico

import re

def inicia_com_prefixo(texto, prefixo):
    padrao = fr"^{prefixo}"
    return bool(re.match(padrao, texto))

if inicia_com_prefixo("https://www.example.com", "http"):
    print("A string começa com 'http'.")
else:
    print("A string não começa com 'http'.")

Saída do Código:

A string começa com 'http'.

Explicação da expressão regular:

^: Início de linha, garante que estamos correspondendo ao início da string.
http: O prefixo que estamos procurando no início da string.

Exemplo: Validando um endereço de e-mail

import re

def valida_email(email):
    padrao = r"^\S+@\S+\.\S+$"
    return bool(re.match(padrao, email))

email_valido = "exemplo@email.com"
email_invalido = "exemplo email.com"

if valida_email(email_valido):
    print(f"{email_valido} é um endereço de e-mail válido.")
else:
    print(f"{email_valido} não é um endereço de e-mail válido.")

if not valida_email(email_invalido):
    print(f"{email_invalido} não é um endereço de e-mail válido.")
else:
    print(f"{email_invalido} é um endereço de e-mail válido.")

Saída do Código:

exemplo@email.com é um endereço de e-mail válido.
exemplo email.com não é um endereço de e-mail válido.

Explicação da expressão regular:

^: Início de linha.
\S+: Corresponde a uma ou mais ocorrências de caracteres não-espaço.
@: Corresponde ao símbolo @.
\S+: Mais uma vez, corresponde a uma ou mais ocorrências de caracteres não-espaço.
\.: Corresponde ao caractere ponto.
\S+: Novamente, corresponde a uma ou mais ocorrências de caracteres não-espaço.
$: Indica o fim de string.

re.findall():

Exemplo: Extraindo todas as ocorrências de uma palavra específica em um texto

import re

texto = "Eu gosto de maçãs, bananas e laranjas. Maçãs são minhas favoritas."
padrao = r"\bmaçã\b"
ocorrencias = re.findall(padrao, texto)
print(ocorrencias)

Saída do Código:

['maçãs', 'maçãs']

Explicação da expressão regular:

\b: Limite de palavra, garante que estamos correspondendo à palavra inteira “maçã”.
“maçã”: A palavra que estamos procurando no texto.

Exemplo: Extraindo datas em um formato específico

import re

texto = "As datas do evento são 2023-05-10, 2023-06-20 e 2023-07-15."
padrao = r"\b\d{4}-\d{2}-\d{2}\b"
datas = re.findall(padrao, texto)
print(datas)

Saída do Código:

['2023-05-10', '2023-06-20', '2023-07-15']

Explicação da expressão regular:

\b: Limite de palavra.
\d{4}: Corresponde a exatamente quatro dígitos (ano).
-: Corresponde ao caractere hífen.
\d{2}: Corresponde a exatamente dois dígitos (mês).
-: Mais uma vez, corresponde ao caractere hífen.
\d{2}: Corresponde a exatamente dois dígitos (dia).
\b: Limite de palavra.

re.sub():

Exemplo: Substituindo todas as ocorrências de uma palavra por outra

import re

texto = "Eu gosto de cachorros, gatos e cachorros."
padrao = r"\bcachorros\b"
substituicao = "gatos"
texto_modificado = re.sub(padrao, substituicao, texto)
print(texto_modificado)

Saída do Código:

Eu gosto de gatos, gatos e gatos.

Explicação da expressão regular:

\b: Limite de palavra, garante que estamos correspondendo à palavra inteira “cachorros”.
“cachorros”: A palavra que estamos procurando para substituir.

Exemplo: Removendo caracteres não alfanuméricos de uma string

import re

texto = "Este texto contém # caracteres $ especiais."
padrao = r"[^a-zA-Z0-9 ]+"
texto_limpo = re.sub(padrao, "", texto)
print(texto_limpo)

Saída do Código:

Este texto contém caracteres especiais

Explicação da expressão regular:

[^a-zA-Z0-9 ]+: Corresponde a uma ou mais ocorrências de caracteres que não são letras (maiúsculas ou minúsculas), dígitos ou espaços.

Exemplo web: Vamos buscar uma palavra padrão em um site.

import requests
import re

# URL do website
url = "https://heltonmaia.com/pythonbook/chapters/ch6/ch6.html"

# Faz a requisição GET para o website
response = requests.get(url)

# Obtém o conteúdo HTML da página
conteudo = response.text

# Procura a palavra "variáveis" no conteúdo
matches = re.findall(r'\bvariáveis\b', conteudo, re.IGNORECASE)

# Imprime o resultado
print(f"A palavra 'variáveis' foi encontrada {len(matches)} vezes no site.")

Explicação rápida:

Importamos as bibliotecas requests para fazer requisições web e re para usar expressões regulares.
Definimos a URL do site que queremos analisar.
Fazemos uma requisição GET para o site e obtemos o conteúdo HTML.
Usamos re.findall() para procurar todas as ocorrências da palavra “variáveis” no conteúdo.
- O padrão r'\bvariáveis\b' busca a palavra inteira “Python”.
- re.IGNORECASE torna a busca insensível a maiúsculas/minúsculas.
Imprimimos o número de vezes que a palavra “Python” foi encontrada.

Saída do Código:

A palavra 'variáveis' foi encontrada 3 vezes no site.

As expressões regulares são uma ferramenta poderosa para manipulação de texto e podem ser aplicadas em diversas tarefas, incluindo busca, extração e transformação de padrões específicos. Para explorar ainda mais as possibilidades, consulte a documentação oficial sobre expressões regulares em Python: Expressões Regulares (re).

Exercícios#

Uma observação antes de começar os exercícios.

Alguns exercícios, dependendo do ambiente onde são resolvidos, podem exigir o tratamento de strings que contenham aspas duplas no início ou no final. Por exemplo, isso pode acontecer ao lidar com dados exportados de arquivos ou APIs. Nesse caso, o método .strip() pode ser usado não apenas para remover espaços em branco, mas também para eliminar as aspas duplas indesejadas.

Exemplos:

Removendo apenas as aspas duplas

# String com aspas duplas no início e no final
texto = '"Olá, Mundo!"'

# Removendo apenas as aspas duplas
texto_sem_aspas = texto.strip('"')

print(texto_sem_aspas)

Saída do Código:

Olá, Mundo!

Removendo apenas os espaços em branco

# String com espaços em branco no início e no final
texto = "   Olá, Mundo!   "

# Removendo apenas os espaços
texto_sem_espacos = texto.strip()

print(texto_sem_espacos)

Saída do Código:

Olá, Mundo!

Strings em Python possuem vários métodos internos que permitem realizar diversas operações de manipulação de texto. Entre os mais usados estão upper(), lower(), capitalize(), split(), join(), e replace(). Cada um deles oferece funcionalidades úteis para transformar ou manipular o conteúdo das strings. Você pode combinar esses métodos para atender às necessidades específicas de seu código.

1. Manipulação Básica de Strings

Desenvolva uma função chamada manipular_string que aceita uma string como entrada e executa as seguintes operações:

Extrai o primeiro caractere da string.
Obtém o último caractere da string.
Seleciona os três primeiros caracteres da string.
Captura os três últimos caracteres da string.
Inverte a ordem dos caracteres na string.
Remove apenas as vogais minúsculas (a, e, i, o, u) da string, mantendo as vogais maiúsculas e todos os outros caracteres.

A função deve compilar os resultados dessas operações em uma lista e retorná-la.

Exemplo de uso:

resultado = manipular_string("Python")
print(resultado)

Saída esperada:

['P', 'n', 'Pyt', 'hon', 'nohtyP', 'Pythn']

Testes a serem realizados:

# Teste 1
Entrada: "Hello"
Saída: ['H', 'o', 'Hel', 'llo', 'olleH', 'Hll']

# Teste 2
Entrada: "A"
Saída: ['A', 'A', 'A', 'A', 'A', 'A']

# Teste 3
Entrada: "Manipulando Strings"
Saída: ['M', 's', 'Man', 'ngs', 'sgnirtS odnalupinaM', 'Mnplnd Strngs']

2. Criando um Padrão de Moldura

Escreva uma função chamada criar_moldura que receba dois parâmetros: uma string (texto) e um caractere (elemento decorativo). A função deve criar uma moldura decorativa ao redor do texto fornecido, utilizando o caractere decorativo escolhido.

A moldura deve seguir estas regras:

Ter uma linha superior e inferior composta pelo caractere decorativo repetido.
O texto deve estar centralizado na moldura.
Deve haver um espaço entre o texto e o caractere decorativo nas laterais.
A largura total da moldura deve ser o comprimento do texto mais 4 caracteres (para os espaços e caracteres decorativos nas laterais).

Exemplo de uso da função:

texto = "Hello, World!"
caractere = "*"
moldura = criar_moldura(texto, caractere)
print(moldura)

Saída esperada:

*****************
* Hello, World! *
*****************

Sua tarefa é implementar a função criar_moldura que produz este resultado. Use concatenação e repetição de strings para criar a moldura. Lembre-se de que a função deve funcionar para textos de diferentes comprimentos e diferentes caracteres decorativos.

Testes adicionais:

# Teste 1
Entrada: Seu Nome,*
Saída:
************
* Seu Nome *
************

# Teste 2
Entrada: Python,#
Saída:
##########
# Python #
##########

# Teste 3
Entrada: _Strings_,=
Saída:
=============
= _Strings_ =
=============

3. Detector de Palavras-Chave em Textos

Você foi contratado para desenvolver um programa que analisa textos e identifica a presença de palavras-chave específicas. O programa deve ser capaz de contar quantas vezes cada palavra-chave aparece no texto, ignorando maiúsculas e minúsculas.

Crie uma função chamada busca_palavras_chave(texto, palavras_chave) que recebe dois parâmetros:

texto: Uma string contendo o texto a ser analisado.
palavras_chave: Uma lista de strings contendo as palavras-chave a serem buscadas.

Faça:

Converta o texto para minúsculas para garantir que a busca seja case-insensitive.
Percorra a lista de palavras-chave e conte quantas vezes cada palavra aparece no texto.
Retorne um dicionário onde as chaves são as palavras-chave e os valores são o número de ocorrências de cada palavra no texto.

Para a leitura da entrada, use o seguinte formato: entrada = input().split(",")

Testes:

# Teste 1
Entrada: Python é uma linguagem de programação poderosa. python é poderoso e fácil de aprender. Muitos programadores adoram Python!, python, programação, linguagem
Saída: {'python': 3, 'programação': 1, 'linguagem': 1}

# Teste 2
Entrada: O gato preto pulou sobre o muro. O GATO branco miou para o gato preto., gato, preto, branco, cachorro
Saída: {'gato': 3, 'preto': 2, 'branco': 1, 'cachorro': 0}

# Teste 3
Entrada: A rápida raposa marrom pula sobre o cão preguiçoso., raposa, cão, gato, pula
Saída: {'raposa': 1, 'cão': 1, 'gato': 0, 'pula': 1}

Dica: Opcionalmente, você pode usar expressões regulares (módulo re) para solucionar o problema.

4. Validador de Senhas

Criar um programa que valide a qualidade de uma senha inserida pelo usuário, com base nos seguintes critérios:

Comprimento mínimo: 8 caracteres;
Letras maiúsculas: Pelo menos uma;
Letras minúsculas: Pelo menos uma;
Números: Pelo menos um.

Seu programa deve solicitar ao usuário que insira uma senha. Em seguida, utilizando funções de manipulação de strings, o programa deve verificar se a senha informada atende a todos os critérios de segurança listados acima.

Implemente uma função chamada validar_senha que recebe a senha como parâmetro e retorna uma lista contendo um booleano para cada uma das condições de segurança estabelecidas. A ordem dos booleanos na lista deve ser:

lista = [comprimento_minimo, tem_letra_maiuscula, tem_letra_minuscula, tem_numero]

Para cada critério, o programa deve exibir uma mensagem informando se ele foi atendido ou não, baseando-se nos valores booleanos retornados pela função.

Ao final da validação, o programa deve exibir uma mensagem geral informando se a senha é considerada forte ou fraca. Uma senha é considerada forte apenas se atender a todos os critérios.

Testes:

# Teste 1
Entrada: Senha123456
Saída:
Comprimento mínimo de 8 caracteres: OK
Pelo menos uma letra maiúscula: OK
Pelo menos uma letra minúscula: OK
Pelo menos um número: OK
Senha forte!

# Teste 2
Entrada: senha
Saída:
Comprimento mínimo de 8 caracteres: NÃO
Pelo menos uma letra maiúscula: NÃO
Pelo menos uma letra minúscula: OK
Pelo menos um número: NÃO
Senha fraca!

# Teste 3
Entrada: SENHA123
Saída:
Comprimento mínimo de 8 caracteres: OK
Pelo menos uma letra maiúscula: OK
Pelo menos uma letra minúscula: NÃO
Pelo menos um número: OK
Senha fraca!

# Teste 4
Entrada: Senha!
Saída:
Comprimento mínimo de 8 caracteres: NÃO
Pelo menos uma letra maiúscula: OK
Pelo menos uma letra minúscula: OK
Pelo menos um número: NÃO
Senha fraca!

5. Limpeza de Dados de Sensores com Expressões Regulares

Você recebeu um arquivo de texto contendo dados de sensores, mas ele contém alguns ruídos e espaços extras. Sua tarefa é criar uma função que utilize expressões regulares para limpar esses dados, tornando-os mais legíveis e organizados.

Implemente a função limpar_dados_sensor(dados) que recebe uma string dados e retorna a versão limpa dessa string.

Requisitos principais:

Remoção de caracteres especiais: Elimine todos os caracteres especiais, mantendo apenas letras, números, espaços, pontos e dois pontos.
Espaços simples: Garanta que haja apenas um espaço entre palavras e números. Remova espaços extras desnecessários.

A função deve ser capaz de lidar com os seguintes tipos de dados de sensores: temperatura (°C), umidade (%) e pressão (hPa).

Teste sua função com os seguintes casos de exemplo:

# Teste 1
Entrada: Temperatura: 23.5°C& Umidade: 45% !@#$ Pressão: 1013.2hPa ^^^
Saída: Temperatura: 23.5°C Umidade: 45% Pressão: 1013.2hPa

# Teste 2
Entrada: Temperatura: -5.6°C !!! Umidade: 70%    @@@ Pressão: 999.5hPa ###
Saída: Temperatura: -5.6°C Umidade: 70% Pressão: 999.5hPa

# Teste 3
Entrada: Temperatura: 25.3°C !!! Umidade: 60%  @  # $ Pressão: 1000hPa   ^^
Saída: Temperatura: 25.3°C Umidade: 60% Pressão: 1000hPa

6. Relatório de Resultados com f-strings

Você foi contratado para desenvolver um programa que gere um relatório com os resultados de um experimento. Cada experimento tem um nome, uma lista de valores medidos e um valor esperado para comparação. O relatório deve exibir o nome do experimento, a média dos valores medidos com duas casas decimais, e a diferença em relação ao valor esperado, também com duas casas decimais.

Crie uma função chamada gerar_relatorio(nome_experimento, valores_medidos, valor_esperado) que recebe:

nome_experimento: Uma string com o nome do experimento.
valores_medidos: Uma lista de 5 valores medidos.
valor_esperado: Um número de ponto flutuante.

Faça:

Calcule a média dos valores medidos.
Determine a diferença absoluta entre a média e o valor esperado.
Retorne uma string formatada com f-strings com o reltório dos resultados.

Obs: Veja que a entrada dos dados é separada por vírgulas.

Testes:

# Teste 1 
Entrada: Resistência do Material, 12.4 13.2 11.8 12.9 12.0, 12.5
Saída:
Experimento: Resistência do Material
Média dos valores medidos: 12.46
Diferença em relação ao valor esperado: 0.04

# Teste 2
Entrada: Teste de Impacto, 102.5 98.7 100.8 101.0, 100.0
Saída:
Experimento: Teste de Impacto
Média dos valores medidos: 100.75
Diferença em relação ao valor esperado: 0.75

# Teste 3
Entrada: Densidade do Líquido, 0.97 0.99 1.02 0.98 0.99, 1.0
Saída:
Experimento: Densidade do Líquido
Média dos valores medidos: 0.99
Diferença em relação ao valor esperado: 0.01

Dica: Use f-strings para formatar os valores numéricos com precisão (duas casas decimais) e para criar a string de saída.

7. Analisador de Textos com Funções de Strings

Você foi contratado para desenvolver um programa que analisa frases fornecidas pelo usuário. O programa precisa identificar informações importantes, como a presença de palavras específicas, contagens de ocorrências e posições de certos termos.

Crie uma função chamada analisar_texto(frase, palavra_alvo) que recebe:

frase: Uma string representando a frase a ser analisada.
palavra_alvo: Uma string representando a palavra que será pesquisada na frase.

Faça:

Verifique se a palavra-alvo está presente na frase.
Conte quantas vezes a palavra-alvo aparece na frase.
Identifique a posição da primeira ocorrência da palavra-alvo (se existir).
Retorne uma string formatada com os resultados da análise.

Obs: A análise não deve ser sensível a maiúsculas/minúsculas.

Testes:

# Teste 1
Entrada: "Python é incrível. Python é poderoso!","Python"
Saída:
A palavra "Python" está presente: Sim
Número de ocorrências: 2
Posição da primeira ocorrência: 0

# Teste 2
Entrada: "Programação é divertida e desafiadora.","python"
Saída:
A palavra "python" está presente: Não
Número de ocorrências: 0
Posição da primeira ocorrência: -1

# Teste 3
Entrada: "Este texto é apenas um exemplo para teste.","teste"
Saída:
A palavra "teste" está presente: Sim
Número de ocorrências: 1
Posição da primeira ocorrência: 35

8. Gerador de Prompts para IA

Crie uma função que receba título e descrição, e formate um prompt padronizado para modelos de IA.

Função a Ser Criada

def gerar_prompt(titulo, descricao):
    """
    Gera um prompt formatado para modelos de IA.

    Args:
        titulo (str): O título do prompt.
        descricao (str): Uma breve descrição do contexto ou objetivo.

    Retorna:
        str: O prompt formatado.
    """

O prompt deve começar com o título entre “=== TÍTULO ===”.
Em seguida, deve exibir a descrição precedida pela palavra “Descrição:”.
Use quebras de linha para organizar o texto, garantindo uma formatação clara e legível.

Obs:

O título deve ser destacado utilizando letras maiúsculas.
A função deve garantir que o prompt seja retornado como uma única string formatada.

Testes:

# Teste 1
Entrada:
"Classificador de Sentimentos","Crie um modelo para classificar sentimentos como positivo; negativo ou neutro."
Saída:  
=== TÍTULO ===
Classificador de Sentimentos

Descrição:
Crie um modelo para classificar sentimentos como positivo; negativo ou neutro.

# Teste 2
Entrada:
"Gerador de Histórias","Desenvolva histórias criativas com base em palavras-chave fornecidas."
Saída:  
=== TÍTULO ===
Gerador de Histórias

Descrição:
Desenvolva histórias criativas com base em palavras-chave fornecidas.

# Teste 3
Entrada: "Assistente de Código","Ajude os usuários a depurar e otimizar seus códigos."
Saída:
=== TÍTULO ===
Assistente de Código

Descrição:
Ajude os usuários a depurar e otimizar seus códigos.

9. Validador de Campos de Formulário com Expressões Regulares

Desenvolva um programa que verifica se os campos de telefone e CPF em um formulário foram preenchidos corretamente, seguindo os formatos padrão.

Crie uma função chamada validar_campos(telefone, cpf) que recebe:

telefone: Uma string representando o número de telefone no formato (XX) XXXXX-XXXX ou (XX) XXXX-XXXX.
cpf: Uma string representando o CPF no formato XXX.XXX.XXX-XX.

Faça:

Verifique se o telefone segue um dos formatos válidos especificados.
Verifique se o CPF segue o formato válido especificado.
Retorne uma string formatada indicando se cada campo é válido ou inválido.

Testes:

# Teste 1
Entrada: "(11) 98765-4321","123.456.789-09"
Saída:
Telefone válido: Sim
CPF válido: Sim

# Teste 2
Entrada: "(21) 8765-432","123.456.78-901"
Saída:
Telefone válido: Não
CPF válido: Não

# Teste 3
Entrada: "(84) 12345-6789","987.654.321-00"
Saída:
Telefone válido: Sim
CPF válido: Sim

# Teste 4
Entrada: "(83) 2345-6789","111.222.333-4A"
Saída:
Telefone válido: Sim
CPF válido: Não

10. Explorador de Artigos da Wiki

Crie uma função que utilize a biblioteca requests para buscar o conteúdo de um artigo da Wikipedia e realizar manipulações de strings com base em palavras-chave fornecidas.

Função a Ser Criada

def explorar_wiki(url, palavra_chave):
    """
    Busca o conteúdo de um artigo da Wikipedia e realiza manipulações com base em uma palavra-chave.

    Args:
        url (str): URL do artigo da Wikipedia.
        palavra_chave (str): Palavra-chave para buscas e análises no conteúdo do artigo.

    Retorna:
        dict: Um dicionário contendo o número de ocorrências da palavra-chave e o título do artigo.
    """

A função deve fazer uma requisição HTTP à URL fornecida usando requests.get().
Extraia o título do artigo (entre as tags <title>).
Conte quantas vezes a palavra-chave aparece no conteúdo.
Organize as informações em um dicionário com as chaves: "titulo" e "ocorrencias".

Observações Importantes:

Status 200: O código de status HTTP 200 indica que a requisição foi bem-sucedida. Na prática, isso significa que:
- A página foi encontrada corretamente no servidor
- O conteúdo foi carregado sem erros
- A página está pronta para ser processada
- É necessário verificar response.status_code == 200 antes de processar o conteúdo para garantir que a requisição foi bem-sucedida
Normalize as buscas para que não sejam sensíveis a maiúsculas e minúsculas.

Testes:

# Teste 1
Entrada: "https://en.wikipedia.org/wiki/Python_(programming_language)","language"
Saída: {'titulo': 'Python (programming language) - Wikipedia', 'ocorrencias': 1325}

# Teste 2
Entrada: "https://en.wikipedia.org/wiki/Artificial_intelligence","machine"
Saída: {'titulo': 'Artificial intelligence - Wikipedia', 'ocorrencias': 331}

# Teste 3
Entrada: "https://en.wikipedia.org/wiki/Quantum_mechanics","relativity"
Saída: {'titulo': 'Quantum mechanics - Wikipedia', 'ocorrencias': 34}

# Teste 4
Entrada: "https://en.wikipedia.org/wiki/Quantum_mechanics","relatividade"
Saída: {'titulo': 'Quantum mechanics - Wikipedia', 'ocorrencias': 0}

Capítulo 6: Manipulação de Strings

Contents

Capítulo 6: Manipulação de Strings#

Introdução às Strings#

O que são strings?#

Criando strings#

Imprimindo strings#

Aspas simples vs. duplas#

Indexação e Fatiamento de Strings#

Acessando caracteres individuais em uma string#

Fatiamento de strings#

Indexação negativa#

Formatação de Strings#

Usando f-strings#

Trabalhando com expressões#

Chamadas de funções#

Alinhamento e largura#

Formatando números em diferentes estilos#

Método str.format()#

Comparação: F-strings vs str.format()#

Operações com Strings#

Concatenando strings#

Repetindo strings#

Comparando strings#

Métodos de String#

Verificação e Conversão de Tipos#

Verificação de números em strings#

Convertendo strings para números#

Tratando entradas inválidas#

Convertendo números para strings#

Funções Úteis para Strings#

Expressões Regulares#

Tabela de Caracteres Especiais em Expressões Regulares#

Tabela de Funções do Módulo re#

Exemplos Práticos#

Exercícios#

Método `str.format()`#

Comparação: F-strings vs `str.format()`#

Tabela de Funções do Módulo `re`#