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, carateres de espaço e de quebra de linha, entre outros.
Sendo imutável, o valor de um objeto str em memória não muda; os métodos que parecem modificar uma string devolvem uma nova cópia ou instância desse objeto str.
Um literal str pode ser declarado com aspas simples ' ou duplas ". O caráter de escape \ está disponível sempre que for preciso.
>>> 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."
>>> escapes = 'If needed, a \'slash\' can be used as an escape character within a string when switching quote styles won\'t work.'
As strings com 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 are fully supported.
You\'ll most often encounter these 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.
'''
As strings podem ser concatenadas com o operador +.
Deves usar este método 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 precisares de combinar uma list, uma 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'
>>> 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]
>>> separator.join(upper_words)
'upper 🌟 uppercrust 🌟 uppercase 🌟 upperclassmen 🌟 uppermost 🌟 uppercut'
Os pontos de código dentro de uma str podem ser referenciados por um número de í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 em Python 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 da notação de fatiamento, com <str>[<start>:stop:<step>] para produzir uma nova string.
Os resultados excluem o índice stop.
Se não for indicado um start, o índice inicial será 0.
Se não for indicado um stop, o índice stop será o fim da string.
moon_and_stars = '🌟🌟🌙🌟🌟⭐'
sun_and_moon = '🌞🌙🌞🌙🌞🌙🌞🌙🌞'
>>> moon_and_stars[1:4]
'🌟🌙🌟'
>>> moon_and_stars[:3]
'🌟🌟🌙'
>>> moon_and_stars[3:]
'🌟🌟⭐'
>>> moon_and_stars[:-1]
'🌟🌟🌙🌟🌟'
>>> moon_and_stars[:-3]
'🌟🌟🌙'
>>> sun_and_moon[::2]
'🌞🌞🌞🌞🌞'
>>> sun_and_moon[:-2:2]
'🌞🌞🌞🌞'
>>> sun_and_moon[1:-1:2]
'🌙🌙🌙🌙'
As strings também podem ser divididas em strings mais pequenas através de <str>.split(<separator>), que devolve uma list de substrings.
A lista pode depois ser novamente indexada ou dividida, se for preciso.
Usar <str>.split() sem qualquer argumento divide a string pelos espaços em branco.
>>> cat_ipsum = "Destroy house in 5 seconds mock the hooman."
>>> cat_ipsum.split()
...
['Destroy', 'house', 'in', '5', 'seconds', 'mock', 'the', 'hooman.']
>>> cat_ipsum.split()[-1]
'hooman.'
>>> cat_words = "feline, four-footed, ferocious, furry"
>>> cat_words.split(', ')
...
['feline', 'four-footed', 'ferocious', 'furry']
Os separadores de <str>.split() podem ter mais do que um caráter.
Para a divisão é usada a string inteira.
>>> colors = """red,
orange,
green,
purple,
yellow"""
>>> colors.split(',\n')
['red', 'orange', 'green', 'purple', 'yellow']
As strings suportam todas as operações comuns de sequência.
Os pontos de código individuais podem ser percorridos num ciclo com for item in <str>.
Os índices com os 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
>>> 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 : ့
Exercício de aprendizagem
