Easily Get All Files in a Directory in Python: A Beginner's Guide

Easily Get All Files in a Directory in Python: A Beginner's Guide

MoeNagy Dev

Understanding File Paths

Absolute vs. Relative Paths

In Python, you can work with both absolute and relative file paths. An absolute path is the complete, unambiguous location of a file or directory, starting from the root of the file system. A relative path, on the other hand, is a path that is relative to the current working directory or a specific location in the file system.

Here's an example of using absolute and relative paths in Python:

# Absolute path
absolute_path = "/Users/username/documents/file.txt"
# Relative path
relative_path = "documents/file.txt"

You can use the os.path.abspath() function to convert a relative path to an absolute path:

import os
relative_path = "documents/file.txt"
absolute_path = os.path.abspath(relative_path)
# Output: /Users/username/documents/file.txt

Navigating the File System with Python

The os and os.path modules in Python provide a set of functions for navigating the file system. Here are some commonly used functions:

  • os.getcwd(): Returns the current working directory.
  • os.chdir(path): Changes the current working directory to the specified path.
  • os.path.join(path1, path2, ...): Joins one or more path components intelligently.
  • os.path.dirname(path): Returns the directory name of the specified path.
  • os.path.basename(path): Returns the base name of the specified path.


import os
# Get the current working directory
current_dir = os.getcwd()
# Change the current working directory
new_dir = os.getcwd()
# Join paths
file_path = os.path.join(new_dir, "file.txt")
# Get the directory and base name
dir_name = os.path.dirname(file_path)
base_name = os.path.basename(file_path)

Getting a List of Files in a Directory

Using the os.listdir() Function

To get a list of files and directories in a specific directory, you can use the os.listdir() function. This function returns a list of all items (files and directories) in the specified directory.


import os
# Get the list of files and directories in the current directory
items = os.listdir(".")

Filtering the List of Files

You can filter the list of files and directories by checking the type of each item using the os.path.isfile() and os.path.isdir() functions.


import os
# Get the list of files and directories in the current directory
items = os.listdir(".")
# Filter the list to get only the files
files = [item for item in items if os.path.isfile(item)]
# Filter the list to get only the directories
directories = [item for item in items if os.path.isdir(item)]

Handling Subdirectories

Recursively Traversing Subdirectories

To traverse subdirectories and get a list of all files in a directory tree, you can use a recursive approach. This involves calling the same function or logic within the function to handle subdirectories.


import os
def get_all_files(directory):
    all_files = []
    for item in os.listdir(directory):
        item_path = os.path.join(directory, item)
        if os.path.isfile(item_path):
        elif os.path.isdir(item_path):
    return all_files
# Get all files in the current directory and subdirectories
all_files = get_all_files(".")

Identifying Directories vs. Files

You can use the os.path.isfile() and os.path.isdir() functions to determine whether an item in the file system is a file or a directory.


import os
# Check if a path is a file
if os.path.isfile("file.txt"):
    print("It's a file!")
    print("It's not a file.")
# Check if a path is a directory
if os.path.isdir("documents"):
    print("It's a directory!")
    print("It's not a directory.")

Working with the os.walk() Function

Exploring the os.walk() Function

The os.walk() function provides a more convenient way to recursively traverse a directory tree and get a list of all files and directories. It yields a 3-tuple for each directory in the tree rooted at the directory top (the first argument):

  1. The root directory
  2. A list of the names of the subdirectories in root (excluding '.' and '..')
  3. A list of the names of the non-directory files in root


import os
for root, dirs, files in os.walk("."):
    print(f"Root directory: {root}")
    print(f"Subdirectories: {dirs}")
    print(f"Files: {files}")

Customizing the os.walk() Behavior

You can customize the behavior of os.walk() by providing additional arguments:

  • topdown: If True, os.walk() visits the directories in the order they appear in the directory tree (default is True).
  • onerror: A function that is called when os.walk() encounters an error. The function should accept a single argument, an OSError instance.
  • followlinks: If True, os.walk() will follow symbolic links (default is False).


import os
for root, dirs, files in os.walk(".", topdown=False, onerror=lambda err: print(f"Error: {err}"), followlinks=True):
    print(f"Root directory: {root}")
    print(f"Subdirectories: {dirs}")
    print(f"Files: {files}")

Filtering Files by Extension

Checking the File Extension

You can check the file extension of a file using the os.path.splitext() function, which returns a 2-tuple containing the root and the extension of the path.


import os
file_path = "documents/file.txt"
root, ext = os.path.splitext(file_path)
print(f"Root: {root}")
print(f"Extension: {ext}")

Creating a List of Files with a Specific Extension

You can combine the file extension check with the directory traversal techniques to create a list of files with a specific extension.


import os
def get_files_by_extension(directory, extension):
    all_files = []
    for root, dirs, files in os.walk(directory):
        for file in files:
            if file.endswith(extension):
                file_path = os.path.join(root, file)
    return all_files
# Get all .txt files in the current directory and subdirectories
txt_files = get_files_by_extension(".", ".txt")

Sorting and Organizing the File List

Sorting the File List

You can sort the list of files based on various criteria, such as file name, size, or modification time. The sorted() function in Python allows you to sort a list of files.


import os
# Get the list of files in the current directory
files = os.listdir(".")
# Sort the files by name
sorted_files = sorted(files)
# Sort the files by size
file_sizes = [(file, os.path.getsize(file)) for file in files]
sorted_by_size = sorted(file_sizes, key=lambda x: x[1])

Grouping Files by Extension

You can group the files by their extensions and create a dictionary or a similar data structure to organize the files.


import os
from collections import defaultdict
def group_files_by_extension(directory):
    file_groups = defaultdict(list)
    for root, dirs, files in os.walk(directory):
        for file in files:
            _, ext = os.path.splitext(file)
            file_path = os.path.join(root, file)
    return file_groups
# Group the files in the current directory and subdirectories
file_groups = group_files_by_extension(".")
for extension, files in file_groups.items():
    print(f"{extension}: {files}")

Handling Errors and Edge Cases

Dealing with Permissions and Access Issues

When working with the file system, you may encounter permissions or access issues. You can use a try-except block to handle these errors and provide appropriate error handling.


import os
def get_file_info(file_path):
        file_size = os.path.getsize(file_path)
        last_modified = os.path.getmtime(file_path)
        return file_size, last_modified
    except OSError as e:
        print(f"Error accessing file {file_path}: {e}")
        return None, None
# Get the file info for a file
file_info = get_file_info("file.txt")
if file_info[0] is not None:
    file_size, last_modified = file_info
    print(f"File size: {file_size} bytes")
    print(f"Last modified: {last_modified}")

Handling Symlinks and Other Special Files

Python's os and os.path modules can handle various types of special files, such as symbolic links, named pipes, and device files. You can use the os.path.islink() function to check if a file is a symbolic link.


import os
def handle_special_files(directory):
    for root, dirs, files in os.walk(directory):
        for file in files:
            file_path = os.path.join(root, file)
            if os.path.islink(file_path):
                print(f"Symbolic link: {file_path}")
            elif os.path.isfifo(file_path):
                print(f"Named pipe: {file_path}")
            elif os.path.isdev(file_path):
                print(f"Device file: {file_path}")
                print(f"Regular file: {file_path}")
# Handle special files in the current directory and subdirectories

Data Structures


Lists are one of the most fundamental data structures in Python. They are ordered collections of items that can hold values of different data types, including numbers, strings, and even other data structures like lists or dictionaries.

Here's an example of creating a list and performing some common operations:

# Creating a list
fruits = ['apple', 'banana', 'cherry']
# Accessing elements
print(fruits[0])  # Output: 'apple'
print(fruits[-1])  # Output: 'cherry'
# Adding elements
print(fruits)  # Output: ['apple', 'banana', 'cherry', 'orange']
# Removing elements
print(fruits)  # Output: ['apple', 'cherry', 'orange']
# Slicing
print(fruits[1:3])  # Output: ['cherry', 'orange']


Tuples are similar to lists, but they are immutable, meaning that you cannot modify their contents after they are created. Tuples are defined using parentheses () instead of square brackets [].

# Creating a tuple
point = (2, 3)
print(point)  # Output: (2, 3)
# Accessing elements
print(point[0])  # Output: 2
print(point[1])  # Output: 3
# Unpacking a tuple
x, y = point
print(x)  # Output: 2
print(y)  # Output: 3


Dictionaries are unordered collections of key-value pairs. They allow you to store and retrieve data quickly using unique keys.

# Creating a dictionary
person = {
    'name': 'John Doe',
    'age': 30,
    'city': 'New York'
# Accessing values
print(person['name'])  # Output: 'John Doe'
print(person['age'])  # Output: 30
# Adding and modifying entries
person['email'] = ''
person['age'] = 31
print(person)  # Output: {'name': 'John Doe', 'age': 31, 'city': 'New York', 'email': ''}
# Iterating over a dictionary
for key, value in person.items():
    print(f"{key}: {value}")


Sets are unordered collections of unique elements. They are useful for performing operations like union, intersection, and difference.

# Creating a set
colors = {'red', 'green', 'blue'}
print(colors)  # Output: {'red', 'green', 'blue'}
# Adding and removing elements
print(colors)  # Output: {'red', 'blue', 'yellow'}
# Set operations
set1 = {1, 2, 3}
set2 = {2, 3, 4}
print(set1 | set2)  # Union: {1, 2, 3, 4}
print(set1 & set2)  # Intersection: {2, 3}
print(set1 - set2)  # Difference: {1}

Control Flow

Conditional Statements

Conditional statements, such as if-else and if-elif-else, allow you to execute different blocks of code based on certain conditions.

# If-else statement
age = 18
if age >= 18:
    print("You are an adult.")
    print("You are a minor.")
# If-elif-else statement
score = 85
if score >= 90:
elif score >= 80:
elif score >= 70:


Loops, such as for and while, allow you to repeatedly execute a block of code.

# For loop
fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
# While loop
count = 0
while count < 5:
    count += 1

List Comprehensions

List comprehensions provide a concise way to create new lists based on existing ones.

# List comprehension
numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]
print(squares)  # Output: [1, 4, 9, 16, 25]
# Conditional list comprehension
even_numbers = [x for x in numbers if x % 2 == 0]
print(even_numbers)  # Output: [2, 4]


Functions are reusable blocks of code that perform a specific task. They can accept arguments, return values, and help you organize your code.

# Defining a function
def greet(name):
    print(f"Hello, {name}!")
# Calling the function
greet("Alice")  # Output: Hello, Alice!
# Functions with return values
def add_numbers(a, b):
    return a + b
result = add_numbers(3, 4)
print(result)  # Output: 7

Modules and Packages

Python's extensive standard library and third-party packages provide a wealth of functionality that you can leverage in your projects.

# Importing a module
import math
print(math.pi)  # Output: 3.141592653589793
# Importing specific functions from a module
from math import sqrt, floor
print(sqrt(16))  # Output: 4.0
print(floor(3.7))  # Output: 3
# Importing a package
import datetime
print(  # Output: 2023-04-24 12:34:56.789012

Exception Handling

Exception handling allows you to gracefully handle errors and unexpected situations in your code.

# Handling exceptions
    result = 10 / 0
except ZeroDivisionError:
    print("Error: Division by zero.")
# Handling multiple exceptions
except ValueError:
    print("Error: Invalid integer format.")

File I/O

Python provides built-in functions and methods for reading from and writing to files.

# Writing to a file
with open('example.txt', 'w') as file:
    file.write("Hello, World!")
# Reading from a file
with open('example.txt', 'r') as file:
    content =
    print(content)  # Output: Hello, World!


In this Python tutorial, you have learned about various data structures, control flow, functions, modules and packages, exception handling, and file I/O. These concepts form the foundation of Python programming and will help you write more efficient and maintainable code. Remember to practice regularly and explore the vast ecosystem of Python libraries and frameworks to expand your knowledge and skills.

MoeNagy Dev