Il vocabolario della sorellina

Una str in Python è una sequenza immutabile di punti di codice Unicode. Queste possono includere lettere, segni diacritici, caratteri di posizionamento, numeri, simboli di valuta, emoji, punteggiatura, spazi e caratteri di interruzione di riga, e altro ancora. Essendo immutabile, il valore di un oggetto str in memoria non cambia; i metodi che sembrano modificare una stringa restituiscono una nuova copia o istanza di quell'oggetto str.

Un letterale str si può dichiarare con virgolette singole ' o doppie ". Il carattere di escape \ è disponibile all'occorrenza.

>>> 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.'

Le stringhe multi-riga si dichiarano con ''' o """.

>>> 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.
    '''

Le stringhe si possono concatenare con l'operatore +. Conviene usare questo metodo con moderazione: non è molto efficiente né facile da mantenere.

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

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

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

Se una list, una tuple, un set o un'altra collezione di singole stringhe deve essere combinata in un'unica str, <str>.join(<iterable>) è un'opzione migliore:

# 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'

I punti di codice all'interno di una str si possono individuare con un numero 0-based index partendo da sinistra:

creative = '창의적인'

>>> creative[0]
'창'

>>> creative[2]
'적'

>>> creative[3]
'인'

L'indicizzazione funziona anche da destra, partendo da un -1-based index:

creative = '창의적인'

>>> creative[-4]
'창'

>>> creative[-2]
'적'

>>> creative[-1]
'인'

In Python non esiste un tipo separato «carattere» o «rune», quindi indicizzare una stringa produce una nuova str di lunghezza 1:

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

>>> len(website[0])
1

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

Le sottostringhe si possono selezionare tramite la slice notation, usando <str>[<start>:stop:<step>] per produrre una nuova stringa. I risultati escludono l'indice stop. Se non viene fornito un start, l'indice iniziale sarà 0. Se non viene fornito uno stop, l'indice stop sarà la fine della stringa.

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]
'🌙🌙🌙🌙'

Le stringhe si possono anche spezzare in stringhe più piccole tramite <str>.split(<separator>), che restituirà una list di sottostringhe. L'array può poi essere ulteriormente indicizzato o suddiviso, se necessario. Usare <str>.split() senza argomenti suddividerà la stringa sugli spazi bianchi.

>>> 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']

I separatori per <str>.split() possono essere più di un carattere. Per la corrispondenza nella suddivisione viene usata l'intera stringa.

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

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

Le stringhe supportano tutte le operazioni comuni sulle sequenze. I singoli punti di codice si possono iterare in un ciclo tramite for item in <str>. Gli indici insieme agli elementi si possono iterare in un ciclo tramite 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 :  ့