I was converting some old Python code to use pathlib
instead of os.path
for most path-related operations, but I ended up with the following problem: I needed to add another extension to a path that already had an extension (not replace it). With os.path
, since we are merely manipulating strings, the solution was to add the extension with string operations:
newpath = path + '.res'
It doesn't work with pathlib.Path
because it doesn't allow concatenation of arbitrary characters. The closest I could find was the following:
newpath = path.with_suffix(path.suffix + '.res')
It looks like a workaround because it still uses string addition in the end. And it has a new pitfall because I forgot at first to handle the case where there are already several extensions and you want to add a new one, leading to the following code to get back the old behaviour:
newpath = path.with_suffix(''.join(path.suffixes) + '.res')
Now it doesn't feel terse nor clean since it uses more and more string operations to achieve the old behaviour instead of pure path operations. The fact that Path.suffixes
exists means that the library's developers considered the case where a file can have multiple extensions, yet I couldn't find a way to simply add a new extension to a path. Is there a more idiomatic way that I have missed to achieve the same behaviour?
EDIT: actually path.with_suffix(path.suffix + '.res')
is enough to handle the case where there are already several file extensions, even though it wasn't immeditely obvious to me.
The pathlib is a Python module which provides an object API for working with files and directories. The pathlib is a standard module. Path is the core object to work with files.
parts : returns a tuple that provides access to the path's components. name : the path component without any directory. parent : sequence providing access to the logical ancestors of the path. stem : final path component without its suffix.
pathlib. Path (WindowsPath, PosixPath, etc.) objects are not considered PathLike : PY-30747.
As mentioned at in this answer, shutil in Python 3.6 can take pathlib.
I find the following slightly more satisfying than the answers that have already been given:
new_path = path.parent / (path.name + '.suffix')
It doesn't seem like Path's like being modified in-place (you can't change .parts[-1]
directory or change .suffixes
, etc.), but that doesn't mean you need to resort to anything too unsavory. The following works just fine, even if it's not quite as elegant as I'd like:
new_path = path.with_suffix(path.suffix + new_suffix)
where path
is your original Path variable, and new_suffix
is the string with your new suffix/extension (including the leading ".")
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With