字符串校验需求下list/set/dictionary选型及匹配问题求助

Hey there! Let's work through your problem step by step—you've got two key goals here: validating that text only contains numbers/letters (or specific allowed symbols like underscores for words like _success), and checking if full words exist in a predefined collection. Let's tackle both, plus clear up that data structure confusion.

First: Pick the Right Data Structure—Go with set! #

You’re stuck choosing between list, set, and dictionary, so let’s cut to the chase:

• List: Terrible for lookups. Checking if a word exists takes O(n) time, which gets slow fast if your word list grows. Skip it.
• Dictionary: You don’t need key-value pairs here—you just want to check if a word is present. Using a dict would waste memory for no reason.
• Set: Perfect. Lookups are O(1) (instant, basically), it only stores unique values, and it’s exactly what you need for checking if a full word is in your collection.

Also, you’re right that using a list of single characters (like ['a','b','c']) won’t let you compare full text directly—character-level validation needs a different approach, which we’ll cover next.

Fixing the Symbol Acceptance Issue: Proper Character Validation #

Your current code is letting symbols slip through, so let’s fix that. You’ve got two solid options:

Option 1: Use Python’s Built-in Method (Simplest & Fastest) #

If you only want numbers and letters, Python’s str.isalnum() method does exactly what you want—it returns True only if every character in the string is a letter (upper/lower) or number, and the string isn’t empty.

def validate_text(text):
    # Reject empty strings and any text with symbols
    return text.isalnum() and len(text) > 0

Option 2: Manual Validation (For Custom Rules Like Allowing Underscores) #

Since you mentioned words like _success which include underscores, adjust the rule to allow specific symbols by checking each character against an allowed set:

# Define exactly which characters you allow (numbers, letters, underscores here)
allowed_chars = set("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_")

def validate_text(text):
    if not text:
        return False
    # Check every character is in the allowed set
    for char in text:
        if char not in allowed_chars:
            return False
    return True

Checking Full Word Existence #

Now, for checking if a complete word (like abc or _success) is in your collection, use a set for your target words. Here’s how to implement it:

# Predefine your collection of valid full words
target_words = {"abc", "_success", "hello123"}

def check_word_exists(word):
    # First validate the word's characters (optional, but recommended to avoid invalid entries)
    if not validate_text(word):
        return False
    # Check if the word is in our set
    return word in target_words

Full Example & Test Cases #

Let’s put it all together, including support for underscores:

def validate_text(text):
    # Allow numbers, letters, and underscores
    return all(char.isalnum() or char == "_" for char in text) and len(text) > 0

target_words = {"abc", "_success", "hello123"}

def check_word_exists(word):
    return validate_text(word) and word in target_words

# Test it out!
print(check_word_exists("abc"))          # True
print(check_word_exists("_success"))     # True
print(check_word_exists("hello!"))       # False (contains an exclamation mark)
print(check_word_exists("123ABC"))       # False (valid characters, but not in target_words)
print(check_word_exists(""))             # False (empty string)

Key Notes to Remember #

• If your valid words include symbols (like underscores), update your validation rule to include those specific symbols—isalnum() rejects underscores by default!
• Always prefer set over list for word lookups—it’s way faster, especially with large collections.
• Keep validation separate from existence checking—it makes your code cleaner and easier to adjust later.

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