Python fractionnement de la chaîne par des parenthèses

J'ai posé une question il y a peu (Python fractionnement inconnu chaîne par des espaces et les parenthèses) qui fonctionnait très bien jusqu'à ce que je devais changer ma façon de penser. Je n'ai toujours pas compris regex j'ai donc besoin d'un peu d'aide avec cela.

Si l'utilisateur tape ceci:

new test (test1 test2 test3) test "test5 test6"

J'aimerais qu'il ressemble à la sortie de la variable comme ceci:

["new", "test", "test1 test2 test3", "test", "test5 test6"]

En d'autres mots, s'il est un mot séparé par un espace, puis le diviser à partir du mot suivant, si c'est dans les parenthèses puis diviser le tout un groupe de mots dans les parenthèses et les supprimer. En va de même pour les guillemets.

Je suis actuellement en utilisant ce code qui ne répondent pas à la norme ci-dessus (à Partir des réponses dans le lien ci-dessus):

>>>import re
>>>strs = "Hello (Test1 test2) (Hello1 hello2) other_stuff"
>>>[", ".join(x.split()) for x in re.split(r'[()]',strs) if x.strip()]
>>>['Hello', 'Test1, test2', 'Hello1, hello2', 'other_stuff']

Cela fonctionne bien, mais il y a un problème, si vous avez ceci:

strs = "Hello Test (Test1 test2) (Hello1 hello2) other_stuff"

Il combine le Bonjour et Test d'un split au lieu de deux.

Il n'autorisons pas l'utilisation de parenthèses et les guillemets fractionnement en même temps.

regardez gourmande et non gourmande de correspondance.
Avez-vous un lien à me diriger vers un tutoriel? La plupart de tout ce que je trouve sont des questions qui ne sont pas vraiment m'aider et je ne peux pas lire le python docs à bien. Si c'est tout ce qui reste, il devra le faire.
Désolé, j'ai mal lu la question. Mais voici un lien vers le tutoriel officiel: docs.python.org/2/library/re.html

OriginalL'auteur TrevorPeyton | 2013-06-27

4

La réponse est tout simplement:
```
re.findall('\[[^\]]*\]|\([^\)]*\)|\"[^\"]*\"|\S+',strs)
```
OriginalL'auteur TrevorPeyton
1

Votre problème n'est pas bien défini.

Votre description de règles est

En d'autres mots, s'il est un mot séparé par un espace, puis le diviser
à partir du mot suivant, si c'est dans les parenthèses puis diviser l'ensemble du groupe
des mots dans les parenthèses et les supprimer. En va de même pour les virgules.

Je suppose qu'avec des virgules tu veux dire, entre guillemets == guillemets.

Puis, avec cette
```
strs = "Hello (Test1 test2) (Hello1 hello2) other_stuff"
```
vous devriez obtenir que
```
["Hello (Test1 test2) (Hello1 hello2) other_stuff"]
```
puisque tout est entouré par des guillemets. Très probablement, vous voulez travailler avec aucun soin de la plus grande des virgules inversées.

Je propose ceci, bien qu'un bot laid
```
import re, itertools
strs = raw_input("enter a string list ")

print [ y for y in list(itertools.chain(*[re.split(r'\"(.*)\"', x) 
        for x in re.split(r'\((.*)\)', strs)])) 
        if y <> '']
```
obtient
```
>>> 
enter a string list here there (x y ) thereagain "there there"
['here there ', 'x y ', ' thereagain ', 'there there']
```
Oui, désolé pour les virgules et les guillemets et le fait que ma formulation n'était pas très bon, c'était une longue nuit. Le code ci-dessus, serait excellent travail, sauf pour une chose, ce que j'ai tenté d'expliquer ici In other words if it is one word separated by a space then split it from the next word serait l'équivalent de votre here there dans votre code et devrait être divisé en deux mots différents 'here', 'there' au lieu de 'hear there'.

OriginalL'auteur octoback

C'est de faire ce que vous attendez

import re, itertools
strs = raw_input("enter a string list ")

res1 = [ y for y in list(itertools.chain(*[re.split(r'\"(.*)\"', x) 
        for x in re.split(r'\((.*)\)', strs)])) 
        if y <> '']

set1 = re.search(r'\"(.*)\"', strs).groups()
set2 = re.search(r'\((.*)\)', strs).groups()

print [k for k in res1 if k in list(set1) or k in list(set2) ] 
   + list(itertools.chain(*[k.split() for k in res1 if k 
   not in set1 and k not in set2 ]))

Presque, il a mis la liste de l'ordre, si j'ai mis new word test (test1 test2) word word "test1 test2 tet3" te st la sortie est ['test1 test2', 'test1 test2 tet3', 'new', 'word', 'test', 'word', 'word', 'te', 'st'] qui est à peu près droit, mais aussi le nouveau mot sortir de la place.
désolé, j'ai raté cet ordre était en effet important
Je pensais que ce serait une donnée, la prochaine fois, je vais préciser. Est-il une solution facile avec ce code?

OriginalL'auteur octoback

1

C'est ce qui pousse ce que les expressions régulières peuvent faire. Pensez à utiliser pyparsing à la place. Il n'descente récursive. Pour cette tâche, vous pouvez utiliser:
```
from pyparsing import *
import string, re

RawWord = Word(re.sub('[()" ]', '', string.printable))
Token = Forward()
Token << ( RawWord | 
           Group('"' + OneOrMore(RawWord) + '"') |
           Group('(' + OneOrMore(Token) + ')') )
Phrase = ZeroOrMore(Token)

Phrase.parseString(s, parseAll=True)
```
C'est robuste contre les étranges les espaces et les poignées de imbriquée parentheticals. C'est aussi un peu plus lisible qu'un grand regexp, et donc plus facile à tordre.

Je me rends compte que vous avez depuis longtemps résolu votre problème, mais c'est l'un des plus élevés de google classement des pages pour ce type de problèmes, et pyparsing est un des moins connus de la bibliothèque.

OriginalL'auteur dspeyer

Vous devez vous connecter pour publier un commentaire.