1787

How do I get the filename without the extension from a path in Python?

"/path/to/some/file.txt"  →  "file"
Improve this question
0

33 Answers 33

Reset to default
1
2
1931

Python 3.4+

Use pathlib.Path.stem

>>> from pathlib import Path
>>> Path("/path/to/file.txt").stem
'file'
>>> Path("/path/to/file.tar.gz").stem
'file.tar'

Python < 3.4

Use os.path.splitext in combination with os.path.basename:

>>> os.path.splitext(os.path.basename("/path/to/file.txt"))[0]
'file'
>>> os.path.splitext(os.path.basename("/path/to/file.tar.gz"))[0]
'file.tar'
Improve this answer
Sign up to request clarification or add additional context in comments.

15 Comments

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]
What if the filename contains multiple dots?
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')).
Note that this code returns the complete file path (without the extension), not just the file name.
yeah, so you'd have to do splitext(basename('/some/path/to/file.txt'))[0] (which i always seem to be doing)
|
1345

Use .stem from pathlib in Python 3.4+

from pathlib import Path

Path('/root/dir/sub/file.ext').stem

will return

'file'

Note that if your file has multiple extensions .stem will only remove the last extension. For example, Path('file.tar.gz').stem will return 'file.tar'.

Improve this answer

17 Comments

This is the recommended way since python 3.
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'
@hoan I think repeatedly calling .with_suffix('') is the way to go. You'd probably want to loop until p.suffix == ''.
It will not work for files with complex extensions: pathlib.Path('backup.tar.gz').stem -> 'backup.tar but expected backup
@pymen it depends on what you define as "extension". How about Fantastic Mr.Fox.mp4?
|
782

You can make your own with:

>>> import os
>>> base=os.path.basename('/root/dir/sub/file.ext')
>>> base
'file.ext'
>>> os.path.splitext(base)
('file', '.ext')
>>> os.path.splitext(base)[0]
'file'

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.

Improve this answer

1 Comment

See this answer for how to remove multiple extensions: stackoverflow.com/a/75504878/102401
279 
>>> print(os.path.splitext(os.path.basename("/path/to/file/hemanth.txt"))[0])
hemanth
Improve this answer

2 Comments

+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.
@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.
119

In Python 3.4+ you can use the pathlib solution 

from pathlib import Path

print(Path(your_path).resolve().stem)
Improve this answer

2 Comments

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.
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'
98

https://docs.python.org/3/library/os.path.html

In python 3 pathlib "The pathlib module offers high-level path objects." so,

>>> from pathlib import Path

>>> p = Path("/a/b/c.txt")
>>> p.with_suffix('')
WindowsPath('/a/b/c')
>>> p.stem
'c'
Improve this answer

1 Comment

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('').
45

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

Improve this answer

2 Comments

This approach fails if files without extensions are located in directories with dot(s) in the name, e.g. ./readme.
also paths with '..' will be incorrectly handled, which may lead to vulnerability. Like the path "a/b/../c/d" will become "a/b/." instead of "a/c/d".
36

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
Improve this answer

1 Comment

If you want to split on the last period, use rsplit: '/root/dir/sub.exten/file.data.1.2.dat'.rsplit('.', 1)
34

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
Improve this answer

4 Comments

index_of_dot = file_name.index('.') This will be done after getting the basename of the file so that it wont split at .env
Important point, as a series of extensions like this is common. .tar.gz .tar.bz .tar.7z
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.
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
30

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
Improve this answer

1 Comment

For last case, you need to add 1 to rsplit to avoid an edge case where a parent directory name could have .tar in it. like this: fn.rsplit(s,1) Also could simplify to: for p in eg_paths: sfx, *_ = Path(p).suffixes fn, *_ = fn.rsplit(sfx,1) print(fn) # prints thefile every time
26 
import os
filename, file_extension =os.path.splitext(os.path.basename('/d1/d2/example.cs'))

  • filename is 'example'

  • file_extension is '.cs'

'

Improve this answer

1 Comment

this actually answers the OP's question
21

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.

Improve this answer

3 Comments

though if you wanted to call foo directly you could use from os import foo.
you have a very non-standard version of the os module if it has a member called foo.
It's a placeholder name. (e.g. consider path, or walk).
21

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)
>>> root
'my_text_file'
>>> ext
'.txt'
Improve this answer

Comments

14

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
Improve this answer

3 Comments

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)
This doesn't work for filename nvdcve-1.1-2002.json.zip
I split it on fileBasename.split('.json')[0] and it worked
7

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'
Improve this answer

Comments

6 
import os
path = "a/b/c/abc.txt"
print os.path.splitext(os.path.basename(path))[0]
Improve this answer

Comments

6

import os

filename = C:\\Users\\Public\\Videos\\Sample Videos\\wildlife.wmv

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)
Improve this answer

Comments

6

Very very very simpely no other modules !!! 

import os
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)
Improve this answer

Comments

6

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]:

Update

This answer somehow got downvoted.

Anyway I just found a better solution.

I didn't know there is a str.rsplit function when I first posted the answer. Using it I don't need to do two reverses.

Performance:

In [11]: file = 'D:/ffmpeg/ffmpeg.exe'

In [12]: file.split('/')[-1][::-1].split('.', 1)[1][::-1]
Out[12]: 'ffmpeg'

In [13]: file.split('/')[-1].rsplit('.', 1)[0]
Out[13]: 'ffmpeg'

In [14]: %timeit file.split('/')[-1].rsplit('.', 1)[0]
359 ns ± 4.59 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)

In [15]: %timeit file.split('/')[-1][::-1].split('.', 1)[1][::-1]
556 ns ± 3.9 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)
Improve this answer

Comments

4

On Windows system I used drivername prefix as well, like:

>>> s = 'c:\\temp\\akarmi.txt'
>>> print(os.path.splitext(s)[0])
c:\temp\akarmi

So because I do not need drive letter or directory name, I use:

>>> print(os.path.splitext(os.path.basename(s))[0])
akarmi
Improve this answer

Comments

4

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

file_path = Path("/path/to.some/target_name.foo.bar.txt")
name = file_path.name.removesuffix("".join(file_path.suffixes))
print(name)

# Outputs: target_name

This approach also works with hidden dot files (e.g .env). Here's a test suite showing what it covers:

from pathlib import Path

cases = [
    ("target_name", "target_name"),
    ("./target_name", "target_name"),
    ("../../target_name", "target_name"),
    ("alfa/bravo/target_name", "target_name"),
    ("/alfa/bravo/target_name", "target_name"),
    ("/alfa/bravo.charlie/target_name", "target_name"),

    (".target_name", ".target_name"),
    ("./.target_name", ".target_name"),
    ("../../.target_name", ".target_name"),
    ("alfa/bravo/.target_name", ".target_name"),
    ("/alfa/bravo/.target_name", ".target_name"),
    ("/alfa/bravo.charlie/.target_name", ".target_name"),

    ("target_name.txt", "target_name"),
    ("./target_name.txt", "target_name"),
    ("../../target_name.txt", "target_name"),
    ("alfa/bravo/target_name.txt", "target_name"),
    ("/alfa/bravo/target_name.txt", "target_name"),
    ("/alfa/bravo.charlie/target_name.txt", "target_name"),

    (".target_name.txt", ".target_name"),
    ("./.target_name.txt", ".target_name"),
    ("../../.target_name.txt", ".target_name"),
    ("alfa/bravo/.target_name.txt", ".target_name"),
    ("/alfa/bravo/.target_name.txt", ".target_name"),
    ("/alfa/bravo.charlie/.target_name.txt", ".target_name"),

    ("target_name.ext.tar.gz", "target_name"),
    ("./target_name.ext.tar.gz", "target_name"),
    ("../../target_name.ext.tar.gz", "target_name"),
    ("alfa/bravo/target_name.ext.tar.gz", "target_name"),
    ("/alfa/bravo/target_name.ext.tar.gz", "target_name"),
    ("/alfa/bravo.charlie/target_name.ext.tar.gz", "target_name"),

    (".target_name.ext.tar.gz", ".target_name"),
    ("./.target_name.ext.tar.gz", ".target_name"),
    ("../../.target_name.ext.tar.gz", ".target_name"),
    ("alfa/bravo/.target_name.ext.tar.gz", ".target_name"),
    ("/alfa/bravo/.target_name.ext.tar.gz", ".target_name"),
    ("/alfa/bravo.charlie/.target_name.ext.tar.gz", ".target_name"),
]

for case in cases:
    file_path = Path(case[0])
    name = file_path.name.removesuffix("".join(file_path.suffixes))
    print(f"{name == case[1]} | got: {name.ljust(12)} | from: {case[0]}")

Result in:

True | got: target_name  | from: target_name
True | got: target_name  | from: ./target_name
True | got: target_name  | from: ../../target_name
True | got: target_name  | from: alfa/bravo/target_name
True | got: target_name  | from: /alfa/bravo/target_name
True | got: target_name  | from: /alfa/bravo.charlie/target_name
True | got: .target_name | from: .target_name
True | got: .target_name | from: ./.target_name
True | got: .target_name | from: ../../.target_name
True | got: .target_name | from: alfa/bravo/.target_name
True | got: .target_name | from: /alfa/bravo/.target_name
True | got: .target_name | from: /alfa/bravo.charlie/.target_name
True | got: target_name  | from: target_name.txt
True | got: target_name  | from: ./target_name.txt
True | got: target_name  | from: ../../target_name.txt
True | got: target_name  | from: alfa/bravo/target_name.txt
True | got: target_name  | from: /alfa/bravo/target_name.txt
True | got: target_name  | from: /alfa/bravo.charlie/target_name.txt
True | got: .target_name | from: .target_name.txt
True | got: .target_name | from: ./.target_name.txt
True | got: .target_name | from: ../../.target_name.txt
True | got: .target_name | from: alfa/bravo/.target_name.txt
True | got: .target_name | from: /alfa/bravo/.target_name.txt
True | got: .target_name | from: /alfa/bravo.charlie/.target_name.txt
True | got: target_name  | from: target_name.ext.tar.gz
True | got: target_name  | from: ./target_name.ext.tar.gz
True | got: target_name  | from: ../../target_name.ext.tar.gz
True | got: target_name  | from: alfa/bravo/target_name.ext.tar.gz
True | got: target_name  | from: /alfa/bravo/target_name.ext.tar.gz
True | got: target_name  | from: /alfa/bravo.charlie/target_name.ext.tar.gz
True | got: .target_name | from: .target_name.ext.tar.gz
True | got: .target_name | from: ./.target_name.ext.tar.gz
True | got: .target_name | from: ../../.target_name.ext.tar.gz
True | got: .target_name | from: alfa/bravo/.target_name.ext.tar.gz
True | got: .target_name | from: /alfa/bravo/.target_name.ext.tar.gz
True | got: .target_name | from: /alfa/bravo.charlie/.target_name.ext.tar.gz
Improve this answer

1 Comment

Great solution. It addresses removing multiple extensions that other answers leave on. I added a giant test suite to show off all the ways it work.
3

Specifically recommend to you use pathlib

from pathlib import Path

path = Path("/path/to/some/file.txt")
filename_without_extension = path.stem
print(filename_without_extension)

So, you got the return

# Output: file
Improve this answer

Comments

2

the easiest way to resolve this is to 

import ntpath 
print('Base name is ',ntpath.basename('/path/to/the/file/'))

this saves you time and computation cost.

Improve this answer

Comments

2

Improving upon @spinup answer:

fn = pth.name
for s in pth.suffixes:
    fn = fn.rsplit(s)[0]
    break
    
print(fn)      # thefile

This works for filenames without extension also

Improve this answer

Comments

2

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

Improve this answer

Comments

2

Use os.path.basename and removesuffix to remove multiple extensions and directory name, and return just the file basename.

Useful, for example, to remove extension .tar.gz from compressed files, or extension .1.fastq.gz from compressed read 1 fastq files - especially if the base file name contains dots.

import os

base_name = os.path.basename('./foo/bar/baz.bletch.tar.gz').removesuffix('.tar.gz')
# base_name = 'baz.bletch'

sample_name = os.path.basename('/foo/bar/baz.bletch.1.fastq.gz').removesuffix('.1.fastq.gz')
# sample_name = 'baz.bletch'
Improve this answer

Comments

1

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
Improve this answer

3 Comments

os.path.splitext()[0] does the same thing.
@CharlesPlager os.path.splitext() won't work if there are multiple dots in the extension. stackoverflow.com/a/37760212/1250044
It works for me: In [72]: os.path.splitext('one.two.three.ext') Out[72]: ('one.two.three', '.ext')
1

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.

Improve this answer

Comments

1 
import os
list = []
def getFileName( path ):
for file in os.listdir(path):
    #print file
    try:
        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:
        pass
return list

getFileName("/home/weexcel-java3/Desktop/backup")
print list
Improve this answer

Comments

1

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."

e.g.

"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")
>> file

get_file_name_prefix("path/to/my.file.json")
>> my.file

get_file_name_prefix("path/to/no_extension")
>> no_extension
Improve this answer

Comments

1
2

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.