Python3实现企业云无限层级文件索引及名称对比需求问询

Hey Daniel, let's tackle this problem step by step! We can use recursive traversal to handle infinite directory levels, and pair it with a counter array to generate that hierarchical numbering like 1. or 1.1. you want. Here's a complete solution tailored to your needs:

核心思路 #

To achieve unlimited depth traversal, recursive functions are the perfect fit (or you can use os.walk with level tracking, but recursion is more intuitive for maintaining hierarchy context). We'll also keep a counter array to track the sequence of each level, which lets us generate the numbered format you're after.

完整实现代码 #

import os

def traverse_directory(current_path, level_list, counter_list, output_file):
    # Sort entries: folders first, then files, both sorted by name
    entries = sorted(
        os.listdir(current_path),
        key=lambda x: (not os.path.isdir(os.path.join(current_path, x)), x)
    )
    
    for idx, entry in enumerate(entries, start=1):
        entry_full_path = os.path.join(current_path, entry)
        
        # Update counter array for current level
        if len(counter_list) == len(level_list):
            counter_list.append(idx)
        else:
            counter_list[len(level_list)] = idx
        
        # Generate hierarchical numbering (e.g., [1,2] → "1.2.")
        numbering = ".".join(map(str, counter_list[:len(level_list)+1])) + "."
        # Generate human-readable level path (e.g., ["Main", "Sub"] → "Main > Sub > Entry")
        level_text = " > ".join(level_list + [entry])
        
        # Write to output file (adjust format as needed)
        output_line = f"{numbering:<12} {level_text}\n"
        output_file.write(output_line)
        
        # Recurse into subdirectories
        if os.path.isdir(entry_full_path):
            traverse_directory(entry_full_path, level_list + [entry], counter_list, output_file)
    
    # Clean up counter when exiting current directory level
    if counter_list:
        counter_list.pop()

def generate_onedrive_index(root_path, output_filename):
    with open(output_filename, "w", encoding="utf-8") as f:
        # Initialize with empty level and counter lists for root directory
        traverse_directory(root_path, [], [], f)
    print(f"Full index generated successfully: {output_filename}")

if __name__ == "__main__":
    # Replace with your OneDrive enterprise mount path
    ONEDRIVE_ROOT = r"C:\Users\YourName\OneDrive - YourCompanyName"
    # Output index file name
    INDEX_FILE = "onedrive_full_index.txt"
    
    generate_onedrive_index(ONEDRIVE_ROOT, INDEX_FILE)

代码细节解释 #

1. Recursive Traversal:

   • The traverse_directory function tracks the current hierarchy with level_list (e.g., ["Project X", "Design Docs"]) and counter_list (e.g., [2, 3] for the 3rd subfolder of the 2nd main folder).
   • When entering a subdirectory, we add the current folder to level_list and recurse; when exiting, we pop the last counter value to return to the parent level's sequence.

2. Hierarchical Numbering:

   • For each entry, we update the counter array to match the current depth. The number string is built by joining the counter values up to the current level, adding a trailing dot for clarity.

3. Consistent Sorting:

   • Entries are sorted to show folders first, then files (both ordered by name) — this ensures your index has a predictable, consistent structure every time you generate it.

对比两次索引检测变更的思路 #

To spot name changes or additions/deletions between two indexes, you can:

1. Generate two index files (e.g., index_old.txt and index_new.txt) at different times.
2. Load both into dictionaries using the numbering as the key and the path text as the value.
3. Compare the dictionaries to find discrepancies.

Here's a quick snippet for comparison:

def load_index_file(filename):
    index_data = {}
    with open(filename, "r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            numbering, path_text = line.split(maxsplit=1)
            index_data[numbering.strip()] = path_text.strip()
    return index_data

# Load both indexes
old_index = load_index_file("onedrive_full_index_old.txt")
new_index = load_index_file("onedrive_full_index_new.txt")

# Detect changes
print("=== New/Renamed Entries ===")
for num, path in new_index.items():
    if num not in old_index or old_index[num] != path:
        print(f"{num} {path}")

print("\n=== Deleted/Renamed Entries ===")
for num, path in old_index.items():
    if num not in new_index or new_index[num] != path:
        print(f"{num} {path}")

实用提示 #

• Make sure your OneDrive is fully synced before generating the index — otherwise, you'll get incomplete results.
• Use raw strings (r"path") for your OneDrive root to avoid escape character issues.
• The utf-8 encoding ensures special characters in filenames are handled correctly.

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