How to Remove Extension from File Name in Python?

In this article, you will learn different ways to remove file extensions in Python to make your code clear, efficient, and adaptable to various scenarios.

In Python, removing the extension from a filename is practical for tasks like organizing or renaming files. For example, if you’re creating a display list of file names, stripping the extension makes the output cleaner and easier to read.

File Name and Extension – A Real-world Analogy

In this picture, we have a text file and an apple. The file name is “MyFile” and it has a tag that says “txt” to show what kind of file it is. The “apple” has a tag that says “Fruit” to show what kind of thing it is. When we only want to say their names, we take off the tags, so we just have “MyFile” and “Apple.” Just like that, when we work with files on a computer, we sometimes remove the type (or extension) like “.txt” so we can only see the name, “MyFile.”

Similarly, in a computer, a file extension is a part at the end of a filename that indicates the type of file. It usually consists of a dot followed by a three characters (can also be 2 or 4 sometimes), such as .txt, .jpg, or .pdf. File extensions help programs identify and handle the type of file correctly. Common extensions include .docx for documents, .png for images, and .mp3 for audio files.

Ways to Get File Name Without Extension in Python

In Python, there are multiple ways to cut off an extension from a file name, just like there are multiple ways to peel an apple. Let’s discuss all possible ways because each method has its own benifits.

Note that in the following codes, we are using the relative path for the filename. That’s why only file name is written instead of the whole path. These methods will work the same for the whole path as well.

Method 1: Use os.path.splitext()

The os.path.splitext() is a built-in method in Python that helps you easily split a file path into the filename and its extension. This method is ideal when you need a quick and reliable way to strip the extension from simple file paths. It works well for most common file types and ensures your code remains easy to read and maintain.

You can also limit or truncate the string (filename) before or after removing the extension.

Example Code

1. The os.path.splitext() function works by analyzing the file_name string. It looks for the last occurrence of a dot (.) in the string.
2. It splits the string into two parts:
   • The first part is everything before the last dot, which is the main filename (name).
   • The second part is everything after the last dot, which is the file extension (e.g., .txt).
3. The function returns these two parts as a tuple. For example, ("example", ".txt").
4. In the code, we assign the first part to name and the second part to _ (a common practice for indicating a variable that won’t be used).
5. This means name now contains only the filename without its extension.
6. Finally, print(name) outputs the value stored in name, which is “example”.

import os
file_name = "example.txt"
name, _ = os.path.splitext(file_name)
print(name)

Output

example

Method 2: Use Path from pathlib

The pathlib approach is well-suited for larger or more complex projects where code readability and maintainability are important. It is also useful when working with cross-platform applications since pathlib handles file paths in a way that abstracts away platform-specific details.

If your filenames contain spaces you can also remove spaces from the string (filename) before or after stripping the extension.

Example Code

1. The Path class from the pathlib module is used to create a Path object from file_name.
2. The .stem attribute of the Path object is then accessed to get the filename without its extension.
3. .stem works by automatically removing the last extension from the filename, so Path("example.txt").stem returns "example".

from pathlib import Path
file_name = "example.txt"
name = Path(file_name).stem
print(name) 

Output

example

Method 3: String rpartition()

The rpartition() method is a straightforward way to split a string by the last occurrence of a dot (“.”). This method separates the filename from its extension and returns only the filename. This method is useful for simple scripts where you need to quickly remove an extension without importing external libraries.

Example Code

1. The rpartition() method splits the string into three parts: the part before the last dot, the dot itself, and the part after the dot.
2. By using [0], we take only the first part, which is the filename without the extension.

file_name = "example.txt"
name = file_name.rpartition('.')[0]
print(name) 

Output

example

Method 4: Use String split() and Join

The split() method, combined with join(), is another way to get rid of the extension from a filename. This approach splits the string by the dot (“.”) character and then joins all the parts except the last one to recreate the filename without the extension. This method is best for quick scripts where you want a simple solution without needing to import additional libraries.

Example Code

1. The split('.') method breaks the file_name string into a list of parts, using the dot as the separator. For "example.txt", this results in ['example', 'txt'].
2. The [:-1] slice removes the last element of the list, which is the extension ('txt').
3. The '.'.join() method then joins the remaining parts of the list back into a string, reconstructing the filename without the extension.
4. The print(name) statement outputs the filename without its extension.

file_name = "example.txt"
name = '.'.join(file_name.split('.')[:-1])
print(name) 

Output

example

Method 5: Regular Expressions (re Module)

Regular expressions (regex) offer powerful and flexible ways to manipulate strings, making them ideal for more complex cases, such as handling filenames with multiple dots or unusual naming conventions. This method is best suited for scenarios where filenames may include multiple dots or more complex structures. Regular expressions provide more control and precision, making them useful for more advanced string handling.

Example Code

1. The re.sub() function is used to search for and replace parts of a string that match a specific pattern.
2. The pattern r'\.[^.]+$' matches the last dot (.) and any characters following it until the end of the string. The [^.] means any character that is not a dot, and + ensures one or more of these characters are matched.
3. The replacement string is an empty string (''), removing the matched extension.
4. The print(name) statement then outputs the filename without its extension.

import re
file_name = "example.txt"
name = re.sub(r'\.[^.]+$', '', file_name)
print(name) 

Output

example

Method 6: Slicing with rfind()

The rfind() method can be used to find the position of the last dot in the filename, allowing you to slice the string up to that position to remove the extension. Lightweight solutions that do not require importing any additional libraries.

Example Code

1. The rfind('.') method searches for the last occurrence of the dot character in the file_name string and returns its index.
2. The slicing operation file_name[:index] extracts the substring from the start up to (but not including) the last dot.
3. If no dot is found, rfind() returns -1, and the entire string is returned without slicing.
4. The print(name) statement outputs the filename without its extension.

file_name = "example.txt"
name = file_name[:file_name.rfind('.')]
print(name) 

Output

example

Comparison of Methods

Below is a table comparing the methods discussed, highlighting their pros, cons, and best use cases:

Handling Files Without Extensions or Hidden Files

For files without extensions or hidden files that start with a dot (e.g., .gitignore), ensure your method can handle these edge cases. Some methods may return an empty string if there is no extension, so adding a check like if '.' in file_name can help avoid issues.

file_name = ".gitignore"
if '.' in file_name:
    name = file_name[:file_name.rfind('.')]
else:
    name = file_name
print(name)  # Output: .gitignore

Manage Filenames with Multiple Extensions

For filenames with multiple extensions (e.g., example.tar.gz), you may want to remove only the last extension or all extensions. Using rpartition() or re.sub() can control this behavior.

To remove only the last extension:

file_name = "example.tar.gz"
name = file_name.rpartition('.')[0]
print(name) 

Output

example.tar

To remove all extensions:

import re
file_name = "example.tar.gz"
name = re.sub(r'\.[^.]+$', '', file_name)
print(name) 

Output

example

Conclusion

Removing file extensions can be done in multiple ways, each with its own benefits. Choose the method that best fits your project’s needs. Just as there are different ways to peel an apple, select the one that works best for your task. Efficient code practices often involve tracking the performance of scripts when removing an extension from a file name. You can learn how to print elapsed time in Python to evaluate how quickly these operations run.

For more articles on such useful scenarios and handling common errors in Python, check out our Python tutorial series by Syntax Scenarios.