Myślę, że to, co chcę zrobić, jest dość powszechnym zadaniem, ale nie znalazłem żadnych odnośników w Internecie. Mam tekst ze znakami interpunkcyjnymi i chcę listę słów.

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

Powinien być

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

Ale Python str.split()działa tylko z jednym argumentem, więc mam wszystkie słowa z interpunkcją po podzieleniu spacją. Jakieś pomysły?

Przypadek, w którym wyrażenia regularne są uzasadnione:

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 (wzór, ciąg [, maxsplit = 0])

Podziel ciąg według wystąpień wzoru. Jeśli we wzorcu używane są nawiasy przechwytujące, tekst wszystkich grup we wzorcu jest również zwracany jako część wynikowej listy. Jeśli parametr maxsplit jest niezerowy, występują najwyżej podziały maxsplit, a pozostała część łańcucha jest zwracana jako ostatni element listy. (Uwaga dotycząca niezgodności: w oryginalnej wersji Python 1.5 maxsplit został zignorowany. Zostało to naprawione w późniejszych wersjach.)

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

Innym szybkim sposobem na zrobienie tego bez wyrażenia regularnego jest zastąpienie znaków, jak poniżej:

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

Tak wielu odpowiedzi, ale nie mogę znaleźć żadnego rozwiązania, które by efektywnie spełniało oczekiwania dosłownie tytułu pytań (podział na wiele możliwych separatorów - zamiast tego wiele odpowiedzi dzieli się na wszystko, co nie jest słowem, co jest inne). Oto odpowiedź na pytanie zawarte w tytule, które opiera się na standardowym i wydajnym remodule Pythona :

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

gdzie:

• z […]wyników jednym z podanych w separatorach,
• \-w wyrażeniu regularnym jest tutaj, aby zapobiec szczególną interpretację -jako wskaźnik zakresu znaków (jak w A-Z)
• +pomija jeden lub więcej ograniczników (może to być pominięte dzięki filter(), ale to niepotrzebnie produkować puste struny między dopasowanych separatorów), oraz
• filter(None, …) usuwa puste ciągi, które mogą zostać utworzone przez separatory wiodące i końcowe (ponieważ puste ciągi mają fałszywą wartość boolowską).

To re.split()właśnie „dzieli z wieloma separatorami”, co postulowano w tytule pytanie.

To rozwiązanie jest ponadto odporne na problemy ze znakami spoza ASCII w słowach znalezionych w niektórych innych rozwiązaniach (patrz pierwszy komentarz do odpowiedzi ghostdog74 ).

reModuł jest znacznie bardziej efektywny (w szybkości i zwięzłości) niż robić pętle Python i testy „ręcznie”!

Innym sposobem, bez wyrażenia regularnego

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

Porada: Użyj string.translatedo najszybszych operacji na łańcuchach, które ma Python.

Jakiś dowód ...

Po pierwsze, droga wolna (przepraszam 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

Następnie używamy re.findall()(zgodnie z sugerowaną odpowiedzią). O wiele szybciej:

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

Wreszcie używamy 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

Wyjaśnienie:

string.translatejest zaimplementowany w C i w przeciwieństwie do wielu funkcji manipulacji ciągiem w Pythonie, string.translate nie robi tego tworzy nowego ciągu. Jest więc tak szybko, jak to możliwe, aby zastąpić ciąg znaków.

Jest to jednak trochę niezręczne, ponieważ do wykonania tej magii potrzebuje tabeli tłumaczeń. Możesz utworzyć tabelę tłumaczeń z maketrans()funkcją wygody. Celem jest przetłumaczenie wszystkich niechcianych postaci na spacje. Zastępca jeden do jednego. Ponownie nie są generowane żadne nowe dane. To jest szybkie !

Następnie używamy starego dobrego split(). split()domyślnie będzie działać na wszystkich znakach spacji, grupując je razem dla podziału. Rezultatem będzie lista słów, które chcesz. To podejście jest prawie 4x szybsze niż re.findall()!

Miałem podobny dylemat i nie chciałem używać modułu „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']

Po pierwsze, chcę zgodzić się z innymi, że regex lub str.translate(...)oparte na nim rozwiązania są najbardziej wydajne. W moim przypadku użycie tej funkcji nie było znaczące, dlatego chciałem dodać pomysły, które wziąłem pod uwagę przy tych kryteriach.

Moim głównym celem było uogólnienie pomysłów z niektórych innych odpowiedzi w jedno rozwiązanie, które może pracować dla ciągów zawierających więcej niż tylko słowa wyrażenia regularnego (tj. Umieszczenie na czarnej liście wyraźnego podzbioru znaków interpunkcyjnych w porównaniu do znaków słów z białej listy).

Zauważ, że w każdym podejściu można również rozważyć użycie string.punctuationzamiast ręcznie zdefiniowanej listy.

Opcja 1 - re

Byłem zaskoczony, że do tej pory nie otrzymałem odpowiedzi, używa re.sub (...) . Uważam to za proste i naturalne podejście do tego problemu.

import re

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

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

W tym rozwiązaniu zagnieździłem wezwanie do re.sub(...)wewnątrz re.split(...)- ale jeśli wydajność jest krytyczna, kompilacja wyrażenia regularnego na zewnątrz może być korzystna - w moim przypadku różnica nie była znacząca, więc wolę prostotę i czytelność.

Opcja 2 - wymiana str

Jest to jeszcze kilka wierszy, ale ma tę zaletę, że można ją rozbudowywać bez konieczności sprawdzania, czy trzeba uciec pewnej postaci w wyrażeniu regularnym.

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

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

words = my_str.split()

Byłoby miło móc zamiast tego zamapować str .replace na ciąg, ale nie sądzę, że można tego dokonać za pomocą niezmiennych ciągów, a podczas mapowania na listę znaków zadziałałoby, uruchamiając każdą zamianę na każdym znaku brzmi nadmiernie. (Edycja: zobacz następną opcję dla funkcjonalnego przykładu.)

Opcja 3 - funkools.reduce

(W Python 2 reducejest dostępny w globalnej przestrzeni nazw bez importowania go z funools.)

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]

To staje się trójliniowe:

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

Wyjaśnienie

To właśnie w Haskell nazywa się monadą List. Idea stojąca za monadą polega na tym, że raz „w monadzie” zostajesz w monadzie, dopóki coś cię nie wyciągnie. Na przykład w Haskell powiedzmy, że mapujesz range(n) -> [1,2,...,n]funkcję python na Listę. Jeśli wynikiem jest lista, zostanie ona dołączona do listy w miejscu, aby uzyskać coś takiego map(range, [3,4,1]) -> [0,1,2,0,1,2,3,0]. Jest to znane jako map-append (lub mappend, a może coś takiego). Chodzi o to, że masz tę operację, którą stosujesz (dzielenie na token), i za każdym razem, gdy to robisz, dołączasz wynik do listy.

Możesz to wydzielić w funkcję i mieć tokens=string.punctuationdomyślnie.

Zalety tego podejścia:

• To podejście (w odróżnieniu od naiwnych metod opartych na wyrażeniach regularnych) może działać z tokenami o dowolnej długości (które to wyrażenie może również wykonywać przy bardziej zaawansowanej składni).
• Nie jesteś ograniczony do zwykłych tokenów; możesz mieć dowolną logikę zamiast każdego tokena, na przykład jeden z „tokenów” może być funkcją, która dzieli się w zależności od zagnieżdżonych nawiasów.

Spróbuj tego:

import re

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

to zostanie wydrukowane ['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

Użyj zamień dwa razy:

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

prowadzi do:

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

Lubię ponownie , ale oto moje rozwiązanie bez niego:

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 .__ zawiera__ jest metodą stosowaną przez operatora „in”. Zasadniczo jest to to samo co

lambda ch: ch in sep

ale jest tutaj wygodniejszy.

groupby pobiera nasz ciąg i funkcję. Dzieli ciąg na grupy za pomocą tej funkcji: ilekroć zmienia się wartość funkcji - generowana jest nowa grupa. Więc sep .__ zawiera__ jest dokładnie tym, czego potrzebujemy.

groupby zwraca ciąg par, gdzie para [0] jest wynikiem naszej funkcji, a para [1] jest grupą. Używając „jeśli nie k” odfiltrowujemy grupy z separatorami (ponieważ wynik sep .__ zawiera__ jest prawdziwy dla separatorów). Cóż, to wszystko - teraz mamy sekwencję grup, w których każda jest słowem (grupa jest w rzeczywistości iterowalna, więc używamy sprzężenia, aby przekonwertować ją na ciąg znaków).

To rozwiązanie jest dość ogólne, ponieważ wykorzystuje funkcję do oddzielania łańcucha znaków (możesz podzielić według dowolnych warunków). Ponadto nie tworzy pośrednich ciągów / list (możesz usunąć złączenie, a wyrażenie stanie się leniwe, ponieważ każda grupa jest iteratorem)

Zamiast korzystać z funkcji ponownego modułu re.split, możesz osiągnąć ten sam wynik, stosując metodę pand serii.str.split.

Najpierw utwórz serię z powyższym ciągiem, a następnie zastosuj metodę do serii.

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

parametr pat pobiera ograniczniki i zwraca podzielony ciąg jako tablicę. Tutaj dwa separatory są przekazywane za pomocą | (lub operator). Dane wyjściowe są następujące:

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

Ponownie zapoznałem się z Pythonem i potrzebowałem tego samego. Rozwiązanie Findall może być lepsze, ale wpadłem na to:

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

używając maketrans i tłumacz, możesz to zrobić łatwo i porządnie

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

W Python 3 możesz użyć metody z PY4E - Python for Everybody .

Możemy rozwiązać oba te problemy za pomocą metody string lower, punctuationi translate. Jest translateto najbardziej subtelna z metod. Oto dokumentacja dla translate:

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

Zamień znaki fromstrna znak na tej samej pozycji tostri usuń wszystkie znaki, które są na deletestr. fromstrI tostrmoże być puste struny i deletestrparametr może zostać pominięty.

Możesz zobaczyć „interpunkcję”:

In [10]: import string

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

Na przykład:

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

Aby uzyskać więcej informacji, możesz odwołać się:

• PY4E - Python dla każdego
• str.translate
• str.maketrans
• Metoda maketrans () w języku Python String

Innym sposobem na osiągnięcie tego jest użycie zestawu 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

To drukuje: ['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

Największą wadą tej metody jest to, że musisz zainstalować pakiet nltk .

Zaletą jest to, że po otrzymaniu tokenów możesz zrobić wiele fajnych rzeczy z resztą pakietu nltk.

Po pierwsze, nie sądzę, że twoim intencją jest używanie interpunkcji jako ograniczników w funkcjach podziału. Twój opis sugeruje, że chcesz po prostu wyeliminować interpunkcję z powstałych ciągów.

Często się z tym spotykam, a moje zwykłe rozwiązanie nie wymaga ponownego.

Jednowierszowa funkcja lambda ze zrozumieniem listy:

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

Funkcja (tradycyjna)

Jako tradycyjna funkcja są to tylko dwa wiersze ze zrozumieniem listy (oprócz 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']

Naturalnie pozostawi również nienaruszone skurcze i dzielone słowa. Zawsze możesz użyć, text.replace("-", " ")aby zamienić łączniki w spacje przed podziałem.

Funkcja ogólna bez analizy lambda lub listy

Aby uzyskać bardziej ogólne rozwiązanie (w którym można określić znaki do wyeliminowania) i bez zrozumienia listy, otrzymujesz:

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

Oczywiście zawsze możesz uogólnić funkcję lambda na dowolny określony ciąg znaków.

Przede wszystkim zawsze używaj re.compile () przed wykonaniem jakiejkolwiek operacji RegEx w pętli, ponieważ działa ona szybciej niż normalna operacja.

więc dla twojego problemu najpierw skompiluj wzór, a następnie wykonaj na nim akcję.

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

Oto odpowiedź z wyjaśnieniem.

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'

lub w jednym wierszu możemy to zrobić w następujący sposób:

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

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

zaktualizowana odpowiedź

Utwórz funkcję, która pobiera jako dane wejściowe dwa ciągi (łańcuch źródłowy, który ma zostać podzielony i ciąg listy rozdzielającej ograniczników) i wyświetla listę podzielonych słów:

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

Podoba mi się rozwiązanie pprzemek, ponieważ nie zakłada, że ​​ograniczniki są pojedynczymi znakami i nie próbuje używać wyrażenia regularnego (co nie działałoby dobrze, gdyby liczba separatorów musiała być szalona długa).

Oto bardziej czytelna wersja powyższego rozwiązania dla przejrzystości:

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

Mam taki sam problem jak @ooboo i uważam, że ten temat @ ghostdog74 zainspirował mnie, może ktoś uzna moje rozwiązanie za przydatne

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

wprowadź coś w miejscu spacji i podziel za pomocą tego samego znaku, jeśli nie chcesz rozdzielać spacji.

Oto mój wybór z podziałem z wieloma ogranicznikami:

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

Myślę, że najlepszą odpowiedzią na twoje potrzeby jest:

\W+ może być odpowiedni dla tego przypadku, ale może nie być odpowiedni dla innych przypadków.

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

Oto moje zdanie na ten temat ....

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()Najbardziej podoba mi się sposób. Poniższa procedura zmienia wszystkie separatory zdefiniowane w ciągu splitlistna pierwszy separator w, splitlista następnie dzieli tekst na tym jednym separatorze. Uwzględnia również, jeśli splitlistakurat jest to pusty ciąg. Zwraca listę słów, bez pustych ciągów.

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

Oto użycie:

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

Jeśli chcesz operacji odwracalnej (zachowaj ograniczniki), możesz użyć tej funkcji:

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

Ostatnio musiałem to zrobić, ale chciałem funkcji, która nieco pasuje do standardowej str.splitfunkcji biblioteki , ta funkcja zachowuje się tak samo jak standardowa biblioteka, gdy jest wywoływana z argumentami 0 lub 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])

UWAGA : Ta funkcja jest przydatna tylko wtedy, gdy separatory składają się z jednego znaku (tak jak moja przypadek użycia).