## Introdução Strings são muito importantes e fazem parte do dia a dia de qualquer programador. Neste guia explicaremos alguns conceitos básicos que envolvem essas estruturas. Este artigo é parte de um trabalho realizado por alunos da disciplina de Estruturas de Dados Básicas I do curso de Bacharelado em Técnologia da Informação pela Universidade Federal do Rio Grande do Norte. _Nota: Os exemplos estão em pseudo-código e python._ ## Table of Contents - [O que são Strings?](#what) - [Como elas funcionam?](#how) - [O que podemos fazer com Strings?](#can-do) - [Concatenação](#concat) - [Tamanho de uma string](#tamanho) - [Aparar uma string](#aparar) - [Encontrar substrings/caracteres](#subs) - [Substituir substrings/caracteres](#substituicao) - [Inverter](#reverse) - [Subsequências](#subset) - [Comparar](#compare) - [Conclusão](#conclusion) ## **O que são Strings?** As Strings são sequências ordenadas de caracteres. Muito parecidas com os _arrays_, são exclusivas para texto, logo só armazenam caracteres. > Em algumas linguagens, como Java e Python, as strings são tipos imutavéis, ou seja, uma vez declaradas não poderão ser alteradas. Não consideraremos isso neste tutorial mas recomendados que você mantenha isso em mente. > Sugerimos que leia sobre o assunto na documentação oficial da sua linguagem de escolha. Para inicializar uma string devemos usar áspas duplas. ```pseudo str = "Ola, mundo!" ``` **Muito cuidado para não se confundir!** ```pseudo a = "2 + 2" b = 2 + 2 ``` _O valor de `a` é o texto "2 + 2", já o valor de `b` é o número 4, resultado da adição `2 + 2`._ ### **Como elas funcionam?** Como nos _arrays_, as strings também possuem um valor de índice que representa cada elemento, ou caractere. Considere o trecho: ```pseudo hello = "hello world" ``` Temos que: | **índice** | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | | :-----------: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | | **caractere** | 'h' | 'e' | 'l' | 'l' | 'o' | ' ' | 'w' | 'o' | 'r' | 'l' | 'd' | Dessa maneira o elemento `hello[0]` é a letra 'h', `hello[5]` é um espaço em branco, `hello[8]` é a letra 'r' e assim por diante. ## **O que podemos fazer com Strings?** Para trabalhar com strings serão necessárias operações especícas. A seguir explicaremos alguns dos métodos e funções mais importantes. _Lembre-se que cada linguagem tem sua própria sintaxe e maneira de aplicar cada uma dessas operações._ ### **Concatenação** O termo concatenar significa conectar algo a uma sequência, logo concatenar strings significa liga-las uma após a outra, resultando em uma única string. Observe o exemplo a seguir: ```pseudo nome = "Fulano" sobrenome = "de Tal" nomeCompleto = nome + ' ' + sobrenome print(nomeCompleto) ``` Saída: ```output "Fulano de Tal" ``` Aqui representamos a operação como uma soma de strings, onde o último caractere da primeira string será seguido pelo primeiro caractere da segunda string e assim por diante. _Perceba que se fizermos `nomeCompleto = nome + sobrenome` teremos como resultado uma string de valor `"Fulanode Tal"`_ ### **Tamanho de uma string** A prática de encontrar o tamanho/comprimento de uma string é muito comum na programação, frequentemente nos deparamos com algum problema que para ser resolvido devemos saber o comprimento total da string para percorrê-la, por exemplo. Sob essa ótica, a linguagem python tem a função interna "len" que retorna o tamanho da string. **Exemplo:** ```python str = "Hello world!" print(len(str)) ``` Saída: ```output 12 ``` Como resultado, temos o valor 12. Entretanto, é possível observar que embora só exista 11 letras, o resultado apontou um elemento a mais, esse elemento corresponde ao "espaço" entre as letras "o e w", que para a função significa um caractere especial. **MÉTODO 2:** Podemos encontrar o tamanho da string em bytes, usando a biblioteca de funções "sys", através do método “getsizeof”, da seguinte forma: **Exemplo:** ```python import sys texto = "Hello World!" res = sys.getsizeof(texto) print(res) ``` Saída: ```output 61 ``` O resultado será 61, que corresponde ao tamanho em bytes da string. **MÉTODO 3:** Embora exista todas essas funções, é possível encontrar o comprimento/tamanho de forma manual, segue abaixo um exemplo: Criamos uma estrutura de repetição, um “for”, por exemplo, que percorre cada posição da string, até o seu último elemento "\0", incrementando uma variável contadora. Ao final, o resultado da variável contadora será o tamanho/comprimento da string. **Exemplo:** ```python x = 'Hello World!' length = 0 for i in x: length += 1 print(length) ``` Saída: ```output 12 ``` ### **Aparar uma string** Remover determinados trechos ou caracteres especiais como espaços ou hífens, por exemplo, é uma prática bem comum na manipulação de strings. Sob essa ótica, a linguagem python tem os métodos strip, rstrip e lstrip que podem ser usados para remover espaços em branco antes e depois na string. strip(): retorna uma nova string removendo todos os espaços em branco iniciais e finais, incluindo tabulações "\t". **Exemplo:** ```python stTeste = " TEXTO " stTesteTrim = stTeste.strip() print("[" + stTesteTrim + "]") ``` Saída: ```output [TEXTO] ``` rstrip(): tem o comportamento semelhante ao “strip”, entretanto, só remove os espaços em branco à direita da string. **Exemplo:** ```python stTeste = " TEXTO " stTesteTrim = stTeste.rstrip() print("[" + stTesteTrim + "]") ``` Saída: ```output [ TEXTO] ``` lstrip(): atua de forma similar ao “rstrip”, porém, só remove os espaços em branco à esquerda da string. **Exemplo:** ```python stTeste = " TEXTO " stTesteTrim = stTeste.lstrip() print("[" + stTesteTrim + "]") ``` Saída: ```output [TEXTO ] ``` ### **Encontrar substrings/caracteres** De modo geral, uma substring é uma string dentro de outra string, na vida real, por exemplo, podemos destacar uma palavra dentro de uma frase, ou até mesmo os prefixos e sufixos que formam as palavras. Na linguagem python podemos fazer algumas operações com as substrings. **MÉTODO 1:** find(): o método "find" retorna o índice do primeiro caracter da substring dentro da string, caso a substring não exista ele retorna "-1". **Exemplo:** ```python substring = "Hello" string = "Hello world!" print(string.find(substring)) ``` Saída: ```output 0 ``` O resultado é "0", que corresponde ao índice inicial da substring na string. **MÉTODO 2:** rfind(): podemos usar também o método “rfind”, que retorna o último índice da substring na string. **Exemplo:** ```python substring = "hello" string = "hello world" print(string.rfind(substring)) ``` Saída: ```output 4 ``` **MÉTODO 3:** index(): Além das funções "find e rfind", também podemos usar o método "index", que funciona de forma semelhante ao método "find", todavia quando a substring não é encontrada o método retorna "ValueError". **Exemplo:** ```python substring = "z" string = "Hello world" print(string.index(substring)) ``` Saída: ```output ValueError ``` **MÉTODO 4:** Operador in: Podemos usar também o operador "in" que verifica se o operando à esquerda está contido na lista/string à direita. **Exemplo:** ```python str = "Hello world!" if 'Hello' in str: print("encontrado!") ``` Saída: ```output encontrado! ``` **MÉTODO 5:** endswith(): O método "endswhith" verifica se a substring está no final da string, caso esteja essa função retorna "true", caso contrário retorna "false". **Exemplo:** ```python str = "Hello world" subs="world" str.startswith( subs ) ``` Saída: ```output true ``` **MÉTODO 6:** startswith(): É semelhante ao "endswhith", entretanto verifica se a substring está no início da string. **Exemplo:** ```python str = "Hello world" subs = "Hello" str.startswith( subs ) ``` Saída: ```output true ``` **MÉTODO 7:** count(): Com o método "count" é possível contar a quantidade de incidências da substring na string. **Exemplo:** ```python str = "Hello world" subs = "Hello" str.count( subs ) ``` Saída: ```output 1 ``` **Outras operações:** splint(): Além de encontrar ou contar substrings, é possível criar uma lista de substrings a partir de uma string, usando a função "split". **Exemplo:** ```python string = "Hello world!" print(string.split()) ``` Saída: ```output ['Hello', 'world!'] ``` ### **Substituir substrings/caracteres** O método replace é utilizado para substituir um ou mais trechos em uma string, sendo o tipo string imutável em python, essa função retorna uma nova string, dada a modificação proposta. Esse método tem 3 parâmetros, dois obrigatórios e um opcional, que auxiliam na forma de substituição. **Exemplo de uso com parâmetros:** ```python string.replace(valorvelho, valornovo, contador) ``` O parâmetro "valorvelho" corresponde ao valor original que será substituído ao final do processo. O parâmetro "valornovo" corresponde ao novo valor que será inserido no lugar do "valorvelho". O parâmetro contador corresponde a quantas vezes o processo de substituição vai ocorrer. Esse parâmetro é opcional, caso não seja inserido o método substituirá todas as ocorrências do "valorvelho" encontrados na string, pelo "valornovo". **Exemplo:** ```python string= "Hello, world!" print(string.replace(",", " -")) ``` Saída: ```output Hello - world! ``` ### **Inverter e Rotacionar** Seguindo uma simples ideia, inversão (ou rotação) é a mudança na ordenação dos caracteres de uma string, onde o primeiro passa a ser o último, o segundo se torna o penúltimo e assim por diante. Tomando como exemplo uma string de 10 caracteres, a posição 0 troca com a 9, a posição 1 troca com a 8 e assim por diante. Considere a função reverse() que recebe uma string e retorna sua inversão. ```pseudo a = "lorem ipsum" b = reverse(a) print(b) ``` Saída: ```output "muspi merol" ``` A ideia das trocas pode ser analisada perante a quantidade de índices da string. Se a quantidade for par, as trocas ocorrerão de acordo com seu equivalente na outra extremidade, se a quantidade for ímpar não ocorre alteração no elemento central. Exemplos: ```pseudo a = "estrutura" b = "rotacionar" c = reverse(a) d = reverse(b) print(c) print(d) ``` Saída: ```output "aruturtse" // quantidade par, todos os elementos são invertidos "ranoicator" // quantidade ímpar, o elemento do meio não é alterado ``` ### **Subsequências** Subsequências são strings formadas a partir de qualquer combinação de caracteres da string original. Com isso, combinações de elementos de uma string que podem ser concatenados um a um, dois a dois, em diante, até n, onde esse n é o tamanho da string. Considerando a palavra "dados", podemos ter as seguintes subsequências: ```pseudo d, a, d, o, s, ..., da, dd, do, ..., dad, dao, das, ..., dado, dads, ..., dados, sodads, ... ``` **Não confunda:** _Substrings são subsequências da string original mas nem toda subsequência é uma substring. Isso acontece porque as subsequências não necessariamente seguem a ordenação original da string._ ### **Comparar** Dizemos que uma string é igual a outra quando seus caracteres são iguais e possuem a mesma ordenação. `polvo` é diferente de `povo`. A partir disso, temos dois possíveis cenários para nossas comparações: 1. **_case sensitive_**: Diferencia-se maiúsculas de minúsculas; ou 2. **_case insensitive_**: Não se diferencia maiúsculas de minúsculas. Uma comparação comum será sempre _case sensitive_. Dessa forma, se quisermos comparar strings sem considerar maiúsculas e minúsculas, precisaremos considerar seus caracteres todos com o mesmo "_case_" , por assim dizer. Para isso, é necessário operar em todos os elementos da string, passando cada um deles para o caso desejado. ```pseudo a = "mundo" b = "MUNDO" // a != b print("a = ", a) print("b = ", b) ``` Saída: ```output a = "mundo" b = "MUNDO" ``` Temos que transformar `b` para que fique somente em minúsculas ou `à` para maiúsculas. Considere uma função lower, onde lower('A') irá retornar 'a'. ```pseudo n = size(b) // n = 5 for (i = 0; while i < n) { b[i] = lower(b[i]) } // a == b print("a = ", a) print("b = ", b) ``` Saída: ```output a = "mundo" b = "mundo" ``` ## **Conclusão** Strings são de fato estruturas muito úteis no nosso dia a dia. Seu uso é essencial em bancos de dados, ferramentas de busca (como o grep, ), criação e validação de senhas, entre outras situações. Se quiser saber mais sobre as Strings acessse os links em nossas referências. ## Referências: - [Complete Guide on Strings With Interview Question](https://www.geeksforgeeks.org/complete-guide-on-strings-with-interview-questions/) - [Encontre um caractere em uma string em Python]() - [Substrings em Python – como dividir uma string](https://www.freecodecamp.org/portuguese/news/substrings-em-python-como-dividir-uma-string/) - [Como procurar palavras em uma string com Python (substring)](https://www.horadecodar.com.br/2020/04/26/como-procurar-palavras-em-uma-string-com-python-substring/) - [Python replace: substituindo substrings em uma string!](https://blog.betrybe.com/python/python-replace/) --- ## Este guia foi desenvolvido por **Luiz Gustavo**[![LinkedIn](https://img.shields.io/badge/linkedin-%230077B5.svg?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/luiz-gustavo-silva-151395205/)[![GitHub](https://img.shields.io/badge/GitHub-100000?style=for-the-badge&logo=github&logoColor=white)](https://github.com/)[![Twitter](https://img.shields.io/badge/Twitter-1DA1F2?style=for-the-badge&logo=twitter&logoColor=white)](https://twitter.com/) **Gabriel Ferreira**[![Dev.to blog](https://img.shields.io/badge/dev.to-0A0A0A?style=for-the-badge&logo=dev.to&logoColor=white)](https://dev.to/ufgabiira)[![LeetCode](https://img.shields.io/badge/LeetCode-000000?style=for-the-badge&logo=LeetCode&logoColor=#d16c06)](https://leetcode.com/gabriel_ferreira/)[![GitHub](https://img.shields.io/badge/github-%23121011.svg?style=for-the-badge&logo=github&logoColor=white)](https://github.com/ufgabiira) **Wellder Bernardo** **Cipriano Jose**

ufgabiira

Um Guia Sobre Strings

Join Our Newsletter. No Spam, Only the good stuff.