Como remover a parte esquerda de uma string?

Eu tenho algum código python simples que pesquisa arquivos por uma string path=c:\path, por exemplo , onde a c:\pathparte pode variar. O código atual é:

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=" ?

Qual é uma maneira simples de obter o texto depois Path=?

Começando em Python 3.9, você pode usar removeprefix:

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

Se a string for fixa, você pode simplesmente usar:

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

que fornece tudo da posição 5 na sequência (uma sequência também é uma sequência, portanto esses operadores de sequência também funcionam aqui).

Ou você pode dividir a linha no primeiro =:

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

Então param é "Caminho" e valor é o restante após o primeiro =.

Remover prefixo de uma sequência

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

Divida na primeira ocorrência do separador 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

Analisar arquivo semelhante ao INI com o 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

Outras opções

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

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

Para fatiar (condicional ou não condicional) em geral, prefiro o que um colega sugeriu recentemente; Use a substituição por uma string vazia. Mais fácil de ler o código, menos código (às vezes) e menos risco de especificar o número errado de caracteres. Está bem; Eu não uso Python, mas em outras línguas prefiro esta abordagem:

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

ou - para acompanhar o primeiro comentário deste post - se isso for feito apenas se a linha começar com Path:

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

A principal diferença em relação ao que foi sugerido acima é que não há "número mágico" (5) envolvido, nem há necessidade de especificar ' 5' e a string ' Path='. Em outras palavras, prefiro essa abordagem a partir de uma manutenção de código ponto de vista.

Eu prefiro popindexar [-1]:

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

para

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

Ou porque não

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

E se..

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

Esse trigêmeo é a cabeça, o separador e a cauda .

A maneira mais simples de pensar é com o fatiamento:

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

Uma observação rápida na notação de fatia, usa dois índices em vez do habitual. O primeiro índice indica o primeiro elemento da sequência que você deseja incluir na fatia e o último índice é o índice imediatamente após o último elemento que você deseja incluir na fatia.
Por exemplo:

sequence_obj[first_index:last_index]

A fatia consiste em todos os elementos entre first_indexe last_index, incluindo first_indexe não last_index. Se o primeiro índice for omitido, o padrão será o início da sequência. Se o último índice for omitido, ele incluirá todos os elementos até o último elemento na sequência. Índices negativos também são permitidos. Use o Google para saber mais sobre o tópico.

>>> import re

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

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

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

Outra linha simples que não foi mencionada aqui:

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

Isso também funcionará corretamente para vários casos extremos:

>>> 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:]

dá-lhe caracteres após os cinco primeiros.

line[5:]dará a substring que você deseja. Pesquise a introdução e procure por 'notação de fatia'

Se você conhece as compreensões da lista:

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

A versão pop não estava certa. Eu acho que você quer:

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

Por que não usar regex com escape? ^corresponde à parte inicial de uma linha e re.MULTILINEcorresponde a cada linha. re.escapegarante que a correspondência seja exata.

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

Experimente o código a seguir

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

Eu acho que é isso que você está procurando exatamente

    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

sem ter que escrever uma função, isso será dividido de acordo com a lista, neste caso 'Sr. | Dr. | Sra.', selecione tudo após dividir com [1], depois divida novamente e pegue qualquer elemento. No caso abaixo, 'Morris' é retornado.

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

Isso é muito semelhante na técnica a outras respostas, mas sem operações repetidas de cadeias, capacidade de saber se o prefixo estava lá ou não, e ainda assim é legível:

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