Python: Strings


Strings

Strings são variáveis usadas para armazenar texto. No Python elas são sequências, coleções de caracteres ordenada por posição. A manipulação de strings é um dos pontos fortes do python e existem diversas funções para isso.

Strings são definidas com aspas simples (') ou aspas duplas ("). Aspas triplas (''' ou """) podem ser usadas para definir strings longas. Strings dentro de parentêses são concatenadas, o que é útil para se escrever uma string longa sem perder a legibilidade.

» string_1 = 'casa'
» string_2 = ' da mãe Joana'
» print(string_1 + string_2)
↳ casa da mãe joana

» string_longa = '''
             este é um
             exemplo de uma
             string longa!
             '''
» print(string_longa)
↳              este é um
               exemplo de uma
               string longa!

# string concatenada com parênteses (quebras de linhas são ignoradas)
» outra_longa = (
     'https://phylos.net/'
     '2020-12-16/'
     'pacote-factoranalyser/'
     )

» print(outra_longa)
↳  'https://phylos.net/2020-12-16/pacote-factoranalyser/'

Quando se usa aspas triplas, (''' ou """), os espaços e quebras de linha são mantidos na string final. Esse recurso é muito utilizado da documentação de módulos e funções, como veremos.  Já nas strings concatenadas com parênteses espaços e quebras de linha são removidos.

Vamos ver alguns exemplos de strings e de suas manipulações. Aqui usamos print(string, end=' ') para exibir a valor de string sem a quebra de linha que é default para essa função. Nesse caso a quebra é substituída por end=’ ‘, um espaço em branco.

# a sequência pode ser percorrida
» for letra in "banana":
»     print(letra, end=' ')
↳ b a n a n a 

# definimos uma variável de string
» palavra = 'Pindamonhangaba!'

# len() fornece seu comprimento (quantos caracteres)
» len(palavra)
↳ 16
# um caracter pode ser obtido por seu índice
» print(palavra[0], palavra[15])
↳ P !
# índices negativos contam do fim para o início
» print(palavra[-1])
↳ !
» print(palavra[-2])
↳ a

# palavra[-n] equivale a palavra[len(palavra)-n]  (desde que n < len(palavra))
» palavra[len(palavra)-3]   # palavra[-3]
↳ 'b'

# uma 'fatia' (slice)
» palavra[1:4]
↳ 'ind'

# se o segundo índice for omitido a fatia vai até o fim
» palavra[5:]
↳ 'monhangaba!'

# se o primeiro índice for omitido a fatia começa no início
» palavra[:5]
↳ 'Pinda'

» palavra[:]
↳ 'Pindamonhangaba!'

# len(palavra[i:j]) = j-i
» len(palavra[1:4])
↳ 3

Vimos nos exemplos acima que uma fatia (ou slice) palavra[i:f] se inicia em i e termina em f, exclusive. Os índices, e todas as contagens em python se iniciam em 0. A posição final não é incluida de forma que len(palavra[i:j]) = j-i.

Os operadores + e * (adição e multiplicação) tem significado especial quando os operandos são strings. + promove a concatenação de strings e * retorna uma repetição.

# Operações com palavras
» p1 = 'casa'
» p2 = 'da mãe Joana'

# '+' faz uma concatenação
» p1 + ' ' + p2
↳ 'casa da mãe Joana'

# '*' repete a string
» p1 * 5
↳ 'casacasacasacasacasa'

Alguns operadores lógicos também são permitidos.

» palavra1 = 'teste'
» palavra2 = 'Teste'

» palavra1 == palavra2   # 2 sinais de =
↳ False

» palavra1 != palavra2
↳ True

» 't' in palavra1
↳ True

» 'y' not in palavra1
↳ True

Observe que nenhuma das operações realizadas até agora afetam o conteúdo da variável. Ao contrário, cada uma delas produz uma nova string. Dizemos que strings são imutáveis no python. Como são imutáveis, strings não podem ser alteradas in loco. No exemplo abaixo, para alterar ‘rato’ para ‘pato’ é necessário construir nova string e atribuí-la à variável.

# Strings são imutáveis
» str = 'rato'
» str[0]
↳ 'r'

# a tentativa de alterar a string resulta em erro
» str[0] = 'p'
↳ TypeError: 'str' object does not support item assignment

# para trocar 'r' por 'p'
» str = 'p' + str[1:]
» str
↳ 'pato'

Métodos das strings

Claro que o leitor não precisa se preocupar em memorizar todas essas funções. Uma primeira leitura serve para se ter conhecimento das possibilidades.

Como objetos, as strings possuem métodos e propriedades (coisas que veremos com detalhes mais tarde). A lista abaixo contém alguns métodos.

Método descrição
capitalize() converte 1º caracter em maiúsculo
casefold() converte string em minúsculas
center() retorna string centralizada
count() retorna número de ocorrências de um valor especificado na string
endswith() retorna True se string termina com valor especificado
find() busca por valor especificado na string e retorna a posição se encontrado
format() Formata de acordo com valores especificados (detalhes abaixo)
index() busca por valor especificado na string e retorna the posição se encontrado
isalnum() retorna True se todos os caracteres são alfa-numéricos
isalpha() retorna True se todos os caracteres são alfabéticos
isdecimal() retorna True se todos os caracteres são decimais
isdigit() retorna True se todos os caracteres são dígitos
islower() retorna True se todos os caracteres são minúsculos
isnumeric() retorna True se todos os caracteres são numéricos
isspace() retorna True se todos os caracteres são espaços
istitle() retorna True se a string segue regra de títulos
isupper() retorna True se todos os caracteres são maiúsculos
join() reune elementos de um iterável no final da string
ljust() retorna a string justificada à esquerda
lower() converte a string para minúsculas
lstrip() retorna a string sem espaços à esquerda
partition() retorna tuple partindo a string em 3 partes
replace() substitui trecho da string por outro especificado
rfind() busca trecho especificado value e retorna última posição
rindex() busca trecho especificado value e retorna última posição
rjust() retorna string justificada à direita
rsplit() quebra a string no separador especificado, retornando lista
rstrip() retorna a string sem espaços à direita
split() quebra a string no separador especificado, retornando lista
splitlines() quebra a string nas quebras de linha, retornando lista
startswith() retorna True se string começa com valor especificado
strip() retorna a string sem espaços laterais
swapcase() inverte minúsculas e maiúsculas
title() converte em maiúscula o 1º caracter de cada palavra
upper() converte a string em maiúsculas
zfill() preencha com número de zeros especificado, no início

Alguns exemplos de uso são apresentados a seguir.

» str = 'uma palavra qualquer'
# tornar a primeira letra maiúscula
» str.capitalize()
↳ 'Uma palavra qualquer'

# contar quantas letras 'a' existem na string
» str.count('a')
↳ 5

# a string termina com 'r'?
» str.endswith('r')
↳ True

# em que posição 'qu' está na string
» str.find('qu')
↳ 12

# se o trecho procurado não existe na string
» str.find('y')
↳ -1

» str.isnumeric()
↳ False

» '1234567890'.isnumeric()
↳ True

» str.replace('palavra','coisa')
'uma coisa qualquer'

» str.startswith('un')
↳ False

# join é usada para concatenar strings
» uma_tupla = ('Carro', 'Casa', 'Gado')
» x = '-'.join(uma_tupla)
» print(x)
↳ Carro-Casa-Gado

# exemplo de uso para join, construindo uma tabela html
» html = '<table><tr><td>'
» html += '</td><td>'.join(uma_tupla)
» html += '</td></tr></table>'
» print(html)
↳ <table><tr><td>Carro</td><td>Casa</td><td>Gado</td></tr></table>

# lembrando que x = 'Carro-Casa-Gado'
» for txt in x.split('-'):
»     print(txt)
↳ Carro
  Casa
  Gado

# quebrando uma frase em palavras
» frase = 'A segunda palavra da frase'
» frase.split(' ')[1]
↳ 'segunda'

No exemplo abaixo str é quebrada nos espaços, pegando cada palavra em separado. O primeiro caso imprime a palavra que começa com ‘r’ e termina com ‘a’. O segundo imprime a palavra que começa com ‘p’ e não termina com ‘a’.

» str = 'pato pata rato rata'

» for palavra in str.split(' '):
»     if palavra.startswith('r') and palavra.endswith('a'):
»         print(palavra)
↳ rata

» for palavra in str.split(' '):
»     if palavra.startswith('p') and not palavra.endswith('a'):
»         print(palavra)
↳ pato

Existem alguns mecanismos de apoio à formatação de strings, particularmente útil na impressão de resultados. Os sinais especiais %d e %s podem ser usados na montagem de strings, o primeiro como substituto de um dígito, o segundo de texto. %f informa a substituição por número de ponto flutuante, sendo %.nf  um número de ponto flutuante com n casas decimais. %E indica número com notação científica (usando potências de 10).

» s1 = 'Uma string com um dígito e texto: dígito: %d; texto: %s' % (10, 'dez')
» print(s1)
↳ Uma string com um dígito e texto: dígito: 10; texto: dez

print('Um inteiro convertido em ponto flutuante: %f' % 5)
↳ Um inteiro convertido em ponto flutuante: 5.000000

print('Exibir o número %.02f com 2 casas decimais' % 25.123456)
↳ Exibir o número 25.12 com 2 casas decimais

print('Um número com notação científica: %E' % 6.789E7)
↳ Um número com notação científica: 6.789000E+07

Um método mais moderno de formatação consiste um usar string.format(), que permite código mais legível.

# marcadores nomeados são supridos por format
» txt1 = "Eu me chamo {nome} e tenho {idade} anos.".format(nome = 'João', idade = 36)
» print(txt1)
↳ Eu me chamo João e tenho 36 anos.

# os lugares podem ser marcados numericamente
» txt2 = "Moro em {0}, {1} há {2} anos.".format('Brasília', 'DF', 20)
» print(txt2)
↳ Moro em Brasília, DF há 20 anos.

# ou marcados apenas por sua ordem de aparecimento
» txt3 = "{} são convertidos em {}. Exemplo: {}.".format('Dígitos', 'strings', 100)
» print(txt3)
↳ Dígitos são convertidos em strings. Exemplo: 100.

# podemos controlar do número de casas decimais exibidos
» txt4 = 'Esse livro custa R$ {preco:.2f} com desconto!'.format(preco = 49.8)
» print(txt4) 
↳ Esse livro custa R$ 49.80 com desconto!

Também existe o chamado método de interpolação de strings que usa o prefixo f para que a string possa incorporar variáveis.

» nome = 'Albert'
» sobrenome = 'Einstein'
» ano = 1879
» print(f'O físico {nome} {sobrenome} nasceu em {ano}')
↳ O físico Albert Einstein nasceu em 1879

# podemos inserir operações dentro da string de formatação
» a = 214
» b = 3
» print(f'{a} multiplicado por {b} é {a * b}.')
↳ 214 multiplicado por 3 é 642.

Observe que strings justapostas são concatenadas. No entanto isso gera um código menos claro. O método de interpolação torna o código de mais fácil entendimento.

print('Paul ''Adrien ''Maurice ''Dirac' ' nascido em ' '1902')
Paul Adrien Maurice Dirac nascido em 1902

fisico = 'P. A. M. Dirac'
ano = 1902
print(f'O físico {fisico} nascem em {ano}' )
O físico P. A. M. Dirac nascem em 1902

Outros exemplos com métodos de strings

Seguem mais alguns exemplos de uso. Os outputs aparecem como comentários.

# um string de teste
original = 'Pedro, Paulo,   Jonas'

# split retorna uma lista com as partes
original.split(',')                      # ['Pedro', ' Paulo', '   Jonas']

# a compreensão de lista com strip para eliminar espaços
partes = [x.strip() for x in original.split(',')]
partes                                   # ['Pedro', 'Paulo', 'Jonas']

# join juntas as partes
' : '.join(partes)                       # 'Pedro : Paulo : Jonas'

# testes de pertencimento
'Jonas' in original     # True
'Jo' in original        # True
'X' in original         # False

original.index('lo')    # 10
original.index('X')     # ValueError substring not found

original.find('Pa')     # 7
original.find('Pu')     # -1

original.count('P')     # 2

original.replace('o','a')                # 'Pedra, Paula,   Janas'

Outras operações mais sofisticadas com strings podem ser realizadas com expressões regulares. Sobre esse assunto você pode ler:

Caracteres de escape

Caracteres especiais podem ser inseridos em uma string por meio de “escapes”. Por exemplo, para usar aspas em uma string podemos fazer o seguinte:

# inserindo aspas simples em string
» print('O cara se chama O\'Maley')
↳ O cara se chama O'Maley

# se aspas duplas são usadas como delimitador a aspa simples pode ser usada
» print("O cara se chama O'Maley")
↳ O cara se chama O'Maley

» print("E seu primeiro nome é \"George\"")
↳ E seu primeiro nome é "George"

# quebra de linha
» print('linha1\nlinha2')
↳ linha1
↳ linha2
código significado
\’ aspas simples
\” aspas duplas
\\ barra invertida
\n nova linha
\r retorno de “carro”
\t tab, tabulação
\b backspace, volta 1 espaço
\f form feed
\ooo valor octal
\xhh valor hexadecimal
🔺Início do artigo

Continue a leituira: Python, testes, laços e funções

Bibliografia

Consulte a bibliografia no final do primeiro artigo dessa série.