Início / coding / Perguntas / 79563265
Accepted
Totura
Asked: 2025-04-09 08:53:32 +0800 CST

Correspondência parcial da coluna Pandas DataFrame e extração do valor correspondente

  • 772

Tenho uma coluna no Pandas DataFrame(Nomes) com uma grande coleção de nomes. Tenho outra coluna de texto DataFrame(Título) e, entre os textos, os nomes no quadro Nome estão lá. Qual seria a maneira mais rápida de extrair nomes correspondentes do Título? A imagem abaixo mostra meu trabalho até agora, e é muito lento para o grande conjunto de dados atual.

import pandas as pd
import re

Names = pd.DataFrame({
    'ENTITY_NAME': ['XYZ', 'ABC', 'NGA', 'METRO','DPAC']
})

Titles = pd.DataFrame({
    'title': ['testing some text XYZ testing some text.',
              'XYZ, ABC some random text',
              'some text DPAC random random']
})

# Function to extract ENTITY_NAME if found in title
def extract_entity_name(title, entity_names):
    pattern = '|'.join([r'\b' + re.escape(entity) + r'\b' for entity in entity_names])
    matches = re.findall(pattern, title)
    return ', '.join(matches)
  



Titles['extracted_entity_name'] = Titles['title'].apply(lambda x: extract_entity_name(x, Names['ENTITY_NAME'].tolist()))

display(Titles.head())
python-3.x

2 respostas

  1. Best Answer

    Seu código é lento porque você está recriando o padrão para cada linha, mesmo que seja o mesmo, e porque você está usando apply.

    Você pode acelerar isso definindo a regex apenas uma vez:

    import re

pattern = r'\b(%s)\b' % '|'.join(map(re.escape, Names['ENTITY_NAME']))
# '\\b(XYZ|ABC|NGA|METRO|DPAC)\\b'

Titles['extracted_entity_name'] = Titles['title'].str.findall(pattern).str.join(', ')

    Dependendo do comprimento do DataFrame, você pode acelerá-lo usando uma compreensão de lista:

    Titles['extracted_entity_name'] = [', '.join(re.findall(pattern, s))
                                   for s in Titles['title']]

    Saída:

                                          title extracted_entity_name
0  testing some text XYZ testing some text.                   XYZ
1                 XYZ, ABC some random text              XYZ, ABC
2              some text DPAC random random                  DPAC

    Horários:

    # 3 rows: str.findall + str.join
255 µs ± 1.11 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
# 3 rows: list comprehension
75.6 µs ± 371 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

# 300 rows: str.findall + str.join
617 µs ± 11.7 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
# 300 rows: list comprehension
570 µs ± 15.4 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

# 30k rows: str.findall + str.join
34.1 ms ± 347 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 30k: list comprehension
50.3 ms ± 208 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

# 300k rows: str.findall + str.join
352 ms ± 5.86 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
# 300k: list comprehension
508 ms ± 2.13 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
    • 2 
  2. result = pd.DataFrame(index=titles_df.index)
# filter out duplicate entity names
# this might be unnecessary, but I do not know your dataset
entity_names = names_df[entity_col].unique()

# precompile regex patterns so we can reuse them during the loop
patterns = {entity: re.compile(r'\b' + re.escape(entity) + r'\b') 
            for entity in entity_names}

# create a boolean mask for each entity name, True if it appears in the title
for entity, pattern in patterns.items():
    # using the precompiled regex and pandas str.contains for searching string columns
    result[entity] = titles_df[title_col].str.contains(pattern, regex=True)

# join that with entity names where True
# this is far faster than apply() in a loop
extracted_entities = result.apply(
    lambda x: ', '.join(x[x].index), axis=1
)

    O principal erro no seu código foi não usar o método vetorizado .str.contains. Ele é um código C pré-compilado e busca todas as linhas "de uma só vez" com uma única chamada, evitando assim um loop Python que gera uma sobrecarga relativamente grande. Além disso, seu código original recompila a expressão regular para cada nome de cada título. Pelo que entendi, isso é perda de tempo, pois os nomes não mudam, então a expressão regular também não muda. Podemos compilar a expressão regular para cada nome uma única vez e usá-la repetidamente.

    Obrigado por fornecer o que você fez até agora, em vez de apenas descrever o problema que estava tendo e esperar que alguém o fizesse por você. Mesmo que você tenha descrito seu caso de uso perfeitamente, o código fornecido deixou muito mais claro o que você estava tentando realizar e por que estava tendo problemas.

    Por favor, responda com um comentário se ainda estiver com problemas de desempenho do código. Existem bibliotecas que podem fornecer métodos mais eficientes para isso, mas implementá-los é muito mais complicado do que as otimizações acima, e acredito que essas mudanças serão a maior melhoria em relação ao esforço para implementá-las.

    • 0

relate perguntas