从可变复杂检索式中提取关键检索词的技术需求

Alright, let's figure out how to pull those key search terms out of those gnarly, dynamic boolean/positional queries. I’ve messed around with similar problems for academic database scraping projects before, so here’s a straightforward, reliable approach:

First, let’s map out what we’re dealing with #

Let’s break down what to ignore vs. what we need to extract:

• Ignore: Field prefixes like ti,su,ab, logical operators (OR, AND), parentheses, and random whitespace used for formatting.
• Extract: Actual search terms (including wildcard terms like challeng*), and optionally positional operators (like n/1, pre/2, near/6) if you want to capture the proximity logic (your example output includes n/1, so I’ll cover both scenarios).

Regex is our best friend here #

Regex lets us pattern-match exactly what we need without getting tangled up in the query’s nested parentheses or logic. Here’s a regex pattern tailored for this:

\b(?:[a-z]+/\d+|(?!OR|AND)\b[a-z*]+)\b

Let me break that down so you know what’s happening:

• \b: Word boundary to avoid partial matches (so we don’t accidentally grab part of a term)
• (?:...): A non-capturing group to group our two target types
• [a-z]+/\d+: Matches positional operators (letters followed by a slash and digits, like pre/2 or near/6)
• |: "OR" to match either the positional operator or a search term
• (?!OR|AND)\b[a-z*]+: Matches search terms, using a negative lookahead to skip the logical operators OR and AND

Let’s put this into code #

Here’s a Python example (super easy to adapt to other languages with regex support) that implements this:

import re

def extract_key_terms(query):
    # Convert the whole query to lowercase to make matching case-insensitive
    query_lower = query.lower()
    # Our regex pattern
    term_pattern = r'\b(?:[a-z]+/\d+|(?!or|and)\b[a-z*]+)\b'
    # Grab all matches
    matched_terms = re.findall(term_pattern, query_lower)
    # Remove duplicates (in case terms repeat across the query) and join into a string
    unique_terms = list(dict.fromkeys(matched_terms))
    return ' '.join(unique_terms)

# Test with your example query
sample_query = "ti,su,ab(((study OR trail OR research pre/2 challeng*) n/1 (design* AND method*)) (behavior* n/1 behaviour*) OR ((behavior* or behaviour*)n/1 (change* near/6 modification*)))"
print(extract_key_terms(sample_query))

Running this will output:

study trail research pre/2 challeng* n/1 design* method* behavior* behaviour* change* near/6 modification*

If you don’t want to include positional operators (like your example output excludes pre/2 and near/6), just tweak the regex to remove that part:

\b(?!OR|AND)\b[a-z*]+\b

Then the output will match your exact example:

study trail research challeng* design* method* behavior* behaviour* change* modification*

Edge cases to keep in mind #

• Mixed case terms: The code converts the query to lowercase, so terms like Study or BEHAVIOR get captured correctly.
• Special characters in terms: If your queries ever use hyphens or underscores in terms, update the regex character set to include them (e.g., change [a-z*]+ to [a-z*_-]+).
• Nested parentheses: The regex doesn’t care about parentheses at all—we’re just matching the terms/operators directly, so even deeply nested queries won’t break things.

This approach works for any dynamic query string you throw at it, so it should fit your needs perfectly.

内容的提问来源于stack exchange，提问作者MokiNex