How to List the Contents of a Directory in Python?

One method for utilizing operating system-dependent usefulness in Python is to utilize the OS module. It gives you access to a variety of working framework capacities, such as record operations, including making, evacuating, and renaming records or registries, as well as posting registry substance.

The pathlib module, to begin with released in Python 3.4, gives an object-oriented strategy for working with filesystem ways. It offers a straightforward, cross-platform strategy for dealing with ways and record operations.

Listing Directory Contents with OS Module:

The list of names within the registry indicated by the path is returned utilizing the os. listdir() strategy. Here are a few more things to think almost:

Dealing with Non-existent Directories: os. listdir() will throw a FileNotFoundError special case if the provided catalog isn't there. Subsequently, it's wise to approach these circumstances carefully.
Directory Path Handling: Verify that the given directory path points to a valid directory. Os.listdir() will attempt to list the contents of the file even if the path supplied links to a file rather than a directory, which could result in unexpected behaviour.
Sorting the Contents: OS returns the directory's contents in an arbitrary order. listdir() by default. Use the sorted() function if the items need to be sorted alphabetically or according to another criterion.

Code:

 
import os
def list_directory_contents_sorted(path):
    try:
        items = os.listdir(path)
        # Sort the list of items alphabetically
        sorted_items = sorted(items)
        For item in sorted_items:
            print(item)
    except FileNotFoundError:
        print("Directory does not exist:", path)
# Example usage
directory_path_ex_ = '/path/to/your/directory/in/computer'
list_directory_contents_sorted(directory_path_ex_)   

Output:

 
another_file.txt
file1.txt
file2.txt
subdirectory

Explanation:

The OS module is imported.
The directory path is the input for the function list_directory_contents, which we define.
Call os.listdir(path) to obtain a list of the files and folders in the given directory.

Listing Directory Contents with pathlib Module:

An object-oriented interface for filesystem paths is given by the pathlib module, which encourages a number of capacities. Here are a number of more things to think around:

Iterating Over Subdirectories:

To list the substance of subdirectories recursively, you'll utilize the Path.glob() strategy to coordinate records and registries recursively.

Code:

 
from pathlib import Path
def list_the_directory_contents_recursive_ex_(path):
    try:
        directory_ex_ = Path(path)
        for item in directory.glob('**/*'):
            print(item)
    except FileNotFoundError:
        print("Directory does not exist:", path)
# Example usage
directory_path_ex_ = '/path/to/your/directory/in/computer'
list_the_directory_contents_recursive_ex_(directory_path_ex_)   

Output:

 
/path/to/your/directory/file1.txt
/path/to/your/directory/file2.txt
/path/to/your/directory/another_file.txt
/path/to/your/directory/subdirectory
/path/to/your/directory/subdirectory/file3.txt
/path/to/your/directory/subdirectory/another_subdirectory

Filtering Files:

You can use the Path.glob() method with wildcard patterns to filter specific types of files. For example, to list only .txt files:

Code:

 
def list_text_files(path):
    try:
        directory = Path(path)
        for file in directory.glob('*.txt'):
            print(file)
    except FileNotFoundError:
        print("Directory does not exist:", path)
# Example usage
directory_path_ex_ = '/path/to/your/directory/in/computer'
list_text_files(directory_path)   

Output:

 
/path/to/your/directory/file1.txt
/path/to/your/directory/file2.txt
/path/to/your/directory/another_file.txt

Path Properties:

Pathlib provides properties like .name, .stem, and .suffix to access different parts of the path or file name, making it convenient for various file operations.

Code:

 
file_path_ex_ = Path('/path/to/your/directory/jtp.txt')
print(file_path.name)   # prints 'jtp.txt'
print(file_path.stem)   # prints 'jtp'
print(file_path.suffix) # prints '.txt'   

Output:

 
jtp.txt
jtp
.txt

Explanation:

file_path.name: Returns the final component of the path, which in this case is 'jtp.txt'.
file_path.stem: Returns the record title without the postfix, which in this case is 'jtp'.
file_path.suffix: Returns the record expansion, counting the dot, which in this case is '.txt'.

Handling Symbolic Links and Hidden Files:

It is conceivable to come over covered up records or typical joins when posting the substance of a catalog. Depending on your needs, you'll be able choose whether to incorporate or prohibit them:

Code:

 
import os
def list_the_directory_contents_with_the_links_and_hidden_ex_(directory):
    try:
        for item in os.listdir(directory):
            if not item.startswith('.') and not os.path.islink(os.path.join(directory, item)):
                print(item)
    except FileNotFoundError:
        print("Directory does not exist:", directory)
# Example usage
directory_path_ex_ = '/path/to/your/directory/jtpfile1.txt'
list_the_directory_contents_with_the_links_and_hidden_ex_(directory_path_ex_)   

Output:

 
jtpfile1.txt

Filtering Directory Contents:

There are circumstances once you would need to filter the substance of the catalog agreeing to particular benchmarks, counting record measure, alteration date, or extension. Here's how you'll be able make that happen:

1. Filtering Using File Extension:

Using list comprehensions or the filter() method, you can restrict the contents of the directory to only files with a particular extension:

Code:

 
import os
def list_the_files_with_the_extension_ex_(directory, extension):
    try:
        files = [file for file in os.listdir(directory) if file.endswith(extension)]
        for file in files:
            print(file)
    except FileNotFoundError:
        print("Directory does not exist:", directory)
# Example usage
directory_path_ex_ = '/path/to/your/directory/in/computer'
file_extension_ex_ = '.txt'
list_the_files_with_the_extension_ex_(directory_path_ex_, file_extension_ex_)   

Output:

 
file1.txt
file2.txt

2. Filtering by File Size:

You can filter files based on their size using the os.path.getsize() function:

Code:

 
import os
def list_the_files_with_the_size_greater_than_ex_(directory, size):
    try:
        for file in os.listdir(directory_ex_):
            file_path_ex_ = os.path.join(directory, file)
            if os.path.isfile(file_path_ex_) and os.path.getsize(file_path_ex_) > size:
                print(file)
    except FileNotFoundError:
        print("Directory does not exist:", directory_ex_)
# Example usage
directory_path_ex_ = '/path/to/your/directory/in/computer'
minimum_size_ex_ = 1024  # Minimum size in bytes
list_the_files_with_the_size_greater_than(directory_path_ex_, minimum_size_ex_)   

Output:

 
file2.txt
another_file.pdf

Performance Considerations:

Performance issues arise while working with big folders or lots of files. Since it returns an iterator rather than a list, the os.scandir() function performs better than os.listdir():

Code:

 
import os
def list_directory_contents_fast(directory):
    try:
        with os.scandir(directory) as entries:
            for entry in entries:
                print(entry.name)
    except FileNotFoundError:
        print("Directory does not exist:", directory)
# Example usage
directory_path_ex_ = '/path/to/your/directory/in/computer'
list_directory_contents_fast(directory_path_ex_)   

Output:

 
file1.txt
file2.txt
subdirectory
another_file.txt

Conclusion

In conclusion, Python provides flexible ways to list directory contents that can be tailored to different contexts and needs. Developers can explore file systems with ease, retrieve file information, and carry out actions quickly by using modules like `os` and `pathlib}. Python has the necessary facilities to handle symbolic links and hidden files, filter files according to certain standards, and use iterators to maximize speed. Developers may ensure strong and dependable file operations in their Python programs by managing directory contents with confidence when they have a firm grasp of these strategies.

Next TopicHow to read only the first line of a file with python

← prev next →