How to Fix 'WinError 2: The System Cannot Find the File Specified' When Running Fortran from Python for Multiple Input Files

If you’ve ever tried to run a Fortran program from Python—especially one that relies on multiple input files—you may have encountered the frustrating WinError 2: The System Cannot Find the File Specified. This error occurs when Windows cannot locate a file required for the operation, leaving you stuck wondering: Which file is missing? Is it the Fortran executable? An input file? Or something else entirely?

In this blog, we’ll demystify this error by breaking down its common causes and providing a step-by-step guide to resolve it. Whether you’re a researcher integrating legacy Fortran code into a Python workflow or a student automating simulations, this guide will help you run your Fortran programs smoothly with multiple input files.

Table of Contents#

  1. Understanding 'WinError 2'
  2. Common Causes of the Error
  3. Step-by-Step Solutions
  4. Preventive Measures
  5. Conclusion
  6. References

Understanding 'WinError 2'#

WinError 2 is a Windows system error indicating that the operating system cannot locate a file specified in a command or operation. When running Fortran from Python, this error typically points to one of two things:

  • The Fortran executable (e.g., my_program.exe) is missing or its path is incorrect.
  • One or more input files required by the Fortran program are missing or their paths are misconfigured.

The error message itself often includes a hint (e.g., The system cannot find the file specified: 'input_data.txt'), but in some cases (e.g., when using subprocess in Python), the message may be vague. The key is to systematically check all files involved in the workflow.

Common Causes of the Error#

Before diving into solutions, let’s identify the most likely culprits:

  1. Uncompiled Fortran Code: The Fortran source code (*.f90, *.for) hasn’t been compiled into an executable, so Python can’t find the .exe file.
  2. Incorrect File Paths: Relative paths (e.g., data/input.txt) may fail if Python runs from a different directory than expected.
  3. Mismatched Working Directory: Python’s working directory (where it executes commands) differs from where the Fortran executable or input files reside.
  4. Malformed Subprocess Command: The command used to run the Fortran program (e.g., via subprocess.run) is missing arguments, has typos, or misformats input file paths.
  5. Hardcoded Paths in Fortran: The Fortran code uses fixed paths (e.g., C:\Users\OldName\input.txt) that no longer exist or aren’t accessible from Python.
  6. Missing Input Files: One or more input files referenced by the Fortran program (or Python script) have been deleted, renamed, or moved.

Step-by-Step Solutions#

Let’s walk through resolving each cause with actionable steps and code examples.

1. Verify the Fortran Executable Exists#

First, ensure your Fortran code is compiled into an executable. Most Fortran compilers (e.g., gfortran, ifort) generate a .exe file when you compile.

Example Compilation Command (using gfortran):

gfortran my_fortran_code.f90 -o my_fortran_program.exe

Check in Python: Use os.path.isfile() to confirm the executable exists:

import os
 
fortran_exe = "path/to/my_fortran_program.exe"  # Replace with your path
 
if not os.path.isfile(fortran_exe):
    raise FileNotFoundError(f"Fortran executable missing: {fortran_exe}")

Tip: Always use the absolute path to the executable (e.g., C:\projects\simulation\my_fortran_program.exe) in Python to avoid ambiguity. Use os.path.abspath() to convert relative paths to absolute:

fortran_exe = os.path.abspath("my_fortran_program.exe")  # Resolves relative to Python's cwd

2. Check Input File Paths#

Next, confirm all input files exist. If your Fortran program reads from files like input1.dat or params.in, verify their paths in Python.

Example Workflow:

import os
 
input_files = ["input1.dat", "params.in", "boundary_conditions.txt"]  # List of input files
 
for file in input_files:
    if not os.path.isfile(file):
        raise FileNotFoundError(f"Input file missing: {os.path.abspath(file)}")

Common Fix: Use absolute paths for input files. For example, if inputs are stored in a data subdirectory relative to your Python script:

# Get the directory of your Python script (avoids relying on cwd)
script_dir = os.path.dirname(os.path.abspath(__file__))
input_dir = os.path.join(script_dir, "data")  # Path to 'data' folder
 
input_files = [
    os.path.join(input_dir, "input1.dat"),
    os.path.join(input_dir, "params.in")
]

Why This Works: os.path.dirname(__file__) gets the directory of your Python script, ensuring paths are resolved relative to the script itself (not where you run the script from).

3. Correct Python’s Working Directory#

Python’s working directory (cwd) is where it executes commands by default. If your Fortran executable or input files are in a different folder, the cwd may need adjustment.

Check Current cwd:

import os
print("Python's current working directory:", os.getcwd())

Fix 1: Change cwd Temporarily (use os.chdir()):

target_dir = "path/to/fortran_and_inputs"  # Folder with exe and inputs
os.chdir(target_dir)  # Switch to this directory
print("New working directory:", os.getcwd())

Fix 2: Specify cwd in subprocess (better for isolation):
Use the cwd parameter in subprocess.run to set the working directory for the Fortran command:

import subprocess
 
result = subprocess.run(
    ["./my_fortran_program.exe"],  # Command to run Fortran (relative to cwd)
    cwd="path/to/fortran_and_inputs",  # Run command in this directory
    capture_output=True,
    text=True
)

4. Validate Subprocess Command Structure#

The subprocess module in Python runs system commands. A malformed command (e.g., missing input files as arguments) will trigger WinError 2.

Scenario A: Fortran Expects Input Files as Command-Line Arguments#

If your Fortran program reads input files passed via the command line (e.g., my_program.exe input1.dat input2.in), structure the subprocess command as a list of arguments:

Fortran Code Example (reads filenames from command line):

program read_inputs
    implicit none
    character(len=256) :: input1, input2
    integer :: ierr
 
    ! Check for 2 input files
    if (command_argument_count() < 2) then
        print *, "Usage: ./my_program.exe input1.dat input2.in"
        stop 1
    end if
 
    ! Get filenames from command line
    call get_command_argument(1, input1)
    call get_command_argument(2, input2)
 
    ! Open files (add error checking!)
    open(newunit=10, file=trim(input1), status='old', iostat=ierr)
    if (ierr /= 0) error stop "Failed to open "//trim(input1)
    ! ... (read data) ...
end program read_inputs

Python Command (pass input files as arguments):

import subprocess
import os
 
fortran_exe = os.path.abspath("my_program.exe")
input1 = os.path.abspath("input1.dat")
input2 = os.path.abspath("input2.in")
 
# Command: [executable, input1, input2]
command = [fortran_exe, input1, input2]
 
result = subprocess.run(
    command,
    capture_output=True,
    text=True,
    check=True  # Raises error if Fortran program fails
)

Scenario B: Fortran Reads Input from stdin#

If the Fortran program reads from standard input (e.g., read(*,*)), use subprocess’s input parameter to pass data from files:

Python Command (concatenate input files and pass to stdin):

# Read all input files into a single string
with open("input1.dat") as f1, open("input2.in") as f2:
    input_data = f1.read() + f2.read()
 
# Run Fortran and pass input_data to stdin
result = subprocess.run(
    [fortran_exe],
    input=input_data,  # Data sent to Fortran's stdin
    capture_output=True,
    text=True,
    check=True
)

Handle Spaces in Filenames#

If paths contain spaces (e.g., My Input File.txt), avoid quoting manually—subprocess handles spaces automatically when using a list of arguments:

# Safe even with spaces:
input_file = os.path.abspath("My Input File.txt")
command = [fortran_exe, input_file]  # No quotes needed!

5. Fix Hardcoded Paths in Fortran#

If your Fortran code uses hardcoded paths (e.g., open(unit=10, file='C:\OldPath\input.txt')), replace them with command-line arguments (as in Scenario A) or relative paths (relative to the executable’s directory).

Bad Fortran Code (hardcoded path):

open(unit=10, file='C:\Users\John\input.txt', status='old')  # Fails if run from Python!

Good Fortran Code (relative path or command-line argument):

open(unit=10, file='input.txt', status='old')  # Reads from executable's directory

6. Debug with Verbose Output#

If the error persists, use Python to print paths and subprocess to capture Fortran’s output/errors:

import subprocess
import os
 
fortran_exe = os.path.abspath("my_program.exe")
input_files = [os.path.abspath(f) for f in ["input1.dat", "input2.in"]]
 
print("Fortran executable path:", fortran_exe)
print("Input file paths:", input_files)
 
try:
    result = subprocess.run(
        [fortran_exe] + input_files,
        capture_output=True,
        text=True,
        check=True
    )
    print("Fortran output:", result.stdout)
except subprocess.CalledProcessError as e:
    print("Fortran failed with error:", e.stderr)
except FileNotFoundError as e:
    print("File not found error:", e)

This will reveal exactly which file is missing (e.g., File not found error: [Errno 2] No such file or directory: 'input2.in').

Preventive Measures#

To avoid WinError 2 in the future, adopt these practices:

  • Use Absolute Paths: Resolve paths with os.path.abspath() or os.path.join() to avoid ambiguity.
  • Centralize Path Configuration: Store paths in a config file (e.g., config.json) or constants at the top of your Python script: 
    # config.py
import os
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
FORTRAN_EXE = os.path.join(SCRIPT_DIR, "bin", "my_program.exe")
INPUT_DIR = os.path.join(SCRIPT_DIR, "data")
  • Check File Existence Proactively: Validate all files before running the Fortran program (as shown in Step 2).
  • Document Dependencies: Maintain a README listing required input files and their expected locations.
  • Test with a Minimal Example: Use a small Fortran program and single input file to isolate path issues before scaling to multiple files.

Conclusion#

WinError 2 when running Fortran from Python is almost always a path or file existence issue. By systematically verifying the Fortran executable, input files, Python’s working directory, and subprocess command structure, you can resolve the error quickly. Remember to use absolute paths, validate file existence, and debug with verbose output to pinpoint missing files. With these steps, you’ll streamline your Fortran-Python workflow and avoid future headaches!

References#

2025-11