How to Get File Size in Python Without os Module

There are several ways to get a file’s size without importing the os module. Each approach has different use cases depending on your needs.

Using pathlib.Path

The most straightforward approach uses pathlib, which is part of the standard library:

from pathlib import Path

file_path = Path('example.txt')
size = file_path.stat().st_size
print(f"File size: {size} bytes")

This is the preferred method in modern Python (3.4+). The stat() method returns a os.stat_result object, and st_size gives you the file size in bytes. It’s clean, cross-platform, and handles paths elegantly.

Using open() with seek()

You can use file object methods to determine size:

with open('example.txt', 'rb') as f:
    f.seek(0, 2)  # Seek to end of file
    size = f.tell()
print(f"File size: {size} bytes")

The seek(0, 2) moves to the end (offset 0 from position 2), and tell() returns the current position. This works but requires opening the file, making it less efficient than pathlib for just checking size.

Using io.FileIO

The io module provides lower-level file operations:

import io

with io.FileIO('example.txt', 'r') as f:
    f.seek(0, 2)
    size = f.tell()
print(f"File size: {size} bytes")

This is similar to the open/seek approach but gives you more control over buffering behavior.

Practical Comparison

For most use cases, use pathlib.Path:

from pathlib import Path

def get_file_size(filepath):
    """Get file size in bytes."""
    return Path(filepath).stat().st_size

# Usage
size = get_file_size('data.json')
print(f"{size / (1024 * 1024):.2f} MB")

If you need to handle missing files gracefully:

from pathlib import Path

def get_file_size_safe(filepath):
    """Get file size with error handling."""
    try:
        return Path(filepath).stat().st_size
    except FileNotFoundError:
        print(f"File not found: {filepath}")
        return None
    except OSError as e:
        print(f"Error accessing file: {e}")
        return None

size = get_file_size_safe('missing.txt')

Working with Multiple Files

When processing directories, pathlib excels:

from pathlib import Path

def total_directory_size(directory):
    """Calculate total size of all files in a directory."""
    return sum(f.stat().st_size for f in Path(directory).rglob('*') if f.is_file())

total = total_directory_size('.')
print(f"Total size: {total / (1024 * 1024):.2f} MB")

Key Differences from os Module

The pathlib approach avoids the os module entirely while providing a more object-oriented interface. You can chain operations:

from pathlib import Path

file = Path('example.txt')
if file.exists() and file.is_file():
    size = file.stat().st_size
    print(f"Size: {size} bytes")

Compare this to the older os approach which would require separate os.path.exists() and os.path.isfile() calls.

Performance Considerations

For checking a single file’s size, performance differences are negligible. However, pathlib is generally preferred because:

• More readable and maintainable code
• Better suited for modern Python (3.6+)
• Handles path separators cross-platform automatically
• Allows method chaining for cleaner code

Use open() with seek() only when you’re already working with an open file handle and need to determine its size without additional system calls.

2026 Best Practices and Advanced Techniques

For How to Get File Size in Python Without os Module, understanding both the fundamentals and modern practices ensures you can work efficiently and avoid common pitfalls. This guide extends the core article with practical advice for 2026 workflows.

Troubleshooting and Debugging

When issues arise, a systematic approach saves time. Start by checking logs for error messages or warnings. Test individual components in isolation before integrating them. Use verbose modes and debug flags to gather more information when standard output is not enough to diagnose the problem.

Performance Optimization

• Monitor system resources to identify bottlenecks
• Use caching strategies to reduce redundant computation
• Keep software updated for security patches and performance improvements
• Profile code before applying optimizations
• Use connection pooling and keep-alive for network operations

Security Considerations

Security should be built into workflows from the start. Use strong authentication methods, encrypt sensitive data in transit, and follow the principle of least privilege for access controls. Regular security audits and penetration testing help maintain system integrity.

Related Tools and Commands

These complementary tools expand your capabilities:

• Monitoring: top, htop, iotop, vmstat for system resources
• Networking: ping, traceroute, ss, tcpdump for connectivity
• Files: find, locate, fd for searching; rsync for syncing
• Logs: journalctl, dmesg, tail -f for real-time monitoring
• Testing: curl for HTTP requests, nc for ports, openssl for crypto

Integration with Modern Workflows

Consider automation and containerization for consistency across environments. Infrastructure as code tools enable reproducible deployments. CI/CD pipelines automate testing and deployment, reducing human error and speeding up delivery cycles.

Quick Reference

This extended guide covers the topic beyond the original article scope. For specialized needs, refer to official documentation or community resources. Practice in test environments before production deployment.