Regex for extracting the keyboard keys from strings with keyboard shortcuts

If you are fine with not using a regex below a function which does the job:

def splitKeybShortcut(keybShortcut):
    lstKeys = []
    max_i = len(keybShortcut)
    i = 1
    key = keybShortcut[0] 
    while i < max_i:
        chr_i = keybShortcut[i] 
        if chr_i != '+':
            key += chr_i
        else:
            lstKeys.append(key)
            i+=1
            key = keybShortcut[i]
        i += 1
    if key:
        lstKeys.append(key)
    return lstKeys
# -------------------------------------
print(splitKeybShortcut('++Super+Alt'))
print(splitKeybShortcut('Super+++Alt'))

The advantage of the above approach over usage of a regular expression is that you have more control about what and how something is done where the regex ‘hides’ the machinery under the hood and you must believe and trust that it will always do what you expect from it with the risk that your way of understanding what and how it does what it does may be a wrong one.

To demonstrate what I have said above below some more code I feed with malformed keyboard shortcut definition strings:

print( "=====================")
import re
regex = r"(.[^+]*)+?"
regexExplanation = """
  "(.[^+]*)+?"
   (.[^+]*)    1-st capturing group (.[^+]*)
    .          matches exactly one char which can be anything (except new line)
     [^+]      match ANY single character EXCEPT a '+' one  
         *          ^---  0 to any times, as many as possible, giving back as needed (greedy)
          +   matches the character '+' with index 4310 (2B16 or 538) literally (case sensitive)
            ?  matches the previous token between zero and one times (greedy)
It matches a beginning '+' if any than finds a match after match for the
capturing group pattern. The pattern that follows fails except at the 
end of a string where it is able to match a single '+'. 
"""

print( 
  re.findall(regex, '+++Super+Alt'),
  re.findall(regex, '++Super++Alt'),
  re.findall(regex, 'Super+Alt+++'),
  re.findall(regex, 'Super+++Alt'),
  sep='n'
)

print( "================================")
def splitKeybShortcut(keybShortcut):
    lstKeys = []
    max_i = len(keybShortcut)
    i = 1
    key = keybShortcut[0] 
    while i < max_i:
        if len(key)>1 and key[0] =='+':
            return f'''
Malformed Shortcut: {keybShortcut} 
''' + f'''
                 {i*' '}--^'''
        chr_i = keybShortcut[i] 
        if chr_i != '+':
            key += chr_i
        else:
            lstKeys.append(key)
            i+=1
            if i < max_i: 
                key = keybShortcut[i]
            else:
                break
        i += 1
    if key == '+' == lstKeys[-1]:
            return f'''
Malformed Shortcut: {keybShortcut} 
''' + f'''
                 {i*' '}--^'''
    else:
        lstKeys.append(key)
    return lstKeys
# -------------------------------------
print( 
  splitKeybShortcut('+++Super+Alt'),
  splitKeybShortcut('++Super++Alt'),
  splitKeybShortcut('Super+Alt+++'),
  splitKeybShortcut('Super+++Alt'),
  sep='n'
)

which prints:

=====================
['+', '+Super', 'Alt']
['+', 'Super', '+Alt']
['Super', 'Alt', '+']
['Super', '+', 'Alt']
================================
Malformed Shortcut: +++Super+Alt 
                     --^
Malformed Shortcut: ++Super++Alt 
                           --^
Malformed Shortcut: Super+Alt+++ 
                             --^
['Super', '+', 'Alt']

Maybe it is possible somehow to tweak the regex along with the code using it to achieve detection of problems with for example typos in the shortcut strings pointing exactly where they occur, but I don’t see myself any as easy way to achieve that as it is the case when using an own function. Anyway, even a short regex needs usually a long explanation because it is not as easy to read and understand as a simple flow of code with a loop and if statements.

An attempt to make a regex pattern better readable code Python re module comes with the flag re.X == re.VERBOSE (see comment by AKX below). Using this flag it is possible to explain the regular expression pattern from ‘inside’:

import re
regex = re.compile(r"""
# Below how the regex engine will work given the regex pattern
#                        r"(.[^+]*)+?"
  (  # remember begin of a capturing group
    .  # look for exactly one char of any kind (except new line)
      [  # remember this is the beginning of a list of characters
        ^+  # item in the list: NOT a plus sign '+' ('^' means here NOT)
      ]  # end of the list covering any character except a plus sign
           # look for any char except the plus sign 
        *    # any number of times (including zero)
               # until bumping into a '+' char 
                 # it is OK not to find a char
  ) # end of the capturing group 
  # if found a group pattern add it to the list of found matches
  + # continue with next charater and look for a plus sign '+' 
  ?    # skip it from consideration if it is there, but also if  
           # there was not any plus sign 
             # restart the search for a match with the capturing group
         # what means:  
       # look for exactly one char of any kind (except new line)
           # look for any char except the plus sign 
               # ... and so on ... 
""", re.X)
print( 
  re.findall(regex, '+++Super+Alt'),
  re.findall(regex, '++Super++Alt'),
  re.findall(regex, 'Super+Alt+++'),
  re.findall(regex, 'Super+++Alt' ),
  sep='n'
)

Looking at this above you can judge yourself if the regular expression pattern is better readable this way or if it gets ‘buried’ between the huge volume of the explanation text.