Python регулярное выражение соответствует всему, что заключено в кавычки, скобки или скобки

Question

ОБНОВЛЕНИЕ

До сих пор это не совсем решение. Это только для предыдущих повторяющихся закрывающих символов (например, )), ]], }}). Я все еще ищу способ захвата вложенного содержимого и обновлю это.

Код:

>>> import re
>>> re.search(r'(\(.+?[?<!)]\))', '((x(y)z))', re.DOTALL).groups()
('((x(y)z))',)

Детали:

r'(\(.+?[?<!)]\))'

• () - Захват специальных групповых символов.
• \( и \) - Открытые и закрывающие символы (например, ', ", (), {}, [] )
• .+? - соответствие любому символьному содержимому (используйте с флагом re.DOTALL)
• [?<!)] - отрицательный вид сзади для символа ) (замените это с соответствующим закрывающим символом). В основном это найдет любой символ ), где символ \) не предшествует (подробнее здесь ).

---

Я пытался что-то проанализировать как оператор присваивания переменной для этого лексера, с которым я работаю, просто пытаюсь получить основы c logi c за интерпретаторами / компиляторами.

Вот базовые c операторы присваивания и литералы I Я имею дело с:

az = none
az_ = true
az09 = false
az09_ = +0.9
az_09 = 'az09_'
_az09 = "az09_"
_az = [
  "az",
  0.9
]
_09 = {
  0: az
  1: 0.9
}
_ = (
  true
)

Каким-то образом мне удалось разобрать эти простые назначения, такие как none, true, false и цифры c литералов. Вот где я сейчас застрял:

import sys
import re

# validate command-line arguments
if (len(sys.argv) != 2): raise ValueError('usage: parse <script>')

# parse the variable name and its value
def handle_assignment(index, source):
    # TODO: handle quotations, brackets, braces, and parenthesis values
    variable = re.search(r'[\S\D]([\w]+)\s+?=\s+?(none|true|false|[-+]?\d+\.?\d+|[\'\"].*[\'\"])', source[index:])
    if variable is not None:
        print('{}={}'.format(variable.group(1), variable.group(2)))
        index += source[index:].index(variable.group(2))
    return index

# parse through the source element by element
with open(sys.argv[1]) as file:
    source = file.read()
    index = 0
    while index < len(source):
        # checks if the line matches a variable assignment statement
        if re.match(r'[\S\D][\w]+\s+?=', source[index:]):
            index = handle_assignment(index, source)
        index += 1

Я искал способ для захвата этих значений с помощью заключенных в кавычки, скобок, скобок и скобок.

Возможно, обновлю этот пост, если найду ответ.

Answer 1

Используйте регулярное выражение с несколькими альтернативами для каждой совпадающей пары.

re.match(r'\'.*?\'|".*?"|\(.*?\)|\[.*?\]|\{.*?\}', s)

Тем не менее, обратите внимание, что при наличии вложенных скобок это будет соответствовать первой конечной скобке, например, если введено значение

(words (and some more words))

результат будет

(words (and some more words)

Регулярные выражения не подходят для сопоставления вложенных структур, вам следует использовать более мощный метод синтаксического анализа.

Answer 2

Решение для рекурсивных символов @ Barmar с использованием стороннего модуля regex:

pip install regex

python3
>>> import regex
>>> recurParentheses = regex.compile(r'[(](?:[^()]|(?R))*[)]')
>>> recurParentheses.findall('(z(x(y)z)x) ((x)(y)(z))')
['(z(x(y)z)x)', '((x)(y)(z))']
>>> recurCurlyBraces = regex.compile(r'[{](?:[^{}]|(?R))*[}]')
>>> recurCurlyBraces.findall('{z{x{y}z}x} {{x}{y}{z}}')
['{z{x{y}z}x}', '{{x}{y}{z}}']
>>> recurSquareBrackets = regex.compile(r'[[](?:[^][]|(?R))*[]]')
>>> recurSquareBrackets.findall('[z[x[y]z]x] [[x][y][z]]')
['[z[x[y]z]x]', '[[x][y][z]]']

Для строковой литеральной рекурсии я предлагаю взглянуть на это .