如何在Python/C++中对动态文件数字做精准随机替换并避免误替换？

First off, this is totally feasible—regex is the perfect tool for targeting standalone digits without messing up numbers like 14 or 45. Both Python and C++ have robust regex support, and handling hundreds of replacement operations (whether on multiple files or repeated tasks) is straightforward with loops and efficient file I/O.

Core Concept: Targeting Standalone 4s #

The key is to match the digit 4 only when it’s not part of a longer number. For cross-language compatibility, using capturing groups is a safe approach:

• Pattern: (^|\D)(4)(\D|$)
  • ^|\D: Matches the start of the string or a non-digit character (before the 4)
  • 4: The standalone digit we want to replace
  • \D|$: Matches a non-digit character or the end of the string (after the 4)
• Replacement: Keep the surrounding non-digit characters and swap 4 with your target value (like 20 or a random number).

Python Implementation #

1. Fixed Replacement (4 → 20) #

This code reads a file, replaces all standalone 4s, and writes the modified content back:

import re

def replace_standalone_4(file_path, replacement="20"):
    # Read the file content
    with open(file_path, 'r', encoding='utf-8') as f:
        content = f.read()
    
    # Regex pattern to match standalone 4s
    pattern = re.compile(r'(^|\D)(4)(\D|$)')
    # Replace while preserving surrounding characters
    modified_content = pattern.sub(r'\g<1>' + replacement + r'\g<3>', content)
    
    # Write back to the file (or a new file if you want to keep the original)
    with open(file_path, 'w', encoding='utf-8') as f:
        f.write(modified_content)

# Example usage:
replace_standalone_4("your_file.txt")

2. Random Value Replacement #

If you need to replace standalone 4s with random numbers (e.g., between 10 and 30) for obfuscation, use a custom replacement function:

import re
import random

def random_replacement(match):
    # Generate a random integer between 10 and 30 (adjust range as needed)
    rand_val = str(random.randint(10, 30))
    # Return the surrounding characters plus the random value
    return match.group(1) + rand_val + match.group(3)

def replace_4_with_random(file_path):
    with open(file_path, 'r', encoding='utf-8') as f:
        content = f.read()
    
    pattern = re.compile(r'(^|\D)(4)(\D|$)')
    modified_content = pattern.sub(random_replacement, content)
    
    with open(file_path, 'w', encoding='utf-8') as f:
        f.write(modified_content)

# Example usage:
replace_4_with_random("your_file.txt")

Handling Hundreds of Operations #

To run this on multiple files, loop through a list of file paths:

file_list = ["file1.txt", "file2.txt", ..., "file100.txt"]
for file_path in file_list:
    replace_standalone_4(file_path)
    # Or replace_4_with_random(file_path)

C++ Implementation #

1. Fixed Replacement (4 → 20) #

C++ uses the <regex> library (C++11 and later). Here’s how to do it:

#include <iostream>
#include <fstream>
#include <regex>
#include <string>

void replaceStandalone4(const std::string& filePath, const std::string& replacement = "20") {
    // Read file content
    std::ifstream inputFile(filePath);
    std::string content((std::istreambuf_iterator<char>(inputFile)), std::istreambuf_iterator<char>());
    inputFile.close();
    
    // Regex pattern (raw string literal for readability)
    std::regex pattern(R"((^|\D)(4)(\D|$))");
    // Replace using backreferences: $1 = first group, $2 = 4, $3 = third group
    std::string modifiedContent = std::regex_replace(content, pattern, "$1" + replacement + "$3");
    
    // Write back to file
    std::ofstream outputFile(filePath);
    outputFile << modifiedContent;
    outputFile.close();
}

int main() {
    replaceStandalone4("your_file.txt");
    return 0;
}

2. Random Value Replacement #

For random replacements, we’ll iterate through matches manually (since std::regex_replace doesn’t support custom replacement functions directly):

#include <iostream>
#include <fstream>
#include <regex>
#include <string>
#include <random>

std::string generateRandomValue() {
    // Random integer between 10 and 30
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> distr(10, 30);
    return std::to_string(distr(gen));
}

void replace4WithRandom(const std::string& filePath) {
    std::ifstream inputFile(filePath);
    std::string content((std::istreambuf_iterator<char>(inputFile)), std::istreambuf_iterator<char>());
    inputFile.close();
    
    std::regex pattern(R"((^|\D)(4)(\D|$))");
    std::string modifiedContent;
    std::sregex_iterator it(content.begin(), content.end(), pattern);
    std::sregex_iterator end;
    
    size_t lastPos = 0;
    for (; it != end; ++it) {
        // Add content from last match to current match start
        modifiedContent += content.substr(lastPos, it->position() - lastPos);
        // Add the surrounding groups plus random value
        modifiedContent += it->str(1) + generateRandomValue() + it->str(3);
        lastPos = it->position() + it->length();
    }
    // Add remaining content after last match
    modifiedContent += content.substr(lastPos);
    
    std::ofstream outputFile(filePath);
    outputFile << modifiedContent;
    outputFile.close();
}

int main() {
    replace4WithRandom("your_file.txt");
    return 0;
}

Handling Hundreds of Operations #

Loop through your list of files:

#include <vector>

int main() {
    std::vector<std::string> fileList = {"file1.txt", "file2.txt", ..., "file100.txt"};
    for (const auto& filePath : fileList) {
        replaceStandalone4(filePath);
        // Or replace4WithRandom(filePath);
    }
    return 0;
}

Key Tips for Efficiency & Accuracy #

• Test First: Always test with sample content (e.g., "14", "4", "45", " 4 ", "4.") to ensure the regex doesn’t accidentally modify unintended values.
• Backup Files: Before running bulk operations, create backups of your files to avoid data loss.
• Large Files: For extremely large files, consider processing in chunks instead of reading the entire file into memory (though regex works best on full strings, so balance memory usage with performance).

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