Acho que o que quero fazer é uma tarefa bastante comum, mas não encontrei nenhuma referência na web. Tenho texto com pontuação e quero uma lista de palavras.

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

deveria estar

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

Mas o Python str.split()funciona apenas com um argumento, então eu tenho todas as palavras com a pontuação depois de dividir com espaço em branco. Alguma ideia?

Um caso em que expressões regulares são justificadas:

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 (padrão, string [, maxsplit = 0])

Divida a string pelas ocorrências do padrão. Se a captura de parênteses for usada no padrão, o texto de todos os grupos no padrão também será retornado como parte da lista resultante. Se maxsplit for diferente de zero, ocorrerão no máximo divisões de maxsplit e o restante da sequência será retornado como o elemento final da lista. (Nota sobre incompatibilidade: na versão original do Python 1.5, o maxsplit foi ignorado. Isso foi corrigido em versões posteriores.)

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

Outra maneira rápida de fazer isso sem uma regexp é substituir os caracteres primeiro, como abaixo:

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

Tantas respostas, mas não consigo encontrar nenhuma solução que faça com eficiência o que o título das perguntas pede literalmente (dividindo-se em vários separadores possíveis - em vez disso, muitas respostas se dividem em qualquer coisa que não seja uma palavra, que seja diferente). Então, aqui está uma resposta para a pergunta no título, que se baseia no remódulo padrão e eficiente do Python :

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

Onde:

• as […]partidas um dos separadores referidos, dentro
• a \-expressão regular está aqui para impedir a interpretação especial de -como um indicador de intervalo de caracteres (como em A-Z),
• os +saltos um ou mais delimitadores (que poderia ser omitida, graças àfilter() , mas isso iria desnecessariamente produzir cadeias vazias entre separadores correspondentes), e
• filter(None, …) remove as cadeias vazias, possivelmente criadas pelos separadores à esquerda e à direita (já que as cadeias vazias têm um valor booleano falso).

Isso re.split()"se divide precisamente com vários separadores", conforme solicitado no título da pergunta.

Além disso, esta solução é imune aos problemas com caracteres não ASCII em palavras encontradas em outras soluções (consulte o primeiro comentário à resposta de ghostdog74 ).

O remódulo é muito mais eficiente (em velocidade e concisão) do que fazer loops e testes em Python "à mão"!

Outra maneira, sem regex

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

Dica profissional: use string.translate para as operações mais rápidas de strings que o Python possui.

Alguma prova ...

Primeiro, o caminho lento (desculpe 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

Em seguida, usamos re.findall()(conforme indicado pela resposta sugerida). Muito mais rapido:

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

Finalmente, usamos 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

Explicação:

string.translateé implementado em C e, diferentemente de muitas funções de manipulação de strings no Python, string.translate não produz uma nova string. Portanto, é o mais rápido possível para a substituição de strings.

É um pouco estranho, porém, pois precisa de uma tabela de tradução para fazer essa mágica. Você pode criar uma tabela de conversão com a maketrans()função de conveniência. O objetivo aqui é converter todos os caracteres indesejados em espaços. Um substituto um por um. Novamente, nenhum novo dado é produzido. Então isso é rápido !

Em seguida, usamos o bom e velho split(). split()por padrão, operará em todos os caracteres de espaço em branco, agrupando-os para a divisão. O resultado será a lista de palavras que você deseja. E essa abordagem é quase 4x mais rápida que re.findall()!

Eu tinha um dilema semelhante e não queria usar o módulo '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']

Primeiro, quero concordar com os outros que o regex ou as str.translate(...)soluções baseadas são de melhor desempenho. Para o meu caso de uso, o desempenho dessa função não foi significativo, então eu queria adicionar idéias que considerasse com esse critério.

Meu principal objetivo era generalizar idéias de algumas das outras respostas em uma solução que pudesse funcionar para seqüências que contenham mais do que apenas palavras regex (ou seja, colocar na lista negra o subconjunto explícito de caracteres de pontuação versus caracteres de palavra na lista de permissões).

Observe que, em qualquer abordagem, também se pode considerar o uso string.punctuationno lugar de uma lista definida manualmente.

Opção 1 - re.sub

Fiquei surpreso ao ver que nenhuma resposta até agora usa re.sub (...) . Acho que é uma abordagem simples e natural para esse problema.

import re

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

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

Nesta solução, aninhei a chamada para re.sub(...)dentro re.split(...)- mas se o desempenho for crítico, compilar o regex fora pode ser benéfico - para o meu caso de uso, a diferença não foi significativa, portanto prefiro simplicidade e legibilidade.

Opção 2 - str.replace

São mais algumas linhas, mas tem o benefício de ser expansível sem precisar verificar se você precisa escapar de um determinado caractere na 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()

Teria sido bom poder mapear o str.replace para a string, mas não acho que isso possa ser feito com strings imutáveis, e o mapeamento de uma lista de caracteres funcionaria, executando todas as substituições de cada personagem parece excessivo. (Editar: veja a próxima opção para um exemplo funcional.)

Opção 3 - functools.reduce

(No Python 2, reduceestá disponível no espaço de nomes global sem importá-lo das funções de ferramenta.)

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]

Em seguida, isso se torna uma lista de três linhas:

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

Explicação

É isso que em Haskell é conhecido como mônada da lista. A idéia por trás da mônada é que uma vez "na mônada" você "fica na mônada" até que alguma coisa o tire. Por exemplo, em Haskell, digamos que você mapeie a range(n) -> [1,2,...,n]função python sobre uma lista. Se o resultado for uma Lista, ela será anexada à Lista no local, para que você obtenha algo parecido map(range, [3,4,1]) -> [0,1,2,0,1,2,3,0]. Isso é conhecido como anexo de mapa (ou mappend, ou talvez algo parecido). A idéia aqui é que você tenha essa operação que está aplicando (dividindo em um token) e, sempre que fizer isso, junte o resultado à lista.

Você pode abstrair isso em uma função e ter tokens=string.punctuationpor padrão.

Vantagens dessa abordagem:

• Essa abordagem (diferente das abordagens ingênuas baseadas em regex) pode funcionar com tokens de tamanho arbitrário (que regex também pode fazer com sintaxe mais avançada).
• Você não está restrito a meros tokens; você pode ter uma lógica arbitrária no lugar de cada token, por exemplo, um dos "tokens" pode ser uma função que se divide de acordo com a parênteses aninhados.

tente isto:

import re

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

isso imprimirá ['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

Use substituir duas vezes:

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

resulta em:

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

Eu gosto de re , mas aqui está a minha solução sem ela:

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__ é um método usado pelo operador 'in'. Basicamente, é o mesmo que

lambda ch: ch in sep

mas é mais conveniente aqui.

groupby obtém nossa string e função. Ele divide a string em grupos usando essa função: sempre que um valor da função é alterado - um novo grupo é gerado. Então, set .__ contém__ é exatamente o que precisamos.

groupby retorna uma sequência de pares, onde o par [0] é o resultado de nossa função e o par [1] é um grupo. Usando 'if not k' , filtramos grupos com separadores (porque o resultado de set .__ contains__ é True nos separadores). Bem, isso é tudo - agora temos uma sequência de grupos em que cada um é uma palavra (o grupo é realmente uma iterável, então usamos join para convertê-lo em string).

Essa solução é bastante geral, porque usa uma função para separar a string (você pode dividir por qualquer condição que precisar). Além disso, ele não cria cadeias / listas intermediárias (você pode remover a junção e a expressão se tornará preguiçosa, pois cada grupo é um iterador)

Em vez de usar a função re module re.split, você pode obter o mesmo resultado usando o método series.str.split dos pandas.

Primeiro, crie uma série com a sequência acima e aplique o método à série.

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

O parâmetro pat pega os delimitadores e retorna a cadeia de divisão como uma matriz. Aqui os dois delimitadores são passados ​​usando um | (ou operador). A saída é a seguinte:

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

Estou me familiarizando com o Python e precisava da mesma coisa. A solução findall pode ser melhor, mas eu vim com isso:

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

usando maketrans e traduza você pode fazê-lo facilmente e ordenadamente

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

No Python 3, você pode usar o método PY4E - Python for Everybody .

Podemos resolver ambos os problemas usando os métodos de cordas lower, punctuatione translate. O translateé o mais sutil dos métodos. Aqui está a documentação para translate:

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

Substitua os personagens fromstrcom o personagem na mesma posição em tostre excluir todos os caracteres que estão em deletestr. As cadeias fromstre tostrpodem ser vazias e o deletestrparâmetro pode ser omitido.

Você pode ver a "pontuação":

In [10]: import string

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

Para o seu exemplo:

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

Para mais informações, você pode consultar:

• PY4E - Python para todos
• str.translate
• str.maketrans
• Método maketrans () da string Python

Outra maneira de conseguir isso é usar o 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

Isso imprime: ['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

A maior desvantagem desse método é que você precisa instalar o pacote nltk .

Os benefícios são que você pode fazer muitas coisas divertidas com o restante do pacote nltk depois de receber seus tokens.

Primeiro de tudo, não acho que sua intenção seja realmente usar pontuação como delimitadores nas funções de divisão. Sua descrição sugere que você simplesmente deseja eliminar a pontuação das seqüências de caracteres resultantes.

Eu me deparei com isso com bastante frequência, e minha solução usual não requer re.

Função lambda de uma linha com compreensão de lista:

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

Função (tradicional)

Como uma função tradicional, ainda são apenas duas linhas com uma compreensão da lista (além 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']

Também deixará naturalmente as contrações e as palavras hifenizadas intactas. Você sempre pode usar text.replace("-", " ")para transformar hífens em espaços antes da divisão.

Função geral sem Lambda ou compreensão de lista

Para uma solução mais geral (onde você pode especificar os caracteres a serem eliminados) e sem uma compreensão da lista, você obtém:

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

Obviamente, você sempre pode generalizar a função lambda para qualquer sequência de caracteres especificada.

Antes de tudo, sempre use re.compile () antes de executar qualquer operação RegEx em um loop, pois funciona mais rápido que a operação normal.

portanto, para o seu problema, primeiro compile o padrão e execute uma ação nele.

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

Aqui está a resposta com alguma explicação.

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 em uma linha, podemos fazer assim:

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

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

resposta atualizada

Crie uma função que tenha como entrada duas cadeias (a cadeia de origem a ser dividida e a cadeia de delimitadores da lista de divisão) e produz uma lista de palavras divididas:

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

Gosto da solução do pprzemek porque ele não supõe que os delimitadores sejam caracteres únicos e não tenta alavancar um regex (o que não funcionaria bem se o número de separadores ficasse louco por muito tempo).

Aqui está uma versão mais legível da solução acima para maior clareza:

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

tenho o mesmo problema que @ooboo e encontre este tópico @ ghostdog74 me inspirou, talvez alguém ache minha solução útil

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

insira algo no espaço e divida usando o mesmo caractere se você não quiser dividir em espaços.

Aqui está a minha chance de dividir com vários deliminadores:

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

Eu acho que a seguinte é a melhor resposta para atender às suas necessidades:

\W+ talvez adequado para este caso, mas pode não ser adequado para outros casos.

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

Heres minha opinião sobre isso ....

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

Eu gosto replace()da melhor maneira. O procedimento a seguir altera todos os separadores definidos em uma seqüência splitlistde caracteres para o primeiro separador splitliste, em seguida, divide o texto nesse separador. Ele também explica se splitlisté uma string vazia. Retorna uma lista de palavras, sem cadeias vazias.

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

Aqui está o uso:

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

Se você deseja uma operação reversível (preserve os delimitadores), poderá usar esta função:

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

Recentemente, eu precisava fazer isso, mas queria uma função que correspondesse à str.splitfunção da biblioteca padrão ; essa função se comporta da mesma forma que a biblioteca padrão quando chamada com argumentos 0 ou 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])

NOTA : Essa função é útil apenas quando seus separadores consistem em um único caractere (como foi meu caso de usuário).