Comment extraire la sous-chaîne entre deux marqueurs?

Disons que j'ai une chaîne 'gfgfdAAA1234ZZZuijjk'et que je veux extraire uniquement la '1234'partie.

Je sais seulement quels seront les quelques personnages directement avant AAAet après ZZZla partie qui m'intéresse 1234.

Avec, sedil est possible de faire quelque chose comme ça avec une chaîne:

echo "$STRING" | sed -e "s|.*AAA\(.*\)ZZZ.*|\1|"

Et cela me donnera 1234comme résultat.

Comment faire la même chose en Python?

Utilisation d'expressions régulières - documentation pour référence ultérieure

import re

text = 'gfgfdAAA1234ZZZuijjk'

m = re.search('AAA(.+?)ZZZ', text)
if m:
    found = m.group(1)

# found: 1234

ou:

import re

text = 'gfgfdAAA1234ZZZuijjk'

try:
    found = re.search('AAA(.+?)ZZZ', text).group(1)
except AttributeError:
    # AAA, ZZZ not found in the original string
    found = '' # apply your error handling

# found: 1234

>>> s = 'gfgfdAAA1234ZZZuijjk'
>>> start = s.find('AAA') + 3
>>> end = s.find('ZZZ', start)
>>> s[start:end]
'1234'

Ensuite, vous pouvez également utiliser des expressions rationnelles avec le module re, si vous le souhaitez, mais ce n'est pas nécessaire dans votre cas.

expression régulière

import re

re.search(r"(?<=AAA).*?(?=ZZZ)", your_text).group(0)

La situation ci-dessus échouera avec un AttributeErrors'il n'y a pas de "AAA" et "ZZZ" dansyour_text

méthodes de chaîne

your_text.partition("AAA")[2].partition("ZZZ")[0]

Ce qui précède retournera une chaîne vide si "AAA" ou "ZZZ" n'existent pas your_text.

Défi PS Python?

import re
print re.search('AAA(.*?)ZZZ', 'gfgfdAAA1234ZZZuijjk').group(1)

Surpris que personne n'ait mentionné cela, qui est ma version rapide pour les scripts uniques:

>>> x = 'gfgfdAAA1234ZZZuijjk'
>>> x.split('AAA')[1].split('ZZZ')[0]
'1234'

vous pouvez utiliser une seule ligne de code

>>> import re

>>> re.findall(r'\d{1,5}','gfgfdAAA1234ZZZuijjk')

>>> ['1234']

le résultat recevra la liste ...

Vous pouvez utiliser le module re pour cela:

>>> import re
>>> re.compile(".*AAA(.*)ZZZ.*").match("gfgfdAAA1234ZZZuijjk").groups()
('1234,)

Avec sed, il est possible de faire quelque chose comme ça avec une chaîne:

echo "$STRING" | sed -e "s|.*AAA\(.*\)ZZZ.*|\1|"

Et cela me donnera 1234 en conséquence.

Vous pouvez faire de même avec une re.subfonction utilisant la même expression régulière.

>>> re.sub(r'.*AAA(.*)ZZZ.*', r'\1', 'gfgfdAAA1234ZZZuijjk')
'1234'

Dans sed de base, le groupe de capture est représenté par \(..\), mais en python, il était représenté par (..).

En python, l'extraction de la chaîne de formulaire de sous-chaîne peut être effectuée à l'aide de la findallméthode du remodule d' expression régulière ( ).

>>> import re
>>> s = 'gfgfdAAA1234ZZZuijjk'
>>> ss = re.findall('AAA(.+)ZZZ', s)
>>> print ss
['1234']

Vous pouvez trouver la première sous-chaîne avec cette fonction dans votre code (par index de caractères). En outre, vous pouvez trouver ce qui se trouve après une sous-chaîne.

def FindSubString(strText, strSubString, Offset=None):
    try:
        Start = strText.find(strSubString)
        if Start == -1:
            return -1 # Not Found
        else:
            if Offset == None:
                Result = strText[Start+len(strSubString):]
            elif Offset == 0:
                return Start
            else:
                AfterSubString = Start+len(strSubString)
                Result = strText[AfterSubString:AfterSubString + int(Offset)]
            return Result
    except:
        return -1

# Example:

Text = "Thanks for contributing an answer to Stack Overflow!"
subText = "to"

print("Start of first substring in a text:")
start = FindSubString(Text, subText, 0)
print(start); print("")

print("Exact substring in a text:")
print(Text[start:start+len(subText)]); print("")

print("What is after substring \"%s\"?" %(subText))
print(FindSubString(Text, subText))

# Your answer:

Text = "gfgfdAAA1234ZZZuijjk"
subText1 = "AAA"
subText2 = "ZZZ"

AfterText1 = FindSubString(Text, subText1, 0) + len(subText1)
BeforText2 = FindSubString(Text, subText2, 0) 

print("\nYour answer:\n%s" %(Text[AfterText1:BeforText2]))

>>> s = '/tmp/10508.constantstring'
>>> s.split('/tmp/')[1].split('constantstring')[0].strip('.')

text = 'I want to find a string between two substrings'
left = 'find a '
right = 'between two'

print(text[text.index(left)+len(left):text.index(right)])

Donne

string

Juste au cas où quelqu'un devra faire la même chose que moi. J'ai dû tout extraire entre parenthèses en ligne. Par exemple, si j'ai une phrase comme «le président américain (Barack Obama) a rencontré ...» et que je veux obtenir uniquement «Barack Obama», c'est la solution:

regex = '.*\((.*?)\).*'
matches = re.search(regex, line)
line = matches.group(1) + '\n'

C'est-à-dire que vous devez bloquer les parenthèses avec slash \ signe. Bien qu'il s'agisse d'un problème d'expressions plus régulières que Python.

De plus, dans certains cas, vous pouvez voir des symboles «r» avant la définition de l'expression régulière. S'il n'y a pas de préfixe r, vous devez utiliser des caractères d'échappement comme en C. Voici plus de discussion à ce sujet.

Utilisation de PyParsing

import pyparsing as pp

word = pp.Word(pp.alphanums)

s = 'gfgfdAAA1234ZZZuijjk'
rule = pp.nestedExpr('AAA', 'ZZZ')
for match in rule.searchString(s):
    print(match)

ce qui donne:

[['1234']]

Voici une solution sans regex qui tient également compte des scénarios où la première sous-chaîne contient la deuxième sous-chaîne. Cette fonction ne trouvera une sous-chaîne que si le deuxième marqueur est après le premier marqueur.

def find_substring(string, start, end):
    len_until_end_of_first_match = string.find(start) + len(start)
    after_start = string[len_until_end_of_first_match:]
    return string[string.find(start) + len(start):len_until_end_of_first_match + after_start.find(end)]

Une autre façon de le faire est d'utiliser des listes (en supposant que la sous-chaîne que vous recherchez est composée uniquement de nombres):

string = 'gfgfdAAA1234ZZZuijjk'
numbersList = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
output = []

for char in string:
    if char in numbersList: output.append(char)

print(f"output: {''.join(output)}")
### output: 1234

Un liners qui renvoie une autre chaîne s'il n'y a pas de correspondance. Edit: la version améliorée utilise la nextfonction, remplacez "not-found"par quelque chose d'autre si nécessaire:

import re
res = next( (m.group(1) for m in [re.search("AAA(.*?)ZZZ", "gfgfdAAA1234ZZZuijjk" ),] if m), "not-found" )

Mon autre méthode pour le faire, moins optimale, utilise la 2e expression régulière, n'a toujours pas trouvé de moyen plus court:

import re
res = ( ( re.search("AAA(.*?)ZZZ", "gfgfdAAA1234ZZZuijjk") or re.search("()","") ).group(1) )