使用多个if-else和split（）简化特定字符串模式的提取

Question

Given a string like this:

>>> s = "X/NOUN/dobj>_hold/VERB/ROOT_<membership/NOUN/dobj_<with/ADP/prep_<Y/PROPN/pobj_>,/PUNCT/punct"

First I want to split the string by underscores, ie:

>>> s.split('_')
['X/NOUN/dobj>',
 'hold/VERB/ROOT',
 '<membership/NOUN/dobj',
 '<with/ADP/prep',
 '<Y/PROPN/pobj',
 '>,/PUNCT/punct']

We assume that the underscore is solely used as the delimiter and never exist as part of the substring we want to extract.

Then I need to first checks whether each of these "nodes" in my splitted list above starts of ends with a '>', '<', then remove it and put the appropriate bracket as the end of the sublist, something like:

result = []
nodes = s.split('_')
for node in nodes:
    if node.endswith('>'):
        result.append( node[:-1].split('/') + ['>'] )
    elif node.startswith('>'):
        result.append(  node[1:].split('/') + ['>'] )
    elif node.startswith('<'):
        result.append(  node[1:].split('/') + ['<'] )
    elif node.endswith('<'):
        result.append(  node[:-1].split('/') + ['<'] )
    else:
        result.append(  node.split('/') + ['-'] )

And if it doesn't start of ends with an angular bracket then we append - to the end of the sublist.

[out]:

[['X', 'NOUN', 'dobj', '>'],
 ['hold', 'VERB', 'ROOT', '-'],
 ['membership', 'NOUN', 'dobj', '<'],
 ['with', 'ADP', 'prep', '<'],
 ['Y', 'PROPN', 'pobj', '<'],
 [',', 'PUNCT', 'punct', '>']]

Given the original input string, is there a less verbose way to get to the result? Maybe with regex and groups?

Answer 1

s = 'X/NOUN/dobj>_hold/VERB/ROOT_<membership/NOUN/dobj_<with/ADP/prep_<Y/PROPN/pobj_>,/PUNCT/punct'

def get_sentinal(node):
    if not node:
        return '-'
    # Assuming the node won't contain both '<' and '>' at a same time
    for index in [0, -1]:
        if node[index] in '<>':
            return node[index]
    return '-'

results = [
    node.strip('<>').split('/') + [get_sentinal(node)]
    for node in s.split('_')
]

print(results)

This does not make it significantly shorter , but personally I'd think it's somehow a little bit cleaner .

Answer 2

Use this:

import re
s_split = "X/NOUN/dobj>_hold/VERB/ROOT_<membership/NOUN/dobj_<with/ADP/prep_<Y/PROPN/pobj_>,/PUNCT/punct".split('_')
for i, text in enumerate(s_split):
    Left, Mid, Right = re.search('^([<>]?)(.*?)([<>]?)$', text).groups()
    s_split[i] = Mid.split('/') + [Left+Right or '-']

print s_split

I can't find a possible answer for a shorter one.

Use ternary to shorten code. Example: print None or "a" will print a . And also use regex to parse the occurence of <> easily.

Answer 3

Yes, although it's not pretty:

s = "X/NOUN/dobj>_hold/VERB/ROOT_<membership/NOUN/dobj_<with/ADP/prep_<Y/PROPN/pobj_>,/PUNCT/punct"

import re

out = []
for part in s.split('_'):
    Left, Mid, Right = re.search('^([<>]|)(.*?)([<>]|)$', part).groups()
    tail = ['-'] if not Left+Right else [Left+Right]
    out.append(Mid.split('/') + tail)

print(out)

Try online: https://repl.it/Civg

It relies on two main things:

1. a regex pattern which always makes three groups ()()() where the edge groups only look for characters < , > or nothing ([<>]|) , and the middle matches everything (non-greedy) (.*?) . The whole thing is anchored at the start ( ^ ) and end ( $ ) of the string so it consumes the whole input string.
2. Assuming that you will never have angles on both ends of the string, then the combined string Left+Right will either be an empty string plus the character to put at the end, one way or the other, or a completely empty string indicating a dash is required.

Answer 4

Instead of my other answer with regexes, you can drop a lot of lines and a lot of slicing, if you know that string.strip('<>') will strip either character from both ends of the string, in one move.

This code is about halfway between your original and my regex answer in linecount, but is more readable for it.

s = "X/NOUN/dobj>_hold/VERB/ROOT_<membership/NOUN/dobj_<with/ADP/prep_<Y/PROPN/pobj_>,/PUNCT/punct"

result = []
for node in s.split('_'):
    if node.startswith('>') or node.startswith('<'):
        tail = node[0]
    elif node.endswith('>') or node.endswith('>'):
        tail = node[-1]
    else:
        tail = '-'
    result.append( node.strip('<>').split('/') + [tail])

print(result)

Try online: https://repl.it/Civr

---

Edit: how much less verbose do you want to get?

result = [node.strip('<>').split('/') + [(''.join(char for char in node if char in '<>') + '-')[0]] for node in s.split('_')]
print(result)

This is quite neat, you don't have to check which side the <> is on, or whether it's there at all. One step strip() s either angle bracket whichever side it's on, the next step filters only the angle brackets out of the string (whichever side they're on) and adds the dash character. This is either a string starting with any angle bracket from either side or a single dash. Take char 0 to get the right one.

Answer 5

Even shorter with a list comprehension and some regex magic:

import re    
s = "X/NOUN/dobj>_hold/VERB/ROOT_<membership/NOUN/dobj_<with/ADP/prep_<Y/PROPN/pobj_>,/PUNCT/punct"

rx = re.compile(r'([<>])|/')
items = [list(filter(None, match)) \
    for item in s.split('_') \
    for match in [rx.split(item)]]

print(items)
# [['X', 'NOUN', 'dobj', '>'], ['hold', 'VERB', 'ROOT'], ['<', 'membership', 'NOUN', 'dobj'], ['<', 'with', 'ADP', 'prep'], ['<', 'Y', 'PROPN', 'pobj'], ['>', ',', 'PUNCT', 'punct']]

---

Explanation: The code splits the items by _ , splits it again with the help of the regular expression rx and filters out empty elements in the end.

---

See a demo on ideone.com .

Answer 6

I did not use regex and groups but it can be solution as shorter way.

>>> result=[]
>>> nodes=['X/NOUN/dobj>','hold/VERB/ROOT','<membership/NOUN/dobj',
 '<with/ADP/prep','<Y/PROPN/pobj','>,/PUNCT/punct']
>>> for node in nodes:
...    nd=node.replace(">",("/>" if node.endswith(">") else ">/"))
...    nc=nd.replace("<",("/<" if nd.endswith("<") else "</"))
...    result.append(nc.split("/"))
>>> nres=[inner for outer in result for inner in outer] #nres used to join all result at single array. If you dont need single array you can use result.