réponse un peu tardive :), mais j'avais un dilemme similaire et je ne voulais pas utiliser le module 're'.

def my_split(s, seps):
    res = [s]
    for sep in seps:
        s, res = res, []
        for seq in s:
            res += seq.split(sep)
    return res

print my_split('1111  2222 3333;4444,5555;6666', [' ', ';', ','])
['1111', '', '2222', '3333', '4444', '5555', '6666']

join = lambda x: sum(x,[])  # a.k.a. flatten1([[1],[2,3],[4]]) -> [1,2,3,4]
# ...alternatively...
join = lambda lists: [x for l in lists for x in l]

puis cela devient un triple-liner:

fragments = [text]
for token in tokens:
    fragments = join(f.split(token) for f in fragments)

---

explication

C'est ce qui dans Haskell est connu sous le nom de la liste monad. L'idée derrière la monade est qu'une fois "dans la monade" vous "rester dans la monade" jusqu'à ce que quelque chose vous prend. Par exemple dans Haskell, dites que vous mappez la fonction python range(n) -> [1,2,...,n] sur une liste. Si le résultat est une Liste, il sera ajouter à la Liste en place, pour avoir quelque chose comme map(range, [3,4,1]) -> [0,1,2,0,1,2,3,0] . Ceci est connu sous le nom de map-append (ou mappend, ou peut-être quelque chose comme ça). L'idée ici est que vous avez cette opération vous postulez (fractionnement sur un jeton), et à chaque fois que vous faites cela, vous rejoignez le résultat dans la liste.

vous pouvez l'abstraire dans une fonction et avoir tokens=string.punctuation par défaut.

avantages de cette approche:

• cette approche (contrairement à les approches basées sur regex naïves) peuvent fonctionner avec des tokens de longueur arbitraire (ce que regex peut aussi faire avec une syntaxe plus avancée).
• vous n'êtes pas limité à de simples tokens; vous pourriez avoir une logique arbitraire à la place de chaque token, par exemple un des "tokens" pourrait être une fonction qui se divise en fonction de la façon dont les parenthèses imbriquées sont.

tout d'abord, je veux être d'accord avec les autres pour dire que les solutions basées sur regex ou str.translate(...) sont les plus performantes. Pour mon cas d'utilisation la performance de cette fonction n'était pas significative, donc je voulais ajouter des idées que j'ai considérées avec ce critère.

mon but principal était de généraliser des idées à partir de certaines des autres réponses dans une solution qui pourrait fonctionner pour les chaînes contenant plus que de simples mots regex (i.e., la liste noire le sous-ensemble explicite de caractères de ponctuation vs une liste blanche des caractères de mot).

noter que, dans n'importe quelle approche, on pourrait également envisager d'utiliser string.punctuation au lieu d'une liste définie manuellement.

Option 1-re.sub

j'ai été surpris de voir pas de réponse jusqu'à présent utilise re.sous.(..) . Je trouve que c'est une approche simple et naturelle de ce problème.

import re

my_str = "Hey, you - what are you doing here!?"

words = re.split(r'\s+', re.sub(r'[,\-!?]', ' ', my_str).strip())

dans cette solution, j'ai imité l'appel à re.sub(...) inside re.split(...) - mais si la performance est critique, compiler le regex à l'extérieur pourrait être bénéfique - pour mon cas d'utilisation, la différence n'était pas significative, donc je préfère la simplicité et la lisibilité.

Option 2-str.remplacer

il s'agit de quelques lignes supplémentaires, mais il a l'avantage d'être extensible sans avoir à vérifier si vous devez échapper à un certain caractère dans regex.

my_str = "Hey, you - what are you doing here!?"

replacements = (',', '-', '!', '?')
for r in replacements:
    my_str = my_str.replace(r, ' ')

words = my_str.split()

il aurait ce fut agréable de pouvoir cartographier la str.remplacer à la chaîne de caractères à la place, mais je ne pense pas que cela puisse être fait avec des chaînes immuables, et alors que la mise en correspondance avec une liste de caractères fonctionnerait, exécuter chaque remplacement contre chaque caractère semble excessif. (Modifier: Voir l'option suivante pour un exemple fonctionnel.)

Option 3-functools.réduire les

(en Python 2, reduce est disponible dans l'Espace-nom global sans l'importer des functools.)

import functools

my_str = "Hey, you - what are you doing here!?"

replacements = (',', '-', '!', '?')
my_str = functools.reduce(lambda s, sep: s.replace(sep, ' '), replacements, my_str)
words = my_str.split()

essayez ceci:

import re

phrase = "Hey, you - what are you doing here!?"
matches = re.findall('\w+', phrase)
print matches

ce sera imprimé ['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

remplacer deux fois:

a = '11223FROM33344INTO33222FROM3344'
a.replace('FROM', ',,,').replace('INTO', ',,,').split(',,,')

résultats dans:

['11223', '33344', '33222', '3344']

j'aime re , Mais voici ma solution sans elle:

from itertools import groupby
sep = ' ,-!?'
s = "Hey, you - what are you doing here!?"
print [''.join(g) for k, g in groupby(s, sep.__contains__) if not k]

sep.__contient__ est une méthode utilisée par les 'dans' l'opérateur. Fondamentalement, il est le même que

lambda ch: ch in sep

mais est plus pratique ici.

groupby reçoit notre chaîne et fonction. Il divise la chaîne dans les groupes en utilisant cette fonction: chaque fois qu'une valeur de la fonction change - un nouveau groupe est généré. So, sep.__contient__ est exactement ce dont nous avons besoin.

groupe renvoie une séquence de paires paire[0] est le résultat de notre fonction et notre paire[1] est un groupe. En utilisant 'if not k ' nous filtrons les groupes avec des séparateurs (parce qu'un résultat de sep.__contient__ est Vrai que sur les séparateurs). Eh bien, c'est tout - maintenant, nous avons une séquence de groupes où chacun est un mot (groupe en fait un itérable donc nous utilisons join pour le convertir en chaîne de caractères).

cette solution est assez générale, car elle utilise une fonction pour séparer la chaîne (vous pouvez diviser par n'importe quelle condition dont vous avez besoin). En outre, il ne crée pas de chaînes/listes intermédiaires (vous pouvez supprimer rejoindre et l'expression deviendra paresseuse, puisque chaque groupe est un itérateur)

je me retrouve avec Python et j'avais besoin de la même chose. La solution de findall est peut-être meilleure, mais j'ai trouvé ceci:

tokens = [x.strip() for x in data.split(',')]

au lieu d'utiliser une fonction re module re.split vous pouvez obtenir le même résultat en utilisant la série.Str.méthode de fractionnement des pandas.

tout d'abord, créer une série avec la chaîne ci-dessus et ensuite appliquer la méthode à la série.

thestring = pd.Series("Hey, you - what are you doing here!?") thestring.str.split(pat = ',|-')

paramètre pat prend les délimiteurs et renvoie la chaîne de caractères fragmentée comme un tableau. Ici, les deux délimiteurs sont passés en utilisant un / (ou un opérateur). La sortie est comme suit:

[Hey, you , what are you doing here!?]

une autre façon d'y parvenir est d'utiliser la boîte à outils du langage naturel ( nltk ).

import nltk
data= "Hey, you - what are you doing here!?"
word_tokens = nltk.tokenize.regexp_tokenize(data, r'\w+')
print word_tokens

Cette affiche: ['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

le plus grand inconvénient de cette méthode est que vous devez installer le paquet nltk .

les avantages sont que vous pouvez faire beaucoup de choses amusantes avec le reste du paquet nltk une fois que vous obtenez vos jetons.

tout d'abord, je ne pense pas que votre intention soit d'utiliser réellement la ponctuation comme délimiteurs dans les fonctions de division. Votre description suggère que vous voulez simplement éliminer la ponctuation des chaînes résultantes.

je rencontre ceci assez fréquemment, et ma solution habituelle ne nécessite pas de Ré.

One-liner fonction lambda w/ compréhension de liste:

(nécessite import string ):

split_without_punc = lambda text : [word.strip(string.punctuation) for word in 
    text.split() if word.strip(string.punctuation) != '']

# Call function
split_without_punc("Hey, you -- what are you doing?!")
# returns ['Hey', 'you', 'what', 'are', 'you', 'doing']

fonction (traditionnelle)

en tant que fonction traditionnelle, ce n'est encore que deux lignes avec une compréhension de liste (en plus de import string ):

def split_without_punctuation2(text):

    # Split by whitespace
    words = text.split()

    # Strip punctuation from each word
    return [word.strip(ignore) for word in words if word.strip(ignore) != '']

split_without_punctuation2("Hey, you -- what are you doing?!")
# returns ['Hey', 'you', 'what', 'are', 'you', 'doing']

elle laissera naturellement intactes les contractions et les mots avec un trait d'Union. Vous pouvez toujours utiliser text.replace("-", " ") pour transformer les traits d'Union en espaces avant la séparation.

fonction générale sans Lambda ou List Compréhension

pour une solution plus générale (où vous pouvez spécifier les caractères à éliminer), et sans compréhension de liste, vous obtenez:

def split_without(text: str, ignore: str) -> list:

    # Split by whitespace
    split_string = text.split()

    # Strip any characters in the ignore string, and ignore empty strings
    words = []
    for word in split_string:
        word = word.strip(ignore)
        if word != '':
            words.append(word)

    return words

# Situation-specific call to general function
import string
final_text = split_without("Hey, you - what are you doing?!", string.punctuation)
# returns ['Hey', 'you', 'what', 'are', 'you', 'doing']

bien sûr, vous pouvez toujours généraliser la fonction lambda à n'importe quel chaîne de caractères.

tout d'abord, toujours utiliser re.compiler () avant d'effectuer toute opération RegEx dans une boucle parce qu'elle fonctionne plus rapidement que l'opération normale.

donc, pour votre problème, compilez d'abord le motif puis effectuez l'action sur celui-ci.

import re
DATA = "Hey, you - what are you doing here!?"
reg_tok = re.compile("[\w']+")
print reg_tok.findall(DATA)

, Voici la réponse avec quelques explications.

st = "Hey, you - what are you doing here!?"

# replace all the non alpha-numeric with space and then join.
new_string = ''.join([x.replace(x, ' ') if not x.isalnum() else x for x in st])
# output of new_string
'Hey  you  what are you doing here  '

# str.split() will remove all the empty string if separator is not provided
new_list = new_string.split()

# output of new_list
['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

# we can join it to get a complete string without any non alpha-numeric character
' '.join(new_list)
# output
'Hey you what are you doing'

ou en une ligne, nous pouvons faire comme ceci:

(''.join([x.replace(x, ' ') if not x.isalnum() else x for x in st])).split()

# output
['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

réponse mise à jour

crée une fonction qui prend en entrée deux chaînes (la chaîne source à diviser et la chaîne splitlist des délimiteurs) et affiche une liste de mots séparés:

def split_string(source, splitlist):
    output = []  # output list of cleaned words
    atsplit = True
    for char in source:
        if char in splitlist:
            atsplit = True
        else:
            if atsplit:
                output.append(char)  # append new word after split
                atsplit = False
            else: 
                output[-1] = output[-1] + char  # continue copying characters until next split
    return output

en utilisant maketrans et translate vous pouvez le faire facilement et proprement

import string
specials = ',.!?:;"()<>[]#$=-/'
trans = string.maketrans(specials, ' '*len(specials))
body = body.translate(trans)
words = body.strip().split()

a eu le même problème que @ooboo et trouver ce sujet @ghostdog74 m'a inspiré, peut-être que quelqu'un trouve ma solution utile

str1='adj:sg:nom:m1.m2.m3:pos'
splitat=':.'
''.join([ s if s not in splitat else ' ' for s in str1]).split()

entrez quelque chose dans l'espace place et séparez en utilisant le même caractère si vous ne voulez pas diviser aux espaces.

voici mon go à une scission avec des délimiteurs multiples:

def msplit( str, delims ):
  w = ''
  for z in str:
    if z not in delims:
        w += z
    else:
        if len(w) > 0 :
            yield w
        w = ''
  if len(w) > 0 :
    yield w

je pense que ce qui suit est la meilleure réponse à vos besoins suite :

\W+ peut-être approprié pour cette affaire, mais peut ne pas être approprié pour d'autres cas.

filter(None, re.compile('[ |,|\-|!|?]').split( "Hey, you - what are you doing here!?")

C'est mon avis....

def split_string(source,splitlist):
    splits = frozenset(splitlist)
    l = []
    s1 = ""
    for c in source:
        if c in splits:
            if s1:
                l.append(s1)
                s1 = ""
        else:
            print s1
            s1 = s1 + c
    if s1:
        l.append(s1)
    return l

>>>out = split_string("First Name,Last Name,Street Address,City,State,Zip Code",",")
>>>print out
>>>['First Name', 'Last Name', 'Street Address', 'City', 'State', 'Zip Code']

j'aime replace() façon la meilleure. La procédure suivante change tous les séparateurs définis dans une chaîne splitlist au premier séparateur dans splitlist et divise ensuite le texte sur ce séparateur. Il représente également si splitlist se trouve être une chaîne vide. Il retourne une liste de mots, sans chaînes vides.

def split_string(text, splitlist):
    for sep in splitlist:
        text = text.replace(sep, splitlist[0])
    return filter(None, text.split(splitlist[0])) if splitlist else [text]

def get_words(s):
    l = []
    w = ''
    for c in s.lower():
        if c in '-!?,. ':
            if w != '': 
                l.append(w)
            w = ''
        else:
            w = w + c
    if w != '': 
        l.append(w)
    return l

Voici l'usage:

>>> s = "Hey, you - what are you doing here!?"
>>> print get_words(s)
['hey', 'you', 'what', 'are', 'you', 'doing', 'here']

si vous voulez une opération réversible (préserver les délimiteurs), vous pouvez utiliser cette fonction:

def tokenizeSentence_Reversible(sentence):
    setOfDelimiters = ['.', ' ', ',', '*', ';', '!']
    listOfTokens = [sentence]

    for delimiter in setOfDelimiters:
        newListOfTokens = []
        for ind, token in enumerate(listOfTokens):
            ll = [([delimiter, w] if ind > 0 else [w]) for ind, w in enumerate(token.split(delimiter))]
            listOfTokens = [item for sublist in ll for item in sublist] # flattens.
            listOfTokens = filter(None, listOfTokens) # Removes empty tokens: ''
            newListOfTokens.extend(listOfTokens)

        listOfTokens = newListOfTokens

    return listOfTokens

en Python 3, vous pouvez utiliser la méthode de PY4E - Python pour tout le monde .

nous pouvons résoudre ces deux problèmes en utilisant les méthodes de chaîne lower , punctuation , et translate . Le translate est la plus subtile des méthodes. Voici la documentation pour translate :

your_string.translate(your_string.maketrans(fromstr, tostr, deletestr))

remplacer les caractères dans fromstr avec le caractère dans la même position dans tostr et supprimer tous les caractères qui sont dans deletestr . Les fromstr et tostr peuvent être des chaînes vides et le paramètre deletestr peut être omis.

vous pouvez voir la "ponctuation":

In [10]: import string

In [11]: string.punctuation
Out[11]: '!"#$%&\'()*+,-./:;<=>?@[\]^_`{|}~'  

pour votre exemple:

In [12]: your_str = "Hey, you - what are you doing here!?"

In [13]: line = your_str.translate(your_str.maketrans('', '', string.punctuation))

In [14]: line = line.lower()

In [15]: words = line.split()

In [16]: print(words)
['hey', 'you', 'what', 'are', 'you', 'doing', 'here']

pour plus d'informations, vous pouvez vous référer à:

• PY4E-Python pour tout le monde
• str.traduire
• str.maketrans
• méthode Python String maketrans ()

vous voulez la méthode findall() du module RegEx de Python:

http://www.regular-expressions.info/python.html

exemple