Python os.stat() Method

Last Updated : 17 Apr 2026

Introduction

Python's os module provides a way of interacting with the operating system, and it includes various methods to work with files and directories. Among these, the os.stat() method stands out as a powerful tool for retrieving detailed information about a file or a directory. This article delves into the intricacies of the os.stat() method, exploring its syntax, the attributes it returns, and practical applications with code examples.

Overview of the os.stat() Method

The os.stat() method is used to perform a stat system call on the specified path. It returns an os.stat_result object, which contains several attributes representing the status of the specified path.

Syntax

import os
os.stat(path, *, dir_fd=None, follow_symlinks=True)

path: A string or bytes object representing the path to the file or directory.
dir_fd: A file descriptor referring to a directory. The default is None.
follow_symlinks: A boolean indicating whether to follow symbolic links. The default is True.

Attributes of os.stat_result

The os.stat_result object returned by os.stat() contains the following attributes:

st_mode: The file type and mode (permissions).
st_ino: The inode number.
st_dev: The device ID.
st_nlink: The number of hard links.
st_uid: The user ID of the owner.
st_gid: The group ID of the owner.
st_size: The size of the file in bytes.
st_atime: The time of last access.
st_mtime: The time of last modification.
st_ctime: The time of last metadata change on Unix or the creation time on Windows.

Understanding the Attributes

st_mode

The st_mode attribute contains both the file type and the file mode (permissions). It can be interpreted using the stat module, which provides constants and functions for interpreting the st_mode value.

import os
import stat

file_stat = os.stat('example.txt')
mode = file_stat.st_mode

# Checking file type
if stat.S_ISDIR(mode):
    print("It's a directory.")
elif stat.S_ISREG(mode):
    print("It's a regular file.")
elif stat.S_ISLNK(mode):
    print("It's a symbolic link.")

# Checking permissions
if mode & stat.S_IRUSR:
    print("Owner has read permission.")
if mode & stat.S_IWUSR:
    print("Owner has write permission.")
if mode & stat.S_IXUSR:
    print("Owner has execute permission.")

Output:

It's a regular file.
Owner has read permission.
Owner has write permission.

st_ino

The st_ino attribute represents the inode number, which is a unique identifier for the file within the filesystem.

inode = file_stat.st_ino
print(f"Inode number: {inode}")

Output:

Inode number: 12345678

st_dev

The st_dev attribute represents the device ID on which the file resides. This can be useful in environments where filesystems are spread across multiple devices.

device = file_stat.st_dev
print(f"Device ID: {device}")

Output:

Device ID: 2049

st_nlink

The st_nlink attribute indicates the number of hard links pointing to the file.

nlink = file_stat.st_nlink
print(f"Number of hard links: {nlink}")

Output:

Number of hard links: 1

st_uid and st_gid

The st_uid and st_gid attributes represent the user ID and group ID of the file's owner, respectively.

uid = file_stat.st_uid
gid = file_stat.st_gid
print(f"User ID: {uid}, Group ID: {gid}")

Output:

User ID: 1000, Group ID: 1000

st_size

The st_size attribute shows the size of the file in bytes.

size = file_stat.st_size
print(f"File size: {size} bytes")

Output:

File size: 12345 bytes

st_atime, st_mtime, and st_ctime

These attributes represent the times of the last access, modification, and metadata change (or creation on Windows), respectively. The values are given as seconds since the epoch (January 1, 1970).

import time

atime = time.ctime(file_stat.st_atime)
mtime = time.ctime(file_stat.st_mtime)
ctime = time.ctime(file_stat.st_ctime)

print(f"Last access time: {atime}")
print(f"Last modification time: {mtime}")
print(f"Last metadata change time: {ctime}")

Output:

Last access time: Mon May 20 14:22:31 2024
Last modification time: Mon May 20 14:20:10 2024
Last metadata change time: Mon May 20 14:20:10 2024

Practical Applications of os.stat()

Example 1: File Metadata

You can use os.stat() to gather and print metadata for a file.

import os
import time

def print_file_metadata(file_path):
    file_stat = os.stat(file_path)
    
    print(f"File: {file_path}")
    print(f"Size: {file_stat.st_size} bytes")
    print(f"Device: {file_stat.st_dev}")
    print(f"Inode: {file_stat.st_ino}")
    print(f"Mode: {file_stat.st_mode}")
    print(f"Number of links: {file_stat.st_nlink}")
    print(f"User ID: {file_stat.st_uid}")
    print(f"Group ID: {file_stat.st_gid}")
    print(f"Last access time: {time.ctime(file_stat.st_atime)}")
    print(f"Last modification time: {time.ctime(file_stat.st_mtime)}")
    print(f"Last metadata change time: {time.ctime(file_stat.st_ctime)}")

print_file_metadata('example.txt')

Output:

File: example.txt
Size: 12345 bytes
Device: 2049
Inode: 12345678
Mode: 33206
Number of links: 1
User ID: 1000
Group ID: 1000
Last access time: Mon May 20 14:22:31 2024
Last modification time: Mon May 20 14:20:10 2024
Last metadata change time: Mon May 20 14:20:10 2024

Example 2: Checking File Permissions

You can check if a file has specific permissions.

import os
import stat

def check_file_permissions(file_path):
    file_stat = os.stat(file_path)
    mode = file_stat.st_mode
    
    permissions = {
        'read': mode & stat.S_IRUSR,
        'write': mode & stat.S_IWUSR,
        'execute': mode & stat.S_IXUSR
    }
    
    for perm, has_perm in permissions.items():
        print(f"Owner has {perm} permission: {'Yes' if has_perm else 'No'}")

check_file_permissions('example.txt')

Output:

Owner has read permission: Yes
Owner has write permission: Yes
Owner has execute permission: No

Example 3: File Age

You can determine the age of a file by comparing its last modification time to the current time.

import os
import time

def file_age(file_path):
    file_stat = os.stat(file_path)
    mtime = file_stat.st_mtime
    current_time = time.time()
    
    age = current_time - mtime
    print(f"File age: {age} seconds")

file_age('example.txt')

Output:

File age: 3600 seconds

Example 4: Identifying Large Files

You can identify files larger than a certain size within a directory.

import os

def find_large_files(directory, size_threshold):
    for filename in os.listdir(directory):
        filepath = os.path.join(directory, filename)
        if os.path.isfile(filepath):
            file_stat = os.stat(filepath)
            if file_stat.st_size > size_threshold:
                print(f"Large file: {filename} - Size: {file_stat.st_size} bytes")

find_large_files('.', 1000000)  # Finds files larger than 1MB in the current directory

Output:

Large file: big_file.txt - Size: 2345678 bytes
Large file: another_big_file.dat - Size: 3456789 bytes

Handling Errors

When working with os.stat(), it's essential to handle potential errors, such as FileNotFoundError if the specified path does not exist.

import os
def safe_stat(file_path):
    try:
        file_stat = os.stat(file_path)
        return file_stat
    except FileNotFoundError:
        print(f"Error: {file_path} does not exist.")
    except PermissionError:
        print(f"Error: Permission denied to access {file_path}.")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")
file_stat = safe_stat('example.txt')
if file_stat:
    print(f"File size: {file_stat.st_size} bytes")

Output:

File size: 12345 bytes

Advantages

Comprehensive File Information: os.stat() provides detailed information about files and directories, including size, permissions, ownership, timestamps, and more. This comprehensive data can be crucial for various file management tasks.
Cross-Platform Compatibility: The os module is designed to work across different operating systems, including Windows, macOS, and Linux. This cross-platform compatibility ensures that scripts using os.stat() can run on various systems without modification.
Efficient File Management: With attributes like st_size, st_mode, st_atime, st_mtime, and st_ctime, you can efficiently manage and monitor files. For instance, you can check file sizes to identify large files, monitor file access and modification times for auditing purposes, and ensure proper file permissions.
Error Handling: The os.stat() method allows for robust error handling. By catching exceptions like FileNotFoundError and PermissionError, you can create more resilient and user-friendly applications that handle edge cases gracefully.
Integration with Other Modules: The os.stat() method integrates seamlessly with other Python modules such as stat, os.path, and time. This integration enhances its functionality, allowing for more advanced file operations, such as checking file types, interpreting file modes, and formatting timestamps.
Automated File Audits: Automated scripts can use os.stat() to perform regular audits of file systems. For example, you can write a script to check for files with incorrect permissions, files that haven't been accessed or modified in a long time, or discrepancies in file sizes.
Security: By checking and verifying file permissions using os.stat(), you can enhance the security of your applications. Ensuring that only authorized users have access to sensitive files can prevent unauthorized access and potential data breaches.
Optimization and Maintenance: Regular use of os.stat() can help in optimizing and maintaining file systems. By identifying and managing large files, unused files, or files with incorrect permissions, you can maintain an organized and efficient file system.
File Backup and Restoration: Use os.stat() to check file modification times (st_mtime) and back up only the files that have changed since the last backup.
Monitoring File Changes: Implement scripts to monitor changes in file access (st_atime) or modification times, useful for tracking usage patterns or unauthorized changes.
Disk Usage Analysis: Analyze disk usage by checking file sizes (st_size) across directories, helping in identifying and cleaning up large or unnecessary files.

Conclusion

The os.stat() method in Python is a versatile tool for retrieving detailed information about files and directories. By understanding its attributes and knowing how to use them, you can perform various file system operations effectively. Whether you need to check file permissions, identify large files, or determine file ages, os.stat() provides a robust foundation for these tasks. Properly handling potential errors ensures your code remains resilient and reliable, making os.stat() an indispensable part of file handling in Python.

Next TopicPython reading rss feed

← prev next →

We deliver comprehensive tutorials, interview question-answers, MCQs, study materials on leading programming languages and web technologies like Data Science, MEAN/MERN full stack development, Python, Java, C++, C, HTML, React, Angular, PHP and much more to support your learning and career growth.