Manipulação de strings com Python

No cotidiano do desenvolvimento de software, em meio a todas as soluções técnicas criadas, seja para resolver um bug...

Andressa Araujo

View posts by Andressa Araujo
Formada em análise e desenvolvimento de sistemas pelo Instituto Federal, iniciei minha minha carreira como desenvolvedora de soluções em software há 5 anos, atuando tanto no frontend quanto no backend. Gosto de ir a praia, assistir animes, cozinhar e conversar.
Data de publicação: 13/04/2020

No cotidiano do desenvolvimento de software, em meio a todas as soluções técnicas criadas, seja para resolver um bug ou para implementar uma nova funcionalidade, programadores deparam-se com a possibilidade de manipular de alguma forma o valor de uma string. Esse cenário pode gerar desconfortos e até resistência para alguns desenvolvedores que consideram a manipulação de strings a opção menos viável do ponto de vista das boas práticas de desenvolvimento. Essas considerações fazem sentido em alguns contextos, mas não é uma regra. Para decidir pela melhor solução técnica é importante conhecer os recursos de manipulação de strings oferecidos pela linguagem utilizada. Partindo desse princípio, este artigo apresenta conceitualmente os métodos para manipulação de strings oferecidos pela linguagem Python.

Python

Python é uma linguagem de programação de alto nível, multiparadigma, open source, com código altamente legível, popular na comunidade de desenvolvimento de software que prioriza o desenvolvimento das lógicas de negócio em relação a preocupação com o gerenciamento dos recursos computacionais. Demandas relacionadas a processamento de dados científicos, textos, imagens ou criação CMSs em páginas dinâmicas para web podem ser facilitadas com os recursos oferecidos pela linguagem Python, junto aos frameworks, bibliotecas e módulos desenvolvidos pela grande e ativa comunidade apoiadora da linguagem.

Strings

String é um tipo de dado que representa textos através de arranjos de bytes que a partir de algum padrão de codificação preestabelecida, armazenam em caracteres uma cadeia sequencial finita, de forma literal ou usando variáveis.

Manipulação de Strings em Python

O Python disponibiliza um conjunto de funções em sua classe str, oferecendo poderosos recursos para manipulação de Strings. Objetos da classe str são imutáveis, dessa forma suas funções retornam uma nova cadeia de caracteres, com um endereço de memória diferente da string utilizada inicialmente. Algumas bibliotecas foram desenvolvidas pela comunidade para potencializar as operações com strings utilizando a linguagem.

Como toda linguagem dinamicamente tipada, em Python não se faz necessário a declaração do tipo da variável. Portanto, para declarar uma string basta apenas realizar a atribuição do seu valor, comumente usado entre aspas simples ou duplas.. As funções nativas do Python são geralmente implementadas em linguagens baixo nível, como por exemplo C ou Fortran. A maioria dos recursos oferecidos pela linguagem podem ser implementadas com Python, porém essas implementações não serão executadas com a mesma performance que suas correspondentes built-in. Abaixo, listamos, definimos e exemplificamos algumas funções de manipulação de strings built-in da linguagem Python, classificadas pelas suas funções:

Operações

Concatenate: concatena strings a partir do operador “+”.

name = 'Andressa'
last_name = 'Araújo'
full_name = name + ' ' + last_name
print(f'{full_name}')

Output:

Andressa Araújo

Contains: retorna a ocorrência de elementos na string com o operador “in”.

name = 'Andressa'
last_name = 'Araújo'
full_name = name + ' ' + 'last_name'
first_name = name in full_name
print(f'{first_name}')

Output:

True

Multiply: repete a string pela quantidade definida pelo operador “*”.

name = 'Andressa'
repeated_name = name * 4
print(f'{repeated_name}')

Output:

AndressaAndressaAndressaAndressa

Obj: o próprio objeto str(), retorna uma string. Seu construtor pode receber tanto um valor como uma operação, seu retorno será sempre uma string do resultado dessa operação.

dolar = 5
real = str(1*dolar)
print(f'R$ {real}')

Output:

R$ 5

Formatação

Center: cria uma string com a quantidade de caracteres recebidas por parâmetro e centraliza o texto com a string aplicada. O center não funciona com strings multilines.

poema = 'o menino quer um burrinho para passear.'
print(poema)
print(poema.center(50))
print(poema.center(100))

Output:

o menino quer um burrinho para passear.
     o menino quer um burrinho para passear.
          o menino quer um burrinho para passear.

Capitalize: retorna o texto com suas iniciais em maiúsculo.

poema = 'o menino quer um burrinho para passear.'
print(poema.capitalize())

Output:

O menino quer um burrinho para passear.

Casefold: remove qualquer formatação da string. Sua diferença em relação a função lower() está no fato da função casefold() obter o código correspondente de cada caractere em sua versão lower num mesmo padrão de codificação em representação de texto, para fins de comparação.

poema = 'O menino quer um burrinho para passear.'
print(poema.casefold())

Output:

o menino quer um burrinho para passear.

Format: Insere a valores no espaço reservado da string “{}”. Provavelmente a função format() será substituída pela função f-string(), que mantém as mesmas características da função format(), porém de maneira mais performática, sendo executada na metade do tempo, com uma sintaxe mais parecida com o template string do Javascript.

animal = 'burrinho'
poema = 'O menino quer um {animal} para passear.'.format(animal)
print(poema)

Output:

O menino quer um burrinho para passear.

Expandtabs: repete os tabs da string pela quantidade de vezes informada.

poema = 'O menino quer um\tburrinho para passear.'
print(poema)
print(poema.expandtabs(30))
print(poema.expandtabs(40))
print(poema.expandtabs(50))

Output:

O menino quer um      burrinho para passear.
O menino quer um          burrinho para passear.
O menino quer um                burrinho para passear.
O menino quer um                     burrinho para passear.

Lower: retorna a string em caracteres minúsculos.

poema = 'O Menino Quer Um Burrinho Para Passear.'
print(poema.lower())

Output:

o menino quer um burrinho para passear.

Ljust: justifica o texto para esquerda.

poema = 'O menino quer um burrinho para passear.'
print(poema)
print(poema.ljust(50))

Output:

O menino quer um burrinho para passear.
O menino quer um burrinho para passear.

Rjust: justifica o texto para direita.

poema = 'O menino quer um burrinho para passear.'
print(poema)
print(poema.rjust(50))

Output:

O menino quer um burrinho para passear.
     O menino quer um burrinho para passear.

Swapcase: altera minusculas para maiúsculas e vice versa.

poema = 'O Menino Quer Um Burrinho Para Passear.'
print(poema.swapcase())

Output:

o mENINO qUER uM bURRINHO pARA pASSEAR.

Upper: retorna a string em caracteres minúsculos.

poema = 'O Menino Quer Um Burrinho Para Passear.'
print(poema.upper())

Output:

O MENINO QUER UM BURRINHO PARA PASSEAR.

Validações

Count: retorna a quantidade de vezes que um elemento ocorre na string.

poema = 'O menino quer um burrinho para passear.'
print(poema.count('a'))

Output:

4

Find: Retorna o índice da primeira ocorrência do termo na string. Caso não exista a ocorrência do termo na string, a função retorna o valor -1.

poema = 'O menino quer um burrinho para passear.'
print(poema.find('i'))

Output:

5

Isupper: verifica se a string esta em caixa alta.

poema = 'O menino quer um burrinho para passear.'
print(poema.isupper())
print(poema.upper().isupper())

Output:

False
True

Islower: verifica se a string esta em caixa baixa.

poema = 'O menino quer um burrinho para passear.'
print(poema.islower())
print(poema.lower().islower())

Output:

False
True

Istitle: verifica se a string esta em formato texto.

poema = 'O menino quer um burrinho para passear.'
print(poema.istitle())
print(poema.title().istitle())

Output:

False
True

Isalnum: verifica se a string representa estritamente um número.

print('24 years old'.isalnum())
print('24'.isalnum())

Output:

False
True

Isalha: verifica se a string representa estritamente textos.

print('twenty four years old'.isalpha())
print('twentyfouryearsold'.isalpha())

Output:

False
True

Isdigit: verifica se a string representa um digito.

print('24 years old'.isdigit())
print('24'.isdigit())

Output:

False
True

Isspace: verifica se a string representa espaços, considerando qualquer representação de espaço em branco.

white_space = '\t\n\r\x0b\x0c'
age = '24 years old'

print([c for c in white_space if c.isspace()])
print([c for c in white_space if not c.isspace()])
print(age.isspace())
print([x for x in age if x.isspace()])
print([x for x in age if not x.isspace()])

Output:

['', '\t', '\n', '\r', '\x0b', '\x0c']
[]
false
['', '']
['2', '4', 'y', 'e', 'a', 'r', 'o', 'l', 'd']

Isprintable: verifica se a string contém elementos printáveis.

print('''O menino quer um burrinho para passear. 
   Um burrinho manso, que não corra nem pule, 
   mas que saiba conversar.'''
.isprintable())

Output:

False

Index: retorna a posição da primeira ocorrência do elemento na string, a diferença no find() para o index() consiste no retorno quando não há incidência do termo na string, no caso do index() retornando uma exceção, enquanto o find() retorna o valor -1.

print('''O menino quer um burrinho para passear. 
   Um burrinho manso, que não corra nem pule, 
   mas que saiba conversar.'''
.index('burrinho'))

Output:

17

Isidentifier: verifica se a string é válida considerando os padrões de identificadores do Python. Um exemplo de utilização da função isidentifier() seria na criação de uma biblioteca com uma função de serialização de models, em que cada atributo é uma variável Python, precisando seguir os padrões de identificadores válidos do Python, sendo iniciada por qualquer carácter texto, não contendo caracteres especiais.

user = 'andressasantosaraujo'
domain = '@gmail.com'
email = user + domain

print(user.identifier())
print(domain.identifier())
print(email.identifier())

Output:

True
False
False

Len: é uma função, implementada para objetos nativos do PyVarObjects, retornando o tamanho do objeto, e para estruturas implementadas em Python, através da implementação da função s.__len__(), retornando de maneira eficiente a quantidade de elementos.

print(len('''O menino quer um burrinho para passear. 
   Um burrinho manso, que não corra nem pule, 
   mas que saiba conversar.'''))

Output:

107

Max: retorna o maior caractere da tabela ascii dentro da string.

print(max('''O menino quer um burrinho para passear. 
   Um burrinho manso, que não corra nem pule, 
   mas que saiba conversar.'''))

Output:

ã

Min: retorna o menor carácter da string dentro da string.

print(min('Andressa'))
print(min('Santos'))

Output:

A
S

Punctuation: é uma constante da lib built-in string que contém uma string com todas as representações de pontuação, acentuação e outros caracteres especiais para texto.

import string

poema = '''O menino quer um burrinho para passear. 
   Um burrinho manso, que não corra nem pule, 
   mas que saiba conversar.'''

print(string.punctuation) 
print([punc for punc in poema if punc in string.punctuation]) 
print([punc for punc in poema if punc not in string.punctuation])

Output:

!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

['.', ',', ',', '.']

['O', ' ', 'm', 'e', 'n', 'i', 'n', 'o', ' ', 'q', 'u',
'e', 'r', ' ', 'u', 'm', ' ', 'b', 'u', 'r', 'r', 'i',
'n', 'h', 'o', ' ', 'p', 'a', 'r', 'a', ' ', 'p', 'a',
's', 's', 'e', 'a', 'r', '\n', 'U', 'm', ' ', 'b', 'u',
'r', 'r', 'i', 'n', 'h', 'o', ' ', 'm', 'a', 'n', 's',
'o', ' ', 'q', 'u', 'e', ' ', 'n', 'ã', 'o', ' ', 'c',
'o', 'r', 'r', 'a', ' ', 'n', 'e', 'm', ' ', 'p', 'u',
'l', 'e', '\n', 'm', 'a', 's', ' ', 'q', 'u', 'e', ' ',
's', 'a', 'i', 'b', 'a', ' ', 'c', 'o', 'n', 'v', 'e',
'r', 's', 'a', 'r']

Startswith: verifica se a string é iniciada com o termo buscado.

import string 

poema = '''O menino quer um burrinho para passear.
   Um burrinho manso, que não corra nem pule, mas que
   saiba conversar.'''

print(poema.startswith('O'))
print(poema.startswith('o'))
TRUE
FALSE

Whitespace: é uma constante da biblioteca built-in string que contém uma string com todas as representações de espaços e quebras de linha.

import string

poema = '''O menino quer um burrinho para passear. 
   Um burrinho manso, que não corra nem pule, 
   mas que saiba conversar.'''

string.whitespace
print([s for s in poema if s in string.whitespace]) 
print([s for s in poema if s not in string.whitespace])

Output:

' \t\n\r\x0b\x0c'

[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
' ', ' ', ' ', ' ', ' ', ' ', ' ']

['O', 'm', 'e', 'n', 'i', 'n', 'o', 'q', 'u', 'e', 'r',
'u', 'm', 'b', 'u', 'r', 'r', 'i', 'n', 'h', 'o', 'p',
'a', 'r', 'a', 'p', 'a', 's', 's', 'e', 'a', 'r', '.',
'U', 'm', 'b', 'u', 'r', 'r', 'i', 'n', 'h', 'o', 'm',
'a', 'n', 's', 'o', ',', 'q', 'u', 'e', 'n', 'ã', 'o',
'c', 'o', 'r', 'r', 'a', 'n', 'e', 'm', 'p', 'u', 'l',
'e', ',', 'm', 'a', 's', 'q', 'u', 'e', 's', 'a', 'i',
'b', 'a', 'c', 'o', 'n', 'v', 'e', 'r', 's', 'a', 'r',
'.']

Manipulação

Encode: retorna a string com o padrão de codificação informado, como por exemplo ascii ou utf-8. Podemos tratar os erros de conversão do padrão de codificação utilizando o parâmetro errors com os valores replace ou backslashreplace, que substitui o termo que não pode ser convertido.

poema = '''O menino quer um burrinho para passear. 
   Um burrinho manso, que não corra nem pule, 
   mas que saiba conversar.'''

print(poema.encode('utf-8'))
print(poema.encode('ascii'))
print(poema.encode('ascii', errors='backslashreplace'))

Output:

b'O menino quer um burrinho para passear. Um burrinho
manso, que n\xc3\xa3o corra nem pule, mas que saiba
conversar.'

UnicodeEncodeError: 'ascii' codec can't encode character
'\xe3' in position 64: ordinal not in range(128)

b'O menino quer um burrinho para passear. Um burrinho
manso, que n\\xe3o corra nem pule, mas que saiba conversar.'

Join: concatena valores com uma iteração de elementos de listas, tuplas ou objetos.

first_name = 'Andressa'
middle_name = 'Santos'
last_name = 'Araújo'
full_name = (first_name, middle_name, last_name)
print(''.join(full_name))

Output:

Andressa Santos Araújo

Partition: particiona a string pela primeira ocorrência do termo informado, retornando uma tupla. Essa tupla é composta possivelmente por três elementos. O primeiro elemento é a substring antes da ocorrência do termo, o segundo elemento é a primeira ocorrência do termo e o terceiro elemento é a substring restante.

poema = '''O menino quer um burrinho para passear.
   Um burrinho manso, que não corra nem pule, mas que
   saiba conversar.'''

print(poema.partition('burrinho'))

Output:

('O menino quer um ', 'burrinho', ' para passear.
   Um burrinho manso, que não corra nem pule,
   mas que saiba conversar.')

Replace: substitui todas as ocorrências de elementos da string pelo termo indicado por parâmetro.

poema = 'O menino quer um burrinho para passear.'
print(poema.replace(' ', ''))

Output:

Omeninoquerumburrinhoparapassear.

Slice: retorna uma substring do intervalo indicado na string original. Essa função está implementada em qualquer PyVarObject.

poema = 'O menino quer um burrinho para passear.'
print(poema[3:8])
print(poema[2:8])

Output:

enino
Menino

Split: retorna uma lista da string segmentada pelo separador informado.

data = '01/02/2021'
print(data.split('/'))

Output:

['01', '02', '2021']

Splitlines: particiona a string por quebra de linha.

poema = '''O menino quer um burrinho para passear.
   Um burrinho manso, que não corra nem pule, mas que
   saiba conversar.'''

print(poema.splitlines())

Output:

['O menino quer um burrinho para passear. Um burrinho manso, que não
corra nem pule, mas que saiba conversar.']

Strip: remove do início e final da string, o termo indicado no parâmetro.

poema = '__O_menino_quer_um_burrinho_para_passear.___'
print(poema.strip('_'))

Output:

O_menino_quer_um_burrinho_para_passear.

Template: permite a utilização de dados computacionais em uma string, assim como a função format() o Template provavelmente cairá em desuso, sendo substituído pela função f-string(), promovendo ganhos de performance e legibilidade.

from string import Template
poema_template = Template('O menino quer um $presente para passear.'
print(poema_template.substitute(presente='burrinho'))

Output:

O menino quer um burrinho para passear.

Translate: mapeia cada termo pelo seu correspondente na tabela de tradução.

intab = 'aeiou'
outtab = '12345'
trantab = str.maketrans(intab, outtab)
poema = 'O menino quer um burrinho para passear.'
print(poema.translate(trantab))

Output:

O m2n3n4 q52r 5m b5rr3nh4 p1r1 p1ss21r.

Expressão regular

O Python segue uma ideologia purista. Devido a isso, os recursos que estão em seu core standard, é apenas aquilo que é fundamental e elementar da linguagem. Recursos adicionais são separados em bibliotecas built-in ou biblioteca de terceiro. Essa organização influencia na leveza e legibilidade do Python com declarações explícitas. Esse é o caso da biblioteca re, que contém recursos para manipulação de string com expressões regulares. Confira abaixo a definição e implementação dessas funções.

Findall: retorna a lista do matches com a expressão na ordem encontrada.

import re
pattern = '([a-z]+)(\d+)'
example = 'covid19'
print(re.findall(pattern, example))

Output:

[('covid', 19)]

Search: retorna o primeira a primeira ocorrência do match.

Group: retorna o trecho da string em que ocorreu o match, segmentado por grupos.

import re
pattern = '([a-z]+)(\d+)'
example = 'covid19'
reg_obj = re.search(pattern, example)
print('group(0): {}, group(1): {}, group(2): {}'.format())

Output:

group(0): covid19, group(1): covid, group(2): 19

Conclusão

String é um tipo de dado primitivo de linguagens de programação de alto nível que representa texto através de uma cadeia de caracteres. O Python é uma popular linguagem de programação flexível e robusta mantida pela comunidade e utilizada para o desenvolvimento de soluções de diferentes nichos. Poderosos recursos de manipulação de strings são oferecidos pelo Python, através de sua classe string e das bibliotecas externas desenvolvidas pela comunidade.

As vantagens da manipulação de strings com Python encontram-se na variedade de funções de operações, formatação, validação e manipulação oferecidas pela linguagem, com legibilidade e simplicidade de implementação. Manipular strings pode ser complexo e perigoso quando programadores não dominam os recursos oferecidos pela linguagem utilizada, mas também pode ser uma possibilidade inteligente em contextos em que o problema incide diretamente na alteração desse tipo de dado.

Referências

https://docs.python.org/3.1/library/strings.html
https://wiki.python.org.br/ManipulandoStringsComPython
https://www.w3schools.com/python/python_ref_string.asp
https://www.programiz.com/python-programming/methods/string
https://realpython.com/python-strings/

Andressa Araujo

View posts by Andressa Araujo
Formada em análise e desenvolvimento de sistemas pelo Instituto Federal, iniciei minha minha carreira como desenvolvedora de soluções em software há 5 anos, atuando tanto no frontend quanto no backend. Gosto de ir a praia, assistir animes, cozinhar e conversar.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

cinco + seis =

Posts relacionados

  1. Sobre a Dextra

    Somos especialistas em desenvolvimento de software sob medida para negócios digitais. Pioneiros na adoção de metodologias de gestão ágil, combinamos processos de design, UX, novas tecnologias e visão de negócio, desenvolvendo soluções que criam oportunidades para nossos clientes.

  2. Categorias

Scroll to top