Skip to content

4. Stringhe

Image

4.1. Script [str_01]: notazione stringa

Lo script [str_01] è il seguente:

1
2
3
4
5
6
7
8
#  character strings
#  three possible notations
chaine1 = "un"
chaine2 = 'deux'
chaine3 = """hélène va au
marché acheter des légumes"""
#  display
print(f"chaine1=[{chaine1}], chaine2=[{chaine2}], chaine3=[{chaine3}]")

Commenti

  • riga 3: una stringa delimitata da virgolette doppie ";
  • riga 4: una stringa delimitata da virgolette singole ';
  • Riga 5: una stringa racchiusa tra virgolette triple """. In questo caso, la stringa può estendersi su più righe;

I risultati sono i seguenti:


C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/strings/str_01.py
chaine1=[un], chaine2=[deux], chaine3=[hélène va au
 marché acheter des légumes]
 
Process finished with exit code 0

4.2. Script [str_02]: Metodi della classe <str>

Lo script [str_02] presenta alcuni dei metodi della classe <str>, ovvero la classe delle stringhe:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#  string functions
#  lowercase string
print(f"'ABCD'.lower()={'ABCD'.lower()}")
#  string in uppercase
print(f"'abcd'.upper()={'abcd'.upper()}")
#  character n° 2
print(f"'cheval[2]={'cheval'[2]}")
#  substring with characters 5 and 6
print(f"'caractères accentués'[5:7]={'caractères accentués'[5:7]}")
#  substring from character 4 inclusive
print(f"'caractères accentués'[4:]={'caractères accentués'[4:]}")
#  substring up to but not including character 6
print(f"'caractères accentués'[:5]={'caractères accentués'[:5]}")
#  chain length
print(f"len('123')={len('123')}")
#  elimination of blanks preceding and following the chain
print(f"'  abcd '.strip()=[{'  abcd '.strip()}]")
#  elimination of whites following the chain
print(f"'  abcd '.rstrip()=[{'  abcd '.rstrip()}]")
#  elimination of blanks preceding the chain
print(f"'  abcd '.lstrip()=[{'  abcd '.lstrip()}]")
#  the term "white" in fact covers different characteristics
str = '  \r\nabcd \t\f'
print(f"str.strip()=[{str.strip()}]")
#  replacing one substring with another
print(f"'abcd'.replace('a','x')={'abcd'.replace('a', 'x')}")
print(f"'abcd'.replace('ab','xy')={'abcd'.replace('ab', 'xy')}")
#  search for substring: returns position or -1 if substring not found
print(f"'abcd'.find('bc')={'abcd'.find('bc')}")
print(f"'abcd'.find('bc')={'abcd'.find('Bc')}")
#  start of a chain
print(f"'abcd'.startswith('ab')={'abcd'.startswith('ab')}")
print(f"'abcd'.startswith('x')={'abcd'.startswith('x')}")
#  end of a chain
print(f"'abcd'.endswith('cd')={'abcd'.endswith('cd')}")
print(f"'abcd'.endswith('x')={'abcd'.endswith('x')}")
#  switch from a channel list to a channel
print(f"'[X]'.join(['abcd', '123', 'èéà'])={'[X]'.join(['abcd', '123', 'èéà'])}")
print(f"''.join(['abcd', '123', 'èéà'])={''.join(['abcd', '123', 'èéà'])}")
#  switch from a channel to a list of channels
print(f"'abcd 123 cdXY'.split('cd')={'abcd 123 cdXY'.split('cd')}")
#  retrieve words from a string
print(f"'abcd 123 cdXY'.split(None)={'abcd 123 cdXY'.split(None)}")

I commenti, insieme ai risultati ottenuti, sono sufficienti per comprendere lo script. I risultati sono i seguenti:


C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/strings/str_02.py
'ABCD'.lower()=abcd
'abcd'.upper()=ABCD
'cheval[2]=e
'caractères accentués'[5:7]=tè
'caractères accentués'[4:]=ctères accentués
'caractères accentués'[:5]=carac
len('123')=3
'  abcd '.strip()=[abcd]
'  abcd '.rstrip()=[  abcd]
'  abcd '.lstrip()=[abcd ]
str.strip()=[abcd]
'abcd'.replace('a','x')=xbcd
'abcd'.replace('ab','xy')=xycd
'abcd'.find('bc')=1
'abcd'.find('bc')=-1
'abcd'.startswith('ab')=True
'abcd'.startswith('x')=False
'abcd'.endswith('cd')=True
'abcd'.endswith('x')=False
'[X]'.join(['abcd', '123', 'èéà'])=abcd[X]123[X]èéà
''.join(['abcd', '123', 'èéà'])=abcd123èéà
'abcd 123 cdXY'.split('cd')=['ab', ' 123 ', 'XY']
'abcd 123 cdXY'.split(None)=['abcd', '123', 'cdXY']
 
Process finished with exit code 0

4.3. Script [str_03]: Codifica delle stringhe (1)

Lo script [str_03] introduce concetti relativi alla codifica delle stringhe:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#  character coding

#  str-type string
str = "hélène va au marché acheter des légumes"
print(f"str=[{str}, type={type(str)}]")
#  utf-8 encoding
print("--- utf-8")
bytes1 = str.encode('utf-8')
print(f"bytes1={bytes1}, type={type(bytes1)}")
bytes2 = bytes(str, 'utf-8')
print(f"bytes2={bytes2}, type={type(bytes2)}")
#  iso-8859-1 encoding
print("--- iso-8859-1")
bytes1 = str.encode('iso-8859-1')
print(f"bytes1={bytes1}, type={type(bytes1)}")
bytes2 = bytes(str, 'iso-8859-1')
print(f"bytes2={bytes2}, type={type(bytes2)}")
#  encoding latin1=iso-8859-1
print("--- latin1")
bytes1 = str.encode('latin1')
print(f"bytes1={bytes1}, type={type(bytes1)}")
bytes2 = bytes(str, 'latin1')
print(f"bytes2={bytes2}, type={type(bytes2)}")

La codifica di una stringa di tipo <str> produce una stringa binaria in cui ogni carattere della stringa è rappresentato da uno o più byte. Esistono diversi tipi di codifica. Lo script sopra riportato mostra i due più comuni in Occidente: "utf-8" e "iso-8859-1", noto anche come "latin1".

Il principio di codifica/decodifica è illustrato di seguito (rif. |https://realpython.com/python-encodings-guide/ |):

Image

Commenti

  • righe 4-5: la stringa di caratteri iniziale da codificare. Le istanze di tipo <str> sono stringhe Unicode |https://docs.python.org/3/howto/unicode.html|, |https://realpython.com/python-encodings-guide/ |;
  • righe 6-11: due modi per codificare una stringa in UTF-8:
    • riga 8: str.encode('utf-8');
    • riga 10: bytes(str, 'utf-8');
  • righe 12-17: facciamo la stessa cosa con la codifica 'iso-8859-1';
  • righe 18-23: 'latin1' è un altro nome per la codifica 'iso-8859-1';

I risultati sono i seguenti:


C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/strings/str_03.py
str=[hélène va au marché acheter des légumes, type=<class 'str'>
--- utf-8
bytes1=b'h\xc3\xa9l\xc3\xa8ne va au march\xc3\xa9 acheter des l\xc3\xa9gumes', type=<class 'bytes'>
bytes2=b'h\xc3\xa9l\xc3\xa8ne va au march\xc3\xa9 acheter des l\xc3\xa9gumes', type=<class 'bytes'>
--- iso-8859-1
bytes1=b'h\xe9l\xe8ne va au march\xe9 acheter des l\xe9gumes', type=<class 'bytes'>
bytes2=b'h\xe9l\xe8ne va au march\xe9 acheter des l\xe9gumes', type=<class 'bytes'>
--- latin1
bytes1=b'h\xe9l\xe8ne va au march\xe9 acheter des l\xe9gumes', type=<class 'bytes'>
bytes2=b'h\xe9l\xe8ne va au march\xe9 acheter des l\xe9gumes', type=<class 'bytes'>
 
Process finished with exit code 0

Commenti

  • riga 4: vediamo che i caratteri accentati sono stati codificati utilizzando due byte:
    • é: [\xc3\xa9], che è la sequenza binaria 11000011 10101001;
    • è: [\xc3\xa8], che è la sequenza binaria 11000011 10101000;
  • Riga 7: Con la codifica ISO-8859-1, questi due caratteri accentati sono codificati in modo diverso:
    • é: [\xe9], che è la sequenza binaria 11101001;
    • è: [\xe8], che è la sequenza binaria 11101000;

4.4. Script [str_04]: Codifica delle stringhe di caratteri (2)

Lo script [str_04] introduce altri due tipi di codifica: "base64" e "quoted-printable". Queste due codifiche non codificano stringhe di caratteri Unicode, ma piuttosto oggetti binari. Ad esempio, quando si allega un documento Word a un'e-mail, questo verrà sottoposto a una di queste due codifiche a seconda del client di posta elettronica utilizzato. Questo vale per la maggior parte dei file allegati.

Lo script è il seguente:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#  encoding / decoding
import codecs

#  chain
print("---- chaîne unicode")
str1 = "hélène va au marché acheter des légumes"
print(f"str1=[{str1}], type(str1)={type(str1)}")

#  utf-8 encoding
print("---- chaîne unicode -> binaire utf-8")
bytes1 = bytes(str1, "utf-8")
print(f"bytes1=[{bytes1}], type(bytes1)={type(bytes1)}")

#  utf-8 decoding
print("---- binaire utf-8 -> chaîne unicode")
str2 = bytes1.decode("utf-8")
print(f"str2=[{str2}], type(str2)={type(str2)}")
print(f"str2==str1={str2 == str1}")

#  iso-8859-1 encoding
print("---- chaîne unicode -> binaire iso-8859-1")
bytes2 = bytes(str1, "iso-8859-1")
print(f"bytes2=[{bytes2}], type(bytes2)={type(bytes2)}")

#  iso-8859-1 decoding
print("---- binaire iso-8859-1 -> chaîne unicode")
str3 = bytes2.decode("iso-8859-1")
print(f"str3=[{str3}], type(str3)={type(str3)}")
print(f"str3==str1={str3 == str1}")

#  decoding error - bytes1 is in utf-8 - decode it in iso-8859-1
print("--- binaire utf-8 (décodage iso-8859-1) --> chaîne unicode")
str4 = bytes1.decode("iso-8859-1")
print(f"str4=[{str4}], type(str4)={type(str4)}")

#  utf-8 encoding of a Unicode string
print("---- chaîne unicode -> binaire utf-8")
bytes3 = codecs.encode(str1, "utf-8")
print(f"bytes3=[{bytes3}], type(bytes3)={type(bytes3)}")

#  encoding a UTF-8 binary string in base64
print("---- binaire utf-8 -> binaire base64")
bytes4 = codecs.encode(bytes1, "base64")
print(f"bytes4=[{bytes4}], type(bytes4)={type(bytes4)}")

#  return to original unicode string
print("---- binaire base64 -> binaire utf-8 -> chaîne unicode")
str6 = codecs.decode(bytes4, "base64").decode("utf-8")
print(f"str6=[{str6}], type(str6)={type(str6)}")

#  encoding a binary string in quoted-printable
print("---- binaire utf-8 -> binaire quoted-printable")
str7 = codecs.encode(bytes1, "quoted-printable")
print(f"str7=[{str7}], type(str7)={type(str7)}")

#  return to original unicode string
print("---- binaire quoted-printable -> binaire utf-8 -> chaîne unicode")
str8 = codecs.decode(str7, "quoted-printable").decode("utf-8")
print(f"str8=[{str8}], type(str8)={type(str8)}")

Commenti

  • riga 2: il modulo [codecs] supporta le codifiche 'base64' e 'quoted-printable'. Ne supporta molte altre;
  • righe 4–7: la stringa Unicode che verrà sottoposta a varie codifiche;
  • righe 9-12: codifica UTF-8. Questo produce una stringa binaria;
  • righe 14-18: decodifica UTF-8 per tornare alla stringa Unicode originale;
  • righe 20–29: ripetiamo lo stesso processo con la codifica 'iso-8859-1';
  • righe 31–34: viene visualizzato un errore di decodifica:
  • riga 33: bytes1 è una stringa binaria codificata in 'utf-8'. La decodifichiamo in 'iso-8859-1';
  • righe 36–39: un altro modo per codificare una stringa in UTF-8 utilizzando il modulo [codecs];
  • righe 41-44: una stringa binaria 'utf-8' viene codificata in 'base64';
  • righe 46–49: mostrano come convertire la stringa binaria 'base64' nella stringa Unicode originale;
  • righe 51–59: ripetiamo questo processo utilizzando la codifica 'quoted-printable' invece di 'base64';

I risultati sono i seguenti:


C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/strings/str_04.py
---- chaîne unicode
str1=[hélène va au marché acheter des légumes], type(str1)=<class 'str'>
---- chaîne unicode -> binaire utf-8
bytes1=[b'h\xc3\xa9l\xc3\xa8ne va au march\xc3\xa9 acheter des l\xc3\xa9gumes'], type(bytes1)=<class 'bytes'>
---- binaire utf-8 -> chaîne unicode
str2=[hélène va au marché acheter des légumes], type(str2)=<class 'str'>
str2==str1=True
---- chaîne unicode -> binaire iso-8859-1
bytes2=[b'h\xe9l\xe8ne va au march\xe9 acheter des l\xe9gumes'], type(bytes2)=<class 'bytes'>
---- binaire iso-8859-1 -> chaîne unicode
str3=[hélène va au marché acheter des légumes], type(str3)=<class 'str'>
str3==str1=True
--- binaire utf-8 (décodage iso-8859-1) --> chaîne unicode
str4=[hélène va au marché acheter des légumes], type(str4)=<class 'str'>
---- chaîne unicode -> binaire utf-8
bytes3=[b'h\xc3\xa9l\xc3\xa8ne va au march\xc3\xa9 acheter des l\xc3\xa9gumes'], type(bytes3)=<class 'bytes'>
---- binaire utf-8 -> binaire base64
bytes4=[b'aMOpbMOobmUgdmEgYXUgbWFyY2jDqSBhY2hldGVyIGRlcyBsw6lndW1lcw==\n'], type(bytes4)=<class 'bytes'>
---- binaire base64 -> binaire utf-8 -> chaîne unicode
str6=[hélène va au marché acheter des légumes], type(str6)=<class 'str'>
---- binaire utf-8 -> binaire quoted-printable
str7=[b'h=C3=A9l=C3=A8ne=20va=20au=20march=C3=A9=20acheter=20des=20l=C3=A9gumes'], type(str7)=<class 'bytes'>
---- binaire quoted-printable -> binaire utf-8 -> chaîne unicode
str8=[hélène va au marché acheter des légumes], type(str8)=<class 'str'>
 
Process finished with exit code 0
  • righe 14-15: un file binario UTF-8 viene decodificato in una stringa Unicode utilizzando il decodificatore errato 'iso-8859-1'. Di conseguenza, alcuni caratteri Unicode generati sono errati, in questo caso i caratteri accentati;
  • righe 18-19: la codifica «base64» prevede l'uso di 64 caratteri ASCII (codificati su 7 bit) per codificare qualsiasi dato binario. Come si può notare, ciò aumenta la dimensione dei dati binari della stringa;
  • righe 22–23: anche la codifica "quoted-printable" utilizza caratteri ASCII (codificati su 7 bit) per codificare qualsiasi dato binario;

È importante ricordare che quando si ricevono dati binari — da Internet, ad esempio — che rappresentano del testo, è necessario conoscere le codifiche a cui sono stati sottoposti per poter recuperare il testo originale.

https://stahe.github.io
Questo tutorial scritto da Serge Tahé è reso disponibile al pubblico secondo i termini della Creative Commons Attribuzione – Non commerciale – Condividi allo stesso modo 3.0 Unported.