Início / coding / Perguntas / 78524354
Accepted
Simon
Asked: 2024-05-23 23:59:20 +0800 CST

Polars para processamento de termos de pesquisa em dados de texto

  • 772

Eu tenho um script Python que carrega termos de pesquisa de um arquivo JSON e processa um DataFrame do Pandas para adicionar novas colunas indicando se determinados termos estão presentes nos dados de texto. No entanto, gostaria de modificar o script para usar Polars em vez de Pandas e possivelmente remover a dependência JSON. Aqui está meu código original:

import pandas as pd
import json


class SearchTermLoader:
    def __init__(self, json_file):
        self.json_file = json_file

    def load_terms(self):
        with open(self.json_file, 'r') as f:
            data = json.load(f)

        terms = {}
        for phase_name, phase_data in data.items():
            terms[phase_name] = (
                phase_data.get('words', []),
                phase_data.get('exact_phrases', [])
            )
        return terms

class DataFrameProcessor:
    def __init__(self, df: pd.DataFrame, col_name: str) -> None:
        self.df = df
        self.col_name = col_name

    def add_contains_columns(self, search_terms):
        columns_to_add = ["type1", "type2"]
        for column in columns_to_add:
            self.df[column] = self.df[self.col_name].apply(
                lambda text: any(
                    term in text
                    for term in search_terms.get(column, ([], []))[0] + search_terms.get(column, ([], []))[1]
                )
            )
        return self.df

# Example Usage
data = {'text_column': ['The apple is red', 'I like bananas', 'Cherries are tasty']}
df = pd.DataFrame(data)

term_loader = SearchTermLoader('word_list.json')
search_terms = term_loader.load_terms()

processor = DataFrameProcessor(df, 'text_column')
new_df = processor.add_contains_columns(search_terms)

new_df

Aqui está um exemplo do arquivo json:

{
    "type1": {
        "words": ["apple", "tasty"],
        "exact_phrases": ["soccer ball"] 
    },
    "type2": {
        "words": ["banana"],
        "exact_phrases": ["red apple"]
    }
}

Entendo que posso usar a .str.contains()função, mas quero usá-la com palavras específicas e frases exatas. Você poderia fornecer alguma orientação sobre como começar com isso?

python

1 respostas

  1. Best Answer

    Para correspondência não-regex, .str.contains_any()provavelmente é uma opção melhor.

    Parece que você deseja concatenar as duas listas:

    word_list = pl.read_json("word_list.json")

""" for older versions without struct "*" expansion
type1 = pl.concat_list(
   pl.col("type1").struct.field("words", "exact_phrases")
)
"""

word_list = word_list.select(
   type1 = pl.concat_list(pl.col("type1").struct["*"]),
   type2 = pl.concat_list(pl.col("type2").struct["*"])
)

    Shape: (1, 2)
┌───────────────────────────────────┬─────────────────────────┐
│ type1                             ┆ type2                   │
│ ---                               ┆ ---                     │
│ list[str]                         ┆ list[str]               │
╞═══════════════════════════════════╪═════════════════════════╡
│ ["apple", "tasty", "soccer ball"] ┆ ["banana", "red apple"] │
└───────────────────────────────────┴─────────────────────────┘

    Você poderia então .concat()colocá-los em seu quadro e correr.contains_any()

    new_df = pl.concat([df, word_list], how="horizontal")

new_df.with_columns(
   type1 = pl.col("text_column").str.contains_any(pl.col("type1").flatten()),
   type2 = pl.col("text_column").str.contains_any(pl.col("type2").flatten())
)

    shape: (3, 3)
┌─────────────────────────────┬───────┬───────┐
│ text_column                 ┆ type1 ┆ type2 │
│ ---                         ┆ ---   ┆ ---   │
│ str                         ┆ bool  ┆ bool  │
╞═════════════════════════════╪═══════╪═══════╡
│ The apple is red            ┆ true  ┆ false │
│ I like bananas              ┆ false ┆ true  │
│ Cherries are tasty          ┆ true  ┆ false │
└─────────────────────────────┴───────┴───────┘
    • 1

relate perguntas