Esse artigo vai dar uma geral nos vários métodos de manipular uma string, cobrindo coisas de métodos básicos até expressões regulares em Python. Manipular uma string é uma técnica que todo programador Python devia se familiarizar.

* Métodos de Strings *

O jeito mais básico de manipular strings é através de métodos que estão dentro delas (strings). Podemos fazer um limitado número de tarefas em strings através desses métodos. Abra sua Python Shell e vamos criar uma string e brincar um pouco com elas.

>>> test = 'This is just a simple string.' 

Vamos dar uma volta rápida e usar a função len. Ela pode ser usada para encontrar o tamanho de uma string contando espacos e caracteres especiais, ou seja, tudo que pertencer a essa string.

>>> len ( test )
29

Beleza, agora vamos voltar aos métodos que eu estava falando.Vamos pegar nossa string e substituir uma palavra usando o método replace.

>>> test = test.replace ( 'simple', 'short' )
>>> test
'This is just a short string.'

Agora vamos contar o numero de vezes que a palavra especificada aparece na string, nesse caso estou apenas procurando por um caracter 'r'.

>>> test.count ( 'r' )
2

Podemos também achar em que posição está certa levra ou palavra.

>>> test.find ( 'r' )
18
>>> test [ 18 ]
'r'

Separar uma string é uma coisa que eu frequentemente faço.O método split é usado para isso.

>>> test.split()
['This', 'is', 'just', 'a', 'short', 'string.']

Podemos escolher o ponto a ser separado.

>>> test.split ( 'a' )
['This is just ', ' short string.']

Para juntar nossa string separada, podemos usar o método join.

>>> ' some '.join ( test.split ( 'a' ) )
'This is just  some  short string.'

Podemos brincar com a caixa das letras (maiúsculo ou minúsculo).Vamos deixar tudo maiúsculo.

>>> test.upper()
'THIS IS JUST A SHORT STRING.'

Agora vamos deixar tudo minúsculo.

>>> test.lower()
'this is just a short string.'

Vamos deixar apenas a primeira letra maiúscula de uma string minúscula.

>>> test.lower().capitalize()
'This is just a short string.'

Podemos usar o método title, que deixa as letras de cada palavra da string maiúscula.

>>> test.title()
'This Is Just A Short String.'

Uma troca também é possível.O que for maiúsculo vira minúsculo e vice-versa.

>>> test.swapcase()
'tHIS IS JUST A SHORT STRING.'

Podemos rodar alguns testes numa string usando poucos métodos. Vamos ver se a string dada é totalmente maiúscula.

>>> 'UPPER'.isupper()
True
>>> 'UpPEr'.isupper()
False

Do mesmo modo, podemos checar se a string dada é minúscula.

 >>> 'lower'.islower()
True
>>> 'Lower'.islower()
False

Checando se ela é um title, no caso, todas as palavras com a primeira letra maiúscula.

>>> 'This Is A Title'.istitle()
True
>>> 'This is A title'.istitle()
False

Podemos checar se a string é alfa-numérica, ou seja, contém apenas letras e números, sem caracteres especiais.

>>> 'aa44'.isalnum()
True
>>> 'a$44'.isalnum()
False

É possível checar se uma string contém apenas letras.

>>> 'letters'.isalpha()
True
>>> 'letters4'.isalpha()
False

Agora checando se ela contém apenas números.

>>> '306090'.isdigit()
True
>>> '30-60-90 Triangle'.isdigit()
False

Podemos checar se uma string contém apenas espacos.

>>> '   '.isspace()
True
>>> ''.isspace()
False

Falando em espacos, podemos adicionar espacos em ambos os lados de uma string.Vamos adicionar espacos no lado direito de uma string.

>>> 'A string.'.ljust ( 15 )
'A string.      '

Para adicionar espacos do lado esquerdo, o método rjust é usado.

>>> 'A string.'.rjust ( 15 )
'      A string.'

O método center é usado para centralizar uma string dentro de espacos.

>>> 'A string.'.center ( 15 )
'   A string.   '

Podemos separar os espacos de ambos os lados de uma string.

>>> 'String.'.rjust ( 15 ).strip()
'String.'
>>> 'String.'.ljust ( 15 ).rstrip()
'String.'

* Expressões regulares *

Expressões regulares são uma ferramenta muito poderosa em qualquer linguagem.Elas permitem que padrões sejam "achados" ou "casados" dentro de strings.Ações como substituição podem ser feitas na string se a expressão regular "casar" com alguma parte da string.O módulo que cuida de expressões regulares no Python é o re.De volta à nossa shell...

>>> import re

Vamos criar uma string simples para brincarmos um pouco.

>>> test = 'This is for testing regular expressions in Python.'

Vamos começar com padrões simples para serem "achados" dentro da string, depois passamos para alguns mais complexos.Existem dois métodos para achar padrões em strings com o módulo re: search e match.Vamos dar uma olhada no search primeiro.

>>> result = re.search ( 'This', test )

Podemos extrair o resultado usando o método group.

>>> result.group ( 0 )
'This'

Você provavelmente está se perguntando sobre o método group e por que passamos zero para ele.É simples, e eu vou explicar.Veja só, padrões são organizados em grupos, desse jeito:

>>> result = re.search ( '(Th)(is)', test )

Aqui há dois grupos dentro dos parenteses.Podemos extraí-los usando o método group.

>>> result.group ( 1 )
'Th'
>>> result.group ( 2 )
'is'

Passando zero para o método retorna ambos os grupos.

>>> result.group ( 0 )
'This'

O benefício dos grupos se tornará claro depois que trabalharmos desse jeito em padrões normais. Primeiro vamos dar uma olhada na função match.Ela funciona similarmente à função search, mas existe uma diferença crucial.

>>> result =  re.match ( 'This', test )
>>> print result
<_sre.SRE_Match object at 0x00994250>
>>> print result.group ( 0 )
'This'
>>> result = re.match ( 'regular', test )
>>> print result
None

Note que None (o valor nulo do Python) foi retornado, mesmo com a palavra "regular" dentro da string.Se você não entendeu, o método match acha os padrões no início da string, e o search examina a função inteira.Você deve estar se perguntando se é possível o match encontar a palavra "regular" na string,mesmo a palavra não estando no início da string.A resposta é sim, é possível e isso nos leva a aprender um pouco sobre padrões ou patterns.

O caracter '.' casa com qualquer caracter.Podemos usar o método match para achar a palavra "regular" colocando um ponto para cada letra antes dele.Vamos separar isso em dois grupos.Um vai conter os pontos, e o outro vai conter o "regular".

>>> result = re.match ( '(....................)(regular)', test )
>>> result.group ( 0 )
'This is for testing regular'
>>> result.group ( 1 )
'This is for testing '
>>> result.group ( 2 )
'regular'

Viu só, conseguimos.No entanto é ridículo ter que colocar todos esses pontos.A boa notícia é que realmente não precisamos colocá-los.Dê uma olhada nisso e lembre que existem 20 caracteres antes da palavra "regular", é só contar.

>>> result = re.match ( '(.{20})(regular)', test )
>>> result.group ( 0 )
'This is for testing regular'
>>> result.group ( 1 )
'This is for testing '
>>> result.group ( 2 )
'regular'

Assim é bem mais fácil.Agora vamos ver um pouco mais sobre padrões.Aqui é como você pode usar chaves de um jeito mais avançado.

>>> result = re.match ( '(.{10,20})(regular)', test )
>>> result.group ( 0 )
'This is for testing regular'
>>> result = re.match ( '(.{10,20})(testing)', test )
'This is for testing'

Colocando dois argumentos {10,20} , quer dizer que você pode achar qualquer número de caracteres em uma escala (range), nesse caso de 10 a 20.Algumas vezes, no entanto, isso pode mostrar-nos um comportamento indesejado.Olhe só:

>>> anotherTest = 'a cat, a dog, a goat, a person'

Vamos fazer uma escala (range) de caracteres.

>>> result = re.match ( '(.{5,20})(,)', anotherTest )
>>> result.group ( 1 )
'a cat, a dog, a goat'

Agora vamos pegar somente "a cat".E isso pode ser feito adicionando "?" ao final das chaves:

>>> result = re.match ( '(.{5,20}?)(,)', anotherTest )
>>> result.group ( 1 )
'a cat'

Adicionando um ponto de interrogação faz a função "achar" a menor quantidade possível de caracteres.Um ponto de interrogação faz isso e não deve ser confundido com esse padrão abaixo:

>>> anotherTest = '012345'
>>> result = re.match ( '01?', anotherTest )
>>> result.group ( 0 )
'01'
>>> result = re.match ( '0123456?', anotherTest )
>>> result.group ( 0 )
'012345'

Como você pode ver, o caracter antes do ponto de interrogação é opcional na procura.

Bom, agora que você já sabe brincar com expressões regulares dentro do Python, aprenda um pouco mais sobre elas em [http://aurelio.net/er/ Site do Aurélio] e compre o seu guia de consulta rápida, muito útil. É isso ai pessoal, por hoje é só. Abraço a todos

EduardoOliva