{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "ULxWGdhVqcRt"
},
"source": [
"# Capítulo 6: Manipulação de Strings"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"## Introdução às Strings\n",
"\n",
"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.\n",
"\n",
"Para mais detalhes técnicos sobre strings em Python, você pode consultar a [PEP 498 - Literal String Interpolation](https://peps.python.org/pep-0498/), que introduz f-strings, uma das formas mais eficientes de formatar strings.\n",
"\n",
"\n",
"### O que são strings?\n",
"\n",
"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.\n",
"\n",
"**Exemplo de string:**\n",
"\n",
"```python\n",
"\"Olá, Mundo!\"\n",
"```\n",
"\n",
"### Criando strings\n",
"\n",
"Existem diversas maneiras de criar strings em Python:\n",
"\n",
"- **Aspas simples ou duplas:** Coloque o texto entre aspas simples (`'`) ou duplas (`\"`). Ambas são equivalentes.\n",
"\n",
" ```python\n",
" string1 = 'Olá, Mundo!'\n",
" string2 = \"Python é incrível!\"\n",
" ```\n",
"\n",
"- **Aspas triplas para strings multilinhas:** Use três aspas simples (`'''`) ou duplas (`\"\"\"`) para criar strings que ocupam várias linhas.\n",
"\n",
" ```python\n",
" mensagem = \"\"\"Este é um exemplo de string\n",
" que ocupa várias linhas. É bastante útil.\"\"\"\n",
" ```\n",
"\n",
"### Imprimindo strings\n",
"\n",
"Use a função `print()` para exibir strings no console:\n",
"\n",
"```python\n",
"saudacao = \"Olá, Mundo!\"\n",
"print(saudacao)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"\n",
"```\n",
"Olá, Mundo!\n",
"```\n",
"\n",
"### Aspas simples vs. duplas\n",
"\n",
"A escolha entre aspas simples e duplas depende de como você deseja lidar com aspas dentro da string:\n",
"\n",
"- **Aspas simples:** Permitem incluir aspas duplas no texto sem necessidade de escape.\n",
"\n",
" ```python\n",
" frase1 = 'Ele disse: \"Python é incrível!\"'\n",
" print(frase1)\n",
" ```\n",
"\n",
" **Saída do Código:**\n",
"\n",
" ```\n",
" Ele disse: \"Python é incrível!\"\n",
" ```\n",
"\n",
"- **Aspas duplas:** Permitem incluir aspas simples no texto sem necessidade de escape.\n",
"\n",
" ```python\n",
" frase2 = \"Ele disse: 'Python é incrível!'\"\n",
" print(frase2)\n",
" ```\n",
"\n",
" **Saída do Código:**\n",
"\n",
" ```\n",
" Ele disse: 'Python é incrível!'\n",
" ```\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Indexação e Fatiamento de Strings\n",
"\n",
"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.\n",
"\n",
"### Acessando caracteres individuais em uma string\n",
"\n",
"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.\n",
"\n",
"Exemplo:\n",
"```python\n",
"string = \"Python\"\n",
"primeiro_caractere = string[0]\n",
"ultimo_caractere = string[5]\n",
"print(primeiro_caractere)\n",
"print(ultimo_caractere)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"P\n",
"n\n",
"```\n",
"\n",
"### Fatiamento de strings\n",
"\n",
"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.\n",
"\n",
"**Exemplo:**\n",
"```python\n",
"string = \"Python é incrível!\"\n",
"substring = string[9:17]\n",
"print(substring)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"incrível\n",
"```\n",
"\n",
"**Exemplo:**\n",
"```python\n",
"string = \"Aprender Python\"\n",
"substring = string[0:8]\n",
"print(substring)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"Aprender\n",
"```\n",
"\n",
"### Indexação negativa\n",
"\n",
"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.\n",
"\n",
"**Exemplo:**\n",
"```python\n",
"string = \"Python\"\n",
"ultimo_caractere = string[-1]\n",
"penultimo_caractere = string[-2]\n",
"print(ultimo_caractere)\n",
"print(penultimo_caractere)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"n\n",
"o\n",
"```\n",
"\n",
"\n",
"**Exemplo:**\n",
"```python\n",
"string = \"Indexação negativa\"\n",
"substring = string[-8:]\n",
"print(substring)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"negativa\n",
"```\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Formatação de Strings\n",
"\n",
"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()`.\n",
"\n",
"### Usando f-strings\n",
"\n",
"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 `{}`.\n",
"\n",
"**Exemplo básico:**\n",
"```python\n",
"saudação = \"Olá\"\n",
"nome = \"Alana\"\n",
"resultado = f\"{saudação}, {nome}!\"\n",
"print(resultado)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"Olá, Alana!\n",
"```\n",
"\n",
"**Exemplo com expressões:**\n",
"```python\n",
"a = 5\n",
"b = 3\n",
"resultado = f\"O resultado de {a} + {b} é {a + b}.\"\n",
"print(resultado)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"O resultado de 5 + 3 é 8.\n",
"```\n",
"\n",
"**Exemplo com chamadas de funções:**\n",
"```python\n",
"nome = \"Carlos\"\n",
"resultado = f\"O nome em maiúsculas é {nome.upper()}.\"\n",
"print(resultado)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"O nome em maiúsculas é CARLOS.\n",
"```\n",
"\n",
"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.\n",
"\n",
"**Exemplo com formatação:**\n",
"```python\n",
"valor = 123.45678\n",
"print(f\"O valor formatado é {valor:.2f}.\")\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"O valor formatado é 123.46.\n",
"```\n",
"\n",
"### Trabalhando com expressões\n",
"```python\n",
"preco = 99.90\n",
"desconto = 0.1\n",
"mensagem = f\"O preço com desconto é {preco * (1 - desconto):.2f}.\"\n",
"print(mensagem)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"O preço com desconto é 89.91.\n",
"```\n",
"**Formatação com `:.2f`**\n",
"\n",
"O formato `:.2f` em f-strings é usado para formatar números diretamente dentro das chaves `{}`. Ele funciona assim: \n",
"- **`:`** Inicia a formatação. \n",
"- **`.2`** Limita o número a duas casas decimais. \n",
"- **`f`** Especifica que o número é um ponto flutuante (float). \n",
"\n",
"\n",
"### Chamadas de funções\n",
"```python\n",
"texto = \"python\"\n",
"mensagem = f\"O texto em maiúsculas é {texto.upper()}.\"\n",
"print(mensagem)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"O texto em maiúsculas é PYTHON.\n",
"```\n",
"\n",
"### Alinhamento e largura\n",
"```python\n",
"nome = \"João\"\n",
"idade = 28\n",
"mensagem = f\"|{nome:<10}|{idade:^6}|{idade:>5}|\"\n",
"print(mensagem)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"|João | 28 | 28|\n",
"```\n",
"\n",
"- `<`: Alinha à esquerda.\n",
"- `^`: Centraliza.\n",
"- `>`: Alinha à direita.\n",
"\n",
"### Formatando números em diferentes estilos\n",
"```python\n",
"valor = 123456789.987654321\n",
"mensagem = (\n",
" f\"O valor formatado é {valor:,.2f}.\\n\"\n",
" f\"O valor em notação científica é {valor:.2e}.\\n\"\n",
" f\"O número alinhado à direita com zeros é {int(valor):08d}.\"\n",
")\n",
"print(mensagem)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"O valor formatado é 123,456,789.99.\n",
"O valor em notação científica é 1.23e+08.\n",
"O número alinhado à direita com zeros é 123456789.\n",
"```\n",
"\n",
"Aqui, combinamos a formatação com separador de milhar, notação científica e preenchimento com zeros para destacar diferentes estilos de exibição.\n",
"\n",
"### Método `str.format()`\n",
"\n",
"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.\n",
"\n",
"**Exemplo básico:**\n",
"```python\n",
"nome = \"Carlos\"\n",
"idade = 25\n",
"mensagem = \"Meu nome é {} e tenho {} anos.\".format(nome, idade)\n",
"print(mensagem)\n",
"```\n",
"\n",
"**Saída:**\n",
"```\n",
"Meu nome é Carlos e tenho 25 anos.\n",
"```\n",
"\n",
"**Referência posicional ou nomeada:**\n",
"```python\n",
"mensagem = \"Meu nome é {0} e tenho {1} anos. Meu nome de novo: {0}.\".format(\"Carlos\", 25)\n",
"print(mensagem)\n",
"```\n",
"\n",
"**Saída:**\n",
"```\n",
"Meu nome é Carlos e tenho 25 anos. Meu nome de novo: Carlos.\n",
"```\n",
"\n",
"**Especificação de formatos:**\n",
"```python\n",
"preco = 1234.56789\n",
"mensagem = \"O valor formatado é {:,.2f}.\".format(preco)\n",
"print(mensagem)\n",
"```\n",
"\n",
"**Saída:**\n",
"```\n",
"O valor formatado é 1,234.57.\n",
"```\n",
"\n",
"\n",
"### Comparação: F-strings vs `str.format()`\n",
"\n",
"| Característica | F-strings | `str.format()` |\n",
"|---------------------------|----------------------------|----------------------------|\n",
"| Simplicidade | Mais legível e intuitiva | Moderadamente legível |\n",
"| Suporte a expressões | Sim | Sim |\n",
"| Chamadas de funções | Sim | Sim |\n",
"| Adotada amplamente | Sim | Moderado (menos usado hoje) |\n",
"\n",
"**Recomendação**\n",
"\n",
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Operações com Strings\n",
"\n",
"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.\n",
"\n",
"### Concatenando strings\n",
"\n",
"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:\n",
"\n",
"**Usando o operador `+`**: O operador `+` é utilizado para concatenar duas ou mais strings.\n",
"\n",
"```python\n",
"string1 = \"Olá,\"\n",
"string2 = \"Pessoal!\"\n",
"resultado = string1 + \" \" + string2\n",
"print(resultado)\n",
"```\n",
"**Saída do Código:**\n",
"```\n",
"Olá, Pessoal!\n",
"```\n",
"\n",
"**Usando o método `join()`**: O método `join()` pode ser utilizado para concatenar uma lista de strings com um delimitador específico.\n",
"\n",
"```python\n",
"palavras = [\"Olá\", \"Pessoal\"]\n",
"resultado = \" \".join(palavras) # Delimitador de espaço nesse caso\n",
"print(resultado)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"Olá, Pessoal\n",
"```\n",
"\n",
"### Repetindo strings\n",
"\n",
"Repetir strings é um processo simples que pode ser realizado usando o operador `*`. Este operador multiplica a string pelo número de vezes especificado.\n",
"\n",
"**Exemplo:**\n",
"```python\n",
"string = \"Oi! \"\n",
"repetida = string * 3\n",
"print(repetida)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"Oi! Oi! Oi!\n",
"```\n",
"\n",
"### Comparando strings\n",
"\n",
"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.\n",
"\n",
"**Igualdade (`==`) e desigualdade (`!=`)**:\n",
"```python\n",
"string1 = \"Python\"\n",
"string2 = \"python\"\n",
"print(string1 == string2) # False, diferencia maiúsculas e minúsculas\n",
"print(string1 != string2) # True, diferencia maiúsculas e minúsculas\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"False\n",
"True\n",
"```\n",
"\n",
"**Comparações lexicográficas (`<`, `>`, `<=`, `>=`)**:\n",
"```python\n",
"string1 = \"Abacate\"\n",
"string2 = \"Banana\"\n",
"print(string1 < string2) # True, \"Abacate\" vem antes de \"Banana\"\n",
"print(string1 > string2) # False, \"Abacate\" vem antes de \"Banana\"\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"True\n",
"False\n",
"```\n",
"\n",
"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.\n",
"\n",
"Exemplo de comparação insensível a caso:\n",
"```python\n",
"string1 = \"Python\"\n",
"string2 = \"python\"\n",
"print(string1.lower() == string2.lower()) # True, ignora maiúsculas e minúsculas\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"True\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Métodos de String \n",
"\n",
"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: \n",
"\n",
"| Método | Descrição | Exemplo | Saída |\n",
"|---------------|------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------|--------------------------------|\n",
"| `upper()` | Converte a string em letras maiúsculas. | `texto = \"Olá, Mundo!\"; texto_maiusculo = texto.upper();` | OLÁ, MUNDO! |\n",
"| `lower()` | Converte a string em letras minúsculas. | `texto = \"OLÁ, MUNDO!\"; texto_minusculo = texto.lower();` | olá, mundo! |\n",
"| `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! |\n",
"| `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! |\n",
"| | | `texto = '\"Olá, Mundo!\"'; texto_sem_aspas = texto.strip('\"');` | Olá, Mundo! |\n",
"| `lstrip()` | Remove espaços em branco apenas do início da string. | `texto = \" Olá, Mundo!\"; texto_sem_espacos_esquerda = texto.lstrip();` | Olá, Mundo! |\n",
"| `rstrip()` | Remove espaços em branco apenas do final da string. | `texto = \"Olá, Mundo! \"; texto_sem_espacos_direita = texto.rstrip();` | Olá, Mundo! |\n",
"| `split()` | Divide a string em uma lista de substrings, separando-a por um delimitador especificado. | `texto = \"Olá, Mundo!\"; palavras = texto.split(\", \");` | ['Olá', 'Mundo'] |\n",
"| `join()` | Junta os elementos de uma lista em uma única string, usando um delimitador especificado. | `palavras = [\"Olá\", \"Mundo\"]; frase = \" \".join(palavras);` | Olá Mundo |\n",
"| `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 |\n",
"| `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 | \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Verificação e Conversão de Tipos\n",
"\n",
"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.\n",
"\n",
"### Verificação de números em strings\n",
"\n",
"Python oferece métodos nativos para verificar se uma string representa números em diferentes contextos. Aqui estão os principais:\n",
"\n",
"| **Método** | **Descrição** | **Exemplo** | **Saída** |\n",
"|----------------|------------------------------------------------------------------------------------------------------|-------------------------------------------|---------------------------|\n",
"| `isdigit()` | Retorna `True` se todos os caracteres na string forem dígitos decimais (0–9). | `\"123\".isdigit()`
`\"12.3\".isdigit()` | `True`
`False` |\n",
"| `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` |\n",
"| `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` |\n",
"\n",
"**Notas importantes:**\n",
"- **`isdigit()`**: Funciona apenas para números inteiros positivos.\n",
"- **`isdecimal()`**: Reconhece dígitos decimais de diferentes idiomas (e.g., números árabes).\n",
"- **`isnumeric()`**: É o mais abrangente, reconhecendo frações, números romanos e caracteres numéricos especiais.\n",
"\n",
"### Convertendo strings para números\n",
"\n",
"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.\n",
"\n",
"**Exemplos:**\n",
"```python\n",
"idade_str = \"25\"\n",
"idade_int = int(idade_str)\n",
"print(idade_int) \n",
"\n",
"preco_str = \"49.99\"\n",
"preco_float = float(preco_str)\n",
"print(preco_float) \n",
"```\n",
"\n",
"**Saída do Código::**\n",
"```\n",
"25\n",
"49.99\n",
"```\n",
"\n",
"### Tratando entradas inválidas\n",
"É uma boa prática verificar a validade da string antes da conversão para evitar erros.\n",
"\n",
"Exemplo:\n",
"```python\n",
"entrada = \"12.34\"\n",
"if entrada.replace(\".\", \"\").isdigit():\n",
" numero = float(entrada)\n",
" print(numero)\n",
"else:\n",
" print(\"Entrada inválida!\")\n",
"```\n",
"\n",
"**Saída do Código::**\n",
"```\n",
"12.34\n",
"```\n",
"\n",
"### Convertendo números para strings\n",
"\n",
"Para exibir números como texto, você pode usar as funções `str()` ou f-strings para obter maior controle sobre a formatação.\n",
"\n",
"**Exemplos:**\n",
"```python\n",
"numero = 42\n",
"numero_str = str(numero)\n",
"print(f\"O número como string é: {numero_str}\") # Usando f-string\n",
"\n",
"valor = 3.14159\n",
"valor_formatado = f\"{valor:.2f}\" # Formata com 2 casas decimais\n",
"print(f\"Valor formatado: {valor_formatado}\")\n",
"```\n",
"\n",
"**Saída do Código::**\n",
"```\n",
"O número como string é: 42\n",
"Valor formatado: 3.14\n",
"```\n",
"\n",
"**Conversão com formatação avançada**\n",
"Você pode personalizar ainda mais a conversão de números para strings.\n",
"\n",
"Exemplo com separador de milhar:\n",
"```python\n",
"numero_grande = 123456789\n",
"numero_str = f\"{numero_grande:,}\" # Usa ',' como separador\n",
"print(f\"Valor formatado: {numero_str}\")\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"Valor formatado: 123,456,789\n",
"```\n",
"\n",
"**Importante:**\n",
"\n",
"- Use os métodos `isdigit()`, `isdecimal()` ou `isnumeric()` para validar strings antes de convertê-las.\n",
"- Utilize `int()` e `float()` para conversões numéricas, garantindo que a string seja válida.\n",
"- Prefira **f-strings** para conversões e formatações avançadas, pois são mais modernas e legíveis."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Funções Úteis para Strings\n",
"\n",
"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:\n",
"\n",
"| **Função** | **Descrição** | **Exemplo** | **Saída (print)** |\n",
"|--------------------|---------------------------------------------------------------------------------------------------|------------------------------------------------------------------|-------------------------|\n",
"| `len()` | Retorna o comprimento (número de caracteres) da string. | `texto = \"Olá, Mundo!\"; comprimento = len(texto)` | `11` |\n",
"| `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` |\n",
"| `count()` | Retorna o número de ocorrências de um substring na string. | `texto = \"Olá, Mundo, Mundo!\"; contagens = texto.count(\"Mundo\")` | `2` |\n",
"| `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` |\n",
"| `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` |\n",
"| | | `outro_texto = \"Olá, Universo!\"; posicao = outro_texto.index(\"Mundo\")` | **`ValueError`** |\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"jp-MarkdownHeadingCollapsed": true
},
"source": [
"## Expressões Regulares\n",
"\n",
"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.\n",
"\n",
"### **Tabela de Caracteres Especiais em Expressões Regulares**\n",
"\n",
"| **Caractere** | **Descrição** | **Exemplo de Padrão** | **Resultado do Exemplo** |\n",
"|---------------|---------------|-----------------------|---------------------------|\n",
"| `.` | Qualquer caractere (exceto nova linha) | `\".asa\"` | Corresponde a \"casa\", \"vasa\", \"basa\", etc. |\n",
"| `*` | Zero ou mais ocorrências do caractere anterior | `\"ab*c\"` | Corresponde a \"ac\", \"abc\", \"abbbc\", etc. |\n",
"| `+` | Uma ou mais ocorrências do caractere anterior | `\"ab+c\"` | Corresponde a \"abc\", \"abbc\", \"abbbc\", etc. |\n",
"| `?` | Zero ou uma ocorrência do caractere anterior | `\"favor?\"` | Corresponde a \"favo\" ou \"favor\". |\n",
"| `^` | Início da linha | `\"^olá\"` | Corresponde a \"olá\" somente no início da linha. |\n",
"| `$` | Fim da linha | `\"mundo$\"` | Corresponde a \"mundo\" somente no final da linha. |\n",
"| `\\A` | Início da string | `\\A\"olá\"` | Corresponde a \"olá\" apenas no início da string. |\n",
"| `\\Z` | Fim da string | `\"mundo\\Z\"` | Corresponde a \"mundo\" apenas no final da string. |\n",
"| `[]` | Conjunto de caracteres | `\"[aeiou]la\"` | Corresponde a \"ala\", \"ela\", \"ila\", etc. |\n",
"| `[^]` | Conjunto de caracteres proibidos | `\"[^aeiou]la\"` | Corresponde a \"bla\", \"cla\", \"fla\", etc. |\n",
"| `\\d` | Qualquer dígito decimal | `\\d{3}` | Corresponde a três dígitos consecutivos como \"123\". |\n",
"| `\\w` | Caractere alfanumérico (letras, dígitos e `_`) | `\\w+` | Corresponde a \"texto\", \"123\", \"_abc\", etc. |\n",
"| `\\s` | Qualquer caractere de espaço (inclui tabulação) | `\\s+` | Corresponde a espaços, tabulações, etc. |\n",
"| `\\S` | Qualquer caractere que não seja espaço | `\\S+` | Corresponde a \"texto\", \"123\", mas não espaços. |\n",
"| `\\b` | Limite de palavra | `\\bgato\\b` | Corresponde a \"gato\" como palavra inteira. |\n",
"| `\\|` | Alternativa entre padrões | `\"gato\\|cão\"` | Corresponde a \"gato\" ou \"cão\". |\n",
"| `{}` | Número de ocorrências do caractere anterior | `\"a{2}\"` | Corresponde a \"aa\". |\n",
"| `()` | Grupo de captura | `(\\d{2})-(\\d{4})` | Captura grupos como \"12-3456\". |\n",
"\n",
"**Nota:** \n",
"Os caracteres `*`, `+`, e `?` podem ser combinados com `{}` para definir a quantidade de repetições com mais precisão.\n",
"\n",
"---\n",
"\n",
"### **Tabela de Funções do Módulo `re`**\n",
"\n",
"| **Função** | **Descrição** | **Exemplo** | **Resultado** |\n",
"|--------------------------|---------------|-------------|---------------|\n",
"| `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\". |\n",
"| `re.match(pattern, string)` | Encontra o padrão no início da string | `re.match(r'gato', 'gato está aqui')` | Match object para \"gato\". |\n",
"| `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']`. |\n",
"| `re.sub(pattern, repl, string)` | Substitui o padrão encontrado | `re.sub(r'[aeiou]', '*', 'olá mundo')` | `'*l* m*nd*'`. |\n",
"| `re.split(pattern, string)` | Divide a string pelo padrão | `re.split(r'\\s+', 'dividir esta frase')` | `['dividir', 'esta', 'frase']`. |\n",
"| `re.compile(pattern)` | Compila um padrão para uso eficiente | `padrao = re.compile(r'\\d+')`
`padrao.findall('Há 4 gatos')` | `['4']`. |\n",
"\n",
"**Explicação detalhada:**\n",
"\n",
"- **`re.search`**: Procura o padrão em qualquer parte da string.\n",
"- **`re.match`**: Limita a busca para o início da string.\n",
"- **`re.findall`**: Retorna uma lista com todas as correspondências.\n",
"- **`re.sub`**: Substitui o padrão por outro texto.\n",
"- **`re.split`**: Divide o texto onde o padrão ocorre.\n",
"- **`re.compile`**: Pré-compila o padrão para repetição eficiente.\n",
"\n",
"\n",
"### Exemplos Práticos\n",
"\n",
"**Sobre o uso de `r` antes do padrão de expressão regular**\n",
"\n",
"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. \n",
"\n",
"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 `\\`.\n",
"\n",
"**Exemplo: Encontrando uma palavra específica em um texto e sua posição**\n",
"\n",
"```python\n",
"import re\n",
"\n",
"texto = \"O rápido cão pulou sobre o coelho lento.\"\n",
"padrao = r\"\\brápido\\b\"\n",
"correspondencia = re.search(padrao, texto)\n",
"if correspondencia:\n",
" print(f\"Palavra encontrada: {correspondencia.group()}\")\n",
" print(f\"Posição inicial: {correspondencia.start()}\")\n",
" print(f\"Posição final: {correspondencia.end()}\")\n",
"else:\n",
" print(\"Palavra não encontrada.\")\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"Palavra encontrada: rápido\n",
"Posição inicial: 2\n",
"Posição final: 8\n",
"```\n",
"Explicação da expressão regular:\n",
"- `\\b`: Limite de palavra, garante que estamos correspondendo à palavra inteira \"rápido\".\n",
"- \"rápido\": A palavra que estamos procurando no texto.\n",
"\n",
"\n",
"**Exemplo: Encontrando um número de telefone em um texto**\n",
"\n",
"```python\n",
"import re\n",
"\n",
"texto = \"Por favor, ligue para 123-456-7890 para mais informações.\"\n",
"padrao = r\"\\d{3}-\\d{3}-\\d{4}\"\n",
"correspondencia = re.search(padrao, texto)\n",
"if correspondencia:\n",
" numero = correspondencia.group()\n",
" print(numero)\n",
"else:\n",
" print(\"Número de telefone não encontrado.\")\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"123-456-7890\n",
"```\n",
"\n",
"Explicação da expressão regular:\n",
"- `\\d{3}`: Corresponde a exatamente três dígitos.\n",
"- `-`: Corresponde ao caractere de hífen.\n",
"- `\\d{3}`: Novamente, corresponde a exatamente três dígitos.\n",
"- `-`: Mais uma vez, corresponde ao caractere de hífen.\n",
"- `\\d{4}`: Corresponde aos últimos quatro dígitos do número de telefone.\n",
"\n",
"**re.match()**:\n",
"\n",
"**Exemplo: Verificando se uma string começa com um prefixo específico**\n",
"\n",
"```python\n",
"import re\n",
"\n",
"def inicia_com_prefixo(texto, prefixo):\n",
" padrao = fr\"^{prefixo}\"\n",
" return bool(re.match(padrao, texto))\n",
"\n",
"if inicia_com_prefixo(\"https://www.example.com\", \"http\"):\n",
" print(\"A string começa com 'http'.\")\n",
"else:\n",
" print(\"A string não começa com 'http'.\")\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"A string começa com 'http'.\n",
"```\n",
"\n",
"Explicação da expressão regular:\n",
"- `^`: Início de linha, garante que estamos correspondendo ao início da string.\n",
"- `http`: O prefixo que estamos procurando no início da string.\n",
"\n",
"**Exemplo: Validando um endereço de e-mail**\n",
"\n",
"```python\n",
"import re\n",
"\n",
"def valida_email(email):\n",
" padrao = r\"^\\S+@\\S+\\.\\S+$\"\n",
" return bool(re.match(padrao, email))\n",
"\n",
"email_valido = \"exemplo@email.com\"\n",
"email_invalido = \"exemplo email.com\"\n",
"\n",
"if valida_email(email_valido):\n",
" print(f\"{email_valido} é um endereço de e-mail válido.\")\n",
"else:\n",
" print(f\"{email_valido} não é um endereço de e-mail válido.\")\n",
"\n",
"if not valida_email(email_invalido):\n",
" print(f\"{email_invalido} não é um endereço de e-mail válido.\")\n",
"else:\n",
" print(f\"{email_invalido} é um endereço de e-mail válido.\")\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"exemplo@email.com é um endereço de e-mail válido.\n",
"exemplo email.com não é um endereço de e-mail válido.\n",
"```\n",
"\n",
"Explicação da expressão regular:\n",
"- `^`: Início de linha.\n",
"- `\\S+`: Corresponde a uma ou mais ocorrências de caracteres não-espaço.\n",
"- `@`: Corresponde ao símbolo @.\n",
"- `\\S+`: Mais uma vez, corresponde a uma ou mais ocorrências de caracteres não-espaço.\n",
"- `\\.`: Corresponde ao caractere ponto.\n",
"- `\\S+`: Novamente, corresponde a uma ou mais ocorrências de caracteres não-espaço.\n",
"- `$`: Indica o fim de string.\n",
"\n",
"**re.findall()**:\n",
"\n",
"**Exemplo: Extraindo todas as ocorrências de uma palavra específica em um texto**\n",
"\n",
"```python\n",
"import re\n",
"\n",
"texto = \"Eu gosto de maçãs, bananas e laranjas. Maçãs são minhas favoritas.\"\n",
"padrao = r\"\\bmaçã\\b\"\n",
"ocorrencias = re.findall(padrao, texto)\n",
"print(ocorrencias)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"['maçãs', 'maçãs']\n",
"```\n",
"\n",
"Explicação da expressão regular:\n",
"- `\\b`: Limite de palavra, garante que estamos correspondendo à palavra inteira \"maçã\".\n",
"- \"maçã\": A palavra que estamos procurando no texto.\n",
"\n",
"**Exemplo: Extraindo datas em um formato específico**\n",
"\n",
"```python\n",
"import re\n",
"\n",
"texto = \"As datas do evento são 2023-05-10, 2023-06-20 e 2023-07-15.\"\n",
"padrao = r\"\\b\\d{4}-\\d{2}-\\d{2}\\b\"\n",
"datas = re.findall(padrao, texto)\n",
"print(datas)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"['2023-05-10', '2023-06-20', '2023-07-15']\n",
"```\n",
"\n",
"Explicação da expressão regular:\n",
"- `\\b`: Limite de palavra.\n",
"- `\\d{4}`: Corresponde a exatamente quatro dígitos (ano).\n",
"- `-`: Corresponde ao caractere hífen.\n",
"- `\\d{2}`: Corresponde a exatamente dois dígitos (mês).\n",
"- `-`: Mais uma vez, corresponde ao caractere hífen.\n",
"- `\\d{2}`: Corresponde a exatamente dois dígitos (dia).\n",
"- `\\b`: Limite de palavra.\n",
"\n",
"**re.sub()**:\n",
"\n",
"**Exemplo: Substituindo todas as ocorrências de uma palavra por outra**\n",
"\n",
"```python\n",
"import re\n",
"\n",
"texto = \"Eu gosto de cachorros, gatos e cachorros.\"\n",
"padrao = r\"\\bcachorros\\b\"\n",
"substituicao = \"gatos\"\n",
"texto_modificado = re.sub(padrao, substituicao, texto)\n",
"print(texto_modificado)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"Eu gosto de gatos, gatos e gatos.\n",
"```\n",
"\n",
"Explicação da expressão regular:\n",
"- `\\b`: Limite de palavra, garante que estamos correspondendo à palavra inteira \"cachorros\".\n",
"- \"cachorros\": A palavra que estamos procurando para substituir.\n",
"\n",
"**Exemplo: Removendo caracteres não alfanuméricos de uma string**\n",
"\n",
"```python\n",
"import re\n",
"\n",
"texto = \"Este texto contém # caracteres $ especiais.\"\n",
"padrao = r\"[^a-zA-Z0-9 ]+\"\n",
"texto_limpo = re.sub(padrao, \"\", texto)\n",
"print(texto_limpo)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"Este texto contém caracteres especiais\n",
"```\n",
"\n",
"Explicação da expressão regular:\n",
"- `[^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.\n",
"\n",
"\n",
"**Exemplo web: Vamos buscar uma palavra padrão em um site.**\n",
"\n",
"```python\n",
"import requests\n",
"import re\n",
"\n",
"# URL do website\n",
"url = \"https://heltonmaia.com/pythonbook/chapters/ch6/ch6.html\"\n",
"\n",
"# Faz a requisição GET para o website\n",
"response = requests.get(url)\n",
"\n",
"# Obtém o conteúdo HTML da página\n",
"conteudo = response.text\n",
"\n",
"# Procura a palavra \"variáveis\" no conteúdo\n",
"matches = re.findall(r'\\bvariáveis\\b', conteudo, re.IGNORECASE)\n",
"\n",
"# Imprime o resultado\n",
"print(f\"A palavra 'variáveis' foi encontrada {len(matches)} vezes no site.\")\n",
"```\n",
"\n",
"Explicação rápida:\n",
"\n",
"- Importamos as bibliotecas `requests` para fazer requisições web e `re` para usar expressões regulares.\n",
"- Definimos a URL do site que queremos analisar.\n",
"- Fazemos uma requisição GET para o site e obtemos o conteúdo HTML.\n",
"- Usamos `re.findall()` para procurar todas as ocorrências da palavra \"variáveis\" no conteúdo.\n",
" - O padrão `r'\\bvariáveis\\b'` busca a palavra inteira \"Python\".\n",
" - `re.IGNORECASE` torna a busca insensível a maiúsculas/minúsculas.\n",
"- Imprimimos o número de vezes que a palavra \"Python\" foi encontrada.\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"A palavra 'variáveis' foi encontrada 3 vezes no site.\n",
"```\n",
"\n",
"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)](https://docs.python.org/3/library/re.html)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exercícios\n",
"\n",
"**Uma observação antes de começar os exercícios.** \n",
"\n",
"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. \n",
"\n",
"**Exemplos:**\n",
"\n",
"**Removendo apenas as aspas duplas**\n",
"```python\n",
"# String com aspas duplas no início e no final\n",
"texto = '\"Olá, Mundo!\"'\n",
"\n",
"# Removendo apenas as aspas duplas\n",
"texto_sem_aspas = texto.strip('\"')\n",
"\n",
"print(texto_sem_aspas)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"Olá, Mundo!\n",
"```\n",
"\n",
"**Removendo apenas os espaços em branco**\n",
"```python\n",
"# String com espaços em branco no início e no final\n",
"texto = \" Olá, Mundo! \"\n",
"\n",
"# Removendo apenas os espaços\n",
"texto_sem_espacos = texto.strip()\n",
"\n",
"print(texto_sem_espacos)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"Olá, Mundo!\n",
"```\n",
"\n",
"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. \n",
"\n",
"--- \n",
"\n",
"**1. Manipulação Básica de Strings**\n",
"\n",
"Desenvolva uma função chamada `manipular_string` que aceita uma string como entrada e executa as seguintes operações:\n",
"\n",
"- Extrai o primeiro caractere da string.\n",
"- Obtém o último caractere da string.\n",
"- Seleciona os três primeiros caracteres da string.\n",
"- Captura os três últimos caracteres da string.\n",
"- Inverte a ordem dos caracteres na string.\n",
"- Remove apenas as vogais minúsculas (a, e, i, o, u) da string, mantendo as vogais maiúsculas e todos os outros caracteres.\n",
"\n",
"A função deve compilar os resultados dessas operações em uma lista e retorná-la.\n",
"\n",
"Exemplo de uso:\n",
"\n",
"```python\n",
"resultado = manipular_string(\"Python\")\n",
"print(resultado)\n",
"```\n",
"\n",
"Saída esperada:\n",
"```\n",
"['P', 'n', 'Pyt', 'hon', 'nohtyP', 'Pythn']\n",
"```\n",
"\n",
"Testes a serem realizados:\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: \"Hello\"\n",
"Saída: ['H', 'o', 'Hel', 'llo', 'olleH', 'Hll']\n",
"\n",
"# Teste 2\n",
"Entrada: \"A\"\n",
"Saída: ['A', 'A', 'A', 'A', 'A', 'A']\n",
"\n",
"# Teste 3\n",
"Entrada: \"Manipulando Strings\"\n",
"Saída: ['M', 's', 'Man', 'ngs', 'sgnirtS odnalupinaM', 'Mnplnd Strngs']\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**2. Criando um Padrão de Moldura**\n",
"\n",
"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.\n",
"\n",
"A moldura deve seguir estas regras:\n",
"- Ter uma linha superior e inferior composta pelo caractere decorativo repetido.\n",
"- O texto deve estar centralizado na moldura.\n",
"- Deve haver um espaço entre o texto e o caractere decorativo nas laterais.\n",
"- A largura total da moldura deve ser o comprimento do texto mais 4 caracteres (para os espaços e caracteres decorativos nas laterais).\n",
"\n",
"Exemplo de uso da função:\n",
"\n",
"```python\n",
"texto = \"Hello, World!\"\n",
"caractere = \"*\"\n",
"moldura = criar_moldura(texto, caractere)\n",
"print(moldura)\n",
"```\n",
"\n",
"Saída esperada:\n",
"```\n",
"*****************\n",
"* Hello, World! *\n",
"*****************\n",
"```\n",
"\n",
"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.\n",
"\n",
"Testes adicionais:\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: Seu Nome,*\n",
"Saída:\n",
"************\n",
"* Seu Nome *\n",
"************\n",
"\n",
"# Teste 2\n",
"Entrada: Python,#\n",
"Saída:\n",
"##########\n",
"# Python #\n",
"##########\n",
"\n",
"# Teste 3\n",
"Entrada: _Strings_,=\n",
"Saída:\n",
"=============\n",
"= _Strings_ =\n",
"=============\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**3. Detector de Palavras-Chave em Textos**\n",
"\n",
"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.\n",
"\n",
"Crie uma função chamada `busca_palavras_chave(texto, palavras_chave)` que recebe dois parâmetros:\n",
"- `texto`: Uma string contendo o texto a ser analisado.\n",
"- `palavras_chave`: Uma lista de strings contendo as palavras-chave a serem buscadas.\n",
"\n",
"Faça:\n",
"- Converta o texto para minúsculas para garantir que a busca seja case-insensitive.\n",
"- Percorra a lista de palavras-chave e conte quantas vezes cada palavra aparece no texto.\n",
"- 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.\n",
"\n",
"Para a leitura da entrada, use o seguinte formato: ``` entrada = input().split(\",\") ```\n",
"\n",
"Testes:\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: Python é uma linguagem de programação poderosa. python é poderoso e fácil de aprender. Muitos programadores adoram Python!, python, programação, linguagem\n",
"Saída: {'python': 3, 'programação': 1, 'linguagem': 1}\n",
"```\n",
" \n",
"```python\n",
"# Teste 2\n",
"Entrada: O gato preto pulou sobre o muro. O GATO branco miou para o gato preto., gato, preto, branco, cachorro\n",
"Saída: {'gato': 3, 'preto': 2, 'branco': 1, 'cachorro': 0}\n",
"```\n",
" \n",
"```python\n",
"# Teste 3\n",
"Entrada: A rápida raposa marrom pula sobre o cão preguiçoso., raposa, cão, gato, pula\n",
"Saída: {'raposa': 1, 'cão': 1, 'gato': 0, 'pula': 1}\n",
"```\n",
"\n",
"Dica: Opcionalmente, você pode usar expressões regulares (módulo `re`) para solucionar o problema."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**4. Validador de Senhas**\n",
"\n",
"Criar um programa que valide a qualidade de uma senha inserida pelo usuário, com base nos seguintes critérios:\n",
"\n",
"* **Comprimento mínimo:** 8 caracteres;\n",
"* **Letras maiúsculas:** Pelo menos uma;\n",
"* **Letras minúsculas:** Pelo menos uma;\n",
"* **Números:** Pelo menos um.\n",
"\n",
"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.\n",
"\n",
"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:\n",
"\n",
"```\n",
"lista = [comprimento_minimo, tem_letra_maiuscula, tem_letra_minuscula, tem_numero]\n",
"```\n",
"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.\n",
"\n",
"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.\n",
"\n",
"Testes:\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: Senha123456\n",
"Saída:\n",
"Comprimento mínimo de 8 caracteres: OK\n",
"Pelo menos uma letra maiúscula: OK\n",
"Pelo menos uma letra minúscula: OK\n",
"Pelo menos um número: OK\n",
"Senha forte!\n",
"```\n",
"\n",
"```python\n",
"# Teste 2\n",
"Entrada: senha\n",
"Saída:\n",
"Comprimento mínimo de 8 caracteres: NÃO\n",
"Pelo menos uma letra maiúscula: NÃO\n",
"Pelo menos uma letra minúscula: OK\n",
"Pelo menos um número: NÃO\n",
"Senha fraca!\n",
"```\n",
"\n",
"```python\n",
"# Teste 3\n",
"Entrada: SENHA123\n",
"Saída:\n",
"Comprimento mínimo de 8 caracteres: OK\n",
"Pelo menos uma letra maiúscula: OK\n",
"Pelo menos uma letra minúscula: NÃO\n",
"Pelo menos um número: OK\n",
"Senha fraca!\n",
"```\n",
"\n",
"```python\n",
"# Teste 4\n",
"Entrada: Senha!\n",
"Saída:\n",
"Comprimento mínimo de 8 caracteres: NÃO\n",
"Pelo menos uma letra maiúscula: OK\n",
"Pelo menos uma letra minúscula: OK\n",
"Pelo menos um número: NÃO\n",
"Senha fraca!\n",
"```\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**5. Limpeza de Dados de Sensores com Expressões Regulares**\n",
"\n",
"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.\n",
"\n",
"Implemente a função `limpar_dados_sensor(dados)` que recebe uma string `dados` e retorna a versão limpa dessa string.\n",
"\n",
"Requisitos principais:\n",
"\n",
"- Remoção de caracteres especiais: Elimine todos os caracteres especiais, mantendo apenas letras, números, espaços, pontos e dois pontos.\n",
"- Espaços simples: Garanta que haja apenas um espaço entre palavras e números. Remova espaços extras desnecessários.\n",
"\n",
"A função deve ser capaz de lidar com os seguintes tipos de dados de sensores: temperatura (°C), umidade (%) e pressão (hPa).\n",
"\n",
"Teste sua função com os seguintes casos de exemplo:\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: Temperatura: 23.5°C& Umidade: 45% !@#$ Pressão: 1013.2hPa ^^^\n",
"Saída: Temperatura: 23.5°C Umidade: 45% Pressão: 1013.2hPa\n",
"```\n",
"\n",
"```python\n",
"# Teste 2\n",
"Entrada: Temperatura: -5.6°C !!! Umidade: 70% @@@ Pressão: 999.5hPa ###\n",
"Saída: Temperatura: -5.6°C Umidade: 70% Pressão: 999.5hPa\n",
"```\n",
"\n",
"```python\n",
"# Teste 3\n",
"Entrada: Temperatura: 25.3°C !!! Umidade: 60% @ # $ Pressão: 1000hPa ^^\n",
"Saída: Temperatura: 25.3°C Umidade: 60% Pressão: 1000hPa\n",
"```\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**6. Relatório de Resultados com f-strings** \n",
"\n",
"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. \n",
"\n",
"Crie uma função chamada `gerar_relatorio(nome_experimento, valores_medidos, valor_esperado)` que recebe: \n",
"- `nome_experimento`: Uma string com o nome do experimento. \n",
"- `valores_medidos`: Uma lista de 5 valores medidos. \n",
"- `valor_esperado`: Um número de ponto flutuante. \n",
"\n",
"Faça: \n",
"- Calcule a média dos valores medidos. \n",
"- Determine a diferença absoluta entre a média e o valor esperado. \n",
"- Retorne uma string formatada com f-strings com o reltório dos resultados. \n",
" \n",
"Obs: Veja que a entrada dos dados é separada por vírgulas.\n",
"\n",
"Testes:\n",
"\n",
"```python\n",
"# Teste 1 \n",
"Entrada: Resistência do Material, 12.4 13.2 11.8 12.9 12.0, 12.5\n",
"Saída:\n",
"Experimento: Resistência do Material\n",
"Média dos valores medidos: 12.46\n",
"Diferença em relação ao valor esperado: 0.04\n",
"```\n",
"\n",
"```python\n",
"# Teste 2\n",
"Entrada: Teste de Impacto, 102.5 98.7 100.8 101.0, 100.0\n",
"Saída:\n",
"Experimento: Teste de Impacto\n",
"Média dos valores medidos: 100.75\n",
"Diferença em relação ao valor esperado: 0.75\n",
"\n",
"```\n",
"\n",
"```python\n",
"# Teste 3\n",
"Entrada: Densidade do Líquido, 0.97 0.99 1.02 0.98 0.99, 1.0\n",
"Saída:\n",
"Experimento: Densidade do Líquido\n",
"Média dos valores medidos: 0.99\n",
"Diferença em relação ao valor esperado: 0.01\n",
"\n",
"``` \n",
"Dica: Use **f-strings** para formatar os valores numéricos com precisão (duas casas decimais) e para criar a string de saída."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**7. Analisador de Textos com Funções de Strings**\n",
"\n",
"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. \n",
"\n",
"Crie uma função chamada `analisar_texto(frase, palavra_alvo)` que recebe: \n",
"- `frase`: Uma string representando a frase a ser analisada. \n",
"- `palavra_alvo`: Uma string representando a palavra que será pesquisada na frase. \n",
"\n",
"Faça: \n",
"- Verifique se a palavra-alvo está presente na frase. \n",
"- Conte quantas vezes a palavra-alvo aparece na frase. \n",
"- Identifique a posição da primeira ocorrência da palavra-alvo (se existir). \n",
"- Retorne uma string formatada com os resultados da análise. \n",
"\n",
"Obs: A análise não deve ser sensível a maiúsculas/minúsculas. \n",
"\n",
"Testes:\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: \"Python é incrível. Python é poderoso!\",\"Python\"\n",
"Saída:\n",
"A palavra \"Python\" está presente: Sim\n",
"Número de ocorrências: 2\n",
"Posição da primeira ocorrência: 0\n",
"```\n",
"\n",
"```python\n",
"# Teste 2\n",
"Entrada: \"Programação é divertida e desafiadora.\",\"python\"\n",
"Saída:\n",
"A palavra \"python\" está presente: Não\n",
"Número de ocorrências: 0\n",
"Posição da primeira ocorrência: -1\n",
"```\n",
"\n",
"```python\n",
"# Teste 3\n",
"Entrada: \"Este texto é apenas um exemplo para teste.\",\"teste\"\n",
"Saída:\n",
"A palavra \"teste\" está presente: Sim\n",
"Número de ocorrências: 1\n",
"Posição da primeira ocorrência: 35\n",
"``` "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**8. Gerador de Prompts para IA**\n",
"\n",
"Crie uma função que receba **título** e **descrição**, e formate um prompt padronizado para modelos de IA. \n",
"\n",
"**Função a Ser Criada**\n",
"```python\n",
"def gerar_prompt(titulo, descricao):\n",
" \"\"\"\n",
" Gera um prompt formatado para modelos de IA.\n",
"\n",
" Args:\n",
" titulo (str): O título do prompt.\n",
" descricao (str): Uma breve descrição do contexto ou objetivo.\n",
"\n",
" Retorna:\n",
" str: O prompt formatado.\n",
" \"\"\"\n",
"```\n",
"- O prompt deve começar com o título entre \"=== TÍTULO ===\". \n",
"- Em seguida, deve exibir a descrição precedida pela palavra \"Descrição:\". \n",
"- Use quebras de linha para organizar o texto, garantindo uma formatação clara e legível. \n",
"\n",
"Obs: \n",
"- O título deve ser destacado utilizando letras maiúsculas. \n",
"- A função deve garantir que o prompt seja retornado como uma única string formatada. \n",
"\n",
"\n",
"Testes:\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada:\n",
"\"Classificador de Sentimentos\",\"Crie um modelo para classificar sentimentos como positivo; negativo ou neutro.\"\n",
"Saída: \n",
"=== TÍTULO ===\n",
"Classificador de Sentimentos\n",
"\n",
"Descrição:\n",
"Crie um modelo para classificar sentimentos como positivo; negativo ou neutro.\n",
"```\n",
"\n",
"```python\n",
"# Teste 2\n",
"Entrada:\n",
"\"Gerador de Histórias\",\"Desenvolva histórias criativas com base em palavras-chave fornecidas.\"\n",
"Saída: \n",
"=== TÍTULO ===\n",
"Gerador de Histórias\n",
"\n",
"Descrição:\n",
"Desenvolva histórias criativas com base em palavras-chave fornecidas.\n",
"```\n",
"\n",
"```python\n",
"# Teste 3\n",
"Entrada: \"Assistente de Código\",\"Ajude os usuários a depurar e otimizar seus códigos.\"\n",
"Saída:\n",
"=== TÍTULO ===\n",
"Assistente de Código\n",
"\n",
"Descrição:\n",
"Ajude os usuários a depurar e otimizar seus códigos.\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**9. Validador de Campos de Formulário com Expressões Regulares** \n",
"\n",
"Desenvolva um programa que verifica se os campos de telefone e CPF em um formulário foram preenchidos corretamente, seguindo os formatos padrão. \n",
"\n",
"Crie uma função chamada `validar_campos(telefone, cpf)` que recebe: \n",
"- `telefone`: Uma string representando o número de telefone no formato `(XX) XXXXX-XXXX` ou `(XX) XXXX-XXXX`. \n",
"- `cpf`: Uma string representando o CPF no formato `XXX.XXX.XXX-XX`. \n",
"\n",
"Faça: \n",
"- Verifique se o telefone segue um dos formatos válidos especificados. \n",
"- Verifique se o CPF segue o formato válido especificado. \n",
"- Retorne uma string formatada indicando se cada campo é válido ou inválido. \n",
"\n",
"Testes: \n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: \"(11) 98765-4321\",\"123.456.789-09\"\n",
"Saída:\n",
"Telefone válido: Sim\n",
"CPF válido: Sim\n",
"\n",
"# Teste 2\n",
"Entrada: \"(21) 8765-432\",\"123.456.78-901\"\n",
"Saída:\n",
"Telefone válido: Não\n",
"CPF válido: Não\n",
"\n",
"# Teste 3\n",
"Entrada: \"(84) 12345-6789\",\"987.654.321-00\"\n",
"Saída:\n",
"Telefone válido: Sim\n",
"CPF válido: Sim\n",
"\n",
"# Teste 4\n",
"Entrada: \"(83) 2345-6789\",\"111.222.333-4A\"\n",
"Saída:\n",
"Telefone válido: Sim\n",
"CPF válido: Não\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**10. Explorador de Artigos da Wiki** \n",
"\n",
"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. \n",
"\n",
"\n",
"**Função a Ser Criada** \n",
"```python\n",
"def explorar_wiki(url, palavra_chave):\n",
" \"\"\"\n",
" Busca o conteúdo de um artigo da Wikipedia e realiza manipulações com base em uma palavra-chave.\n",
"\n",
" Args:\n",
" url (str): URL do artigo da Wikipedia.\n",
" palavra_chave (str): Palavra-chave para buscas e análises no conteúdo do artigo.\n",
"\n",
" Retorna:\n",
" dict: Um dicionário contendo o número de ocorrências da palavra-chave e o título do artigo.\n",
" \"\"\"\n",
"```\n",
"\n",
"- A função deve fazer uma requisição HTTP à URL fornecida usando `requests.get()`. \n",
"- Extraia o título do artigo (entre as tags ``). \n",
"- Conte quantas vezes a palavra-chave aparece no conteúdo. \n",
"- Organize as informações em um dicionário com as chaves: `\"titulo\"` e `\"ocorrencias\"`.\n",
"\n",
"\n",
"**Observações Importantes:** \n",
"- **Status 200**: O código de status HTTP 200 indica que a requisição foi bem-sucedida. Na prática, isso significa que:\n",
" * A página foi encontrada corretamente no servidor\n",
" * O conteúdo foi carregado sem erros\n",
" * A página está pronta para ser processada\n",
" * É necessário verificar `response.status_code == 200` antes de processar o conteúdo para garantir que a requisição foi bem-sucedida\n",
"\n",
"- Normalize as buscas para que não sejam sensíveis a maiúsculas e minúsculas. \n",
"\n",
"\n",
"Testes:\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: \"https://en.wikipedia.org/wiki/Python_(programming_language)\",\"language\"\n",
"Saída: {'titulo': 'Python (programming language) - Wikipedia', 'ocorrencias': 1325}\n",
"```\n",
"\n",
"```python\n",
"# Teste 2\n",
"Entrada: \"https://en.wikipedia.org/wiki/Artificial_intelligence\",\"machine\"\n",
"Saída: {'titulo': 'Artificial intelligence - Wikipedia', 'ocorrencias': 331}\n",
"```\n",
"\n",
"```python\n",
"# Teste 3\n",
"Entrada: \"https://en.wikipedia.org/wiki/Quantum_mechanics\",\"relativity\"\n",
"Saída: {'titulo': 'Quantum mechanics - Wikipedia', 'ocorrencias': 34}\n",
"```\n",
"\n",
"```python\n",
"# Teste 4\n",
"Entrada: \"https://en.wikipedia.org/wiki/Quantum_mechanics\",\"relatividade\"\n",
"Saída: {'titulo': 'Quantum mechanics - Wikipedia', 'ocorrencias': 0}\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!-- \n",
"9. Analisador de Texto para Estatísticas Básicas\n",
"\n",
"Você está desenvolvendo um programa que analisa textos para fornecer estatísticas básicas úteis para escritores e editores. O programa deve processar uma string representando um texto e calcular informações como o número de palavras, número de frases, e a palavra mais frequente no texto. \n",
"\n",
"**Função a Ser Criada** \n",
"```python\n",
"def analisar_texto(texto):\n",
" \"\"\"\n",
" Analisa um texto e retorna estatísticas básicas.\n",
"\n",
" Args:\n",
" texto (str): O texto a ser analisado.\n",
"\n",
" Retorna:\n",
" dict: Um dicionário com as estatísticas:\n",
" - 'num_palavras': Número total de palavras.\n",
" - 'num_frases': Número total de frases.\n",
" - 'palavra_mais_frequente': Palavra mais frequente no texto.\n",
" \"\"\"\n",
"```\n",
"\n",
"**Requisitos** \n",
"- Considere palavras como sequências de caracteres separadas por espaços. \n",
"- Considere frases como sequências de texto terminadas por \".\", \"!\" ou \"?\". \n",
"- A contagem de palavras deve ignorar diferenças entre maiúsculas e minúsculas (e.g., \"Python\" e \"python\" contam como a mesma palavra). \n",
"- Retorne as estatísticas em um dicionário no formato especificado. \n",
"\n",
"**Obs** \n",
"- Se houver empate na palavra mais frequente, retorne qualquer uma delas. \n",
"- O texto fornecido será uma string válida, sem necessidade de validações adicionais. \n",
"\n",
"**Testes** \n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada:\n",
"\"Python é incrível. Python é poderoso! Programação com Python é divertida.\"\n",
"Saída:\n",
"{\n",
" 'num_palavras': 8,\n",
" 'num_frases': 3,\n",
" 'palavra_mais_frequente': 'python'\n",
"}\n",
"\n",
"# Teste 2\n",
"Entrada:\n",
"\"Aprender a programar é essencial. Programação abre portas! Programar é criativo.\"\n",
"Saída:\n",
"{\n",
" 'num_palavras': 9,\n",
" 'num_frases': 3,\n",
" 'palavra_mais_frequente': 'programar'\n",
"}\n",
"\n",
"# Teste 3\n",
"Entrada:\n",
"\"Este é um texto simples. Ele tem duas frases.\"\n",
"Saída:\n",
"{\n",
" 'num_palavras': 7,\n",
" 'num_frases': 2,\n",
" 'palavra_mais_frequente': 'é'\n",
"}\n",
"``` \n",
"-->"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!-- \n",
"\n",
"10. **Codificador e Decodificador de Mensagens Secretas** \n",
"\n",
"**Contexto do Problema** \n",
"Você está desenvolvendo um sistema básico de criptografia para mensagens secretas. O sistema deve transformar uma mensagem utilizando um esquema de substituição de caracteres. Cada letra será substituída por outra conforme um \"mapa de codificação\" definido. Além disso, o sistema deve ser capaz de decodificar mensagens utilizando o mapa reverso. \n",
"\n",
"**Função a Ser Criada** \n",
"```python\n",
"def codificar_mensagem(mensagem, mapa):\n",
" \"\"\"\n",
" Codifica uma mensagem utilizando o mapa de substituição.\n",
"\n",
" Args:\n",
" mensagem (str): A mensagem a ser codificada.\n",
" mapa (dict): Um dicionário onde as chaves são os caracteres originais\n",
" e os valores são os caracteres substitutos.\n",
"\n",
" Retorna:\n",
" str: A mensagem codificada.\n",
" \"\"\"\n",
" \n",
"def decodificar_mensagem(mensagem_codificada, mapa):\n",
" \"\"\"\n",
" Decodifica uma mensagem utilizando o mapa de substituição reverso.\n",
"\n",
" Args:\n",
" mensagem_codificada (str): A mensagem a ser decodificada.\n",
" mapa (dict): Um dicionário onde as chaves são os caracteres originais\n",
" e os valores são os caracteres substitutos.\n",
"\n",
" Retorna:\n",
" str: A mensagem decodificada.\n",
" \"\"\"\n",
"```\n",
"\n",
"**Requisitos** \n",
"1. A função `codificar_mensagem` deve substituir cada caractere na mensagem conforme o mapa fornecido. Caracteres que não estão no mapa devem permanecer inalterados. \n",
"2. A função `decodificar_mensagem` deve usar o mapa reverso (inverter as chaves e valores do mapa original) para decodificar a mensagem. \n",
"3. Ambas as funções devem ser case-sensitive (diferenciar maiúsculas e minúsculas). \n",
"4. O mapa será sempre válido, sem chaves duplicadas ou caracteres inválidos. \n",
"\n",
"**Obs** \n",
"- Garanta que as funções funcionem tanto para letras quanto para números e caracteres especiais. \n",
"\n",
"**Testes** \n",
"\n",
"```python\n",
"# Teste 1\n",
"mensagem = \"Segredo123!\"\n",
"mapa = {\"S\": \"A\", \"e\": \"x\", \"g\": \"y\", \"r\": \"z\", \"o\": \"u\", \"1\": \"9\", \"2\": \"8\", \"3\": \"7\"}\n",
"mensagem_codificada = codificar_mensagem(mensagem, mapa)\n",
"mensagem_decodificada = decodificar_mensagem(mensagem_codificada, mapa)\n",
"\n",
"# Resultados esperados\n",
"mensagem_codificada: \"Axyzdux987!\"\n",
"mensagem_decodificada: \"Segredo123!\"\n",
"\n",
"# Teste 2\n",
"mensagem = \"Criptografia é legal.\"\n",
"mapa = {\"C\": \"X\", \"r\": \"p\", \"i\": \"o\", \"p\": \"q\", \"t\": \"z\", \"o\": \"m\", \"g\": \"k\", \"f\": \"h\", \"a\": \"u\", \"é\": \"w\", \"l\": \"v\"}\n",
"mensagem_codificada = codificar_mensagem(mensagem, mapa)\n",
"mensagem_decodificada = decodificar_mensagem(mensagem_codificada, mapa)\n",
"\n",
"# Resultados esperados\n",
"mensagem_codificada: \"Xpqzoqzkmohu w vumu.\"\n",
"mensagem_decodificada: \"Criptografia é legal.\"\n",
"```\n",
"-->"
]
}
],
"metadata": {
"colab": {
"provenance": [],
"toc_visible": true
},
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.20"
}
},
"nbformat": 4,
"nbformat_minor": 4
}