Python Language
Metodi di stringa

Sintassi

• str.capitalize () -> str
• str.casefold () -> str [solo per Python> 3.3]
• str.center (width [, fillchar]) -> str
• str.count (sub [, start [, end]]) -> int
• str.decode (encoding = "utf-8" [, errors]) -> unicode [solo in Python 2.x]
• str.encode (encoding = "utf-8", errors = "strict") -> byte
• str.endswith (suffisso [, inizio [, fine]]) -> bool
• str.expandtabs (tabsize = 8) -> str
• str.find (sub [, start [, end]]) -> int
• str.format (* args, ** kwargs) -> str
• str.format_map (mapping) -> str
• str.index (sub [, start [, end]]) -> int
• str.isalnum () -> bool
• str.isalpha () -> bool
• str.isdecimal () -> bool
• str.isdigit () -> bool
• str.isidentifier () -> bool
• str.islower () -> bool
• str.isnumeric () -> bool
• str.isprintable () -> bool
• str.isspace () -> bool
• str.istitle () -> bool
• str.isupper () -> bool
• str.join (iterable) -> str
• str.ljust (width [, fillchar]) -> str
• str.lower () -> str
• str.lstrip ([chars]) -> str
• statico str.maketrans (x [, y [, z]])
• str.partition (sep) -> (testa, sep, coda)
• str.replace (old, new [, count]) -> str
• str.rfind (sub [, start [, end]]) -> int
• str.rindex (sub [, start [, end]]) -> int
• str.rjust (width [, fillchar]) -> str
• str.rpartition (sep) -> (testa, sep, coda)
• str.rsplit (sep = None, maxsplit = -1) -> elenco di stringhe
• str.rstrip ([chars]) -> str
• str.split (sep = None, maxsplit = -1) -> elenco di stringhe
• str.splitlines ([keepends]) -> lista di stringhe
• str.startswith (prefisso [, inizio [, fine]]) -> libro
• str.strip ([chars]) -> str
• str.swapcase () -> str
• str.title () -> str
• str.translate (table) -> str
• str.upper () -> str
• str.zfill (larghezza) -> str

Osservazioni

Modifica della maiuscola di una stringa

Il tipo di stringa di Python fornisce molte funzioni che agiscono sulla maiuscola di una stringa. Questi includono :

• str.casefold
• str.upper
• str.lower
• str.capitalize
• str.title
• str.swapcase

Con le stringhe unicode (l'impostazione predefinita in Python 3), queste operazioni non sono mappature 1: 1 o reversibili. La maggior parte di queste operazioni è destinata alla visualizzazione, piuttosto che alla normalizzazione.

"XßΣ".casefold()
# 'xssσ'

"XßΣ".lower()
# 'xßς'

str.upper()

str.upper prende ogni carattere in una stringa e lo converte in equivalente in maiuscolo, ad esempio:

"This is a 'string'.".upper()
# "THIS IS A 'STRING'."

str.lower()

str.lower fa il contrario; prende ogni carattere in una stringa e lo converte in equivalente in lettere minuscole:

"This IS a 'string'.".lower()
# "this is a 'string'."

str.capitalize()

str.capitalize restituisce una versione in maiuscolo della stringa, ovvero rende il primo carattere con maiuscole e il resto inferiore:

"this Is A 'String'.".capitalize() # Capitalizes the first character and lowercases all others
# "This is a 'string'."

str.title()

str.title restituisce la versione con str.title del titolo della stringa, cioè ogni lettera all'inizio di una parola è fatta in maiuscolo e tutte le altre sono scritte in minuscolo:

"this Is a 'String'".title()
# "This Is A 'String'"

str.swapcase()

str.swapcase restituisce un nuovo oggetto stringa in cui tutti i caratteri minuscoli vengono scambiati in maiuscolo e tutti i caratteri maiuscoli in basso:

"this iS A STRiNG".swapcase() #Swaps case of each character
# "THIS Is a strIng"

Utilizzo come metodi di classe str

Vale la pena notare che questi metodi possono essere chiamati sia su oggetti stringa (come mostrato sopra) o come metodo di classe della classe str (con una chiamata esplicita a str.upper , ecc.)

str.upper("This is a 'string'")
# "THIS IS A 'STRING'"

Questo è molto utile quando si applica uno di questi metodi a più stringhe contemporaneamente, ad esempio, una funzione map .

map(str.upper,["These","are","some","'strings'"])
# ['THESE', 'ARE', 'SOME', "'STRINGS'"]

Dividere una stringa in base a un delimitatore in un elenco di stringhe

str.split(sep=None, maxsplit=-1)

str.split prende una stringa e restituisce una lista di sottostringhe della stringa originale. Il comportamento varia a seconda che l'argomento sep sia fornito o omesso.

Se sep non è fornito, o è None , la suddivisione avviene ovunque ci sia spazio bianco. Tuttavia, gli spazi bianchi iniziali e finali vengono ignorati e più caratteri spazi bianchi consecutivi vengono trattati allo stesso modo di un singolo carattere di spaziatura:

>>> "This is a sentence.".split()
['This', 'is', 'a', 'sentence.']

>>> " This is    a sentence.  ".split()
['This', 'is', 'a', 'sentence.']

>>> "            ".split()
[]

Il parametro sep può essere utilizzato per definire una stringa delimitatore. La stringa originale è divisa in cui si verifica la stringa del delimitatore e il delimitatore stesso viene scartato. Più delimitatori consecutivi non vengono trattati allo stesso modo di una singola occorrenza, ma piuttosto creano stringhe vuote da creare.

>>> "This is a sentence.".split(' ')
['This', 'is', 'a', 'sentence.']

>>> "Earth,Stars,Sun,Moon".split(',')
['Earth', 'Stars', 'Sun', 'Moon']

>>> " This is    a sentence.  ".split(' ')
['', 'This', 'is', '', '', '', 'a', 'sentence.', '', '']

>>> "This is a sentence.".split('e')
['This is a s', 'nt', 'nc', '.']

>>> "This is a sentence.".split('en')
['This is a s', 't', 'ce.']

L'impostazione predefinita è dividere ogni occorrenza del delimitatore, tuttavia il parametro maxsplit limita il numero di errori che si verificano. Il valore predefinito di -1 indica nessun limite:

>>> "This is a sentence.".split('e', maxsplit=0)
['This is a sentence.']

>>> "This is a sentence.".split('e', maxsplit=1)
['This is a s', 'ntence.']

>>> "This is a sentence.".split('e', maxsplit=2)
['This is a s', 'nt', 'nce.']

>>> "This is a sentence.".split('e', maxsplit=-1)
['This is a s', 'nt', 'nc', '.']

str.rsplit(sep=None, maxsplit=-1)

str.rsplit ("right split") si differenzia da str.split ("left split") quando viene specificato maxsplit . La divisione inizia alla fine della stringa anziché all'inizio:

>>> "This is a sentence.".rsplit('e', maxsplit=1)
['This is a sentenc', '.']

>>> "This is a sentence.".rsplit('e', maxsplit=2)
['This is a sent', 'nc', '.']

Nota : Python specifica il numero massimo di suddivisioni eseguite, mentre la maggior parte degli altri linguaggi di programmazione specifica il numero massimo di sottostringhe create. Ciò potrebbe creare confusione durante il porting o il confronto del codice.

Sostituisci tutte le occorrenze di una sottostringa con un'altra sottostringa

Il tipo str di Python ha anche un metodo per sostituire le occorrenze di una sottostringa con un'altra sottostringa in una determinata stringa. Per i casi più impegnativi, si può usare re.sub .

str.replace(old, new[, count]) :

str.replace accetta due argomenti old e new contenenti la old sottostringa che deve essere sostituita dalla new sottostringa. Il count argomento facoltativo specifica il numero di sostituzioni da apportare:

Ad esempio, per sostituire 'foo' con 'spam' nella stringa seguente, possiamo chiamare str.replace con old = 'foo' e new = 'spam' :

>>> "Make sure to foo your sentence.".replace('foo', 'spam')
"Make sure to spam your sentence."

Se la stringa data contiene più esempi che corrispondono al old argomento, tutte le occorrenze vengono sostituite con il valore fornito in new :

>>> "It can foo multiple examples of foo if you want.".replace('foo', 'spam')
"It can spam multiple examples of spam if you want."

a meno che, ovviamente, forniamo un valore per il count . In questo caso, le occorrenze di count verranno sostituite:

>>> """It can foo multiple examples of foo if you want, \
... or you can limit the foo with the third argument.""".replace('foo', 'spam', 1)
'It can spam multiple examples of foo if you want, or you can limit the foo with the third argument.'

str.format e f-strings: formatta i valori in una stringa

Python fornisce funzionalità di interpolazione e formattazione delle str.format attraverso la funzione str.format , introdotta nella versione 2.6 e nella sezione f introdotta nella versione 3.6.

Date le seguenti variabili:

i = 10
f = 1.5
s = "foo"
l = ['a', 1, 2]
d = {'a': 1, 2: 'foo'}

Le seguenti affermazioni sono tutte equivalenti

"10 1.5 foo ['a', 1, 2] {'a': 1, 2: 'foo'}"

>>> "{} {} {} {} {}".format(i, f, s, l, d)

>>> str.format("{} {} {} {} {}", i, f, s, l, d)

>>> "{0} {1} {2} {3} {4}".format(i, f, s, l, d)

>>> "{0:d} {1:0.1f} {2} {3!r} {4!r}".format(i, f, s, l, d)

>>> "{i:d} {f:0.1f} {s} {l!r} {d!r}".format(i=i, f=f, s=s, l=l, d=d)

>>> f"{i} {f} {s} {l} {d}"

>>> f"{i:d} {f:0.1f} {s} {l!r} {d!r}"

Per riferimento, Python supporta anche qualificatori in stile C per la formattazione delle stringhe. Gli esempi di seguito sono equivalenti a quelli precedenti, ma le versioni str.format sono preferite a causa dei vantaggi in termini di flessibilità, coerenza della notazione ed estensibilità:

"%d %0.1f %s %r %r" % (i, f, s, l, d)

"%(i)d %(f)0.1f %(s)s %(l)r %(d)r" % dict(i=i, f=f, s=s, l=l, d=d)

Le graffe utilizzate per l'interpolazione in str.format possono anche essere numerate per ridurre la duplicazione durante la formattazione delle stringhe. Ad esempio, i seguenti sono equivalenti:

"I am from Australia. I love cupcakes from Australia!"

>>> "I am from {}. I love cupcakes from {}!".format("Australia", "Australia")

>>> "I am from {0}. I love cupcakes from {0}!".format("Australia")

Mentre la documentazione ufficiale di Python è, come al solito, abbastanza completa, pyformat.info ha una grande serie di esempi con spiegazioni dettagliate.

Inoltre, i caratteri { e } possono essere sfuggiti utilizzando le parentesi doppie:

"{'a': 5, 'b': 6}"

>>> "{{'{}': {}, '{}': {}}}".format("a", 5, "b", 6)

>>> f"{{'{'a'}': {5}, '{'b'}': {6}}"

Vedere Formattazione di stringhe per ulteriori informazioni. str.format() stato proposto in PEP 3101 e f-string in PEP 498 .

Numero di volte in cui una sottostringa viene visualizzata in una stringa

Un metodo è disponibile per il conteggio del numero di occorrenze di una sottostringa in un'altra stringa, str.count .

str.count(sub[, start[, end]])

str.count restituisce un int che indica il numero di occorrenze non sovrapposte alla sub-stringa sub in un'altra stringa. Gli argomenti opzionali start e end indicano l'inizio e la fine in cui avverrà la ricerca. Di default start = 0 e end = len(str) significa che verrà cercata l'intera stringa:

>>> s = "She sells seashells by the seashore."
>>> s.count("sh")
2
>>> s.count("se")
3
>>> s.count("sea")
2
>>> s.count("seashells")
1

Specificando un valore diverso per start , end possiamo ottenere una ricerca più localizzata e contare, ad esempio, se start è uguale a 13 la chiamata a:

>>> s.count("sea", start)
1

è equivalente a:

>>> t = s[start:]
>>> t.count("sea")
1

Prova i caratteri iniziali e finali di una stringa

Per testare l'inizio e la fine di una data stringa in Python, si possono usare i metodi str.startswith() e str.endswith() .

str.startswith(prefix[, start[, end]])

Come suggerisce il nome, str.startswith viene utilizzato per verificare se una determinata stringa inizia con i caratteri specificati nel prefix .

>>> s = "This is a test string"
>>> s.startswith("T")
True
>>> s.startswith("Thi")
True
>>> s.startswith("thi")  
False

Gli argomenti facoltativi di start e end specificano i punti di inizio e di fine da cui inizierà e terminerà il test. Nell'esempio seguente, specificando un valore iniziale di 2 nostra stringa verrà ricercata dalla posizione 2 e in seguito:

>>> s.startswith("is", 2)
True

Questo produce True poiché s[2] == 'i' and s[3] == 's' .

Puoi anche usare una tuple per verificare se inizia con una serie di stringhe

>>> s.startswith(('This', 'That'))
True
>>> s.startswith(('ab', 'bc'))
False

str.endswith(prefix[, start[, end]])

str.endswith è esattamente simile a str.startswith con la sola differenza che cerca caratteri finali e non caratteri iniziali. Ad esempio, per verificare se una stringa termina con un punto, si potrebbe scrivere:

>>> s = "this ends in a full stop."
>>> s.endswith('.')
True
>>> s.endswith('!')
False

come con startswith più di un carattere può essere usato come sequenza finale:

>>> s.endswith('stop.')
True
>>> s.endswith('Stop.')
False

Puoi anche usare una tuple per verificare se termina con una serie di stringhe

>>> s.endswith(('.', 'something'))
True
>>> s.endswith(('ab', 'bc'))
False

Test di cosa è composta una stringa

Il tipo str di Python include anche numerosi metodi che possono essere utilizzati per valutare il contenuto di una stringa. Questi sono str.isalpha , str.isdigit , str.isalnum , str.isspace . Le maiuscole possono essere testate con str.isupper , str.islower e str.istitle .

str.isalpha

str.isalpha non accetta argomenti e restituisce True se tutti i caratteri in una determinata stringa sono alfabetici, ad esempio:

>>> "Hello World".isalpha()  # contains a space
False
>>> "Hello2World".isalpha()  # contains a number
False
>>> "HelloWorld!".isalpha()  # contains punctuation
False
>>> "HelloWorld".isalpha()
True

Come caso limite, la stringa vuota "".isalpha() False se utilizzata con "".isalpha() .

str.isupper , str.islower , str.istitle

Questi metodi verificano la maiuscola in una determinata stringa.

str.isupper è un metodo che restituisce True se tutti i caratteri di una data stringa sono maiuscoli e False altrimenti.

>>> "HeLLO WORLD".isupper()
False
>>> "HELLO WORLD".isupper()
True
>>> "".isupper()
False

Al contrario, str.islower è un metodo che restituisce True se tutti i caratteri in una data stringa sono in minuscolo e False altrimenti.

>>> "Hello world".islower()
False
>>> "hello world".islower()
True
>>> "".islower()
False

str.istitle restituisce True se la stringa data è title cased; cioè, ogni parola inizia con un carattere maiuscolo seguito da caratteri minuscoli.

>>> "hello world".istitle()
False
>>> "Hello world".istitle()
False
>>> "Hello World".istitle()
True
>>> "".istitle()
False

str.isdecimal , str.isdigit , str.isnumeric

str.isdecimal restituisce se la stringa è una sequenza di cifre decimali, adatta a rappresentare un numero decimale.

str.isdigit include cifre non in una forma adatta a rappresentare un numero decimale, come le cifre in apice.

str.isnumeric include tutti i valori numerici, anche se non le cifre, come valori al di fuori dell'intervallo 0-9.

            isdecimal    isdigit   isnumeric

12345        True        True       True
១2߃໔5        True        True       True
①²³🄅₅       False       True       True
⑩⒓          False       False      True
Five         False       False      False

Bytestrings ( bytes in Python 3, str in Python 2), supportano solo isdigit , che controlla solo le cifre ASCII di base.

Come con str.isalpha , la stringa vuota str.isalpha False .

str.isalnum

Questa è una combinazione di str.isalpha e str.isnumeric , in particolare valuta su True se tutti i caratteri nella stringa data sono alfanumerici , ovvero sono costituiti da caratteri alfabetici o numerici:

>>> "Hello2World".isalnum()
True
>>> "HelloWorld".isalnum()
True
>>> "2016".isalnum()
True
>>> "Hello World".isalnum()  # contains whitespace
False

str.isspace

Valuta True se la stringa contiene solo caratteri di spaziatura.

>>> "\t\r\n".isspace()
True
>>> " ".isspace()
True

A volte una stringa sembra "vuota" ma non sappiamo se è perché contiene solo spazi bianchi o nessun carattere

>>> "".isspace()
False

Per coprire questo caso abbiamo bisogno di un test aggiuntivo

>>> my_str = ''
>>> my_str.isspace()
False
>>> my_str.isspace() or not my_str
True

Ma il modo più breve per verificare se una stringa è vuota o contiene solo caratteri di spaziatura è usare la strip (senza argomenti rimuove tutti i caratteri di spaziatura iniziali e finali)

>>> not my_str.strip()
True

str.translate: traduzione di caratteri in una stringa

Python supporta un metodo di translate sul tipo str che consente di specificare la tabella di conversione (utilizzata per le sostituzioni) e qualsiasi carattere che dovrebbe essere eliminato nel processo.

str.translate(table[, deletechars])

Il metodo maketrans ( str.maketrans in Python 3 e string.maketrans in Python 2) consente di generare una tabella di traduzione.

>>> translation_table = str.maketrans("aeiou", "12345")
>>> my_string = "This is a string!"
>>> translated = my_string.translate(translation_table)
'Th3s 3s 1 str3ng!'

Il metodo translate restituisce una stringa che è una copia tradotta della stringa originale.

È possibile impostare l'argomento table su None se è necessario solo cancellare caratteri.

>>> 'this syntax is very useful'.translate(None, 'aeiou')
'ths syntx s vry sfl'

Eliminazione di caratteri iniziali / finali indesiderati da una stringa

Vengono forniti tre metodi che offrono la possibilità di str.strip str.rstrip e finali da una stringa: str.strip , str.rstrip e str.lstrip . Tutti e tre i metodi hanno la stessa firma e tutti e tre restituiscono un nuovo oggetto stringa con caratteri indesiderati rimossi.

str.strip([chars])

str.strip agisce su una determinata stringa e rimuove (strisce) qualsiasi carattere iniziale o finale contenuto nei chars argomento; se i chars non vengono forniti o è None , tutti i caratteri dello spazio bianco vengono rimossi per impostazione predefinita. Per esempio:

>>> "    a line with leading and trailing space     ".strip() 
'a line with leading and trailing space'

Se vengono forniti chars , tutti i caratteri in esso contenuti vengono rimossi dalla stringa, che viene restituita. Per esempio:

>>> ">>> a Python prompt".strip('> ')  # strips '>' character and space character 
'a Python prompt'

str.rstrip([chars]) e str.lstrip([chars])

Questi metodi hanno semantica e argomenti simili con str.strip() , la loro differenza sta nella direzione da cui partono. str.rstrip() inizia dalla fine della stringa mentre str.lstrip() divide dall'inizio della stringa.

Ad esempio, utilizzando str.rstrip :

>>> "     spacious string      ".rstrip()
'     spacious string'

Mentre, usando str.lstrip :

>>> "     spacious string      ".rstrip()
'spacious string      '

Confronto tra stringhe senza confronti tra maiuscole e minuscole

Confrontando la stringa in un modo insensibile al caso sembra qualcosa di banale, ma non lo è. Questa sezione considera solo stringhe unicode (il default in Python 3). Si noti che Python 2 può avere debolezze sottili rispetto a Python 3 - la successiva gestione unicode è molto più completa.

La prima cosa da notare è che le conversioni di rimozione del caso in Unicode non sono banali. C'è del testo per il quale text.lower() != text.upper().lower() , come "ß" :

>>> "ß".lower()
'ß'

>>> "ß".upper().lower()
'ss'

Ma diciamo che si voleva maiuscole e minuscole confrontare "BUSSE" e "Buße" . Diamine, probabilmente vuoi anche confrontare "BUSSE" e "BUẞE" uguale - questa è la nuova forma maiuscola. Il modo consigliato è utilizzare la casefold :

>>> help(str.casefold)
"""
Help on method_descriptor:

casefold(...)
      S.casefold() -> str
    
     Return a version of S suitable for caseless comparisons.
"""

Non usare solo lower . Se la casefold e casefold non è disponibile, facendo .upper().lower() aiuta (ma solo un po ').

Quindi dovresti considerare gli accenti. Se il tuo renderer dei font è buono, probabilmente pensi "ê" == "ê" - ma non lo fa:

>>> "ê" == "ê"
False

Questo perché sono in realtà

>>> import unicodedata

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E WITH CIRCUMFLEX']

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E', 'COMBINING CIRCUMFLEX ACCENT']

Il modo più semplice per unicodedata.normalize è unicodedata.normalize . Probabilmente vuoi usare la normalizzazione NFKD , ma sentiti libero di controllare la documentazione. Quindi si

>>> unicodedata.normalize("NFKD", "ê") == unicodedata.normalize("NFKD", "ê")
True

Per finire, qui questo è espresso in funzioni:

import unicodedata

def normalize_caseless(text):
    return unicodedata.normalize("NFKD", text.casefold())

def caseless_equal(left, right):
    return normalize_caseless(left) == normalize_caseless(right)

Unisci un elenco di stringhe in un'unica stringa

Una stringa può essere utilizzata come separatore per unire un elenco di stringhe insieme in una singola stringa utilizzando il metodo join() . Ad esempio è possibile creare una stringa in cui ogni elemento di una lista è separato da uno spazio.

>>> " ".join(["once","upon","a","time"])
"once upon a time"

L'esempio seguente separa gli elementi stringa con tre trattini.

>>> "---".join(["once", "upon", "a", "time"])
"once---upon---a---time"

Costanti utili del modulo stringa

Il modulo di string di Python fornisce costanti per le operazioni legate alle stringhe. Per usarli, importa il modulo string :

>>> import string

string.ascii_letters :

Concatenazione di ascii_lowercase e ascii_uppercase :

>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.ascii_lowercase :

Contiene tutti i caratteri ASCII in minuscolo:

>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

string.ascii_uppercase :

Contiene tutti i caratteri ASCII maiuscoli:

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.digits :

Contiene tutti i caratteri decimali:

>>> string.digits
'0123456789'

string.hexdigits :

Contiene tutti i caratteri a cifre esadecimali:

>>> string.hexdigits
'0123456789abcdefABCDEF'

string.octaldigits :

Contiene tutti i caratteri ottali delle cifre:

>>> string.octaldigits
'01234567'

string.punctuation :

Contiene tutti i caratteri che sono considerati segni di punteggiatura nella locale C :

>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

string.whitespace :

Contiene tutti i caratteri ASCII considerati spazi bianchi:

>>> string.whitespace
' \t\n\r\x0b\x0c'

In modalità script, print(string.whitespace) stamperà i caratteri reali, usa str per ottenere la stringa restituita sopra.

string.printable :

Contiene tutti i caratteri che sono considerati stampabili; una combinazione di string.digits , string.ascii_letters , string.punctuation e string.whitespace .

>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

Inversione di una stringa

Una stringa può essere invertita usando la funzione built-in reverse reversed() , che prende una stringa e restituisce un iteratore in ordine inverso.

>>> reversed('hello')
<reversed object at 0x0000000000000000>
>>> [char for char in reversed('hello')]
['o', 'l', 'l', 'e', 'h']

reversed() può essere racchiuso in una chiamata a ''.join() per creare una stringa dall'iteratore.

>>> ''.join(reversed('hello'))
'olleh'

Mentre l'uso di reversed() potrebbe essere più leggibile agli utenti non esperti di Python, l'uso di slicing esteso con un passo di -1 è più veloce e più conciso. Qui, prova ad implementarlo come funzione:

>>> def reversed_string(main_string):
...     return main_string[::-1]
...
>>> reversed_string('hello')
'olleh'

Giustificare le corde

Python fornisce funzioni per giustificare le stringhe, consentendo al padding del testo di rendere molto più semplice l'allineamento di varie stringhe.

Di seguito è riportato un esempio di str.ljust e str.rjust :

interstates_lengths = {
    5: (1381, 2222),
    19: (63, 102),
    40: (2555, 4112),
    93: (189,305),
}
for road, length in interstates_lengths.items():
    miles,kms = length
    print('{} -> {} mi. ({} km.)'.format(str(road).rjust(4), str(miles).ljust(4), str(kms).ljust(4)))

  40 -> 2555 mi. (4112 km.)
  19 -> 63   mi. (102  km.)
   5 -> 1381 mi. (2222 km.)
  93 -> 189  mi. (305  km.)

ljust e le rjust sono molto simili. Entrambi hanno un parametro width e un parametro fillchar opzionale. Qualsiasi stringa creata da queste funzioni è lunga almeno quanto il parametro width passato nella funzione. Se la stringa è più lunga della width , non viene troncata. L'argomento fillchar , che ha come valore predefinito il carattere spazio ' ' deve essere un singolo carattere, non una stringa multicharacter.

La ljust funzione pads alla fine della stringa è chiamato con il fillchar finché è width lungo caratteri. La funzione rjust l'inizio della stringa in modo simile. Pertanto, la l e r nei nomi di queste funzioni si riferiscono al lato che la stringa originale, non il fillchar , è posizionata nella stringa di output.

Conversione tra str o byte di dati e caratteri Unicode

Il contenuto di file e messaggi di rete può rappresentare caratteri codificati. Spesso devono essere convertiti in unicode per una visualizzazione corretta.

In Python 2, potrebbe essere necessario convertire i dati str in caratteri Unicode. Il valore predefinito ( '' , "" , ecc.) È una stringa ASCII, con qualsiasi valore esterno all'intervallo ASCII visualizzato come valori di escape. Le stringhe Unicode sono u'' (o u"" , ecc.).

# You get "© abc" encoded in UTF-8 from a file, network, or other data source

s = '\xc2\xa9 abc'  # s is a byte array, not a string of characters
                    # Doesn't know the original was UTF-8
                    # Default form of string literals in Python 2
s[0]                # '\xc2' - meaningless byte (without context such as an encoding)
type(s)             # str - even though it's not a useful one w/o having a known encoding

u = s.decode('utf-8')  # u'\xa9 abc'
                       # Now we have a Unicode string, which can be read as UTF-8 and printed properly
                       # In Python 2, Unicode string literals need a leading u
                       # str.decode converts a string which may contain escaped bytes to a Unicode string
u[0]                # u'\xa9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # unicode

u.encode('utf-8')   # '\xc2\xa9 abc'
                    # unicode.encode produces a string with escaped bytes for non-ASCII characters

In Python 3 potrebbe essere necessario convertire array di byte (indicati come "byte letterali") in stringhe di caratteri Unicode. L'impostazione predefinita è ora una stringa Unicode e ora i valori letterali devono essere immessi come b'' , b"" , ecc. Un byte letterale restituirà True a isinstance(some_val, byte) , assumendo some_val come stringa che potrebbe essere codificata come byte.

# You get from file or network "© abc" encoded in UTF-8

s = b'\xc2\xa9 abc' # s is a byte array, not characters
                    # In Python 3, the default string literal is Unicode; byte array literals need a leading b
s[0]                # b'\xc2' - meaningless byte (without context such as an encoding)
type(s)             # bytes - now that byte arrays are explicit, Python can show that.

u = s.decode('utf-8')  # '© abc' on a Unicode terminal
                       # bytes.decode converts a byte array to a string (which will, in Python 3, be Unicode)
u[0]                # '\u00a9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # str
                    # The default string literal in Python 3 is UTF-8 Unicode

u.encode('utf-8')   # b'\xc2\xa9 abc'
                    # str.encode produces a byte array, showing ASCII-range bytes as unescaped characters.

La stringa contiene

Python rende estremamente intuitivo verificare se una stringa contiene una sottostringa data. Basta usare il in dell'operatore:

>>> "foo" in "foo.baz.bar"
True

Nota: testare una stringa vuota risulterà sempre in True :

>>> "" in "test"
True