Let's say I have a string 'gfgfdAAA1234ZZZuijjk' and I want to extract just the '1234' part.
I only know what will be the few characters directly before AAA, and after ZZZ the part I am interested in 1234.
With sed it is possible to do something like this with a string:
echo "$STRING" | sed -e "s|.*AAA\(.*\)ZZZ.*|\1|" And this will give me 1234 as a result.
How to do the same thing in Python?
Using regular expressions - documentation for further reference
import re text = 'gfgfdAAA1234ZZZuijjk' m = re.search('AAA(.+?)ZZZ', text) if m: found = m.group(1) # found: 1234 or:
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' Then you can use regexps with the re module as well, if you want, but that's not necessary in your case.
re method not faster though?
s, s.find will return -1. the slicing operator s[begin:end] will accept it as valid index, and return undesired substring.
import re re.search(r"(?<=AAA).*?(?=ZZZ)", your_text).group(0) The above as-is will fail with an AttributeError if there are no "AAA" and "ZZZ" in your_text
your_text.partition("AAA")[2].partition("ZZZ")[0] The above will return an empty string if either "AAA" or "ZZZ" don't exist in your_text.
PS Python Challenge?
Surprised that nobody has mentioned this which is my quick version for one-off scripts:
>>> x = 'gfgfdAAA1234ZZZuijjk' >>> x.split('AAA')[1].split('ZZZ')[0] '1234' 
if s.find("ZZZ") > s.find("AAA"): to it, avoids issues if 'ZZZ` isn't in the string, which would return '1234uuijjk'
partition instead of split seems more robust (depending on your needs), as it returns an empty string if one of the substrings isn't found.you can do using just one line of code
>>> import re >>> re.findall(r'\d{1,5}','gfgfdAAA1234ZZZuijjk') >>> ['1234'] result will receive list...
You can use re module for that:
>>> import re >>> re.compile(".*AAA(.*)ZZZ.*").match("gfgfdAAA1234ZZZuijjk").groups() ('1234,) In python, extracting substring form string can be done using findall method in regular expression (re) module.
>>> import re >>> s = 'gfgfdAAA1234ZZZuijjk' >>> ss = re.findall('AAA(.+)ZZZ', s) >>> print ss ['1234'] 
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)]) Gives
string 
>>> s = '/tmp/10508.constantstring' >>> s.split('/tmp/')[1].split('constantstring')[0].strip('.') With sed it is possible to do something like this with a string:
echo "$STRING" | sed -e "s|.*AAA\(.*\)ZZZ.*|\1|"
And this will give me 1234 as a result.
You could do the same with re.sub function using the same regex.
>>> re.sub(r'.*AAA(.*)ZZZ.*', r'\1', 'gfgfdAAA1234ZZZuijjk') '1234' In basic sed, capturing group are represented by \(..\), but in python it was represented by (..).
You can find first substring with this function in your code (by character index). Also, you can find what is after a substring.
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])) Using 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) which yields:
[['1234']]
One liner with Python 3.8 if text is guaranteed to contain the substring:
text[text.find(start:='AAA')+len(start):text.find('ZZZ')] Just in case somebody will have to do the same thing that I did. I had to extract everything inside parenthesis in a line. For example, if I have a line like 'US president (Barack Obama) met with ...' and I want to get only 'Barack Obama' this is solution:
regex = '.*\((.*?)\).*' matches = re.search(regex, line) line = matches.group(1) + '\n' I.e. you need to block parenthesis with slash \ sign. Though it is a problem about more regular expressions that Python.
Also, in some cases you may see 'r' symbols before regex definition. If there is no r prefix, you need to use escape characters like in C. Here is more discussion on that.
also, you can find all combinations in the bellow function
s = 'Part 1. Part 2. Part 3 then more text' def find_all_places(text,word): word_places = [] i=0 while True: word_place = text.find(word,i) i+=len(word)+word_place if i>=len(text): break if word_place<0: break word_places.append(word_place) return word_places def find_all_combination(text,start,end): start_places = find_all_places(text,start) end_places = find_all_places(text,end) combination_list = [] for start_place in start_places: for end_place in end_places: print(start_place) print(end_place) if start_place>=end_place: continue combination_list.append(text[start_place:end_place]) return combination_list find_all_combination(s,"Part","Part") result:
['Part 1. ', 'Part 1. Part 2. ', 'Part 2. '] In case you want to look for multiple occurences.
content ="Prefix_helloworld_Suffix_stuff_Prefix_42_Suffix_andsoon" strings = [] for c in content.split('Prefix_'): spos = c.find('_Suffix') if spos!=-1: strings.append( c[:spos]) print( strings ) Or more quickly :
strings = [ c[:c.find('_Suffix')] for c in content.split('Prefix_') if c.find('_Suffix')!=-1 ] Here's a solution without regex that also accounts for scenarios where the first substring contains the second substring. This function will only find a substring if the second marker is after the first marker.
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)] Another way of doing it is using lists (supposing the substring you are looking for is made of numbers, only) :
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 Typescript. Gets string in between two other strings.
Searches shortest string between prefixes and postfixes
prefixes - string / array of strings / null (means search from the start).
postfixes - string / array of strings / null (means search until the end).
public getStringInBetween(str: string, prefixes: string | string[] | null, postfixes: string | string[] | null): string { if (typeof prefixes === 'string') { prefixes = [prefixes]; } if (typeof postfixes === 'string') { postfixes = [postfixes]; } if (!str || str.length < 1) { throw new Error(str + ' should contain ' + prefixes); } let start = prefixes === null ? { pos: 0, sub: '' } : this.indexOf(str, prefixes); const end = postfixes === null ? { pos: str.length, sub: '' } : this.indexOf(str, postfixes, start.pos + start.sub.length); let value = str.substring(start.pos + start.sub.length, end.pos); if (!value || value.length < 1) { throw new Error(str + ' should contain string in between ' + prefixes + ' and ' + postfixes); } while (true) { try { start = this.indexOf(value, prefixes); } catch (e) { break; } value = value.substring(start.pos + start.sub.length); if (!value || value.length < 1) { throw new Error(str + ' should contain string in between ' + prefixes + ' and ' + postfixes); } } return value; } a simple approach could be the following:
string_to_search_in = 'could be anything' start = string_to_search_in.find(str("sub string u want to identify")) length = len("sub string u want to identify") First_part_removed = string_to_search_in[start:] end_coord = length Extracted_substring=First_part_removed[:end_coord] 
If you want to check whether the substrings exists and return empty string if they don't:
def substr_between(str_all, first_string, last_string): pos1 = str_all.find(first_string) if pos1 < 0: return "" pos1 += len(first_string) pos2 = str_all[pos1:].find(last_string) if pos2 < 0: return "" return str_all[pos1:pos1 + pos2] I used this Split method:
main_text="dsfsgaehere535353box" start = "here" end = "box" z1 = main_text.split(start) z2 = z1[1].split(end) print(z2[0]) will be "535353"
If your markers might appear multiple times or even be identical, you can safely extract all matches using re.escape():
import re s = "XXXAAAfirstAAAsecondAAAthirdZZZ" start, end = "AAA", "AAA" pattern = f"{re.escape(start)}(.*?){re.escape(end)}" matches = re.findall(pattern, s) print(matches) # ['first', 'second'] This approach correctly handles repeated or identical markers and avoids regex injection issues.
One liners that return other string if there was no match. Edit: improved version uses next function, replace "not-found" with something else if needed:
import re res = next( (m.group(1) for m in [re.search("AAA(.*?)ZZZ", "gfgfdAAA1234ZZZuijjk" ),] if m), "not-found" ) My other method to do this, less optimal, uses regex 2nd time, still didn't found a shorter way:
import re res = ( ( re.search("AAA(.*?)ZZZ", "gfgfdAAA1234ZZZuijjk") or re.search("()","") ).group(1) ) 
text[text.find(start:='AAA')+len(start):text.find('ZZZ')]