Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Teams

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Documentation for os.path.splitext .

Important Note: If the filename has multiple dots, only the extension after the last one is removed. For example:

import os
print(os.path.splitext("/path/to/some/file.txt.zip.asc")[0])
Prints:
/path/to/some/file.txt.zip
See other answers below if you need to handle that case.
                If this is a common enough operation, perhaps it should merit it's own official command? Something like os.path.filename(path_to_file) instead of os.path.splitext(os.path.basename(path_to_file))[0]
– Fnord
                Jul 2, 2014 at 17:13
                For anyone wondering the same as matteok, if there are multiple dots, splitext splits at the last one (so splitext('kitty.jpg.zip') gives ('kitty.jpg', '.zip')).
– Chuck
                Jan 22, 2015 at 18:15
                Note that this code returns the complete file path (without the extension), not just the file name.
– Aran-Fey
                Oct 17, 2018 at 7:13
                yeah, so you'd have to do splitext(basename('/some/path/to/file.txt'))[0] (which i always seem to be doing)
– CpILL
                Nov 4, 2019 at 23:51
                Note that, like os.path solutions, this will only strip one extension (or suffix, as pathlib calls it). Path('a.b.c').stem == 'a.b'
– BallpointBen
                Mar 18, 2020 at 4:26
                @hoan I think repeatedly calling .with_suffix('') is the way to go. You'd probably want to loop until p.suffix == ''.
– BallpointBen
                May 13, 2020 at 15:00
                It will not work for files with complex extensions:  pathlib.Path('backup.tar.gz').stem -> 'backup.tar but expected backup
– pymen
                Jun 15, 2020 at 11:11
Important note: If there is more than one . in the filename, only the last one is removed. For example:
/root/dir/sub/file.ext.zip -> file.ext
/root/dir/sub/file.ext.tar.gz -> file.ext.tar
See below for other answers that address that.
                +1 for this. 3 exact same answers, but this is the most direct one. You just could have used ` for showing the code, and "/somepath/hermanth.txt" as a path instance.
– cregox
                May 21, 2010 at 20:57
                @hemanth.hm Note that in this statement you provided, os.path.basename is not necessary. os.path.basename should be only used to get the file name from the file path.
– arrt_
                Jan 25, 2018 at 12:53
                Why do you resolve() the path? Is it really possible to get a path to a file and not have the filename be a part of the path without that? This means that if you're give a path to symlink, you'll return the filename (without the extension) of the file the symlink points to.
– Boris Verkhovskiy
                Oct 11, 2019 at 15:43
                One possible reason to use resolve() is to help deal with the multiple dots problem.  The answer below about using the index will not work if the path is './foo.tar.gz'
– William Allcock
                Feb 12, 2020 at 22:51
https://docs.python.org/3/library/os.path.html
In python 3 pathlib "The pathlib module offers high-level path objects."
>>> from pathlib import Path
>>> p = Path("/a/b/c.txt")
>>> p.with_suffix('')
WindowsPath('/a/b/c')
>>> p.stem
                This is the best python 3 solution for the generic case of removing the extension from a full path. Using stem also removes the parent path. In case you are expecting a double extension (such as bla.tar.gz) then you can even use it twice: p.with_suffix('').with_suffix('').
– Eelco van Vliet
                Feb 26, 2020 at 12:37
As noted by @IceAdor in a comment to @user2902201's solution, rsplit is the simplest solution robust to multiple periods (by limiting the number of splits to maxsplit of just 1 (from the end of the string)).
Here it is spelt out:
file = 'my.report.txt'
print file.rsplit('.', maxsplit=1)[0]
my.report
                This approach fails if files without extensions are located in directories with dot(s) in the name, e.g. ./readme.
– Wolf
                Feb 22 at 9:21
If you want to keep the path to the file and just remove the extension
>>> file = '/root/dir/sub.exten/file.data.1.2.dat'
>>> print ('.').join(file.split('.')[:-1])
/root/dir/sub.exten/file.data.1.2
                If you want to split on the last period, use rsplit: '/root/dir/sub.exten/file.data.1.2.dat'.rsplit('.', 1)
– IceArdor
                Dec 4, 2014 at 22:32
os.path.splitext() won't work if there are multiple dots in the extension.
For example, images.tar.gz
>>> import os
>>> file_path = '/home/dc/images.tar.gz'
>>> file_name = os.path.basename(file_path)
>>> print os.path.splitext(file_name)[0]
images.tar
You can just find the index of the first dot in the basename and then slice the basename to get just the filename without extension.
>>> import os
>>> file_path = '/home/dc/images.tar.gz'
>>> file_name = os.path.basename(file_path)
>>> index_of_dot = file_name.index('.')
>>> file_name_without_extension = file_name[:index_of_dot]
>>> print file_name_without_extension
images
                index_of_dot =  file_name.index('.') This will be done after getting the basename of the file so that it wont split at .env
– Dheeraj Chakravarthi
                Oct 5, 2016 at 4:22
                Important point, as a series of extensions like this is common. .tar.gz .tar.bz .tar.7z
– user6798019
                Oct 18, 2017 at 12:23
                Note that 'haystack'.index('needle') throws a ValueError exception if the needle (in above case the dot, .) is not found in haystack. Files without any extension exist too.
– Czechnology
                Mar 27, 2018 at 7:54
                to solve that problem, use a try-catch, or use str.find() and check for -1. if there's no dot, then just return file_name
– Starwarswii
                Jun 15, 2021 at 17:52
Answers using Pathlib for Several Scenarios
Using Pathlib, it is trivial to get the filename when there is just one extension (or none), but it can be awkward to handle the general case of multiple extensions.
Zero or One extension
from pathlib import Path
pth = Path('./thefile.tar')
fn = pth.stem
print(fn)      # thefile
# Explanation:
# the `stem` attribute returns only the base filename, stripping
# any leading path if present, and strips the extension after
# the last `.`, if present.
# Further tests
eg_paths = ['thefile',
            'thefile.tar',
            './thefile',
            './thefile.tar',
            '../../thefile.tar',
            '.././thefile.tar',
            'rel/pa.th/to/thefile',
            '/abs/path/to/thefile.tar']
for p in eg_paths:
    print(Path(p).stem)  # prints thefile every time
Two or fewer extensions
from pathlib import Path
pth = Path('./thefile.tar.gz')
fn = pth.with_suffix('').stem
print(fn)      # thefile
# Explanation:
# Using the `.with_suffix('')` trick returns a Path object after
# stripping one extension, and then we can simply use `.stem`.
# Further tests
eg_paths += ['./thefile.tar.gz',
             '/abs/pa.th/to/thefile.tar.gz']
for p in eg_paths:
    print(Path(p).with_suffix('').stem)  # prints thefile every time
Any number of extensions (0, 1, or more)
from pathlib import Path
pth = Path('./thefile.tar.gz.bz.7zip')
fn = pth.name
if len(pth.suffixes) > 0:
    s = pth.suffixes[0]
    fn = fn.rsplit(s)[0]
# or, equivalently
fn = pth.name
for s in pth.suffixes:
    fn = fn.rsplit(s)[0]
    break
# or simply run the full loop
fn = pth.name
for _ in pth.suffixes:
    fn = fn.rsplit('.')[0]
# In any case:
print(fn)     # thefile
# Explanation
# pth.name     -> 'thefile.tar.gz.bz.7zip'
# pth.suffixes -> ['.tar', '.gz', '.bz', '.7zip']
# If there may be more than two extensions, we can test for
# that case with an if statement, or simply attempt the loop
# and break after rsplitting on the first extension instance.
# Alternatively, we may even run the full loop and strip one 
# extension with every pass.
# Further tests
eg_paths += ['./thefile.tar.gz.bz.7zip',
             '/abs/pa.th/to/thefile.tar.gz.bz.7zip']
for p in eg_paths:
    pth = Path(p)
    fn = pth.name
    for s in pth.suffixes:
        fn = fn.rsplit(s)[0]
        break
    print(fn)  # prints thefile every time
Special case in which the first extension is known
For instance, if the extension could be .tar, .tar.gz, .tar.gz.bz, etc; you can simply rsplit the known extension and take the first element:
pth = Path('foo/bar/baz.baz/thefile.tar.gz')
fn = pth.name.rsplit('.tar')[0]
print(fn)      # thefile
import os
filename, file_extension =os.path.splitext(os.path.basename('/d1/d2/example.cs'))
filename is 'example'
file_extension is '.cs'
Thought I would throw in a variation to the use of the os.path.splitext without the need to use array indexing. 
The function always returns a (root, ext) pair so it is safe to use:
root, ext = os.path.splitext(path)
Example:
>>> import os
>>> path = 'my_text_file.txt'
>>> root, ext = os.path.splitext(path)
'my_text_file'
'.txt'
  
But even when I import os, I am not able to call it path.basename. Is it possible to call it as directly as basename?
import os, and then use os.path.basename
importing os doesn't mean you can use os.foo without referring to os.
The other methods don't remove multiple extensions. Some also have problems with filenames that don't have extensions. This snippet deals with both instances and works in both Python 2 and 3. It grabs the basename from the path, splits the value on dots, and returns the first one which is the initial part of the filename.
import os
def get_filename_without_extension(file_path):
    file_basename = os.path.basename(file_path)
    filename_without_extension = file_basename.split('.')[0]
    return filename_without_extension
Here's a set of examples to run:
example_paths = [
    "FileName", 
    "./FileName",
    "../../FileName",
    "FileName.txt", 
    "./FileName.txt.zip.asc",
    "/path/to/some/FileName",
    "/path/to/some/FileName.txt",
    "/path/to/some/FileName.txt.zip.asc"
for example_path in example_paths:
    print(get_filename_without_extension(example_path))
In every case, the value printed is:
FileName
                Except for the added value of handling multiple dots, this method is way more fast than Path('/path/to/file.txt').stem. (1,23μs vs 8.39μs)
– raratiru
                Aug 6, 2019 at 18:02
A multiple extension aware procedure. Works for str and unicode paths. Works in Python 2 and 3.
import os
def file_base_name(file_name):
    if '.' in file_name:
        separator_index = file_name.index('.')
        base_name = file_name[:separator_index]
        return base_name
    else:
        return file_name
def path_base_name(path):
    file_name = os.path.basename(path)
    return file_base_name(file_name)
Behavior:
>>> path_base_name('file')
'file'
>>> path_base_name(u'file')
u'file'
>>> path_base_name('file.txt')
'file'
>>> path_base_name(u'file.txt')
u'file'
>>> path_base_name('file.tar.gz')
'file'
>>> path_base_name('file.a.b.c.d.e.f.g')
'file'
>>> path_base_name('relative/path/file.ext')
'file'
>>> path_base_name('/absolute/path/file.ext')
'file'
>>> path_base_name('Relative\\Windows\\Path\\file.txt')
'file'
>>> path_base_name('C:\\Absolute\\Windows\\Path\\file.txt')
'file'
>>> path_base_name('/path with spaces/file.ext')
'file'
>>> path_base_name('C:\\Windows Path With Spaces\\file.txt')
'file'
>>> path_base_name('some/path/file name with spaces.tar.gz.zip.rar.7z')
'file name with spaces'
This returns the filename without the extension(C:\Users\Public\Videos\Sample Videos\wildlife)
temp = os.path.splitext(filename)[0]  
Now you can get just the filename from the temp with
os.path.basename(temp)   #this returns just the filename (wildlife)
p = r"C:\Users\bilal\Documents\face Recognition python\imgs\northon.jpg"
# Get the filename only from the initial file path.
filename = os.path.basename(p)
# Use splitext() to get filename and extension separately.
(file, ext) = os.path.splitext(filename)
# Print outcome.
print("Filename without extension =", file)
print("Extension =", ext)
So because I do not need drive letter or directory name, I use:
>>> print(os.path.splitext(os.path.basename(s))[0])
akarmi
I've read the answers, and I notice that there are many good solutions.
So, for those who are looking to get either (name or extension), here goes another solution, using the os module, both methods support files with multiple extensions.
import os
def get_file_name(path):
    if not os.path.isdir(path):
        return os.path.splitext(os.path.basename(path))[0].split(".")[0]
def get_file_extension(path):
    extensions = []
    copy_path = path
    while True:
        copy_path, result = os.path.splitext(copy_path)
        if result != '':
            extensions.append(result)
        else:
            break
    extensions.reverse()
    return "".join(extensions)
Note: this solution on windows does not support file names with the "\" character
Using pathlib.Path.stem is the right way to go, but here is an ugly solution that is way more efficient than the pathlib based approach.
You have a filepath whose fields are separated by a forward slash /, slashes cannot be present in filenames, so you split the filepath by /, the last field is the filename.
The extension is always the last element of the list created by splitting the filename by dot ., so if you reverse the filename and split by dot once, the reverse of the second element is the file name without extension.
name = path.split('/')[-1][::-1].split('.', 1)[1][::-1]
Performance:
Python 3.9.10 (tags/v3.9.10:f2f3f53, Jan 17 2022, 15:14:21) [MSC v.1929 64 bit (AMD64)]
Type 'copyright', 'credits' or 'license' for more information
IPython 7.28.0 -- An enhanced Interactive Python. Type '?' for help.
In [1]: from pathlib import Path
In [2]: file = 'D:/ffmpeg/ffmpeg.exe'
In [3]: Path(file).stem
Out[3]: 'ffmpeg'
In [4]: file.split('/')[-1][::-1].split('.', 1)[1][::-1]
Out[4]: 'ffmpeg'
In [5]: %timeit Path(file).stem
6.15 µs ± 433 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
In [6]: %timeit file.split('/')[-1][::-1].split('.', 1)[1][::-1]
671 ns ± 37.8 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [7]:
We could do some simple split / pop magic as seen here (https://stackoverflow.com/a/424006/1250044), to extract the filename (respecting the windows and POSIX differences).
def getFileNameWithoutExtension(path):
  return path.split('\\').pop().split('/').pop().rsplit('.', 1)[0]
getFileNameWithoutExtension('/path/to/file-0.0.1.ext')
# => file-0.0.1
getFileNameWithoutExtension('\\path\\to\\file-0.0.1.ext')
# => file-0.0.1
                @CharlesPlager os.path.splitext() won't work if there are multiple dots in the extension. stackoverflow.com/a/37760212/1250044
– yckart
                Sep 13, 2016 at 15:05
                It works for me:  In [72]: os.path.splitext('one.two.three.ext') Out[72]: ('one.two.three', '.ext')
– Charles Plager
                Sep 13, 2016 at 18:35
For convenience, a simple function wrapping the two methods from os.path :
def filename(path):
  """Return file name without extension from path.
  See https://docs.python.org/3/library/os.path.html
  import os.path
  b = os.path.split(path)[1]  # path, *filename*
  f = os.path.splitext(b)[0]  # *file*, ext
  #print(path, b, f)
  return f
Tested with Python 3.5.
        base=os.path.basename(file)
        splitbase=os.path.splitext(base)
        ext = os.path.splitext(base)[1]
        if(ext):
            list.append(base)
        else:
            newpath = path+"/"+file
            #print path
            getFileName(newpath)
    except:
return list
getFileName("/home/weexcel-java3/Desktop/backup")
print list
I didn't look very hard but I didn't see anyone who used regex for this problem.
I interpreted the question as "given a path, return the basename without the extension."
"path/to/file.json" => "file"
"path/to/my.file.json" => "my.file"
In Python 2.7, where we still live without pathlib...
def get_file_name_prefix(file_path):
    basename = os.path.basename(file_path)
    file_name_prefix_match = re.compile(r"^(?P<file_name_pre fix>.*)\..*$").match(basename)
    if file_name_prefix_match is None:
        return file_name
    else:
        return file_name_prefix_match.group("file_name_prefix")
get_file_name_prefix("path/to/file.json")
get_file_name_prefix("path/to/my.file.json")
>> my.file
get_file_name_prefix("path/to/no_extension")
>> no_extension
Assuming you're already using pathlib and Python 3.9 or newer, here's a simple one-line approach that removes all extensions.
>>> from pathlib import Path
>>> pth = Path("/path/to.some/file.foo.bar.txt")
>>> pth.name.removesuffix("".join(pth.suffixes))
'file'
import pathlib
filename = '/path/to/dir/stem.ext.tar.gz'
pathlib.Path(filename).name[:-len(''.join(pathlib.Path(filename).suffixes))]
# -> 'stem'
or this equivalent?
pathlib.Path(filename).name[:-sum(map(len, pathlib.Path(filename).suffixes))]
>>>print(os.path.splitext(os.path.basename("/path/to/file/varun.txt"))[0])                 varun
Here /path/to/file/varun.txt is the path to file and the output is varun