Python: Utilisation de la fonction find non dans l'ordre

Question

Ainsi, le code ci-dessous prend une chaîne d'informations entrées (expression mathématique) et utilise la fonction find pour trouver l'un des opérateurs dans "*/+ -" et sépare la chaîne en conséquence .

def splitting1(z): 
    for operators in "*/+-": 
     if operators in z: 
      position1= z.find(operators) 
      position2= z.rfind(operators) 
      text_before_operators= (z[:position1]).strip() 
      text_after_operators= (z[(position1+1):(position2)]).strip() 
      return text_before_operators,text_after_operators 

Mon problème est que si j'ai une expression entrée tels que 3/5*7 puis position1 va d'abord trouver * avant de trouver /. Je veux que le code associe 'position1' à l'opérateur le plus à gauche. Existe-t-il un moyen d'omettre la priorité des opérateurs lors de l'utilisation des fonctions for/in? Sinon, existe-t-il un meilleur manipulateur de chaîne qui peut omettre l'ordre de priorité.

Remarque z est l'entrée. Et l'entrée est limitée à deux opérateurs au cas où cela créerait une ambiguïté.

Answer 1

Vous effectuez l'itération sur */+-, le premier caractère trouvé est donc le premier qui a été renvoyé.

Vous voulez fondamentalement trouver les index de tous ces opérateurs et ensuite trouver le plus grand ou le plus petit. Essayez récrire cette fonction travailler pour l'autre côté de la chaîne:

def find_operator_right(text): 
    position = -1 

    for oper in '*/+-': 
     index = text.rfind(oper) 

     if index > position: 
      position = index 

    return position 

Une solution un peu plus Pythonic serait quelque chose comme ceci:

right_index = max(map(text.rfind, '+-/*')) 

Answer 2

Il semble que vous essayez de lex, de sorte Je vous suggère de regarder dans des modules conçus spécialement à cet effet, par exemple ply.

.

Dire que, je pense que vous êtes sur la bonne voie pour cet exemple, mais il vous manque un peu récursion (pour faire un lexer plus général pour ces):

def splitting1(z): 
    for char in "*/+-": 
     if char in z: 
      position = z.find(char) 
      text_before_operator= (z[:position]).strip() 
      text_after_operator= (z[position+1:]).strip() 
      return (char, splitting1(text_before_operator), splitting1(text_after_operator)) 
    return ("number", z) 

Une façon de trouver la le plus à gauche opérateur quelle que soit la priorité à savoir Omettre la priorité des opérateurs, est de réorganiser ce que vous itérer sur:

def splitting2(z): 
    for char in z: 
     if char in "*/+-": 
      position = z.find(char) 
      text_before_operator= (z[:position]).strip() 
      text_after_operator= (z[position+1:]).strip() 
      return (char, splitting2(text_before_operator), splitting2(text_after_operator)) 
    return ("number", z) 

Notez ces fonctions renvoient un résultat différent à votre fonction d'origine.