Python 3.6中批量替换字符串子串及生成合法类名的最优方案

Hey Catherine, great question! Let's break this down into two clear parts: efficient bulk substring replacement, and the most robust way to convert text into valid Python class names (since your end goal is more specific than just removing characters).

1. Efficient Bulk Substring Replacement (For Simple Removal) #

Your current chain of str.replace() calls works, but it's inefficient because each call creates a new string and scans the text from scratch. Here are two far better approaches compatible with Python 3.6:

Option 1: str.translate() (Fastest for Simple Deletions) #

This method uses a translation table to map characters to None (effectively deleting them) in a single pass. It's the most performant option for bulk character removal:

# Create a translation table that maps unwanted chars to None
trans_table = str.maketrans("", "", " ,/'’-")
my_str = "bad-Classname's"
cleaned_str = my_str.translate(trans_table)
# Output: 'badClassnames'

The str.maketrans("", "", chars_to_delete) syntax tells Python to remove all characters in the third argument. This is a low-level operation, so it’s way faster than multiple replace() calls, especially with large text.

Option 2: re.sub() (Flexible for Pattern-Based Replacement) #

If you ever need to handle more complex patterns (not just single characters), use a regex to match all unwanted characters at once:

import re

my_str = "bad-Classname's"
# Match any of the unwanted characters and replace with empty string
cleaned_str = re.sub(r"[ ,/'’-]", "", my_str)
# Output: 'badClassnames'

The regex [ ,/'’-] creates a character class that matches any of the listed characters. This is slower than translate() but more versatile—you could easily extend it to match patterns like multiple spaces or special symbols.

2. Best Practice: Convert Text to Valid Python Class Names #

Your current approach only removes invalid characters, but Python class names (a type of identifier) have strict rules:

• Must start with a letter or underscore
• Can only contain letters, numbers, and underscores
• Can’t be a reserved keyword (like class or def)

Plus, standard Python style uses PascalCase (capitalized words, no separators) for class names. Here’s a robust function that handles all these requirements:

import re
import keyword

def to_valid_classname(input_str):
    # Step 1: Replace all non-alphanumeric characters with spaces
    normalized = re.sub(r"[^a-zA-Z0-9]", " ", input_str)
    
    # Step 2: Split into words and convert to PascalCase
    words = normalized.split()
    if not words:
        return "DefaultClass"  # Fallback for empty input
    
    class_name = ''.join(word.capitalize() for word in words)
    
    # Step 3: Fix if starts with a number
    if class_name[0].isdigit():
        class_name = "_" + class_name
    
    # Step 4: Avoid reserved keywords
    if keyword.iskeyword(class_name):
        class_name += "_"
    
    return class_name

# Test cases
print(to_valid_classname("bad-Classname's"))  # Output: 'BadClassnames'
print(to_valid_classname("123-hello_world"))  # Output: '_123HelloWorld'
print(to_valid_classname("class"))            # Output: 'Class_'

This function doesn’t just clean the text—it ensures your class name is:

1. Syntactically valid in Python
2. Followed standard naming conventions
3. Handles edge cases like numeric starts or reserved words

Performance Comparison #

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