Strings em

Sobre Strings

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

Para se aprofundar no que uma string codifica (ou, "como um computador sabe traduzir zeros e uns em letras?"), este post de blog é sempre útil. A documentação do Python também traz um HOWTO de Unicode bem detalhado, que aborda o suporte do Python à especificação Unicode nos módulos str, bytes e re, considerações sobre locales e alguns problemas comuns de codificação e tradução.

Strings implementam todas as operações comuns de sequência e podem ser percorridas com a sintaxe for item in <str> ou for index, item in enumerate(<str>). Pontos de código individuais (strings de comprimento 1) podem ser acessados por um índice 0-based index a partir da esquerda, ou por um índice -1-based index a partir da direita.

Strings podem ser concatenadas com <str> + <other str> ou <str>.join(<iterable>), e divididas com <str>.split(<separator>). Elas também oferecem várias outras opções de formatação, montagem e templates.

Um literal str pode ser declarado com aspas simples ' ou duplas ". O caractere de escape \ fica disponível quando 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."

Strings de várias linhas são declaradas 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, ele não vai iterar nem desempacotar um objeto. Isso é diferente do comportamento dos construtores de outros tipos de dados, como list(), set(), dict() ou tuple(), e pode gerar resultados surpreendentes.

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

Os pontos de código dentro de uma str podem ser acessados por um índice 0-based index a partir da esquerda:

creative = '창의적인'

>>> creative[0]
'창'

>>> creative[2]
'적'

>>> creative[3]
'인'

A indexação também funciona a partir da direita, começando com um índice -1-based index:

creative = '창의적인'

>>> creative[-4]
'창'

>>> creative[-2]
'적'

>>> creative[-1]
'인'

Não existe um tipo separado para "caractere" ou "rune" em Python, então 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

Substrings podem ser selecionadas por meio de slice notation, usando <str>[<start>:<stop>:<step>] para produzir uma nova string. O resultado exclui o índice stop. Se nenhum start for informado, o índice inicial será 0. Se nenhum stop for informado, 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]
'🌟🌟🌙'

Strings também podem ser divididas em strings menores com <str>.split(<separator>), que retorna uma list de substrings. Usar <str>.split() sem nenhum argumento divide a string nos 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']

Strings podem ser concatenadas com o operador +. Use esse método com moderação, pois ele 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 uma list, uma tuple, um set ou outra coleção de strings individuais precisar ser combinada em uma ú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'

Strings suportam todas as operações comuns de sequência. Pontos de código individuais podem ser percorridos em um laço com for item in <str>. Índices com itens podem ser percorridos em um laço 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 oferece um rico conjunto de métodos de string que ajudam na busca, na limpeza, na divisão, na transformação, na tradução e em muitas outras operações. Uma seleção desses métodos é abordada em outro exercício.

Formatação

O Python também oferece um rico conjunto de ferramentas para formatação e criação de templates de strings, além de processamento de texto mais sofisticado por meio dos módulos re (expressões regulares), difflib (comparação de sequências) e textwrap. Para uma ótima introdução à formatação de strings em Python, veja este post no Real Python. Para uma introdução aos métodos de string, veja 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 os tipos de sequência binária 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 com eficiência. Além disso, Streams permitem enviar e receber dados binários por uma conexão de rede sem usar callbacks.