Strings em

Sobre Strings

Uma str em Python é uma sequência imutável de pontos de código Unicode. Estes podem incluir letras, sinais diacríticos, carateres de posicionamento, números, símbolos de moeda, emoji, pontuação, espaços e carateres de quebra de linha, entre muitos outros.

Para uma análise aprofundada da informação que uma string codifica (ou, "como é que um computador sabe traduzir zeros e uns em letras?"), esta publicação de blog continua a ser muito útil. A documentação do Python disponibiliza também um HOWTO sobre Unicode muito detalhado, que aborda o suporte do Python à especificação Unicode nos módulos str, bytes e re, as considerações sobre locales e alguns problemas comuns de codificação e tradução.

As strings implementam todas as operações comuns de sequências e podem ser iteradas através da sintaxe for item in <str> ou for index, item in enumerate(<str>). Cada ponto de código individual (strings de comprimento 1) pode ser referido por um número 0-based index a contar da esquerda, ou por um número -1-based index a contar da direita.

As strings podem ser concatenadas com <str> + <other str> ou <str>.join(<iterable>) e divididas através de <str>.split(<separator>). Oferecem também várias opções adicionais de formatação, montagem e criação de modelos.

Um literal str pode ser declarado com aspas simples ' ou aspas duplas ". O caráter de escape \ está disponível sempre que for necessário.

>>> single_quoted = 'These allow "double quoting" without "escape" characters.'

>>> double_quoted = "These allow embedded 'single quoting', so you don't have to use an 'escape' character."

As strings multilinha declaram-se com ''' ou """.

>>> triple_quoted = '''Three single quotes or "double quotes" in a row allow for multi-line string literals.
  Line break characters, tabs and other whitespace is fully supported. Remember - The escape "\" character is also available if needed (as can be seen below). 
  
  You\'ll most often encounter multi-line strings as "doc strings" or "doc tests" written just below the first line of a function or class definition.
    They\'re often used with auto documentation ✍ tools.
    '''

O construtor str(<object>) pode ser usado para criar/converter strings a partir de outros objetos:

>>> my_number = 42
>>> str(my_number)
...
"42"

Embora o construtor str(<object>) possa ser usado para converter strings, não itera nem desempacota um objeto. Isto é diferente do comportamento dos construtores de outros tipos de dados, como list(), set(), dict() ou tuple(), e pode ter resultados surpreendentes.

>>> numbers = [1,3,5,7]
>>> str(numbers)
...
'[1,3,5,7]'

Os pontos de código dentro de uma str podem ser referidos por um número 0-based index a contar da esquerda:

creative = '창의적인'

>>> creative[0]
'창'

>>> creative[2]
'적'

>>> creative[3]
'인'

A indexação também funciona a partir da direita, começando num número -1-based index:

creative = '창의적인'

>>> creative[-4]
'창'

>>> creative[-2]
'적'

>>> creative[-1]
'인'

Em Python não existe um tipo separado de «caráter» ou «rune», por isso indexar uma string produz uma nova str de comprimento 1:

>>> website = "exercism"
>>> type(website[0])
<class 'str'>

>>> len(website[0])
1

>>> website[0] == website[0:1] == 'e'
True

As substrings podem ser selecionadas através de notação de slice, usando <str>[<start>:<stop>:<step>] para produzir uma nova string. Os resultados excluem o índice stop. Se não for dado um start, o índice inicial será 0. Se não for dado um stop, o índice stop será o fim da string.

moon_and_stars = '🌟🌟🌙🌟🌟⭐'

>>> moon_and_stars[1:4]
'🌟🌙🌟'

>>> moon_and_stars[:3]
'🌟🌟🌙'

>>> moon_and_stars[3:]
'🌟🌟⭐'

>>> moon_and_stars[:-1]
'🌟🌟🌙🌟🌟'

>>> moon_and_stars[:-3]
'🌟🌟🌙'

As strings também podem ser divididas em strings mais pequenas através de <str>.split(<separator>), que devolve uma list de substrings. Usar <str>.split() sem quaisquer argumentos divide a string pelos espaços em branco.

>>> cat_ipsum = "Destroy house in 5 seconds command the hooman."
>>> cat_ipsum.split()
...
['Destroy', 'house', 'in', '5', 'seconds', 'command', 'the', 'hooman.']


>>> cat_words = "feline, four-footed, ferocious, furry"
>>> cat_words.split(',')
...
['feline', ' four-footed', ' ferocious', ' furry']


>>> colors = """red,
orange,
green,
purple,
yellow"""

>>> colors.split(',\n')
['red', 'orange', 'green', 'purple', 'yellow']

As strings podem ser concatenadas com o operador +. Este método deve ser usado com moderação, pois não é muito eficiente nem fácil de manter.

language = "Ukrainian"
number = "nine"
word = "дев'ять"

sentence = word + " " + "means" + " " + number + " in " + language + "."

>>> print(sentence)
...
"дев'ять means nine in Ukrainian."

Se for preciso combinar uma list, um tuple, um set ou outra coleção de strings individuais numa única str, <str>.join(<iterable>) é uma opção melhor:

# str.join() makes a new string from the iterables elements.
>>> chickens = ["hen", "egg", "rooster"] # Lists are iterable.
>>> ' '.join(chickens)
'hen egg rooster'

# Any string can be used as the joining element.
>>> ' :: '.join(chickens)
'hen :: egg :: rooster'

>>> ' 🌿 '.join(chickens)
'hen 🌿 egg 🌿 rooster'


# Any iterable can be used as input.
>>> flowers = ("rose", "daisy", "carnation")  # Tuples are iterable.
>>> '*-*'.join(flowers)
'rose*-*daisy*-*carnation'

>>> flowers = {"rose", "daisy", "carnation"}  # Sets are iterable, but output order is not guaranteed.
>>> '*-*'.join(flowers)
'rose*-*carnation*-*daisy'

>>> phrase = "This is my string"  # Strings are iterable, but be careful!
>>> '..'.join(phrase)
'T..h..i..s.. ..i..s.. ..m..y.. ..s..t..r..i..n..g'


# Separators are inserted **between** elements, but can be any string (including spaces).
# This can be exploited for interesting effects.
>>> under_words = ['under', 'current', 'sea', 'pin', 'dog', 'lay']
>>> separator = ' ⤴️ under' # Note the leading space, but no trailing space.
>>> separator.join(under_words)
'under ⤴️ undercurrent ⤴️ undersea ⤴️ underpin ⤴️ underdog ⤴️ underlay'

# The separator can be composed different ways, as long as the result is a string.
>>> upper_words = ['upper', 'crust', 'case', 'classmen', 'most', 'cut']
>>> separator = ' 🌟 ' + upper_words[0] # This becomes one string, similar to ' ⤴️ under'.
>>> separator.join(upper_words)
 'upper 🌟 uppercrust 🌟 uppercase 🌟 upperclassmen 🌟 uppermost 🌟 uppercut'

As strings suportam todas as operações comuns de sequências. Cada ponto de código individual pode ser percorrido num ciclo com for item in <str>. Os índices com os respetivos itens podem ser percorridos num ciclo com for index, item in enumerate(<str>).

>>> exercise = 'လေ့ကျင့်'

# Note that there are more code points than perceived glyphs or characters.
# Care should be used when iterating over languages that use
# combining characters, or when dealing with emoji.
>>> for code_point in exercise:
...    print(code_point)
...
လ
ေ
့
က
ျ
င
်
့

# Using enumerate will give both the value and index position of each element.
>>> for index, code_point in enumerate(exercise):
...    print(index, ": ", code_point)
...
0 :  လ
1 :  ေ
2 :  ့
3 :  က
4 :  ျ
5 :  င
6 :  ်
7 :  ့

Métodos de string

O Python disponibiliza um conjunto rico de métodos de string que ajudam a pesquisar, limpar, dividir, transformar, traduzir e realizar muitas outras operações. Uma seleção destes métodos é abordada noutro exercício.

Formatação

O Python disponibiliza também um conjunto rico de ferramentas para formatar e criar modelos de strings, bem como processamento de texto mais sofisticado através dos módulos re (expressões regulares), difflib (comparação de sequências) e textwrap. Para uma excelente introdução à formatação de strings em Python, vê esta publicação no Real Python. Para uma introdução aos métodos de string, vê Strings and Character Data in Python no mesmo site.

Tipos e codificações relacionados

Além de str (uma sequência de texto), o Python tem tipos de sequências binárias correspondentes, resumidos em serviços de dados binários: bytes (uma sequência binária), bytearray e memoryview, para armazenar e manipular dados binários de forma eficiente. Além disso, os Streams permitem enviar e receber dados binários através de uma ligação de rede sem usar callbacks.