str() – Programmare con Python

Una costante stringa può essere espressa in diversi modi

`s = 'Ciao mondo'`	Sequenza di caratteri limitati con apostrofi
`s = "Ciao mondo"`	Sequenza di caratteri limitati con virgolette
`s1 = 'Ciao ' 'mondo'` `s2 = "Ciao " "mondo"`	Più sequenze consecutive
`s = 'Ciao "mondo"'`	Le virgolette come carattere
`s = "Ciao 'mondo'"`	L’apostrofo come carattere
`s1 = '''Ciao mondo'''` `s2 = """Ciao mondo"""`	Il triplo apostrofo, oppure il triplo virgolettato, permette di scrivere testi che vanno a capo

Vedi le sequenze di escape…

Costruttori

La funzione predefinita str(...) converte qualsiasi cosa in stringa…

Operatori

`stringa1 == stringa2`	Le due stringhe sono uguali?
`stringa1 != stringa2`	Le due stringhe sono diverse?
`stringa1 < stringa2`	La 1° stringa precede la 2°?
`stringa1 <= stringa2`	La 1° stringa precede la 2° oppure sono uguali?
`stringa1 > stringa2`	La 1° stringa segue la 2°?
`stringa1 >= stringa2`	La 1° stringa segue la 2° oppure sono uguali?
`stringa1 + stringa2`	Concatenazione delle due stringhe
`n * stringa`	n volte la concatenazione della stringa
`stringa[p]`	Il carattere alla posizione p (vedi SLICING)
`c in stringa`	Il carattere c è compreso nella stringa?
`c not in stringa`	Il carattere c NON è compreso nella stringa?

Funzioni/metodi

s.capitalize() — primo carattere maiuscolo e tutto il resto minuscolo.
s.casefold() — tutto minuscolo (…more aggressive), da 3.3
s.center(n) — centra in una stringa con n caratteri, aggiunge spazi.
s.center(n, ‘c’) — centra in una stringa con n caratteri, aggiunge un certo carattere.
c=chr(n) — il carattere corrispondente al codice
s1.count(s2) — conta quante volte compare s2 in s1
s1.count(s2, start) — conta quante volte compare s2 in s1 a partire da start
s1.count(s2, start, stop) — conta quante volte compare s2 in s1 a partire da start, fino a stop-1.
s1.endswith(s2) — restituisce True se s1 finisce con s2
s1.endswith(s2, start)
s1.endswith(s2, start, stop)
s1.find(s2) — la prima posizione di s2 in s1; -1 se non è presente.
s1.find(s2, start)
s1.find(s2, start, stop)
s1.index(s2) — la prima posizione di s2 in s1; errore se non è presente.
s1.index(s2, start)
s1.index(s2, start, stop)
s=input()
s2=input(s1)
s.isalnum() — restituisce True se i caratteri soddisfano c.isalpha() | c.isdecimal() | c.isdigit() | c.isnumeric()
s.isalpha()
s.isdecimal()
s.isdigit()
s.isidentifier()
s.islower()
s.isnumeric()
s.isprintable()
s.isspace()
s.istitle()
s.isupper()
s.join(it) — restituisce la concatenazione delle stringhe contenute nell’iteratore; utilizza s come concatenatore…
s.lower() — tutto minuscolo
s.lstrip() — restituisce la stringa senza spazi iniziali
s1.lstrip(s2) — rimuove i caratteri specificati con s2
n=len(s) — lunghezza, numero di caratteri
c=max(s) — restituisce il carattere con il codice più alto
c=min(s) — restituisce il carattere con il codice più basso
n=ord(c) — il codice corrispondente al carattere
s.rstrip() — restituisce la stringa senza spazi finali
s1.partition(s2) — restituisce una lista di tre stringhe, la seconda è s2 se esiste.
s1.replace(s2, s3) — sostituisce s2 con s3
s1.replace(s2, s3, n) — sostituisce s2 con s3, le prime n occorrenze
s1.rfind(s2) — come find ma dalla fine…
s1.rindex(s2) — come index ma dalla fine…
l=sorted(s) — restituisce una lista con i caratteri di s in ordine crescente
s.split() — restituisce una lista con i dati (separati da spazi…) contenuti nella stringa
s.split(c) — restituisce una lista con i dati contenuti nella stringa, separati da un certo carattere
s.split(c, n) — restituisce una lista con i dati contenuti nella stringa, separati da un certo carattere, al più n
s.splitlines() — restituisce una lista con i dati (di linee diverse) contenuti nella stringa
s1.startswith(s2) — restituisce True se s1 inizia con s2
s1.startswith(s2, start)
s1.startswith(s2, start, stop)
s.strip() — restituisce la stringa senza spazi iniziali e finali
s1.strip(s2) — rimuove i caratteri specificati con s2
s.swapcase() — restituisce la stringa con le lettere maiuscole che diventano minuscole e viceversa
s.title() — restituisce la stringa con il primo carattere di ogni parola maiuscolo e tutto il resto minuscolo
s.upper() — tutto maiuscolo
s.zfill(n) — completa con zeri a sinistra fino a raggiungere n caratteri, se si tratta di un numero negativo, mantiene il segno.
…

Leggere una stringa da tastiera

1 2	s=input() s=input("Stringa = ")

Costruttori equivalenti

s="pyTHon"

s="p" "yT" "H" "on"

s=str("pyTHon")

Operatori

s="pyTHon"

s1=s[1] # 'y'

s1=s[1:3] # 'yT'

s1=s[1:] # 'yTHon'

s1=s[:3] # 'pyT'

s1=s+" "+s # 'pyTHon pyTHon'

s1=3*s # 'pyTHonpyTHonpyTHon'

x =('y' in s) # True

x =('y' not in s) # False

Funzioni / metodi

s="pyTHon"

x =len(s) # 6

s1=max(s) # 'y'

s1=min(s) # 'H'

x=s.isalpha() # True

x=s.islower() # False

x=s.istitle() # False

x=s.isupper() # False

s1=s.capitalize() # 'Python'

s1=s.center(20) # ' pyTHon '

s1=s.center(20,'x') # 'xxxxxxxpyTHonxxxxxxx'

s1=s.lower() # 'python'

s1=s.replace('y','?') # 'p?THon'

s1=s.swapcase() # 'PYthON'

s1=s.title() #

s1=s.upper() # 'PYTHON'

s1=s.zfill(20) # '00000000000000pyTHon'

s="18011928"

p=s.index('8') # p=1

p=s.index('9') # p=5

p=s.index('7') # ERRORE!

p=s.find('8') # p=1

p=s.find('7') # p=-1

n=s.count('8') # n=2

n=s.count('9') # n=1

n=s.count('7') # n=0

p=s.index('8',1) # p=1

p=s.index('8',2) # p=7

p=s.find('8',1) # p=1

p=s.find('8',2) # p=7

p=s.find('8',9) # p=-1

n=s.count('8',1) # n=2

n=s.count('8',4) # n=1

p=s.index('8',2,4) # ERRORE!

p=s.index('8',2,8) # p=7

p=s.find('8',2,4) # p=-1

p=s.find('8',2,8) # p=7

n=s.count('8',2,4) # n=0

n=s.count('8',2,8) # n=1

Per manipolare liste e stringhe si possono utilizzare START, STOP, STEP… con lo slicing

1	stringa[START:STOP:STEP] # stringa[START], lista[START+STEP], ...,