Is there a way to recursively parse the string to get the dict?
string:
string = 'a {\
b: text;\
c {\
d: text;\
}\
}';
out:
{
'a' : {
'b': 'text',
'c': {
'd' : 'text';
}
}
}
upd: I'm new in Python, and I don't have a ready solution in the form of a library and etc, I want to understand the logic (any code if it possible or theory) of the algorithm for this problem
You should have a look at the pyparsing module.
The pyparsing module is an alternative approach to creating and executing simple grammars, vs. the traditional lex/yacc approach, or the use of regular expressions. The pyparsing module provides a library of classes that client code uses to construct the grammar directly in Python code.
For a case like this, you would write the grammar that describes the string you are trying to parse, and avoid writing the parser.
Update (per comment): If one was interested in learning about the theoretical basis behind parsing strings such as these, then you need to understand what your goal is. This problem, in a more general form, is parsing a context-free language. You have a set of rules, known as a grammar that dictates the hierarchy of the data structure from the input. A good place to start reading (from an educational perspective) is the Backus–Naur Form.
theoretical basis for how to do it myself. I need more practice :)Writing a recursive descent parser for this shouldn't be too difficult. There are tutorials out there that describe how to do it.
Using lepl parser library:
#!/usr/bin/env python
from lepl import AnyBut, Delayed, Drop, DroppedSpace
def Parser():
dict_ = Delayed()
str_ = AnyBut('{}:;')[1::'n',...]
with DroppedSpace():
pair = str_ & Drop(':') & str_ & Drop(';') > tuple
value = str_ & dict_ > tuple
dict_ += Drop('{') & (pair | value)[:] & Drop('}') > dict
return value > dict
print(Parser().parse("a { b: text; c { d: text; }}")[0])
{'a': {'c': {'d': 'text'}, 'b': 'text'}}
See also Python parsing tools.
To understand the theory behind the code you could read a book that talks about lexical analysis (regular expressions and finite automata), syntax analysis (EBNF, context-free grammars, LL parsers).
dict. And I want to understand the algorithm