Comment obtenir une sous-chaîne d'une chaîne en Python?

Existe-t-il un moyen de sous-chaîne d'une chaîne en Python, pour obtenir une nouvelle chaîne du troisième caractère à la fin de la chaîne?

Peut-être comme myString[2:end]?

Si quitter la deuxième partie signifie «jusqu'à la fin», et si vous quittez la première partie, cela commence-t-il depuis le début?

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

Python appelle ce concept "slicing" et il fonctionne sur plus que des chaînes. Jetez un œil ici pour une introduction complète.

Juste pour être complet car personne d'autre ne l'a mentionné. Le troisième paramètre d'une tranche de tableau est une étape. Donc, inverser une chaîne est aussi simple que:

some_string[::-1]

Ou sélectionner des caractères alternatifs serait:

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

La possibilité d'avancer et de reculer dans la chaîne maintient la cohérence avec la possibilité de créer une tranche de tableau depuis le début ou la fin.

Substr () fonctionne normalement (ie PHP et Perl) de cette façon:

s = Substr(s, beginning, LENGTH)

Les paramètres sont donc beginninget LENGTH.

Mais le comportement de Python est différent; il attend le début et un après la FIN (!). C'est difficile à repérer par les débutants. Donc, le remplacement correct pour Substr (s, début, LONGUEUR) est

s = s[ beginning : beginning + LENGTH]

Un moyen courant d'y parvenir est de couper les chaînes.

MyString[a:b] vous donne une sous-chaîne de l'index a à (b - 1).

Un exemple semble manquer ici: copie complète (peu profonde).

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

C'est un idiome commun pour créer une copie des types de séquence (pas de chaînes internées), [:]. Shallow copie une liste, voir Syntaxe de tranche de liste Python utilisée sans raison évidente .

Existe-t-il un moyen de sous-chaîne d'une chaîne en Python, pour obtenir une nouvelle chaîne du 3ème caractère à la fin de la chaîne?

Peut-être comme myString[2:end]?

Oui, cela fonctionne en fait , si vous attribuez, ou se lier , le nom, endà singleton constante, None:

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

La notation de tranche a 3 arguments importants:

• début
• Arrêtez
• étape

Leurs valeurs par défaut lorsqu'elles ne sont pas données sont None- mais nous pouvons les transmettre explicitement:

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

Si quitter la deuxième partie signifie «jusqu'à la fin», si vous quittez la première partie, cela commence-t-il depuis le début?

Oui, par exemple:

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

Notez que nous incluons start dans la tranche, mais nous n'allons que jusqu'à, et non compris, stop.

Lorsque l'étape est None, par défaut, la tranche utilise 1pour l'étape. Si vous marchez avec un entier négatif, Python est assez intelligent pour aller de la fin au début.

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

J'explique la notation de tranche en détail dans ma réponse à la question Expliquer la notation de tranche.

Vous l'avez ici, sauf pour "end". C'est ce qu'on appelle la notation de tranche. Votre exemple devrait se lire:

new_sub_string = myString[2:]

Si vous omettez le deuxième paramètre, il s'agit implicitement de la fin de la chaîne.

Je voudrais ajouter deux points à la discussion:

1. Vous pouvez utiliser à la Noneplace sur un espace vide pour spécifier "du début" ou "jusqu'à la fin":

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

   Ceci est particulièrement utile dans les fonctions, où vous ne pouvez pas fournir un espace vide comme argument:

   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 a des objets slice :

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

Si myString contient un numéro de compte qui commence à l' offset 6 et 9 a une longueur, vous pouvez extraire le numéro de compte de cette façon: acct = myString[6:][:9].

Si le PO accepte cela, il pourrait vouloir essayer, de manière expérimentale,

myString[2:][:999999]

Cela fonctionne - aucune erreur n'est déclenchée et aucun «remplissage de chaîne» par défaut ne se produit.

Je l'ai peut-être manqué, mais je n'ai pas trouvé de réponse complète sur cette page aux questions d'origine car les variables ne sont pas discutées plus en détail ici. J'ai donc dû continuer à chercher.

Comme je ne suis pas encore autorisé à commenter, permettez-moi d'ajouter ma conclusion ici. Je suis sûr que je n'étais pas le seul intéressé à y accéder en accédant à cette page:

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

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

Si vous quittez la première partie, vous obtenez

 >>>myString[:end]
 'Hello' 

Et si vous avez laissé le: au milieu également, vous avez la sous-chaîne la plus simple, qui serait le 5ème caractère (comptez en commençant par 0, c'est donc le blanc dans ce cas):

 >>>myString[end]
 ' '

Eh bien, j'ai eu une situation où je devais traduire un script PHP en Python, et il avait de nombreuses utilisations de substr(string, beginning, LENGTH).
Si je choisissais Python, string[beginning:end]je devrais calculer beaucoup d'index de fin, donc la façon la plus simple était d'utiliser string[beginning:][:length], cela m'a sauvé beaucoup de problèmes.

L'utilisation d'index codés en dur peut être un gâchis.

Afin d'éviter cela, Python propose un objet intégré slice().

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

Si nous voulons savoir combien d'argent il me reste.

Solution normale:

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

Utilisation de tranches:

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

En utilisant la tranche, vous gagnez en lisibilité.