Comment supprimer la partie gauche d'une chaîne?

J'ai un code python simple qui recherche dans les fichiers une chaîne, par exemple path=c:\path, où la c:\pathpartie peut varier. Le code actuel est:

def find_path(i_file):
    lines = open(i_file).readlines()
    for line in lines:
        if line.startswith("Path="):
            return # what to do here in order to get line content after "Path=" ?

Quel est le moyen simple d'obtenir le texte après Path=?

À partir de Python 3.9, vous pouvez utiliser removeprefix:

'Path=helloworld'.removeprefix('Path=')
# 'helloworld'

Si la chaîne est fixe, vous pouvez simplement utiliser:

if line.startswith("Path="):
    return line[5:]

qui vous donne tout à partir de la position 5 dans la chaîne (une chaîne est aussi une séquence, donc ces opérateurs de séquence fonctionnent ici aussi).

Ou vous pouvez diviser la ligne au début =:

if "=" in line:
    param, value = line.split("=",1)

Alors param est "Path" et value est le reste après le premier =.

Supprimer le préfixe d'une chaîne

# ...
if line.startswith(prefix):
   return line[len(prefix):]

Fractionner à la première occurrence du séparateur via str.partition()

def findvar(filename, varname="Path", sep="=") :
    for line in open(filename):
        if line.startswith(varname + sep):
           head, sep_, tail = line.partition(sep) # instead of `str.split()`
           assert head == varname
           assert sep_ == sep
           return tail

Analyser un fichier de type INI avec ConfigParser

from ConfigParser import SafeConfigParser
config = SafeConfigParser()
config.read(filename) # requires section headers to be present

path = config.get(section, 'path', raw=1) # case-insensitive, no interpolation

Autres options

• str.split()
• re.match()

def remove_prefix(text, prefix):
    return text[len(prefix):] if text.startswith(prefix) else text

Pour le tranchage (conditionnel ou non conditionnel) en général, je préfère ce qu'un collègue a suggéré récemment; Utilisez le remplacement par une chaîne vide. Plus facile à lire le code, moins de code (parfois) et moins de risque de spécifier le mauvais nombre de caractères. D'accord; Je n'utilise pas Python, mais dans d'autres langages, je préfère cette approche:

rightmost = full_path.replace('Path=', '', 1)

ou - pour donner suite au premier commentaire de cet article - si cela ne doit être fait que si la ligne commence par Path:

rightmost = re.compile('^Path=').sub('', full_path)

La principale différence avec certains de ce qui a été suggéré ci-dessus est qu'il n'y a pas de "nombre magique" (5) impliqué, ni aucun besoin de spécifier à la fois ' 5' et la chaîne ' Path=', En d'autres termes, je préfère cette approche à une maintenance de code point de vue.

Je préfère popindexer [-1]:

value = line.split("Path=", 1).pop()

à

value = line.split("Path=", 1)[1]
param, value = line.split("Path=", 1)

Ou pourquoi pas

if line.startswith(prefix):
    return line.replace(prefix, '', 1)

Que diriez-vous..

>>> line = r'path=c:\path'
>>> line.partition('path=')
('', 'path=', 'c:\\path')

Ce triplet est la tête, le séparateur et la queue .

Le moyen le plus simple auquel je puisse penser est le tranchage:

def find_path(i_file): 
    lines = open(i_file).readlines() 
    for line in lines: 
        if line.startswith("Path=") : 
            return line[5:]

Une note rapide sur la notation des tranches, il utilise deux indices au lieu de l'habituel. Le premier index indique le premier élément de la séquence que vous souhaitez inclure dans la tranche et le dernier index est l'index immédiatement après le dernier élément que vous souhaitez inclure dans la tranche.
Par exemple:

sequence_obj[first_index:last_index]

La tranche se compose de tous les éléments entre first_indexet last_index, y compris first_indexet non last_index. Si le premier index est omis, il prend par défaut le début de la séquence. Si le dernier index est omis, il inclut tous les éléments jusqu'au dernier élément de la séquence. Les indices négatifs sont également autorisés. Utilisez Google pour en savoir plus sur le sujet.

>>> import re

>>> p = re.compile(r'path=(.*)', re.IGNORECASE)

>>> path = "path=c:\path"

>>> re.match(p, path).group(1)
'c:\\path'

Un autre simple one-liner qui n'a pas été mentionné ici:

value = line.split("Path=", 1)[-1]

Cela fonctionnera également correctement pour divers cas extrêmes:

>>> print("prefixfoobar".split("foo", 1)[-1])
"bar"

>>> print("foofoobar".split("foo", 1)[-1])
"foobar"

>>> print("foobar".split("foo", 1)[-1])
"bar"

>>> print("bar".split("foo", 1)[-1])
"bar"

>>> print("".split("foo", 1)[-1])
""

line[5:]

vous donne des caractères après les cinq premiers.

line[5:]donnera la sous-chaîne souhaitée. Recherchez l' introduction et recherchez la `` notation de tranche ''

Si vous connaissez la compréhension des listes:

lines = [line[5:] for line in file.readlines() if line[:5] == "Path="]

La version pop n'était pas tout à fait correcte. Je pense que tu veux:

>>> print('foofoobar'.split('foo', 1).pop())
foobar

Pourquoi ne pas utiliser regex avec escape? ^correspond à la partie initiale d'une ligne et re.MULTILINEcorrespond à chaque ligne. re.escapegarantit que la correspondance est exacte.

>>> print(re.sub('^' + re.escape('path='), repl='', string='path=c:\path\nd:\path2', flags=re.MULTILINE))
c:\path
d:\path2

Essayez le code suivant

if line.startswith("Path="): return line[5:]

Je suppose que c'est exactement ce que tu cherches

    def findPath(i_file) :
        lines = open( i_file ).readlines()
        for line in lines :
            if line.startswith( "Path=" ):
                output_line=line[(line.find("Path=")+len("Path=")):]
                return output_line

sans avoir à écrire une fonction, cela sera divisé en fonction de la liste, dans ce cas «M. | Dr. | Mme.», sélectionnez tout après la séparation avec [1], puis divisez à nouveau et prenez n'importe quel élément. Dans le cas ci-dessous, «Morris» est renvoyé.

re.split('Mr.|Dr.|Mrs.', 'Mr. Morgan Morris')[1].split()[1]

Cette technique est très similaire à celle des autres réponses, mais sans opérations répétées sur les chaînes, possibilité de dire si le préfixe était là ou non, et toujours assez lisible:

parts = the_string.split(prefix_to_remove, 1):
    if len(parts) == 2:
        #  do things with parts[1]
        pass