DEV Community: josephmads

(Another) Simple Python File Renaming Script

josephmads — Thu, 21 Apr 2022 01:04:37 +0000

Intro

This is a walk-through of a file renaming script that allows the user to specify the type of file to be renamed and to choose the naming convention.

The Script

import pathlib

# set the directory containing the files to be renamed
path = pathlib.Path("/home/joe/Pictures/examplePics/")

# set the new name of the files 
file_name = "photos"
file_list = []
counter = 1

for file in sorted(path.glob("*.JPG")): # file type to rename
    file_list.append(file)
for file in file_list:
    new_file = file_name + str(counter) + str(file.suffix).lower()
    file.rename(path / new_file)
    counter += 1

How It Works

This directory has two file types, .jpg and .txt. For this example I only want to change the names of the .jpg files.

First, the script imports the pathlib module from the standard library. Functions from this module allow the script to navigate directories, iterate by file type, and rename files. The .Path() class tells the script where the files are that need to be renamed. It gets assigned to the path variable.

import pathlib

path = pathlib.Path("/home/joe/Pictures/examplePics/")

If the script is run from the same directory as the files being renamed, path can be written:

path = pathlib.Path().cwd()

Next, the user assigns a string to file_name which will become the stem of the new file names. file_list initializes an empty list. counter starts the file numbering scheme at 1.

file_name = "photo"
file_list = []
counter = 1

The first 'for loop' iterates over the files that path points to. The .glob() method specifies the file type by matching the relative pattern (also assigned by the user). The files are sorted and appended to the file_list that was initialized above.

for file in sorted(path.glob("*.JPG")): # file type to rename
    file_list.append(file)

Without this first 'for loop', there is a fringe case where the renaming script overwrites and erases some files. This happens if it is run twice in a row without changing the file_name string. I only encountered this problem in Linux (both WSL and a Linux machine) when running the script from outside the working directory. I could not get Windows to duplicate the problem.

It doesn't seem very likely that the user would run into this file erasure issue. However, since no one likes unexpectedly losing files, I kept it in the script just to be on the safe side.

The second 'for loop' iterates over the sorted files appended to file_list. new_file is initialized and the new file name is concatenated from the string in file_name, the integer in counter (converted to a string), and the file type suffix specified in the first 'for loop'. file.suffix is converted to a string and made lowercase using the .lower() string method.*

for file in file_list:
    new_file = file_name + str(counter) + str(file.suffix).lower()

*I made the file suffix conversion because I like my file extensions lowercase. If uppercase extensions are preferred, or the extensions are already lowercase, the line can be written like this:

    new_file = file_name + str(counter) + file.suffix

Finally, the .rename() method renames the file to the targeted directory path and returns a new Path instance pointing to target.
counter is increased by 1, and the script loops until every specified file has been renamed.

    file.rename(path / new_file)
    counter += 1

After the script is run the directory looks like this:

Thanks for reading!

Edited 4/25/2022

DISCLAIMER:
I wrote this script and this article as part of an assignment for my programming course. While I believe this script to be safe, I am a beginner and this script should be treated as an imperfect tool. If you choose to use this script, please test it on a sample or practice directory first.

Using Python's String Slicing to Add/Replace Characters in Specific Positions

josephmads — Mon, 11 Apr 2022 11:25:19 +0000

Intro

This article demonstrates how to replace characters in one string for the characters in another using the classic game of hangman. This may seem like it should be fairly straightforward but it is actually somewhat tricky. I will show the game code, the main problem I encountered, and a solution to that problem.

The Game

word = "hello"
perm_word = "hello"
blank = "-" * len(word)
count = len(word) * 2

print(f"This is a hangman game. Can you guess the word: {blank} in 10 tries?")

while blank != perm_word and count != 0:
    guess = input("Guess a letter: ")
    if len(guess) > 1:
        print("Type a single letter.")
        continue 
    for char in guess:
        if char in word:
            i = word.find(char) 
            blank = blank[:i] + char + blank[i+1:]
            word = word[:i] + "-" + word[i+1:]
            count -= 1
            print(blank)
            print(f"Correct! You have {count} tries left.")
        else:
            count -= 1
            print(f"Wrong. You have {count} tries left.")

if count != 0:
    print("You win!")
else:
    print("You lose.")

THE PROBLEM

All of the code executed properly except for the lines that replace the dashes in blank with the properly guessed characters from word.

When played, the game printed a correct guess as a single character like this: e. If the second guess was an h the game would print eh instead of he.

THE SOLUTION

The key thing to remember for this problem is that strings in Python are immutable. To replace or add characters to a string, Python needs to create a copy of the string and replace characters in that copy.

The following three lines of code provide this function.

i = word.find(char) 
blank = blank[:i] + char + blank[i+1:]
word = word[:i] + "-" + word[i+1:]

The first line gets the index value for the guessed character.

Using this value, the second line slices the dashes in blank by selecting all the index values before the guessed character with blank[:i]. It then concatenates this first slice with the guessed character and the ending slice. blank[i+1:] is the final slice. It selects all of the remaining index values after the guessed character.

Now if you guess e the game prints: -e---.

Problem solved? Not quite.

The word "hello" has two "l's". Everything works as expected for the first "l". The game prints: -el--. However, when a second "l" is guessed, the game stops at the first "l" and continues to print: -el--.

The third line of the code above solves this. It functions similarly to the previous line except it operates on word instead of blank. Essentially this makes the two variables exchange their values as characters are guessed.

If l is guessed the values of blank and word will look like this:

blank = "--l--"
word = "he-lo"

Now when the second l is guessed, word only contains one l. The game functions as it should. The values of blank and word will look like this:

blank = "--ll-"
word = "he--o"

ADDING A CHARACTER

To add a character in a specific position instead of replacing it, remove the +1 from i in the final slice. For example, if e is guessed the following line of code:

word = word[:i] + "-" + word[i:]

will print:

"h-ello"

Thanks for reading!