Come posso ottenere una sottostringa di una stringa in Python?

C'è un modo per sottostringa di una stringa in Python, per ottenere una nuova stringa dal terzo carattere alla fine della stringa?

Forse piace myString[2:end]?

Se lasciare la seconda parte significa "fino alla fine" e se si lascia la prima parte, inizia dall'inizio?

>>> x = "Hello World!"
>>> x[2:]
'llo World!'
>>> x[:2]
'He'
>>> x[:-2]
'Hello Worl'
>>> x[-2:]
'd!'
>>> x[2:-2]
'llo Worl'

Python chiama questo concetto "slicing" e funziona su più di semplici stringhe. Dai un'occhiata qui per un'introduzione completa.

Solo per completezza come nessun altro ha menzionato. Il terzo parametro di una sezione di array è un passaggio. Quindi invertire una stringa è semplice come:

some_string[::-1]

O la selezione di caratteri alternativi sarebbe:

"H-e-l-l-o- -W-o-r-l-d"[::2] # outputs "Hello World"

La possibilità di spostarsi avanti e indietro nella stringa mantiene la coerenza con la possibilità di disporre la sezione dall'inizio o alla fine.

Substr () normalmente (cioè PHP e Perl) funziona in questo modo:

s = Substr(s, beginning, LENGTH)

Quindi i parametri sono beginninge LENGTH.

Ma il comportamento di Python è diverso; si aspetta l'inizio e uno dopo END (!). Questo è difficile da individuare per i principianti. Quindi la sostituzione corretta per Substr (s, inizio, LUNGHEZZA) è

s = s[ beginning : beginning + LENGTH]

Un modo comune per raggiungere questo obiettivo è affettare le stringhe.

MyString[a:b] ti dà una sottostringa dall'indice a a (b - 1).

Qui sembra mancare un esempio: copia completa (superficiale).

>>> x = "Hello World!"
>>> x
'Hello World!'
>>> x[:]
'Hello World!'
>>> x==x[:]
True
>>>

Si tratta di un linguaggio comune per la creazione di una copia di tipi di sequenze (non di stringhe internati), [:]. Shallow copia un elenco, vedi la sintassi della slice dell'elenco Python utilizzata senza motivo ovvio .

C'è un modo per sottostringa di una stringa in Python, per ottenere una nuova stringa dal 3 ° carattere alla fine della stringa?

Forse piace myString[2:end]?

Sì, questo in realtà funziona se si assegna o si legano , il nome, endper costante Singleton, None:

>>> end = None
>>> myString = '1234567890'
>>> myString[2:end]
'34567890'

La notazione delle sezioni ha 3 argomenti importanti:

• inizio
• fermare
• passo

I loro valori predefiniti quando non sono indicati sono None- ma possiamo passarli esplicitamente:

>>> stop = step = None
>>> start = 2
>>> myString[start:stop:step]
'34567890'

Se lasciare la seconda parte significa "fino alla fine", se si lascia la prima parte, inizia dall'inizio?

Sì, ad esempio:

>>> start = None
>>> stop = 2
>>> myString[start:stop:step]
'12'

Nota che includiamo start nella sezione, ma andiamo solo fino a, e non includendo, stop.

Quando il passaggio è None, per impostazione predefinita la sezione utilizza 1per il passaggio. Se passi con un numero intero negativo, Python è abbastanza intelligente da andare dalla fine all'inizio.

>>> myString[::-1]
'0987654321'

Spiego la notazione delle sezioni in modo molto dettagliato nella mia risposta a Spiega la domanda sulla notazione delle sezioni.

Ce l'hai proprio lì tranne "end". Si chiama slice notation. Il tuo esempio dovrebbe leggere:

new_sub_string = myString[2:]

Se si omette il secondo parametro, è implicitamente la fine della stringa.

Vorrei aggiungere due punti alla discussione:

1. È possibile utilizzare Noneinvece su uno spazio vuoto per specificare "dall'inizio" o "fino alla fine":

   'abcde'[2:None] == 'abcde'[2:] == 'cde'

   Ciò è particolarmente utile nelle funzioni, in cui non è possibile fornire uno spazio vuoto come argomento:

   def substring(s, start, end):
       """Remove `start` characters from the beginning and `end` 
       characters from the end of string `s`.
   
       Examples
       --------
       >>> substring('abcde', 0, 3)
       'abc'
       >>> substring('abcde', 1, None)
       'bcde'
       """
       return s[start:end]

2. Python ha oggetti slice :

   idx = slice(2, None)
   'abcde'[idx] == 'abcde'[2:] == 'cde'

Se myString contiene un numero di conto che inizia all'offset 6 e ha lunghezza 9, quindi è possibile estrarre il numero di conto in questo modo: acct = myString[6:][:9].

Se l'OP lo accetta, potrebbe voler provare, in modo sperimentale,

myString[2:][:999999]

Funziona: non viene generato alcun errore e non si verifica alcun 'string stringding' predefinito.

Forse l'ho perso, ma non sono riuscito a trovare una risposta completa in questa pagina alle domande originali perché le variabili non sono ulteriormente discusse qui. Quindi ho dovuto continuare a cercare.

Dato che non sono ancora autorizzato a commentare, vorrei aggiungere la mia conclusione qui. Sono sicuro di non essere il solo interessato ad accedere a questa pagina:

 >>>myString = 'Hello World'
 >>>end = 5

 >>>myString[2:end]
 'llo'

Se lasci la prima parte, ottieni

 >>>myString[:end]
 'Hello' 

E se hai lasciato il: anche nel mezzo hai la sottostringa più semplice, che sarebbe il 5 ° carattere (conta a partire da 0, quindi in questo caso è lo spazio vuoto):

 >>>myString[end]
 ' '

Bene, ho avuto una situazione in cui dovevo tradurre uno script PHP in Python, e aveva molti usi substr(string, beginning, LENGTH).
Se avessi scelto Python's string[beginning:end]avrei dovuto calcolare molti indici finali, quindi il modo più semplice era quello di usare string[beginning:][:length], mi ha risparmiato un sacco di problemi.

L'uso stesso degli indici hardcoded può essere un casino.

Per evitarlo, Python offre un oggetto incorporato slice().

string = "my company has 1000$ on profit, but I lost 500$ gambling."

Se vogliamo sapere quanti soldi mi sono rimasti.

Soluzione normale:

final = int(string[15:19]) - int(string[43:46])
print(final)
>>>500

Usando le sezioni:

EARNINGS = slice(15, 19)
LOSSES = slice(43, 46)
final = int(string[EARNINGS]) - int(string[LOSSES])
print(final)
>>>500

Usando la fetta ottieni leggibilità.