如何自动迭代每个列表项并执行唯一 function

Question

I have various files in one directory;

• foo.1001.exr
• foo.1002.exr
• bar.1001.exr
• bar.1002.exr

I'd like to rename all of the files in this directory, but in the case of this directory holding more than one type of image sequence I would like to iterate over them one at a time so I don't overwrite anything and only end up with 2 files.

I was planning on separating them by the first part of the filename and adding them to a list, to get the number of variations. What I am unsure of is how to have the function iterate over newList[0], newList[1] and so on, automatically. It would need to be robust to cater to an indefinite amount of list items.

The output should be:

• foo_test.1001.exr
• foo_test.1002.exr
• bar_test.1001.exr
• bar_test.1002.exr

The code below is not indicative of the renaming task, it was just to start planning how to iterate procedurally over the list items.

import os

dir = "/test/"

# File formats
imageFileFormats = (".exr", ".dpx")

fileName = []
for file in os.listdir(dir):
    for ext1 in imageFileFormats:
        if ext1 in file:
            fileName.append(file.split('.')[0])

newList = list(set(fileName))
newList.sort()

for file in os.listdir(dir):
    for ext1 in imageFileFormats:
        if ext1 in file:
            if newList[0] in file:
                print (file)

Answer 1

This seems like a bit of an XY problem - instead of renaming the file collection in place, causing the potential for conflicts, have you considered creating a new folder to move all the files to, renaming them in the process? Once complete, you can move them back to the original location, avoiding the problem altogether.

As long as you have a mapping from old name to new name for each file that won't cause a conflict in the final result, the order of moving the files then won't matter.

And as long as the target folder is on the same volume, a move operation is basically a renaming anyway, so there's no space issues or performance problems.

So, something like:

from pathlib import Path

def do_rename(fn):
    # whatever non-conflicting renaming operation you need
    p = Path(fn)
    return p.parent / f'{p.stem}_renamed{p.suffix}'


def do_reverse_rename(fn):
    # just including the reverse of the above here for testing purposes
    p = Path(fn)
    return p.parent / f'{p.stem[:-8]}{p.suffix}' if p.stem.endswith('_renamed') else p


def safe_rename_all(location, rename_func):
    p = Path(location)

    # come up with a folder name that doesn't exist, right next to the original
    n = 1
    while (p.parent / f'{p.name}_{n}').is_dir():
        n += 1

    # create the new temporary folder
    (target := p.parent / f'{p.name}_{n}').mkdir()

    # move all the files into the new folder, this example matches *all* files
    #  of course you could filter, etc.
    for fn in p.glob('*'):
        new_fn = rename_func(fn)
        fn.rename(target / new_fn.name)  # move to the temporary location

    # once done, move everything back and delete the temporary folder
    for fn in target.glob('*'):
        fn.rename(p / fn.name)
    target.rmdir()


safe_rename_all('some/folder/with/files', do_rename)
# can be undone with safe_rename_all('output', do_reverse_rename)

Some considerations might be to not create a folder right next to the original (to avoid rights issues, etc.) but instead create a temporary folder on the same volume using the standard library tempfile . And you were filtering for certain suffixes, so that's easy to add.