सिंगल, डबल, या ट्रिपल कोट्स के साथ लेक्स स्ट्रिंग्स

Question

मेरा उद्देश्य पाइथन स्ट्रिंग के साथ पार्स करना है।

प्रश्न: निम्नलिखित का समर्थन करने के एक लेक्स लिखने के लिए कैसे:

1. "string..."
2. 'string...'
3. """multi line string \n \n end"""
4. '''multi line string \n \n end'''

कुछ ग स्तोत्र:

 
states = (
     ('string', 'exclusive'), 
     ) 

# Strings 
def t_begin_string(self, t): 
    r'(\'|(\'{3})|\"|(\"{3}))' 
    t.lexer.push_state('string') 

def t_string_end(self, t): 
    r'(\'|(\'{3})|\"|(\"{3}))' 
    t.lexer.pop_state() 

def t_string_newline(self, t): 
    r'\n' 
    t.lexer.lineno += 1 

def t_string_error(self, t): 
    print("Illegal character in string '%s'" % t.value[0]) 
    t.lexer.skip(1) 

---

मेरे वर्तमान विचार 4 अद्वितीय राज्यों कि 4 अलग स्ट्रिंग मामलों से मिलान करेगा बनाने के लिए है, लेकिन वहाँ एक बेहतर तरीका है, तो मैं सोच रहा हूँ।

आपकी मदद के लिए धन्यवाद!

Answer 1

pyparsing module का उपयोग करने का प्रयास करें। इस मॉड्यूल के साथ आप नियमित अभिव्यक्तियों का उपयोग किये बिना अच्छी शैली के साथ तारों को आसानी से पार्स कर सकते हैं।

निम्नलिखित उदाहरण आपको "string..." और """string""" जैसे अभिव्यक्तियों को पार्स करने में मदद कर सकता है।

from pyparsing import Word, OneOrMore, alphas 

string = """string""" 
w = OneOrMore('\"') + Word(alphas + '.') + OneOrMore('\"') 
w.parseString(string) 

Answer 2

आम स्ट्रिंग को अलग एक राज्य बनाने के लिए और फिर भी यू py लेक्स याक पर देख सकते हैं अगर यू एक बाहरी पुस्तकालय है कि उर काम आसान बना देता है का उपयोग कर के बारे में चिंतित नहीं हैं कम राज्यों के साथ एक automaton का निर्माण करने की कोशिश करने के लिए

हालांकि यू लेक्स याक की मूल बातें की जरूरत है /// दिखाया

tokens = (
    'NAME','NUMBER', 
    'PLUS','MINUS','TIMES','DIVIDE','EQUALS', 
    'LPAREN','RPAREN', 
    ) 
    enter code here 

# Tokens 

t_PLUS = r'\+' 
t_MINUS = r'-' 
t_TIMES = r'\*' 
t_DIVIDE = r'/' 
t_EQUALS = r'=' 
t_LPAREN = r'\(' 
t_RPAREN = r'\)' 
t_NAME = r'[a-zA-Z_][a-zA-Z0-9_]*' 

def t_NUMBER(t): 
    r'\d+' 
    try: 
     t.value = int(t.value) 
    except ValueError: 
     print("Integer value too large %d", t.value) 
     t.value = 0 
    return t 

# Ignored characters 
t_ignore = " \t" 

def t_newline(t): 
    r'\n+' 
    t.lexer.lineno += t.value.count("\n") 

def t_error(t): 
    print("Illegal character '%s'" % t.value[0]) 
    t.lexer.skip(1) 

# Build the lexer 
import ply.lex as lex 
lex.lex() 

# Parsing rules 

precedence = (
    ('left','PLUS','MINUS'), 
    ('left','TIMES','DIVIDE'), 
    ('right','UMINUS'), 
    ) 

# dictionary of names 
names = { } 

def p_statement_assign(t): 
    'statement : NAME EQUALS expression' 
    names[t[1]] = t[3] 

def p_statement_expr(t): 
    'statement : expression' 
    print(t[1]) 

def p_expression_binop(t): 
    '''expression : expression PLUS expression 
        | expression MINUS expression 
        | expression TIMES expression 
        | expression DIVIDE expression''' 
    if t[2] == '+' : t[0] = t[1] + t[3] 
    elif t[2] == '-': t[0] = t[1] - t[3] 
    elif t[2] == '*': t[0] = t[1] * t[3] 
    elif t[2] == '/': t[0] = t[1]/t[3] 

def p_expression_uminus(t): 
    'expression : MINUS expression %prec UMINUS' 
    t[0] = -t[2] 

def p_expression_group(t): 
    'expression : LPAREN expression RPAREN' 
    t[0] = t[2] 

def p_expression_number(t): 
    'expression : NUMBER' 
    t[0] = t[1] 

def p_expression_name(t): 
    'expression : NAME' 
    try: 
     t[0] = names[t[1]] 
    except LookupError: 
     print("Undefined name '%s'" % t[1]) 
     t[0] = 0 

def p_error(t): 
    print("Syntax error at '%s'" % t.value) 

import ply.yacc as yacc 
yacc.yacc() 

while 1: 
    try: 
     s = input('calc > ') # Use raw_input on Python 2 
    except EOFError: 
     break 
    yacc.parse(s)