Removing data between double squiggly brackets with nested sub brackets in python

Question

I'm having some difficulty with this problem. I need to remove all data that's contained in squiggly brackets.

Like such:

Hello {{world of the {{ crazy}} {{need {{ be}}}} sea }} there.

Becomes:

Hello there.

Here's my first try (I know it's terrible):

while 1:
    firstStartBracket = text.find('{{')
    if (firstStartBracket == -1):
        break;
    firstEndBracket = text.find('}}')
    if (firstEndBracket == -1):
        break;
    secondStartBracket = text.find('{{',firstStartBracket+2);
    lastEndBracket = firstEndBracket;
    if (secondStartBracket == -1 or secondStartBracket > firstEndBracket):
        text = text[:firstStartBracket] + text[lastEndBracket+2:];
        continue;
    innerBrackets = 2;
    position = secondStartBracket;
    while innerBrackets:
        print innerBrackets;
        #everytime we find a next start bracket before the ending add 1 to inner brackets else remove 1
        nextEndBracket = text.find('}}',position+2);
        nextStartBracket = text.find('{{',position+2);
        if (nextStartBracket != -1 and nextStartBracket < nextEndBracket):
            innerBrackets += 1;
            position = nextStartBracket;
            # print text[position-2:position+4];
        else:
            innerBrackets -= 1;
            position = nextEndBracket;
            # print text[position-2:position+4];
            # print nextStartBracket
            # print lastEndBracket
            lastEndBracket = nextEndBracket;
        print 'pos',position;
    text = text[:firstStartBracket] + text[lastEndBracket+2:];

It seems to work but runs out of memory quite fast. Is there any better way to do this (hopefully with regex)?

EDIT: I was not clear so I'll give another example. I need to allow for multiple top level brackets.

Like such:

Hello {{world of the {{ crazy}} {{need {{ be}}}} sea }} there {{my }} friend.

Becomes:

Hello there friend.

However as a point , if you dont want use `regex` use stack for count number of open brackets and close ones , it's more easier than sample code here. — ᴀʀᴍᴀɴ, Feb 25 '16 at 00:21

score 4 · Answer 1 · edited May 23 '17 at 11:59

4

You can use pyparsing module here. Solution based on this answer:

from pyparsing import nestedExpr


s = "Hello {{world of the {{ crazy}} {{need {{ be}}}} sea }} there {{my }} friend."

expr = nestedExpr('{{', '}}')
result = expr.parseString("{{" + s + "}}").asList()[0]
print(" ".join(item for item in result if not isinstance(item, list)))

Prints:

Hello there friend.

The following would only work if there is only one top-level pair of braces.

If you want to remove everything inside the double curly braces with the braces themselves:

>>> import re
>>> 
>>> s = "Hello {{world of the {{ crazy}} {{need {{ be}}}} sea }} there."
>>> re.sub(r"\{\{.*\}\} ", "", s)
'Hello there.'

\{\{.*\}\} would match double curly braces followed by any characters any number of times (intentionally left it "greedy") followed by double curly braces and a space.

edited May 23 '17 at 11:59

Community

1
1

answered Feb 25 '16 at 00:21

alecxe

462,703
120
1,088
1,195

1

Only works if you assume there cannot be more than one top level pair of braces. – Jason S Feb 25 '16 at 00:23
@alecxe I'm sorry I wasn't clear with my original question. – thewormsterror Feb 25 '16 at 00:34
`while '{{' in s and '}}' in s` will take care of @JasonS's concern, though it will be screwed by `'}}{{'`... – gil Feb 25 '16 at 00:36
@thewormsterror sure, no problem, updated with an alternative option. – alecxe Feb 25 '16 at 00:43

Jason S · Accepted Answer · 2016-02-25T00:47:07.643

This is a regex/generator based solution that works with any number of braces. This problem does not need an actual stack because there is only 1 type (well, pair) of token involved. The level fills the role that a stack would fill in a more complex parser.

import re

def _parts_outside_braces(text):
    level = 0
    for part in re.split(r'(\{\{|\}\})', text):
        if part == '{{':
            level += 1
        elif part == '}}':
            level = level - 1 if level else 0
        elif level == 0:
            yield part

x = 'Hello {{world of the {{ crazy}} {{need {{ be}}}} sea }} there.  {{ second set {{ of }} braces }}'
print(''.join(_parts_outside_braces(x)))

More general points... the capture group in the regex is what makes the braces show up in the output of re.split, otherwise you only get the stuff in between. There's also some support for mismatched braces. For a strict parser, that should raise an exception, as should running off the end of the string with level > 0. For a loose, web-browser style parser, maybe you would want to display those }} as output...

This is actually the fastest solution so far. ~ 15 µs – Moritz Feb 25 '16 at 01:41 — Moritz, Feb 25 '16 at 01:41

score 1 · Answer 3 · answered Feb 25 '16 at 00:23

1

Try the following code:

import re

s = 'Hello {{world of the {{ crazy}} {{need {{ be}}}} sea }} there'
m = re.search('(.*?) {.*}(.*)',s)
result = m.group(1) + m.group(2)
print(result)

answered Feb 25 '16 at 00:23

Ren

2,852
2
23
45

Only works if you assume there cannot be more than one top level pair of braces. – Jason S Feb 25 '16 at 00:24

score 1 · Answer 4 · answered Feb 25 '16 at 00:43

The problem is that you would have to deal with nested structure, which means regular expression may not suffice. However, a simple parser with a memory of depth level may come to rescue - it is very simple to write, just store the depth level into a variable.

I just post a more pythonic way of writing the solution here, which may be a good reference for you.

import re

def rem_bra(inp):
    i = 0
    lvl = 0
    chars = []
    while i < len(inp):
        if inp[i:i+2] == '{{':
            lvl += 1
            i += 1
        elif inp[i:i+2] == '}}':
            lvl -= 1
            i += 1
        else:
            if lvl < 1:
                chars.append(inp[i])
        i += 1
    result = ''.join(chars)

    # If you need no more contigious spaces, add this line:
    result = re.sub(r'\s\s+', r' ', result)

    return result


inp = "Hello {{world of the {{ crazy}} {{need {{ be}}}} sea }} there."

print(rem_bra(inp))
>>> Hello there.

score 1 · Answer 5 · answered Feb 25 '16 at 01:02

1

For good measure, yet another solution. It starts by finding and replacing the leftmost innermost braces and works its way outwards, rightwards. Takes care of multiple top level braces.

import re

def remove_braces(s):
    pattern = r'\{\{(?:[^{]|\{[^{])*?\}\}'
    while re.search(pattern, s):
        s = re.sub(pattern, '', s)
    return s

Not the most efficient, but short.

>>> remove_braces('Hello {{world of the {{ crazy}} {{need {{ be}}}} sea }} there {{my }} friend.')
'Hello  there  friend.'

answered Feb 25 '16 at 01:02

gil

2,086
12
13

are you kidding ? Yours is highly efficient. Takes about 90 ns for one loop compared to 10 - 25 microseconds for most other solutions. – Moritz Feb 25 '16 at 01:29
@Moritz I guessed so :) It does search/match the string multiple times, while Jason S's solution, say, does it only once. But I like it short. – gil Feb 25 '16 at 01:38
It takes 90ns to compile your function – Moritz Feb 25 '16 at 01:41
@Moritz have you figured out what solution was the fastest between all answers? – thewormsterror Feb 25 '16 at 01:58
Jasons answer is. about 15 µs. Mine is about 25 µs. Probably because i do have to convert the iterable to a list – Moritz Feb 25 '16 at 02:04

score 1 · Answer 6 · answered Feb 25 '16 at 01:23

This question makes fun. Here is my attempt:

import re

def find_str(string):

    flag = 0

    for index,item in enumerate(string):

        if item == '{':
            flag += 1

        if item == '}':
            flag -= 1

        if flag == 0:
            yield index

s = 'Hello {{world of the {{ crazy}} {{need {{ be}}}} sea }} there {{my }} friend.'

index = list(find_str(s))

l = [s[i] for i in index]

s = ' '.join(l)

re.sub('}\s+','',s)

'H e l l o t h e r e f r i e n d .'

bobble bubble · Answer 7 · 2022-09-25T06:04:46.357

0

With PyPI regex and recursive regex eg like this:

p = r'{{(?>[^}{]+|(?0))*}} ?'

See this demo at regex101 or Python demo at tio.run.

import regex as re

str = re.sub(p, '', str)

fyi: Regular expression to match balanced parentheses

edited Sep 25 '22 at 06:04

answered Feb 25 '16 at 10:30

bobble bubble

16,888
3
27
46

Removing data between double squiggly brackets with nested sub brackets in python

7 Answers7