From 18cd0f5494d530ef391909520da5aa577b47b71e Mon Sep 17 00:00:00 2001 From: Henrique Branco Date: Thu, 11 Jul 2024 08:13:13 -0300 Subject: [PATCH] =?UTF-8?q?feat:=20continuidade=20cap=C3=ADtulo=20strings?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- book/05-operacoes-basicas/04-variaveis.md | 8 +- book/06-estruturas-de-dados/01-strings.ipynb | 221 ++++++++++++++++++- 2 files changed, 218 insertions(+), 11 deletions(-) diff --git a/book/05-operacoes-basicas/04-variaveis.md b/book/05-operacoes-basicas/04-variaveis.md index 134f48a..65065a4 100644 --- a/book/05-operacoes-basicas/04-variaveis.md +++ b/book/05-operacoes-basicas/04-variaveis.md @@ -20,6 +20,9 @@ A melhor forma de entender isso é através de exemplos. ## Exemplos básicos + +### Exemplo 1 + ```python idade = 25 nome = "Henrique Branco" @@ -36,7 +39,10 @@ O nome da variável fica a escolha de quem desenvolve, embora existam regras obr Eu, particularmente, não gosto de ler esta linha como *variável idade igual a 25*, pois igualdade é uma comparação, se uma coisa é igual à outra. Na criação de variáveis, usando o `=`, estamos falando de uma alocação ou de uma atribuição. Então, eu sugiro você começar a ler esta linha como *atribui o valor 25 à variável idade*, ou então *variável idade recebe 25*. Mais a frente vamos aprender que existe também o operador de comparação `==`, que pode ser facilmente confundido com `=` se você não se atentar ao que eu disse aqui. ``` -E podemos usar estas variáveis para criar uma outra variável, e imprimir uma mensagem na tela +E podemos usar estas variáveis para criar uma outra variável, e imprimir uma mensagem na tela. + +(exemplo-2)= +### Exemplo 2 ```python idade = 25 diff --git a/book/06-estruturas-de-dados/01-strings.ipynb b/book/06-estruturas-de-dados/01-strings.ipynb index a8b7b75..55897d5 100644 --- a/book/06-estruturas-de-dados/01-strings.ipynb +++ b/book/06-estruturas-de-dados/01-strings.ipynb @@ -128,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -155,7 +155,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Concatenação" + "### Concatenação com `+`" ] }, { @@ -171,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -195,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -220,7 +220,67 @@ "\n", "Já no segundo caso, estamos juntando o caracter `1` com outro caracter `1` (ambos são strings), resultando em `11`. Tal operação de juntar texto é chamada de concatenação.\n", "\n", - "Agora você entende que `1 + 1` pode ser `11`? No caso em que ambos `1` forem string!" + "Agora você entende que `1 + 1` pode ser `11`? No caso em que ambos `1` forem string!\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Concatenação com f-strings" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Além do uso do operador `+` para concatenação, tal operação também pode ser feita através de f-strings, conforme vimos no [exemplo 2](exemplo-2) no capítulo sobre variáveis. \n", + "\n", + "Usar f-strings para concatenação é muito mais comum em projetos reais, e elegante, do que usar `+`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "11\n" + ] + } + ], + "source": [ + "caracter_um = \"1\"\n", + "print(f\"{caracter_um}{caracter_um}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "O interessante sobre f-strings é que mesmo a variável sendo do tipo `int`, ao usá-la dentro do contexto de f-string, o Python faz a conversão automática para `str` ao usar variávels em f-strings. Vamos ver conversões entre tipos mais à frente." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "11\n" + ] + } + ], + "source": [ + "numero_um = 1\n", + "print(f\"{caracter_um}{caracter_um}\")" ] }, { @@ -239,7 +299,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -306,9 +366,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OI, EU SOU UMA STRING!\n" + ] + } + ], "source": [ "mensagem = \"Oi, eu sou uma string!\"\n", "print(mensagem.upper())" @@ -324,12 +392,145 @@ "\n", "```{image} ../gifs/06-01-vscode-methods-str-autocomplete.gif\n", ":width: 400px\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Métodos mais usados de strings" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{admonition} Nota (lista completa de métodos)\n", + ":class: note\n", + "\n", + "Strings tem uma lista enorme de métodos disponíveis e aqui serão demonstrados apenas os mais comumente usados. Mas é de extrema importância que você saiba consultar todos os métodos disponíveis na documentação oficial. A lista completa com todos os métodos de string e suas respectivas documentações pode ser encontrada [aqui](https://docs.python.org/3/library/stdtypes.html#string-methods).\n", "```\n", "\n", - "```{admonition} Nota\n", + "```{admonition} Nota (valores booleanos)\n", ":class: note\n", "\n", - "Strings tem uma lista enorme de métodos disponíveis e aqui serão demonstrados apenas os mais comumente usados. Mas é de extrema importância que você saiba consultar todos os métodos disponíveis na documentação oficial. A lista completa com todos os métodos de string pode ser encontrada [aqui](https://docs.python.org/3/library/stdtypes.html#string-methods).\n", + "Ao longo desta lista de métodos, vamos ver de forma indireta um outro tipo de dado chamado booleano, ou `bool`. Ele é bem simples, pois é uma estrutura de dados que contém apenas 2 valores: `True`, representando verdadeiro, e `False` representando falso. \n", + "\n", + "Notem que as primeiras letras **`T`** e **`F`** são **maísculas**, caso contrário o Python gera erro de sintaxe.\n", + "```\n", + "\n", + "Para fins puramente didáticos, vou separar os métodos em casos de uso, trazendo exemplos de uso de cada método.\n", + "\n", + "1. Transformação de Case\n", + "- `str.upper()`: Converte todos os caracteres da string para maiúsculas.\n", + "- `str.lower()`: Converte todos os caracteres da string para minúsculas.\n", + "- `str.capitalize()`: Converte o primeiro caractere da string para maiúscula e o restante para minúscula.\n", + "- `str.title()`: Converte o primeiro caractere de cada palavra para maiúscula." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HENRIQUE BRANCO\n", + "henrique branco\n", + "Henrique branco\n", + "Henrique Branco\n" + ] + } + ], + "source": [ + "nome = \"Um noME QuAlQuEr\"\n", + "print(nome.upper())\n", + "print(nome.lower())\n", + "print(nome.capitalize())\n", + "print(nome.title())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Remoção de Espaços\n", + "- `str.lstrip()`: Remove espaços em branco do início da string.\n", + "- `str.rstrip()`: Remove espaços em branco do fim da string.\n", + "- `str.strip()`: Remove espaços em branco do início e do fim da string.\n", + "- \n", + "```{admonition} Dica\n", + ":class: tip\n", + "\n", + "O espaço em branco não é visível na saída. Sugiro selecionar o texto todo com o mouse para verificar os espaços em branco remanescentes.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Henrique Branco \n", + " Henrique Branco\n", + "Henrique Branco\n" + ] + } + ], + "source": [ + "string_com_espacos = \" Um texto qualquer com espaços em branco no começo e no final... \"\n", + "print(string_com_espacos.lstrip())\n", + "print(string_com_espacos.rstrip())\n", + "print(string_com_espacos.strip())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Contagem e verificação de sufixo/prefixo\n", + "- `str.startswith(prefix)`: Verifica se a string começa com um determinado prefixo.\n", + "- `str.endswith(suffix)`: Verifica se a string termina com um determinado sufixo.\n", + "- `str.count(sub)`: Conta o número de ocorrências de uma substring na string." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n", + "6\n" + ] + } + ], + "source": [ + "frase = \"Olá, eu estou aprendendo a manipular textos em Python \"\n", + "print(frase.startswith(\"Olá\"))\n", + "print(frase.endswith(\"Python\")) # False? Está correto mesmo?\n", + "print(frase.count(\"e\")) # A letra 'e' aparece 5 vezes na frase" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{admonition} Atenção\n", + ":class: warning\n", + "\n", + "O espaço em branco (deixado propositalmente) é super relevante na comparação de strings, por isso as strings `Python` (sem espaço em branco) e `Python ` (com espaço em branco no final) são diferentes, apesar de ser apenas por um único caracter em branco. Por esta razão tivemos `frase.endswith(\"Python\") = False`\n", "```" ] }