私がやりたいことはかなり一般的な仕事だと思いますが、Webでの参照は見つかりませんでした。句読点のあるテキストがあり、単語のリストが必要です。

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

する必要があります

['hey', 'you', 'what', 'are', 'you', 'doing', 'here']

しかし、Python str.split()は1つの引数でのみ機能するため、空白で分割した後、すべての単語に句読点が付きます。何か案は？

正規表現が正当化されるケース：

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

re.split（）

re.split（パターン、文字列[、maxsplit = 0]）

パターンの出現によって文字列を分割します。キャプチャ括弧がパターンで使用されている場合、パターン内のすべてのグループのテキストも結果のリストの一部として返されます。maxsplitがゼロ以外の場合、最大でmaxsplit分割が行われ、残りの文字列がリストの最後の要素として返されます。（非互換性に関する注意：元のPython 1.5リリースでは、maxsplitは無視されました。これは後のリリースで修正されました。）

>>> re.split('\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split('(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split('\W+', 'Words, words, words.', 1)
['Words', 'words, words.']

正規表現なしでこれを行う別の簡単な方法は、以下のように、最初に文字を置き換えることです。

>>> 'a;bcd,ef g'.replace(';',' ').replace(',',' ').split()
['a', 'bcd', 'ef', 'g']

非常に多くの回答がありますが、質問のタイトルが文字通り要求するものを効率的に実行する解決策は見つかりません（複数の可能な区切り文字で分割します。代わりに、多くの回答は、単語ではないもので分割されます。違います）。タイトルの質問に対する答えは次のとおりです。これは、Pythonの標準で効率的なreモジュールに依存しています。

>>> import re  # Will be splitting on: , <space> - ! ? :
>>> filter(None, re.split("[, \-!?:]+", "Hey, you - what are you doing here!?"))
['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

どこ：

• […]試合の1内部の列挙されたセパレータの、
• \-正規表現の中の特殊な解釈を防ぐために、ここで-のように、文字範囲インジケータ（としてA-Z）、
• +スキップ1 以上の区切り文字は、（それはへの感謝を省略することができますfilter()が、これは不必要にマッチしたセパレータの間に空の文字列を生成する）、および
• filter(None, …) 先頭と末尾のセパレータによって作成された可能性のある空の文字列を削除します（空の文字列には偽のブール値があるため）。

これre.split()は、質問のタイトルで要求されているとおり、正確に「複数のセパレータで分割」されます。

さらに、このソリューションは、他のいくつかのソリューションで見つかった単語の非ASCII文字の問題の影響を受けません（ghostdog74の回答の最初のコメントを参照）。

このreモジュールは、Pythonループを実行して「手動」でテストするよりも（速度と簡潔さにおいて）はるかに効率的です！

別の方法、正規表現なし

import string
punc = string.punctuation
thestring = "Hey, you - what are you doing here!?"
s = list(thestring)
''.join([o for o in s if not o in punc]).split()

プロのヒント：使用 string.translate Pythonが持つ最速の文字列操作にします。

いくつかの証拠...

まず、遅い方法（申し訳ありませんがpprzemek）：

>>> import timeit
>>> S = 'Hey, you - what are you doing here!?'
>>> def my_split(s, seps):
...     res = [s]
...     for sep in seps:
...         s, res = res, []
...         for seq in s:
...             res += seq.split(sep)
...     return res
... 
>>> timeit.Timer('my_split(S, punctuation)', 'from __main__ import S,my_split; from string import punctuation').timeit()
54.65477919578552

次に、使用しますre.findall()（推奨される回答で示されているとおり）。はるかに高速：

>>> timeit.Timer('findall(r"\w+", S)', 'from __main__ import S; from re import findall').timeit()
4.194725036621094

最後に、使用しますtranslate：

>>> from string import translate,maketrans,punctuation 
>>> T = maketrans(punctuation, ' '*len(punctuation))
>>> timeit.Timer('translate(S, T).split()', 'from __main__ import S,T,translate').timeit()
1.2835021018981934

説明：

string.translateCで実装され、Pythonの多くの文字列操作関数とは異なり、新しい文字列を生成string.translate しません。そのため、文字列の置換が可能な限り高速です。

ただし、この魔法を行うには変換テーブルが必要なので、少し厄介です。maketrans()便利な機能で変換テーブルを作ることができます。ここでの目的は、すべての不要な文字をスペースに変換することです。1対1の代替。この場合も、新しいデータは生成されません。これは速いです！

次に、古き良きを使用しますsplit()。split()デフォルトでは、すべての空白文字を操作して、分割のためにグループ化します。結果は、必要な単語のリストになります。そして、このアプローチはre.findall()！

同様のジレンマがあり、「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']

最初に、正規表現またはstr.translate(...)ベースのソリューションが最もパフォーマンスが高いことを他の人に同意したいと思います。私のユースケースでは、この関数のパフォーマンスはそれほど重要ではなかったので、その基準で検討したアイデアを追加したいと思いました。

私の主な目的は、他のいくつかの回答からのアイデアを、正規表現以外の単語を含む文字列で機能する1つのソリューションに一般化することでした（つまり、句読文字の明示的なサブセットのブラックリストと単語文字のホワイトリスト）。

どのアプローチでもstring.punctuation、手動で定義したリストの代わりに使用することを検討する場合があることに注意してください。

オプション1-re.sub

今のところre.sub（...）を使用しているので、答えが見つからないことに驚きました。私はそれがこの問題へのシンプルで自然なアプローチだと思います。

import re

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

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

このソリューションでは、re.sub(...)内部への呼び出しを入れ子にしましたre.split(...)—パフォーマンスが重要な場合、外部で正規表現をコンパイルすることは有益かもしれません—私の使用例では、違いは重要ではなかったので、単純さと読みやすさを優先します。

オプション2-str.replace

これはさらに数行ですが、正規表現で特定の文字をエスケープする必要があるかどうかを確認する必要なく拡張できるという利点があります。

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

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

words = my_str.split()

代わりにstr.replaceを文字列にマップできれば良かったのですが、不変の文字列では実行できないと思います。文字のリストに対するマッピングは機能しますが、すべての文字に対してすべての置換を実行します過度に聞こえます。（編集：機能例については、次のオプションを参照してください。）

オプション3-functools.reduce

（Python 2では、reducefunctoolsからインポートせずにグローバル名前空間で使用できます。）

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()

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]

次に、これは3行になります。

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

説明

これはHaskellではListモナドとして知られているものです。モナドの背後にある考え方は、いったん「モナドに」入ると、何かがあなたを連れ出すまで「モナドにとどまる」というものです。たとえば、Haskellで、Python range(n) -> [1,2,...,n]関数をリストにマッピングするとします。結果がリストの場合は、その場でリストに追加されるので、のようなものが得られますmap(range, [3,4,1]) -> [0,1,2,0,1,2,3,0]。これはmap-append（またはmappend、あるいはそのようなもの）として知られています。ここでの考え方は、適用している（トークンで分割する）この操作があり、それを実行するたびに、結果をリストに結合するということです。

これを関数に抽象化してtokens=string.punctuation、デフォルトで持つことができます。

このアプローチの利点：

• このアプローチは（単純な正規表現ベースのアプローチとは異なり）任意の長さのトークンで機能します（正規表現はより高度な構文でも実行できます）。
• あなたは単なるトークンに制限されていません。各トークンの代わりに任意のロジックを使用できます。たとえば、「トークン」の1つは、ネストされた括弧がどのようにあるかに応じて分割する関数である可能性があります。

これを試して：

import re

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

これは印刷されます ['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

replaceを2回使用します。

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

結果は：

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

私はreが好きですが、ここにそれなしの私の解決策があります：

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 .__ contains__は、「in」演算子で使用されるメソッドです。基本的には同じです

lambda ch: ch in sep

ここではより便利です。

groupbyは文字列と関数を取得します。関数を使用して文字列をグループに分割します。関数の値が変更されるたびに、新しいグループが生成されます。したがって、sep .__ contains__はまさに必要なものです。

groupbyはペアのシーケンスを返します。ここで、pair [0]は関数の結果で、pair [1]はグループです。使用して、K「でない場合は、」私たちはセパレータでグループをフィルタリング（の結果ので、9月.__ contains__は、セパレータに真です）。さて、これですべてです。これで、それぞれが単語である一連のグループができました（グループは実際には反復可能であるため、結合を使用して文字列に変換します）。

関数を使用して文字列を分離するため、このソリューションは非常に一般的です（必要な任意の条件で分割できます）。また、中間の文字列やリストは作成されません（結合を削除すると、各グループがイテレータであるため、式が遅延になります）。

reモジュール関数re.splitを使用する代わりに、pandasのseries.str.splitメソッドを使用して同じ結果を得ることができます。

最初に、上記の文字列でシリーズを作成してから、メソッドをシリーズに適用します。

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

パラメータpatは区切り文字を受け取り、分割された文字列を配列として返します。ここでは、2つの区切り文字が|を使用して渡されます。（または演算子）。出力は次のとおりです。

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

私はPythonに慣れ親しんでおり、同じことを必要としていました。findallソリューションの方が良いかもしれませんが、私はこれを思いつきました：

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

maketransとtranslateを使用すると、簡単かつきちんとそれを行うことができます

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

Python 3では、PY4E-Python for Everybodyのメソッドを使用できます。

私たちは、文字列のメソッドを使用することにより、これらの問題の両方を解決することができlower、punctuationとtranslate。translateメソッドの中で最も微妙です。ここにドキュメントがありますtranslate：

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

fromstrの文字をの同じ位置の文字に置き換え、にあるtostrすべての文字を削除しdeletestrます。空の文字列にすることができ、パラメータは省略することができます。fromstrtostrdeletestr

あなたは「句読点」を見ることができます：

In [10]: import string

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

あなたの例のために：

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']

詳細については、次を参照してください。

• PY4E-みんなのためのPython
• str.translate
• str.maketrans
• Python String maketrans（）メソッド

これを実現する別の方法は、Natural Language Tool Kit（nltk）を使用することです。

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

これは印刷します： ['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

この方法の最大の欠点は、nltkパッケージをインストールする必要があることです。

利点は、トークンを取得すると、nltkパッケージの残りの部分で多くの楽しいことができることです。

まず、実際に句読点を分割関数の区切り文字として使用する意図はないと私は思います。説明では、結果の文字列から句読点を単に削除したいことを示しています。

私はかなり頻繁にこれに遭遇し、私の通常の解決策はreを必要としません。

リスト内包表記付きのワンライナーラムダ関数：

（が必要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']

機能（伝統的）

従来の関数として、これは（2に加えてimport string）リスト内包表記を含む2行のみです。

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']

また、縮約やハイフネーションされた単語はそのまま残します。text.replace("-", " ")分割の前にハイフンをスペースに変換するためにいつでも使用できます。

ラムダまたはリスト内包なしの一般関数

より一般的な解決策（削除する文字を指定できる場合）で、リストを理解していなければ、次のようになります。

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']

もちろん、常にラムダ関数を指定した文字列に一般化することもできます。

まず、ループでRegEx操作を実行する前に、必ずre.compile（）を使用してください。これは、通常の操作よりも高速に動作するためです。

したがって、問題については、まずパターンをコンパイルしてから、それに対してアクションを実行します。

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

ここにいくつかの説明付きの答えがあります。

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'

または1行で、次のようにできます。

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

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

更新された回答

2つの文字列（分割されるソース文字列と区切り文字のsplitlist文字列）を入力として受け取り、分割された単語のリストを出力する関数を作成します。

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

私はpprzemekのソリューションが好きです。区切り文字が単一の文字であるとは想定しておらず、正規表現を利用しようとしないためです（区切り文字の数が非常に長くなるとうまく機能しません）。

わかりやすくするために、上記のソリューションのより読みやすいバージョンを次に示します。

def split_string_on_multiple_separators(input_string, separators):
    buffer = [input_string]
    for sep in separators:
        strings = buffer
        buffer = []  # reset the buffer
        for s in strings:
            buffer = buffer + s.split(sep)

    return buffer

@oobooと同じ問題を抱えており、このトピックを見つけました@ ghostdog74が私にインスピレーションを与えました、多分誰かが私の解決策を見つけました

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

スペースで何かを入力し、スペースで分割したくない場合は、同じ文字を使用して分割します。

これが、複数のデリミタを使用した分割の私の歩みです。

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

以下はあなたのニーズに合う最良の答えだと思います：

\W+ このケースには適しているかもしれませんが、他のケースには適していません。

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

僕の見解はこちら…

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']

私はreplace()方法が一番好きです。次の手順では、文字列で定義されたすべてのセパレータをsplitlist最初のセパレータに変更しsplitlist、その1つのセパレータでテキストを分割します。また、splitlistたまたま空の文字列の場合も考慮されます。空の文字列を含まない単語のリストを返します。

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

使い方は次のとおりです。

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

可逆操作が必要な場合（区切り文字を保持）、この関数を使用できます。

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

私は最近これを行う必要がありましたが、標準ライブラリ関数と多少一致する関数が必要でしたstr.split。この関数は、0または1の引数で呼び出されたときに標準ライブラリと同じように動作します。

def split_many(string, *separators):
    if len(separators) == 0:
        return string.split()
    if len(separators) > 1:
        table = {
            ord(separator): ord(separator[0])
            for separator in separators
        }
        string = string.translate(table)
    return string.split(separators[0])

注：この関数は、セパレータが単一の文字で構成されている場合にのみ役立ちます（私のユースケースと同様）。