When you need to get a list of files and directories inside a particular folder, os.listdir is the simplest function to reach for. It returns all entries in the directory as a list of string names. This includes files, directories, and symbolic links.
Here’s the basic usage:
import os
entries = os.listdir('/path/to/some/directory')
print(entries)
Notice that the names you get back are just the basenames, not full paths. If you want to work with the files themselves, you’ll often need to join these names back with the directory path, using os.path.join. This is crucial to avoid errors, especially when you’re working across different operating systems with varying path separators.
directory = '/path/to/some/directory'
entries = os.listdir(directory)
for entry in entries:
full_path = os.path.join(directory, entry)
print(full_path)
One thing to watch out for: os.listdir throws an exception if the path doesn’t exist or if you don’t have permissions to access it. Wrapping your call in a try-except block is a good idea when dealing with user input or unpredictable environments.
try:
entries = os.listdir(directory)
except FileNotFoundError:
print(f"The directory {directory} does not exist.")
except PermissionError:
print(f"Permission denied to access {directory}.")
This function doesn’t filter out hidden files or directories by default. Nor does it tell you whether an entry is a file, directory, or something else. For that, you’ll need to add checks using os.path.isfile, os.path.isdir, or even os.scandir for a more efficient approach, but we’ll get to that later.
If you only want to see files inside a directory (excluding subdirectories), you might pair os.listdir with a filter like this:
files = [f for f in os.listdir(directory) if os.path.isfile(os.path.join(directory, f))] print(files)
Keep in mind that for directories with a large number of entries, os.listdir reads everything into memory at once. For massive directories, this might be inefficient, so consider alternatives like os.scandir or generators if performance becomes an issue.
Also, os.listdir is a synchronous call; it blocks until the listing is complete. If you’re working inside an asynchronous framework or GUI application, you might want to offload this operation to a background thread to avoid freezing the main thread.
Finally, remember that os.listdir does not sort the output. If you want an ordered list, just wrap it with sorted():
entries = sorted(os.listdir(directory)) print(entries)
This can be useful if your application relies on alphabetical order or consistent ordering between runs.
Using os.listdir is straightforward, but it’s only the first step. Once you have the raw list of names, you’ll often want to filter, map, and handle those entries carefully to suit your needs. Next, we’ll cover how to do that effectively.
RingConn Gen 3 Sizing Kit - Size First Before You Buy - Choose from 10 Sizes - Sizes 6 to 15 - Exclusive to Gen 3
$1.50 (as of July 17, 2026 15:16 GMT +00:00 - More infoProduct prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on [relevant Amazon Site(s), as applicable] at the time of purchase will apply to the purchase of this product.)Filtering and handling file lists effectively
When dealing with file lists, it’s important to filter them effectively to suit your application’s needs. You might need to exclude certain files based on their extensions, their names, or even their sizes. A common approach is to use list comprehensions for this purpose, which allows for concise and readable filtering.
For example, if you want to get only Python files from a directory, you can filter the list like this:
python_files = [f for f in os.listdir(directory) if f.endswith('.py')]
print(python_files)
This simple line checks each entry in the directory and includes it in the resulting list only if it ends with the ‘.py’ extension. However, be cautious with this method, as it doesn’t differentiate between files and directories.
If you want to combine multiple filtering criteria, you can use a more complex condition. For instance, if you want both Python files and text files, you could do something like this:
filtered_files = [
f for f in os.listdir(directory)
if f.endswith(('.py', '.txt')) and os.path.isfile(os.path.join(directory, f))
]
print(filtered_files)
This method checks for multiple file extensions and ensures that only files are included in the final list. It’s a good practice to use os.path.isfile to ensure you’re not including directories in your results.
Another useful approach is to use regular expressions for more complex patterns. The re module can help you match filenames based on various criteria. Here’s how you might include files that start with a specific prefix:
import re pattern = re.compile(r'^data_.*.csv$') csv_files = [f for f in os.listdir(directory) if pattern.match(f)] print(csv_files)
In this case, the list comprehension uses a regular expression to filter for files that start with “data_” and end with “.csv”. Regular expressions can become complex, but they provide powerful pattern matching capabilities.
For those who require more advanced file handling, consider using os.scandir. This function not only retrieves directory entries but also provides information about each entry, including whether it’s a file or a directory, without needing additional calls to os.path.isfile or os.path.isdir.
with os.scandir(directory) as entries:
files = [entry.name for entry in entries if entry.is_file() and entry.name.endswith('.py')]
print(files)
This method is more efficient, particularly for large directories, as it retrieves the necessary information in a single pass. It’s also more readable, as it clearly communicates the intent of checking whether an entry is a file.
Lastly, if you need to handle file names that may contain spaces or special characters, consider normalizing these names. You can use the unicodedata module to ensure that file names are handled consistently, which can avoid potential issues when processing or displaying them.
import unicodedata
normalized_files = [unicodedata.normalize('NFC', f) for f in os.listdir(directory)]
print(normalized_files)
By taking these filtering and handling techniques into account, you can create robust file management scripts that cater to your specific requirements, ensuring your applications run smoothly and efficiently.
