To write a binary file in Python:

• Use the bytearray() function to convert the list of bytes to a bytearray type object.
• Use a with clause with open() the method in write binary mode(wb)
• Use write() method to write the byte_array to the file.

byte_list = [100, 56, 35, 94]
byte_array = bytearray(byte_list)

try:
    with open("bytes_array.txt", 'wb') as f:
        f.write(byte_array)
        print(str(byte_array) + " successfully stored in a file...")
except Exception as e:
    print(e)

bytearray(b'd8#^') successfully stored in a file...

We created a byte_list using a sequence of values from 0 to 255 in binary form.

The bytearray() function is a built-in function in Python that takes an iterable to convert it into an array of bytes.It is an object constructor for a mutable array of bytes, like a list, but unordered. From an iterable of integers, it only accepts values in the range(256), or the function throws a ValueError: byte must be in range(0, 256).

We used the bytearray() function to convert the byte_list to the byte_array. To successfully write the byte_array to the file, we used Python’s try-except control flow statement. It handles errors and exceptions without disrupting the flow of the program.

We used the with keyword to wrap the code block of writing the byte_array to the bytes_array.txt file. Next, we used the open() function to open a file for reading, or writing is a built-in function in Python. It took two arguments: the filename and the mode.

The mode is an optional argument. It defaults to r (read) if it’s not specified. We specified the mode as wb to create or truncate the existing file named bytes_array.txt as binary. The write() function wrote the byte_array to the bytes_array.txt file.

Use bytes() Function

To write a binary file in Python:

• Use the bytes() function to convert the list of bytes to a bytes type object.
• Use a with clause with open() the method in write binary mode(wb)
• Use write() method to write the byte_array to the file.

byte_list = [100, 56, 35, 94]
byte_array = bytes(byte_list)

try:
    with open("bytes_array.txt", 'wb') as f:
        f.write(byte_array)
        print(str(byte_array) + " successfully stored in a file...")
except Exception as e:
    print(e)

b'd8#^' successfully stored in a file...

We have already discussed the creation of the byte_list, try-except clause, with keyword, and open() and write() functions while explaining the code snippet using the bytearray() function.

In this section, we used the bytes() function, similar to the bytearray() function but returned an immutable sequence of bytes type. We used this function to convert a byte_list to a byte_array. Once we got the byte_array, we used the write() function to write the byte_array to the bytes_array.txt file.

Use struct.pack() Function

To write a binary file in Python:

• Use the struct.pack() function to convert the list of bytes to a bytes type object.
• Use a with clause with open() the method in write binary mode(wb)
• Use write() method to write the byte_array to the file.

import struct
byte_list = [100, 56, 35, 94]
byte_array = struct.pack('4B', *byte_list)
try:
    with open("bytes_array.txt", 'wb') as f:
        f.write(byte_array)
        print(str(byte_array) + " successfully stored in a file...")
except Exception as e:
    print(e)

b'd8#^' successfully stored in a file...

After successfully creating the byte_list, we imported the struct library.

Python’s struct module is a collection of functions that are used with binary data to perform operations such as packing, unpacking, and analyzing the contents of structs like C-structure formats. We imported it to process the byte_list.

The library provides the struct.pack() function that converts regular Python data types into packed binary data. It holds two arguments, as listed below.

• fmt – specifies the format in which the objects are to be packed.
• vals – contains any number of parameters needed to create the binary representation required for each element specified in the fmt parameter.

We used the 4B format to convert the byte_list into packed byte_array of the bytes data type. We used try-except blocks to handle the errors properly. Finally, we used the open() and write() functions to open the file and write the array to the byte_array.txt file.

Use encode() Function with join()

To write a binary file in Python:

• Use the join() function to combine list elements as char.
• Use the encode() function to convert the string of bytes to a bytes type object.
• Use a with clause with open() the method in write binary mode(wb)
• Use write() method to write the byte_array to the file.

byte_list = [100, 56, 35, 94]
byte_array = ''.join(chr(byte) for byte in byte_list).encode('charmap')
try:
    with open("bytes_array.txt", 'wb') as f:
        f.write(byte_array)
        print(str(byte_array) + " successfully stored in a file...")
except Exception as e:
    print(e)

b'd8#^' successfully stored in a file...

The join() function in Python is a built-in method that combines multiple strings into one string. It takes an iterable object as an argument and returns a single string formed from the elements of the iterable object separated by a separator character(s). We used the join() function to join the elements of byte_list as char.

The encode() function represents data in an alternative form. It converts information from one format to another, such as text to binary or vice versa. The purpose of encoding is to make the data more secure and easier to access and store.

We applied the encode() function on byte_array to convert it into a bytes type object and then wrote the array to the file using the open() and write() functions wrapped under the with statement.

Use to_bytes() Function

To write a binary file in Python:

• Use with keyword with the open() function to open the file.
• Use the for loop to iterate every element in the list of bytes.
• Use the to_bytes() function on every element to convert it to a byte.
• Use the write() function to write the byte to the file.

byte_list = [100, 56, 35, 94]
try:
    with open("bytes_array.txt", 'wb') as f:
        for byte in byte_list:
            f.write(byte.to_bytes(1, byteorder='big'))
        print("Successfully stored in a file...")
except Exception as e:
    print(e)

Successfully stored in a file...

We created the byte_list of integers in the range(0-255). Then, after opening the file using the open() function, we used the for loop to iterate every element of byte_list.

Python’s to_bytes() function provides a convenient way to convert various built-in data types, such as integers, into an equivalent representation in bytes of specified size. It enables the user to easily store or manipulate data represented as a sequence of bytes. The function holds arguments:

• The length to ensure that the result has enough bytes to represent the number without data loss.
• The byteorder specifies an endian encoding that represents the integer.

We applied the to_bytes() function over every element of byte_list and wrote the returned byte to the file.

To remove empty lines from a Text File in Python:

• Open a file in read and write mode(r+).
• Use for loop for iterate over each line in the file.
• Use isspace() method to check if line is empty. if it is not empty, add it to result.
• Use seek(0) to move cursor to the start of the file.
• Use write() method to write the result to the file.

result = ""
with open("./test.txt", "r+") as file:
    for line in file:
        if not line.isspace():
            result += line

    file.seek(0)  
    file.write(result)

Code assumes that you have test.txt in current directory with following content.

It's line one.
It's line two.

It's line three.

It's line four.

It's line five.
It's line six.

When you execute above program, you will get following result:

It's line one.
It's line two.
It's line three.
It's line four.
It's line five.
It's line six.

We created a string type variable result and initialize it with an empty string.

Next, the with statement is used to open the test.txt file in read and write mode (r+). The r+ mode is used to open a file to read and write and will produce an I/O error if the specified text file is not found.

Then, a for loop is used to iterate over each line of the test.txt file.

On each iteration, check if the current line is empty or not using the isspace() method.

The isspace() returns True if the current line has all whitespaces; otherwise False.

We used the seek() function to change the current file position to 0 because we wanted to overwrite the file with the data without empty lines.

Finally, the write() function is used to write into the file.

Another way of achieving the same results is to use join(), which joins all non-empty lines as follows.

result = ""
with open("./test.txt", "r+") as file:
    result += "".join(line for line in file
                 if not line.isspace())
    file.seek(0) 
    file.write(result)

It's line one.
It's line two.
It's line three.
It's line four.
It's line five.
It's line six.

If we don’t want to replace the data in the original file (test.txt) then we can create another file (new_test.txt) using another with statement.

Here, the w mode overwrites the existing file (if any) and creates a new file to write if it is not already there.

result = ""
with open("./test.txt", "r") as file:
    for line in file:
        if not line.isspace():
            result += line

with open("./new_test.txt", "w") as file:
    file.write(result)

It's line one.
It's line two.
It's line three.
It's line four.
It's line five.
It's line six.

The above output will be saved in the new_test.txt file, the test.txt will remain unchanged. You can learn about different modes to read and write text files here.

Use strip() Method

The following code is similar to the above code examples except for one difference, here, we are using the strip() function which is used to remove trailing and leading whitespaces from the string.

To identify an empty line, we find the length of the line.strip() using the len() function and continue execution if it is 0; otherwise concatenate the line with result.

Finally, change the current file position to 0 to overwrite the file while the write() is used to write data to the file.

result = ""

with open("./test.txt","r+") as file:
    for line in file.readlines():
        if (len(line.strip()) == 0):
            continue
        if line:
            result += line  

    file.seek(0)
    file.write(result)

It's line one.
It's line two.
It's line three.
It's line four.
It's line five.
It's line six.

Till this point, we used the open() function to open a .txt file. What if we want to open multiple text files, remove empty lines and save the data without empty lines in a new text file?

For that, we will be using multiple open() functions as follows which will reduce the readability.

with open("./test1.txt","r+") as file1, open("./test2.txt","r+") as file2

To maintain code readability, we can use the fileinput module.

Use the FileInput() Method

Here, we import the fileinput module to use its FileInput() method. We can use it as the context manager in the with statement. The FileInput() takes the following three parameters:

• files – It denotes a tuple of multiple text files that we want to read.
• inplace – It is set to True then the file content will be moved to the backup file. If we don’t want to lose data from the .txt files then, it must be False.
• backup – This parameter is given to specify the extension of the backup file.

After that, we use the for loop to iterate over the data of both files, remove empty lines and concatenate non-empty lines with the result variable.

The important point is that we add a new line when the pointer starts reading the second file, otherwise, the last line of the test1.txt file and the first line of the test2.txt file would be on the same line. Don’t be confused, we will test both scenarios below using code examples.

import fileinput

result=""

with fileinput.FileInput(
               files=("./test1.txt", "./test2.txt"),
               inplace = False, backup ='.bak')
               as file:

    for line in file:
        if (len(line.strip()) == 0):
                continue
        if line:
            result += line

with open("./two_files_data.txt", "w") as file:
     file.write(result)

It's line one.
It's line two.
It's line three.
It's line four.
It's line five.
It's line six.It's line seven.
It's line eight.
It's line nine.
It's line ten.

See, we have It's line six from test1.txt and It's line seven from test2.txt on the same line. To get rid of this, we will use the if condition to add a new line character if we are on the first line of the test2.txt file.

import fileinput

result=""

with fileinput.FileInput(
              files=("./test1.txt", "./test2.txt"),
              inplace = False, backup ='.bak')
              as file:

    for line in file:
        if (len(line.strip()) == 0):
                continue
        if line:
            if (file.filename() == "./test2.txt"
                and file.filelineno() == 1):
                result += '\n'
            result += line

with open("./two_files_data.txt", "w") as file:
     file.write(result)

It's line one.
It's line two.
It's line three.
It's line four.
It's line five.
It's line six.
It's line seven.
It's line eight.
It's line nine.
It's line ten.

That’s all about how to remove empty lines from text file in Python.

How to Create Temp File in Python

This tutorial will demonstrate how to create temp file in Python.

Using the tempfile.NamedTemporaryFile object

The NamedTemporaryFile constructor is used to create objects that resemble a file-like object in the temporary storage area and can be used to read and write data. The file is created securely using some predefined rules and is destroyed as soon as it is closed. The file has a certain name in the system that can be retrieved with the name attribute.

We can open the file in the required mode using the mode parameter. Other parameters are also available like encoding, prefix, newline, and more.

The default value of the mode parameter is w+b which means we can read and write using the same object without closing it.

See the code below.

import tempfile
with tempfile.NamedTemporaryFile() as f:
    name = f.name
    f.write(b'Java2Blog') 
    f.seek(0) 
    data = f.read() 
    print(f"Directory: {name} Content: {data}")

Output:

In the above example, we create Temp file in Python and write data to the same. The name attribute is used to access the directory and name of the temporary file. The write() function is used to write data to this file.

Then we seek the file pointer to the starting position using the seek() method, read the data using the read() function, and display the same. Since we are using the with statement there is no need to use the close() function to destroy the object.

Using the tempfile.TemporaryFile object

The TemporaryFile object works similarly to the NamedTemporaryFile object but it does not explicitly return a file name. However, for platforms that nor PSOIX neither Cygwin, this is an alias for NamedTemporaryFile object.

We use it similarly to the previous function.

import tempfile
with tempfile.TemporaryFile() as f:
    f.write(b'Java2Blog') 
    f.seek(0) 
    data = f.read() 
    print(f"Content: {data}")

Output:

Using the mkstemp() function

This function works similarly to the previous methods to create temp file in Python. It returns a tuple with the file object and the file name.

However, it does not provide functions to read or write data but we can use the methods from the os library. Also unlike the previous methods, we need to destroy the file explicitly after creating it.

See the code below.

import os
import tempfile
f, name = tempfile.mkstemp()
print(name)
os.write(f, b"Java2Blog")
os.close(f)

Output:

Conclusion

To conclude this article, we discussed several methods to create temp file in Python. For this, we used the tempfile library that allows us to create temporary files and directories. T

TemporaryFile and NamedTemporaryFile objects work very similarly in allowing us to create file-like objects that create such temporary files and we can read-write data accordingly. The difference between the two lies in the fact that the latter returns an explicit name of the file that can be accessed using the name attribute.

We can also use the mkstemp() function that works similarly to these methods but we need to explicitly close and clean the temporary files.

In this tutorial, we will discuss how to get temp directory in Python.

Get Temp Directory in Python

The tempfile module is used in Python to work with and create temporary files and directories. We will discuss different methods from this module to get temp directory in Python.

Using the tempfile.Gettempdir() Function to Get Temp Directory in Python

The gettempdir() function from the tempfile module is used to return the default temporary directory that is used by the user for working with temporary files. It follows a set of precedents to determine the temporary directory.

This directory can be interpreted from the environment variables. Usually, it is the directory named TMP, TEMP, or TMPDIR by the environment variable.

If the directory cannot be interpreted from the same then it may return the platform-specific directory. This can be like C:\TMP, C:\TEMP in the windows or like tmp, usr/tmp on other platforms.

If still the temporary directory is not determined, then the function will return the current working directory as the same.

For example,

import tempfile
path = tempfile.gettempdir()
print(path)

Output:

The above example shows how to get temp directory in Python using the gettempdir() method. In case, you need to create temp file, you can follow how to create temp file in Python.

In Python 3.1 and above, the result is returned as a string. To get the value in bytes we can use the function discussed below.

Using the tempfile.Gettempdirb() Function to Get Temp Directory in Python

The gettempdirb() function from the tempfile module returns the temporary directory as bytes. That is the only distinction between the gettempdir() and gettempdirb() functions.

This can be useful in Python 3 which changed the encoding and introduced a distinction between strings and bytes.

For example,

import tempfile
path = tempfile.gettempdirb()
print(path)

Output:

The b prefix in the above example indicates that the final result is in the form of bytes.

Using the tempfile.Tempdir Variable to Get Temp Directory in Python

An important thing to remember is that both the above-mentioned methods use a pre-defined global variable to return the temp directory. This variable is called tempfile.tempdir. It is not recommended to set this variable manually and it is also not advised to set its value as bytes as it will alter the return type of functions like mkdtemp and mkstemp that create further temp directories and files.

We can view this variable directly as well after calling any of the above two functions.

For example,

import tempfile
path = tempfile.tempdir
print(path)

Output:

Conclusion

To conclude, we discussed several methods of the tempfile module to get temp directory in Python. First, we discussed the use of the tempfile module. Then, we demonstrated the use of the gettempdir() and gettempdirb() functions to get temp directory in Python in different formats. We discussed the precedence of rules to determine the same and how they both use the global variable tempdir to return the value.

How to Remove Extension From Filename in Python?

To Remove Extension From Filename in python, we can use the functions provided in the os module or the pathlib module. Let us discuss them one by one.  

Remove Extension From Filename in Python Using the os Module

Given a file name, we can remove the file extension using the os.path.splitext() function. The splitext() function takes the file name as its input argument and returns a tuple containing the file name as its first element and the file extension as its second argument. 

To remove the file extension, we can assign the first element of the tuple returned by the splitext() function to the variable containing the original filename as follows.

import os

filename = 'Demo.csv'
print("The original filename:", filename)
tempTuple = os.path.splitext(filename)
print("The tuple is:", tempTuple)
filename = tempTuple[0]
print("The output filename:", filename)

Output:

The original filename: Demo.csv
The tuple is: ('Demo', '.csv')
The output filename: Demo

Instead of the filename, when we pass the entire file path to the splitext() function, it returns the entire file path as the first element of the tuple as shown below. 

import os

filename = '/home/aditya1117/PycharmProjects/pythonProject/Demo.csv'
print("The original filename:", filename)
tempTuple = os.path.splitext(filename)
print("The tuple is:", tempTuple)
filename = tempTuple[0]
print("The output filename:", filename)

Output:

The original filename: /home/aditya1117/PycharmProjects/pythonProject/Demo.csv
The tuple is: ('/home/aditya1117/PycharmProjects/pythonProject/Demo', '.csv')
The output filename: /home/aditya1117/PycharmProjects/pythonProject/Demo

To remove the file type and get only the file name in such cases, we will first use the os.path.basename() to get the file name. The os.path.basename() function takes the string containing the file name as its input argument and returns the name of the file as shown below.

import os

filename = '/home/aditya1117/PycharmProjects/pythonProject/Demo.csv'
print("The original filename:", filename)
filename = os.path.basename(filename)
print("The output filename:", filename)

Output:

The original filename: /home/aditya1117/PycharmProjects/pythonProject/Demo.csv
The output filename: Demo.csv

After obtaining the filename, you can use the os.path.splitext() function to remove the file extension or file type from the filename in python as follows.

import os

filename = '/home/aditya1117/PycharmProjects/pythonProject/Demo.csv'
print("The original filename:", filename)
filename = os.path.basename(filename)
print("The modified filename:", filename)
tempTuple = os.path.splitext(filename)
print("The tuple is:", tempTuple)
filename = tempTuple[0]
print("The output filename:", filename)

Output:

The original filename: /home/aditya1117/PycharmProjects/pythonProject/Demo.csv
The modified filename: Demo.csv
The tuple is: ('Demo', '.csv')
The output filename: Demo

The os.path.splitext() method works only when the input file name has only one file extension as in ‘abc.txt’, ‘abc.pdf’, or ‘x/y/z/abc.txt’. If the file name or path has more than one extension as in ‘abc.tar.gz’, The os.path.splitext() method can only be used to remove the last extension of the file. You can observe this in the following example.

import os

filename = 'Demo.tar.gz'
print("The original filename:", filename)
tempTuple = os.path.splitext(filename)
print("The tuple is:", tempTuple)
filename = tempTuple[0]
print("The output filename:", filename)

Output:

The original filename: Demo.tar.gz
The tuple is: ('Demo.tar', '.gz')
The output filename: Demo.tar

In the output, you can observe that the splitext() method is only splitting the Demo.tar.gz into Demo.tar and ‘gz’. To remove the file extension of these types of file names, we can use an iterative method, which we have discussed in the coming sections. 

Remove Extension From Filename in Python using the pathlib module

To remove the file extension from a filename using the pathlib module, we will first create a path object using the Path() method. The Path() method takes a string containing the filename as an input argument and returns a POSIX path object in UNIX-based machines or ntpath object in Windows machines. After obtaining the path object, we can remove the file extension using the stem attribute of the path object as follows.

import pathlib

filename = pathlib.Path('Demo.csv')
print("The original filename:", filename)
filename = filename.stem
print("The output filename:", filename)

Output:

The original filename: Demo.csv
The output filename: Demo

In this approach, even if we pass the full path of the file instead of the filename, we get only the filename. You can observe this in the following example.

import pathlib

filename = pathlib.Path('/home/aditya1117/PycharmProjects/pythonProject/Demo.csv')
print("The original filename:", filename)
filename = filename.stem
print("The output filename:", filename)

Output:

The original filename: /home/aditya1117/PycharmProjects/pythonProject/Demo.csv
The output filename: Demo

Again, this approach works only when the input file name has only one file extension as in ‘abc.txt’, ‘abc.pdf’, or ‘x/y/z/abc.txt’. If the file name or path has more than one extension as in ‘abc.tar.gz’, The stem attribute can only be used to remove the last extension of the file. You can observe this in the following example.

import pathlib

filename = pathlib.Path('Demo.tar.gz')
print("The original filename:", filename)
filename = filename.stem
print("The output filename:", filename)

Output:

The original filename: Demo.tar.gz
The output filename: Demo.tar

In the output, you can observe that the stem attribute only returns Demo.tar instead of Demo, which is the actual filename. To remove the file extension of these types of file names, we can use an iterative method using the suffixes attribute as discussed below.

Remove Multiple File Extensions Using pathlib Module in Python

After creating the path object using the Path() function, we can access all the extensions of the file using the suffixes attribute as follows.

import pathlib

filename = pathlib.Path('Demo.tar.gz')
print("The original filename:", filename)
extensions=filename.suffixes
print("The file extensions are:",extensions)

Output:

The original filename: Demo.tar.gz
The file extensions are: ['.tar', '.gz']

Now that we have the total number of extensions in the file name, we can use a for loop to remove all the extensions from the file as follows.

import pathlib

filename = pathlib.Path('Demo.tar.gz')
print("The original filename:", filename)
extensions = filename.suffixes
print("The file extensions are:", extensions)
for extension in extensions:
    filename = filename.stem
    filename = pathlib.Path(filename)
print("The output filename is:", filename)

Output:

The original filename: Demo.tar.gz
The file extensions are: ['.tar', '.gz']
The output filename is: Demo

In the for loop, we need to convert the filename to a path object each time after extracting the filename using the stem attribute. Otherwise, the program will run into an error. This is due to the reason that the stem attribute contains the filename as a string. We cannot use the stem attribute on a string. Therefore, we need to convert the string into a path object using the Path() method, each time we obtain the filename in the for loop.

Conclusion

In this article, we have discussed different approaches to remove file extension or file type in python. I would suggest you use the approaches with the pathlib module as the pathlib module makes it easy to handle the file path.

I hope you enjoyed reading this article. Stay tuned for more informative articles.

Happy Learning

How to Get directory name from file path in python?

Python provides us with the os module to perform file operations. Additionally, we can also use the pathlib module to get the directory from the file path in python. Let us discuss programs to get directory from file path using both the modules in python.

Get Directory Name From File Path Using the os Module in Python

The os.path module provides us with the dirname() method and the split() method with which we can get the directory from the file name in python. Let us discuss both methods one by one.

Get Directory Name From File Path Using the os.path.dirname() Function

The os.path.dirname() function takes a file path as its input argument and returns a string containing the directory. For instance, if you will provide the file path of a file, the dirname() function will return the directory containing the file as shown below.

import os

filepath = '/home/aditya1117/PycharmProjects/pythonProject/Demo.csv'
print("The file path is:")
print(filepath)
directoryName = os.path.dirname(filepath)
print("The directory is:")
print(directoryName)

Output:

The file path is:
/home/aditya1117/PycharmProjects/pythonProject/Demo.csv
The directory is:
/home/aditya1117/PycharmProjects/pythonProject

Similarly, if we pass the file path of a directory, the dirname() function will return the path of the directory containing the current directory. You can observe this in the following example.

import os

filepath = '/home/aditya1117/PycharmProjects/pythonProject'
print("The file path is:")
print(filepath)
directoryName = os.path.dirname(filepath)
print("The directory is:")
print(directoryName)

Output:

The file path is:
/home/aditya1117/PycharmProjects/pythonProject
The directory is:
/home/aditya1117/PycharmProjects

Get Directory Name From File Path Using the os.path.split() Function

We can also get the directory from the file path using the os.path.split() function. The split() function takes the file name as its input argument and returns a tuple containing two strings. The first string contains the file path of the parent directory of the current file or directory. The second element of the tuple contains the name of the current directory or file. 

If given the file path of a file, we can get the directory using the split() function from the first element of the tuple returned by the split() function as follows.

import os

filepath = '/home/aditya1117/PycharmProjects/pythonProject/Demo.csv'
print("The file path is:")
print(filepath)
nameTuple = os.path.split(filepath)
print("The tuple is:")
print(nameTuple)
directoryName = nameTuple[0]
print("The directory is:")
print(directoryName)

Output:

The file path is:
/home/aditya1117/PycharmProjects/pythonProject/Demo.csv
The tuple is:
('/home/aditya1117/PycharmProjects/pythonProject', 'Demo.csv')
The directory is:
/home/aditya1117/PycharmProjects/pythonProject

If we pass the file path of a directory to the split() function, we can get the name of the parent directory as follows.

import os

filepath = '/home/aditya1117/PycharmProjects/pythonProject'
print("The file path is:")
print(filepath)
nameTuple = os.path.split(filepath)
print("The tuple is:")
print(nameTuple)
directoryName = nameTuple[0]
print("The directory is:")
print(directoryName)

Output:

The file path is:
/home/aditya1117/PycharmProjects/pythonProject
The tuple is:
('/home/aditya1117/PycharmProjects', 'pythonProject')
The directory is:
/home/aditya1117/PycharmProjects

Get Directory Name From File Path Using the pathlib Module

Instead of using the os module, we can also use the pathlib module to get the directory from the file path in python. For this, we can use the Path() function. The Path() function takes the file path as its input argument and returns a POSIX path object in UNIX or ntpath object in NTFS (windows). 

To get the directory from the path object, we can use the parent attribute of the path object. The parent attribute of the path object contains the file path of the current directory. We can convert the POSIX or ntpath object containing the directory path in the parent attribute to a simple directory path using the str() method. In this way, we can get the directory from the file path using the pathlib module as follows.

import pathlib

filepath = '/home/aditya1117/PycharmProjects/pythonProject/Demo.csv'
print("The file path is:")
print(filepath)
pathObject = pathlib.Path(filepath)
directoryName = pathObject.parent
print("The directory is:")
print(directoryName)

Output:

The file path is:
/home/aditya1117/PycharmProjects/pythonProject/Demo.csv
The directory is:
/home/aditya1117/PycharmProjects/pythonProject

Similarly, we can get the parent directory of a directory using the pathlib module as follows.

import pathlib

filepath = '/home/aditya1117/PycharmProjects/pythonProject'
print("The file path is:")
print(filepath)
pathObject = pathlib.Path(filepath)
directoryName = pathObject.parent
print("The directory is:")
print(directoryName)

Output:

The file path is:
/home/aditya1117/PycharmProjects/pythonProject
The directory is:
/home/aditya1117/PycharmProjects

Remove FilnName from File Path

There are multiple ways to remove Filename from file path. Let’s go through them.

Remove Filename From the File Path Using the OS Module in Python

To remove the filename from the file path, we can use the os module and the pathlib module. 

To remove the filename from a file path using the os module, we will first get the directory from the file path using the os.path.dirnname() function. Then, we will assign the directory to the file path. In this way, we can remove the filename from the file path as shown below.

import os

filepath = '/home/aditya1117/PycharmProjects/pythonProject/Demo.csv'
print("The file path is:")
print(filepath)
filepath = os.path.dirname(filepath)
print("The new file path is:")
print(filepath)

Output:

The file path is:
/home/aditya1117/PycharmProjects/pythonProject/Demo.csv
The new file path is:
/home/aditya1117/PycharmProjects/pythonProject

In a similar manner, we can remove the filename from a file path using the os.path.split() function. Here, we will assign the first element of the tuple given as output by the split function i.e. the directory name to the variable containing the file path. In this way, we can remove the filename from the file path using the os.path.split() function as shown below.

import os

filepath = '/home/aditya1117/PycharmProjects/pythonProject/Demo.csv'
print("The file path is:")
print(filepath)
nameTuple = os.path.split(filepath)
print("The tuple is:")
print(nameTuple)
filepath = nameTuple[0]
print("The new file path is:")
print(filepath)

Output:

The file path is:
/home/aditya1117/PycharmProjects/pythonProject/Demo.csv
The tuple is:
('/home/aditya1117/PycharmProjects/pythonProject', 'Demo.csv')
The new file path is:
/home/aditya1117/PycharmProjects/pythonProject

Remove Filename From File Path Using the Pathlib Module in Python

To remove the filename from the file path using the pathlib module, we will first get the name of the parent directory using the parent attribute of the file path object returned by the Path() object. as discussed in the previous section. After that, we will assign the directory to the variable containing the original file path. In this way, we can remove the filename from the file path using the pathlib module as follows.

import pathlib

filepath = '/home/aditya1117/PycharmProjects/pythonProject/Demo.csv'
print("The file path is:")
print(filepath)
pathObject = pathlib.Path(filepath)
filepath = pathObject.parent
print("The new file path is:")
print(filepath)

Output:

The file path is:
/home/aditya1117/PycharmProjects/pythonProject/Demo.csv
The new file path is:
/home/aditya1117/PycharmProjects/pythonProject

Conclusion

In this article, we have discussed how to get the directory name from the file path in python using different approaches. We also saw how we can filename from the file path in python. All of the approaches are semantically similar and have almost the same time complexity. So, you can use any of the approaches to get the work done. 

I hope you enjoyed reading this article. Stay tuned for more informative articles. 

Happy Learning!