014 Python3 – Manipolazione delle stringhe
014 Python3 – Manipolazione delle stringhe
1) In questa parte di appunti di Python 3 si spiega l’uso di alcuni operatori e metodi per manipolare le stringhe.
1A) Concatenare stringhe e variabili utilizzando l’operatore +
L’operatore [+] permette di concatenare fra loro stringhe e variabili alfanumeriche nel medesimo ordine in cui sono indicate nell’istruzione. Qualora si intenda utilizzare questo operatore per concatenare variabili non di tipo stringa, la concatenazione non avviene, ovvero avviene solo previo conversione delle variabili da concatenare in variabili tipo stringa.
Seguono alcuni esempi.
A = "Roma"; B = 3 # Imposta il valore della variabile stringa A e della variabile numerica B
C = "Via " + A + " n." + str(B) # Concatena stringhe, una variabile stringa ed una variabile numerica e mette il risultato nella variabile C
print(C) # Imposta il valore di una variabile stringa ed una variabile numerica, le concatena, e stampa il risultato
ovvero, in un'unica riga:
A = "Roma"; B = 3; C = "Via " + A + " n." + str(B); print(C)
>>> A = "Roma"; B = 3; C = "Via " + A + " n." + str(B); print(C) # Esempio di concatenazione di stringhe e variabili
Via Roma n.3
>>>
1B) Concatenare stringhe e variabili utilizzando f-string
Python 3.6 ha introdotto l’istruzione f-string che, a metà fra un operatore ed un metodo, permette di concatenare fra loro stringhe e variabili nel medesimo ordine in cui sono indicate nell’istruzione. Questa istruzione può essere utilizzata per concatenare variabili di qualsiasi tipo e/o stringhe, purchè: l’istruzione inizi con [f”] (senza parentesi quadre), termini con [“] (senza parentesi quadre), e le variabili da concatenare siano racchiuse fra parentesi graffe.
Seguono alcuni esempi.
A = "Roma"; B = 3 # Imposta il valore della variabile stringa A e della variabile numerica B
C = f"Via {A} n.{B}" # Concatena stringhe, una variabile stringa ed una variabile numerica e mette il risultato nella variabile C
print(C) # Imposta il valore di una variabile stringa ed una variabile numerica, le concatena, e stampa il risultato
ovvero, in un'unica riga:
A = "Roma"; B = 3; C = f"Via {A} n.{B}"; print(C)
>>> A = "Roma"; B = 3; C = f"Via {A} n.{B}"; print(C) # Esempio di concatenazione di stringhe e variabili
Via Roma n.3
>>>
2) Estrarre parti di una stringa
Esempi di istruzione:
B = A[I:F] # I ed F non corrispondono a caratteri, ma al punto di separazione fra 2 caratteri.
# Mette nella variabile B i caratteri consecutivi della variabile A che vanno dall’I_esimo al F_esimo.
# Se I > 0 si conta da sinistra, se I < 0 si conta da destra.
# Se F > 0 si conta da sinistra, se F < 0 si conta da destra.
# Il carattere I deve sempre essere più a sinistra del carattere F.
B = A[3] # Mette nella variabile B il quarto carattere della variabile A contando da sinistra
B = A[-3] # Mette nella variabile B il terzo carattere della variabile A contando da destra
B = A[3:7] # Mette nella variabile B i caratteri consecutivi della variabile A dal quarto al settimo contando da sinistra
B = A[3:-7] # Mette nella variabile B i caratteri consecutivi della variabile A dal 4° da sinistra al 8° da destra
B = A[7:-3] # Mette nella variabile B i caratteri consecutivi della variabile A dal 4° da destra al 8° da sinistra
B = A[-7:-3] # Mette nella variabile B i caratteri consecutivi della variabile A dal 4° al 7° a partire da destra
B = A[:3] # Mette nella variabile B i primi 3 caratteri della variabile A
B = A[-3:] # Mette nella variabile B tutti i caratteri della variabile A tranne gli ultimi 3
B = A[3:] # Mette nella variabile B i primi 3 caratteri della variabile A
B = A[:-3] # Mette nella variabile B tutti i caratteri della variabile A tranne i primi 3
A = “abcdefgh1234″; C = 3; B = A[C]; print(f”Il {C + 1}° carattere a partire da sinistra della stringa ‘{A}’ è ‘{B}'”)
A = “abcdefgh1234″; C = 3; B = A[-C]; print(f”Il {C}° carattere a partire da destra della stringa ‘{A}’ è ‘{B}'”)
A = “abcdefgh1234″; C = 3; D = 7; B = A[C:D]; print(f”I {D – C} caratteri dal {C + 1}° al {D}° carattere da sinistra della stringa ‘{A}’ sono ‘{B}'”)
A = “abcdefgh1234″; C = 3; D = 7; B = A[C:-D]; print(f”I caratteri dal {C + 1}° da sinistra al {D + 1}° da destra della stringa ‘{A}’ sono ‘{B}'”)
A = “abcdefgh1234″; C = 3; D = 7; B = A[D:-C]; print(f”I caratteri dal {D + 1}° da sinistra al {C + 1}° da destra della stringa ‘{A}’ sono ‘{B}'”)
A = “abcdefgh1234″; C = 3; D = 7; B = A[-D:-C]; print(f”I {D – C} caratteri dal {C+1}° al {D}° a partire da destra della stringa ‘{A}’ sono ‘{B}'”)
A = “abcdefgh1234″; C = 3; B = A[:C]; print(f”I primi {C} caratteri della stringa ‘{A}’ sono ‘{B}'”)
A = “abcdefgh1234″; C = 3; B = A[-C:]; print(f”Gli ultimi {C} caratteri della stringa ‘{A}’ sono ‘{B}'”)
A = “abcdefgh1234″; C = 3; B = A[C:]; print(f”Se alla stringa ‘{A}’ togliamo i primi {C} caratteri, resta ‘{B}'”)
A = “abcdefgh1234″; C = 3; B = A[:-C]; print(f”Se alla stringa ‘{A}’ togliamo gli ultimi {C} caratteri, resta ‘{B}'”)
Esempi di output:
>>> A = "abcdefgh1234"; C = 3; B = A[C]; print(f"Il {C + 1}° carattere a partire da sinistra della stringa '{A}' è '{B}'")
Il 4° carattere a partire da sinistra della stringa 'abcdefgh1234' è 'd'
>>> A = "abcdefgh1234"; C = 3; B = A[-C]; print(f"Il {C}° carattere a partire da destra della stringa '{A}' è '{B}'")
Il 3° carattere a partire da destra della stringa 'abcdefgh1234' è '2'
>>> A = "abcdefgh1234"; C = 3; D = 7; B = A[C:D]; print(f"I {D - C} caratteri dal {C + 1}° al {D}° carattere da sinistra della stringa '{A}' sono '{B}'")
I 4 caratteri dal 4° al 7° carattere da sinistra della stringa 'abcdefgh1234' sono 'defg'
>>> A = "abcdefgh1234"; C = 3; D = 7; B = A[C:-D]; print(f"I caratteri dal {C + 1}° da sinistra al {D + 1}° da destra della stringa '{A}' sono '{B}'")
I caratteri dal 4° da sinistra al 8° da destra della stringa 'abcdefgh1234' sono 'de'
>>> A = "abcdefgh1234"; C = 3; D = 7; B = A[D:-C]; print(f"I caratteri dal {D + 1}° da sinistra al {C + 1}° da destra della stringa '{A}' sono '{B}'")
I caratteri dal 8° da sinistra al 4° da destra della stringa 'abcdefgh1234' sono 'h1'
>>> A = "abcdefgh1234"; C = 3; D = 7; B = A[-D:-C]; print(f"I {D - C} caratteri dal {C+1}° al {D}° a partire da destra della stringa '{A}' sono '{B}'")
I 4 caratteri dal 4° al 7° a partire da destra della stringa 'abcdefgh1234' sono 'fgh1'
>>> A = "abcdefgh1234"; C = 3; B = A[:C]; print(f"I primi {C} caratteri della stringa '{A}' sono '{B}'")
I primi 3 caratteri della stringa 'abcdefgh1234' sono 'abc'
>>> A = "abcdefgh1234"; C = 3; B = A[-C:]; print(f"Gli ultimi {C} caratteri della stringa '{A}' sono '{B}'")
Gli ultimi 3 caratteri della stringa 'abcdefgh1234' sono '234'
>>> A = "abcdefgh1234"; C = 3; B = A[C:]; print(f"Se alla stringa '{A}' togliamo i primi {C} caratteri, resta '{B}'")
Se alla stringa 'abcdefgh1234' togliamo i primi 3 caratteri, resta 'defgh1234'
>>> A = "abcdefgh1234"; C = 3; B = A[:-C]; print(f"Se alla stringa '{A}' togliamo gli ultimi {C} caratteri, resta '{B}'")
Se alla stringa 'abcdefgh1234' togliamo gli ultimi 3 caratteri, resta 'abcdefgh1'
>>>
3) I METODI
In Python, è detto “metodo” ogni “funzione speciale” già definita dal linguaggio di programmazione allo scopo di assolvere un compito specifico. Analogamente alle funzioni create dagli utenti, i “metodi” hanno una sintassi tipo
DATO.nome_metodo(Eventuali_parametri)
dove:
DATO è il dato a cui si applica il metodo;
nome_metodo() è il nome del metodo che assolve la funzione specifica predefinita da Python;
Eventuali_parametri sono gli eventuali parametri che occorre fornire per poter applicare il metodo.
ATTENZIONE!! Quando si cercano informazioni sui metodi per Python, occorre tener ben presente che libri e siti web, vuoi per desiderio di semplificazione, vuoi perché scritti da persone aventi formazione da autodidatta, spesso utilizzano il termine METODO ed il termine FUNZIONE come se fossero l’uno sinonimo dell’altro.
I tipi di dato messi a disposizione da Python sono i seguenti: interi (int), interi lunghi (long), numeri in virgola mobile (float), numeri complessi (complex), valori booleani (bool), stringhe (str), tuple (tuple), insiemi immutabili (frozenset), liste (list), dizionari (dict), insiemi (set), file (file).
Per conoscere la lista dei metodi relativi ad un tipo di dato, impartire il comando [print(dir(tipoDiDato))] (senza parentesi quadre). Seguono alcuni esempi.
>>> print(dir(int)) # Lista dei metodi relativi a dati tipo numeri interi
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
>>> print(dir(float)) # Lista dei metodi relativi a dati tipo numeri a virgola mobile
['__abs__', '__add__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getformat__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__int__', '__le__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__pos__', '__pow__', '__radd__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rmod__', '__rmul__', '__round__', '__rpow__', '__rsub__', '__rtruediv__', '__set_format__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', 'as_integer_ratio', 'conjugate', 'fromhex', 'hex', 'imag', 'is_integer', 'real']
>>> print(dir(str)) # Lista dei metodi relativi a dati tipo stringa
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
>>>
4) Analisi del contenuto di una stringa.
4A) Verificare se una stringa contiene un’altra utilizzando l’operatore in
L’operatore [in] (senza parentesi quadre) consente di verificare se la stringa scritta prima dell’operatore in è contenuta nella stringa scritta dopo l’operatore [in]. L’esito della verifica può essere sia stampato sullo schermo, sia messo dentro una variabile. A seguito della verifica, sono possibili solo due esiti: [True] (senza parentesi quadre) e [Folse] (senza parentesi quadre). Quando la verifica ha esito positivo, l’output dell’istruzione è [True]; quando la verifica ha esito negativo, output dell’istruzione è [Folse]; anteponendo l’operatore logico [not] all’ L’operatore [in], la combinazione di operatori consente di verificare se la stringa scritta prima dell’operatore [not in] NON è contenuta nella stringa scritta dopo l’operatore [not in]; in altre parole, l’esito della verifica è l’opposto di quello che si avrebbe in assenza dell’operatore [not].
"Roma" in "Via Roma n.3" # Verifica se la stringa scritta prima dell'operatore in è contenuta nella stringa scritta dopo l'operatore in
A = "Roma"; A in "Via Roma n.3" # Verifica se la stringa contenuta nella variabile A è contenuta nella stringa scritta dopo l'operatore in
B = "Via Roma n.3"; "Roma" in B # Verifica se la stringa scritta prima dell'operatore in è contenuta nella variabile B
A = "Roma"; B = "Via Roma n.3"; A in B # Verifica se la stringa contenuta nella variabile A è contenuta nella stringa contenuta nella variabile B
A = "Roma"; B = "Via Roma n.3";C = f"L'ipotesi che '{A}' sia contenuta in '{B}' è {A in B}"; print(C)
>>> A = "Roma"; B = "Via Roma n.3";C = f"L'ipotesi che '{A}' sia contenuta in '{B}' è {A in B}"; print(C)
L'ipotesi che 'Roma' sia contenuta in 'Via Roma n.3' è True
>>> A = "roma"; B = "Via Roma n.3";C = f"L'ipotesi che '{A}' sia contenuta in '{B}' è {A in B}"; print(C)
L'ipotesi che 'roma' sia contenuta in 'Via Roma n.3' è False
>>> A = "Roma"; B = "Via Roma n.3";C = f"L'ipotesi che '{A}' NON sia contenuta in '{B}' è {A not in B}"; print(C)
L'ipotesi che 'Roma' NON sia contenuta in 'Via Roma n.3' è False
>>>
4B) Contare quante volte una stringa è contenuta all’interno di un’altra: il metodo .count()
[.count] è un metodo che permette di contare quante volte una stringa è contenuta all’interno di un’altra.
La sua sintassi è qualcosa tipo:
[“Stringa o variabile in cui cercare”.count(“Stringa cercata”)] (senza parentesi quadre). Si può cercare anche una singola lettera, e le lettere maiuscole sono diverse dalle lettere minuscole. Se la stringa cercata NON è contenuta nella stringa in cui cercare, l’esito del comando è il numero 0. Per esempio:
>>> A = "Roma"; B = "Via Roma n.3"; C = B.count(A); print("La stringa '"+A+"' è contenuta",C,"volte all’interno della stringa '"+B+"'")
La stringa 'Roma' è contenuta 1 volte all’interno della stringa 'Via Roma n.3'
>>> A = "a"; B = "Via Roma n.3"; C = B.count(A); print("La stringa '"+A+"' è contenuta",C,"volte all’interno della stringa '"+B+"'")
La stringa 'a' è contenuta 2 volte all’interno della stringa 'Via Roma n.3'
>>> A = "A"; B = "Via Roma n.3"; C = B.count(A); print("La stringa '"+A+"' è contenuta",C,"volte all’interno della stringa '"+B+"'")
La stringa 'A' è contenuta 0 volte all’interno della stringa 'Via Roma n.3'
>>>
4C) Posizione di una stringa all’interno di un’altra: il metodo .index()
[.index] è un metodo che permette di conoscere la posizione di una stringa all’interno di un’altra, contando da sinistra.
La sua sintassi è qualcosa tipo:
[“Stringa o variabile in cui cercare”.index(“Stringa cercata”)] (senza parentesi quadre). Si può cercare anche una singola lettera, e le lettere maiuscole sono diverse dalle lettere minuscole. Se la stringa cercata è contenuta più volte nella stringa in cui cercare, la posizione fornita è quella della prima ricorrenza; se la stringa cercata NON è contenuta nella stringa in cui cercare, l’esito del comando è un errore “substring not found”. Per esempio:
>>> A = "Roma"; B = "Via Roma n.3"; C = B.index(A); print("La posizione della stringa '"+A+"' all’interno della stringa '"+B+"' è", C)
La posizione della stringa 'Roma' all’interno della stringa 'Via Roma n.3' è 4
>>> A = "a"; B = "Via Roma n.3"; C = B.index(A); print("La posizione della stringa '"+A+"' all’interno della stringa '"+B+"' è", C)
La posizione della stringa 'a' all’interno della stringa 'Via Roma n.3' è 2
>>> A = "A"; B = "Via Roma n.3"; C = B.index(A); print("La posizione della stringa '"+A+"' all’interno della stringa '"+B+"' è", C)
Traceback (most recent call last):
File "
A = "A"; B = "Via Roma n.3"; C = B.index(A); print("La posizione della stringa '"+A+"' all’interno della stringa '"+B+"' è", C)
ValueError: substring not found
>>>
4D) Trovare l’elemento di minore o maggiore valore all’interno di una stringa: metodi min() e max()
Ad ogni singolo carattere alfanumerico corrisponde un numero d’ordine, secondo una codifica prestabilita. Oggigiorno la codifica più diffusa è la UTF-16 nella quale ad ogni carattere alfanumerico è associato un numero a 16 bit, ma esiste anche la codifica UTF-32. Ogni codifica UTF conserva la compatibilità con le codifiche UTF precedenti, quindi i primi 256 caratteri della codifica UTF coincidono con i caratteri della tabella ASCII.
La tabella ASCII contiene 256 caratteri, a ciascuno dei quali corrisponde un numero da 0 a 255, ma solo i codici dal 32 al 126 sono caratteri alfanumerici stampabili. Un carattere alfanumerico stampabile, può essere una lettera maiuscola, o una lettera minuscola, o un numero, o un simbolo matematico, o un simbolo di punteggiatura, o un simbolo grafico di qualsiasi altro tipo.
Per conoscere il numero d’ordine associato ad un carattere alfanumerico, si utilizza il comando [ord(X)] (senza parentesi quadre) dove X è una variabile che contiene il singolo carattere alfanumerico di cui si vuole conoscere il numero d’ordine, oppure può essere sostituito direttamente col carattere di cui si vuole conoscere il numero d’ordine, purché fra apici.
Per intenderci: i comandi [X=”A”; ord(X)] forniscono il medesimo output del comando [ord(“A”)].
Se invece si desidera conoscere il carattere corrispondente ad un numero d’ordine, occorre utilizzare il comando [chr(X)] (senza parentesi quadre) dove X è una variabile che contiene il numero d’ordine di cui si vuole conoscere il corrispondente carattere alfanumerico, oppure può essere sostituito direttamente dal numero d’ordine di cui si vuole conoscere il carattere alfanumerico corrispondente.
Per intenderci: i comandi [X=65; chr(X)] forniscono il medesimo output del comando [chr(65)].
Per “elemento di minor valore”, si intende il carattere alfanumerico avente il corrispondente numero d’ordine più basso; per elemento di minor valore, si intende il carattere alfanumerico avente il corrispondente numero d’ordine più alto.
[min()] è un metodo che permette di conoscere l’elemento di minor valore contenuto all’interno di una stringa. La sua sintassi è qualcosa tipo:
[min(“Stringa o variabile in cui cercare”)] (senza parentesi quadre).
[max()] è un metodo che permette di conoscere l’elemento di maggior valore contenuto all’interno di una stringa. La sua sintassi è qualcosa tipo: [max(“Stringa o variabile in cui cercare”)] (senza parentesi quadre).
Per esempio:
>>> A="Stringa-Variabile!";B=min(A);C=max(A);print(f"All’interno della stringa '{A}' il valore minimo è '{B}' (valore: {ord(B)}) ed il valore massimo è '{C}' (valore: {ord(C)}).\nAl numero d'ordine {ord(C)+1} corrisponde il carattere '{chr(ord(C)+1)}'.")
All’interno della stringa 'Stringa-Variabile!' il valore minimo è '!' (valore: 33) ed il valore massimo è 't' (valore: 116).
Al numero d'ordine 117 corrisponde il carattere 'u'.
>>>
5) METODI propri dei dati tipo “STRINGA”
Questi appunti, trattano i metodi per manipolare le stringhe di seguito elencati:
startswith(), endswith(), isalnum(), isalpha(), isdecimal(), isspace(), upper(), lower(), split(), join(), e len()
Esempi di istruzione:
A.startswith(B) # Se contenuto della variabile A inizia con il contenuto della variabile B, fornisce output [True]
A.endswith(B) # Se contenuto della variabile A inizia con il contenuto della variabile B, fornisce output [True]
A.isalnum() # Se la variabile A contiene solo lettere, o solo numeri, o solo lettere e numeri, fornisce output [True]
A.isalpha() # Se la variabile A contiene solo lettere, fornisce output [True]
A.isdecimal() # Se la variabile A contiene solo numeri, fornisce output [True]
A.isspace() # Se la variabile A contiene solo spazi, fornisce output [True]
A.upper() # L'output fornito è il medesimo contenuto della variabile A ma tutto in lettere maiuscole
B = A.upper() # Mette nella variabile B il contenuto della variabile A, ma tutto in lettere maiuscole
A.lower() # L'output fornito è il medesimo contenuto della variabile A ma tutto in lettere maiuscole
B = A.lower() # Mette nella variabile B il contenuto della variabile A, ma tutto in lettere maiuscole
A.split(B) # Divide una stringa contenuta nella variabile A in una lista di stringhe, previo indicazione, all'interno della variabile D, del carattere che fa da separatore
A.join(B) # L'output fornito è l'insieme degli elementi contenuti nella variabile-lista B separati dal contenuto della variabile A
len(A) # L'output fornito è il numero di caratteri alfanumerici contenuti nella stringa A.
A = "Verifica variabile"; B = "Veri"; C = A.startswith(B);C = f"L'ipotesi che '{A}' inizi con '{B}' è {C}"; print(C)
A = "Verifica variabile"; B = "bile"; C = A.endswith(B);C = f"L'ipotesi che '{A}' termini con '{B}' è {C}"; print(C)
A = "ViaRoma3"; C = A.isalnum(); C = f"L'ipotesi che '{A}' contenga solo lettere e numeri, è {C}"; print(C)
A = "ViaRoma"; C = A.isalpha(); C = f"L'ipotesi che '{A}' contenga solo lettere, è {C}"; print(C)
A = "3"; C = A.isdecimal(); C = f"L'ipotesi che '{A}' contenga solo numeri, è {C}"; print(C)
A = " "; C = A.isspace(); C = f"L'ipotesi che '{A}' contenga solo spazi vuoti, è {C}"; print(C)
A = "Via Roma n.3"; C = A.upper(); C = f"La stringa '{A}' tutta in maiuscolo, diventa '{C}'"; print(C)
A = "Via Roma n.3"; C = A.lower(); C = f"La stringa '{A}' tutta in minuscolo, diventa '{C}'"; print(C)
A = "Via Roma n.3"; B = " "; C = A.split(B); print(f"Il contenuto della stringa '{A}' suddiviso in valori di una variabile-lista, è {C}")
A = " "; B = ["Via", "Roma", "N.3"]; C = A.join(B); print(f"I singoli valori '{B}' della variabile-lista B uniti in un'unica variabile intervallati da '{A}', diventano '{C}'.")
A = "Via Roma n.3"; B = len(A); print(f"La stringa '{A}' contiene {B} caratteri.")
Esempi di output:
>>> A = "Verifica variabile"; B = "Veri"; C = A.startswith(B);C = f"L'ipotesi che '{A}' inizi con '{B}' è {C}"; print(C)
L'ipotesi che 'Verifica variabile' inizi con 'Veri' è True
>>> A = "Verifica variabile"; B = "bile"; C = A.endswith(B);C = f"L'ipotesi che '{A}' termini con '{B}' è {C}"; print(C)
L'ipotesi che 'Verifica variabile' termini con 'bile' è True
>>> A = "ViaRoma3"; C = A.isalnum(); C = f"L'ipotesi che '{A}' contenga solo lettere e numeri, è {C}"; print(C)
L'ipotesi che 'ViaRoma3' contenga solo lettere e numeri, è True
>>> A = "ViaRoma"; C = A.isalpha(); C = f"L'ipotesi che '{A}' contenga solo lettere, è {C}"; print(C)
L'ipotesi che 'ViaRoma' contenga solo lettere, è True
>>> A = "3"; C = A.isdecimal(); C = f"L'ipotesi che '{A}' contenga solo numeri, è {C}"; print(C)
L'ipotesi che '3' contenga solo numeri, è True
>>> A = " "; C = A.isspace(); C = f"L'ipotesi che '{A}' contenga solo spazi vuoti, è {C}"; print(C)
L'ipotesi che ' ' contenga solo spazi vuoti, è True
>>> A = "Via Roma n.3"; C = A.upper(); C = f"La stringa '{A}' tutta in maiuscolo, diventa '{C}'"; print(C)
La stringa 'Via Roma n.3' tutta in maiuscolo, diventa 'VIA ROMA N.3'
>>> A = "Via Roma n.3"; C = A.lower(); C = f"La stringa '{A}' tutta in minuscolo, diventa '{C}'"; print(C)
La stringa 'Via Roma n.3' tutta in minuscolo, diventa 'via roma n.3'
>>> A = "Via Roma n.3"; B = " "; C = A.split(B); print(f"Il contenuto della stringa '{A}' suddiviso in valori di una variabile-lista, è {C}")
Il contenuto della stringa 'Via Roma n.3' suddiviso in valori di una variabile-lista, è ['Via', 'Roma', 'n.3']
>>> A = " "; B = ["Via", "Roma", "N.3"]; C = A.join(B); print(f"I singoli valori '{B}' della variabile-lista B uniti in un'unica variabile intervallati da '{A}', diventano '{C}'.")
I singoli valori '['Via', 'Roma', 'N.3']' della variabile-lista B uniti in un'unica variabile intervallati da ' ', diventano 'Via Roma N.3'.
>>> A = "Via Roma n.3"; B = len(A); print(f"La stringa '{A}' contiene {B} caratteri.")
La stringa 'Via Roma n.3' contiene 12 caratteri.
>>>