How to check if a file exists.
pathlib. Or try/except.

The three methods compared:

pathlib:
  ✅ Modern (Python 3.4+)
  ✅ Object-oriented: Path('file').exists()
  ✅ Chains nicely: Path('dir').joinpath('file')
  ✅ Reads like English: file.is_file()
  ✅ Cross-platform: no os.sep or \ issues
  ✅ More methods: read_text, write_text, glob, rglob
  ❌ Not available in very old Python (pre-3.4)

os.path:
  ✅ Works everywhere (pre-3.4 too)
  ✅ Familiar to old-timers
  ✅ Slightly faster for very large loops (no object)
  ❌ Function-based, less discoverable
  ❌ Verbose: os.path.isfile(os.path.join(a, b))
  ❌ Mixes strings and path handling

try/except:
  ✅ Race-condition-free
  ✅ Handles the actual failure mode (open)
  ✅ One operation instead of two
  ❌ Doesn't tell you WHY it failed without catching
    multiple exceptions (FileNotFoundError,
    PermissionError, IsADirectoryError, OSError)
  ❌ Verbose for "I just want to know if it exists"

Which to use:

✅ To check existence (e.g., "is this config file present?"):
   pathlib.Path('file').exists()
   
✅ To check type (file vs directory):
   pathlib.Path('file').is_file()
   pathlib.Path('file').is_dir()

✅ Before opening a file:
   try/except FileNotFoundError — the pattern
   that actually works.

❌ Don't do:
   if Path('file').exists():
       Path('file').read_text()
   → The file can be deleted between the two.

✅ Do:
   try:
       content = Path('file').read_text()
   except FileNotFoundError:
       content = ''
   → The read is the check. No race.

The race condition is real:

  Time    Process A              Process B
  ────    ─────────              ─────────
  t=0     exists('file') → True
  t=1                            delete('file')
  t=2     open('file') → FileNotFoundError!

  The exists() check returned True, but by
  the time open() runs, the file is gone.
  The check was useless.

  Fix: just try to open. If it fails, handle
  the error. The failure and the handling are
  separated by microseconds, not by an intermediate
  check.

  Or: if you really need a check (for logging,
  for deciding whether to create a default file),
  the check is informational. The actual file
  operation still needs try/except.

The pattern:

  try:
      # do the file operation
  except FileNotFoundError:
      # handle "doesn't exist"
  except PermissionError:
      # handle "exists but no access"
  except IsADirectoryError:
      # handle "it's a directory, not a file"
  except OSError:
      # catch-all for other OS errors

  The specific exception tells you what happened.
  The generic OSError catches the rest.

  For "I need to know if it exists":
    exists = Path('file').exists()
    → This is fine for logging, for reporting,
    for the "check" part of "check then maybe create."

  For "I need to read this file":
    try:
        with open('file') as f:
            ...
    except FileNotFoundError:
        ...
    → No race. Correct.

Why check-then-open is a race:

  Thread A                    Thread B
  ─────────                   ─────────
  exists('file') → True
                              delete('file')
  open('file') → FileNotFoundError

  Between the check and the open, the world
  changed. The check result is stale.

  The bug is subtle:
    - Most of the time it works.
    - Rarely, under load or with concurrent
      processes, it fails.
    - The failure is in the log at 3 AM.
    - Reproducing is hard.
    - Fixing is easy (try/except), but only
      if you know the pattern.

  This is a classic "time-of-check to time-of-use"
  (TOCTOU) bug. It's not Python-specific — it's
  a general concurrency issue.

  The fix: don't check. Do the thing and handle
  the failure. This is atomic-ish —
  - The file is either there when you open it,
    or it's not.
  - The exception is definitive.
  - No intermediate state to be wrong about.

When checking is still okay:

  The existence check is fine when:
  → The result is informational (logging,
    displaying to the user).
  → You're not acting on it in a way that
    assumes the state will persist.
  → You handle the failure of the subsequent
    operation anyway.

  Example of acceptable checking:

    if not Path('config.json').exists():
        print('Warning: no config file found, '
              'using defaults')
    
    try:
        content = Path('config.json').read_text()
    except FileNotFoundError:
        content = DEFAULT_CONFIG
    
    The check is for the warning.
    The try/except is for correctness.
    Both can be true.

  The rule:
    Use exists() for information.
    Use try/except for control flow.
    Never use exists() to guard an operation
    that assumes the file is still there.

Real-world example:

  ❌ def load_config():
        if not Path('config.json').exists():
            raise ConfigError('No config')
        return json.loads(Path('config.json').read_text())
  
  Between exists() and read_text(), the file
  could disappear.
  
  ✅ def load_config():
        try:
            return json.loads(Path('config.json').read_text())
        except FileNotFoundError:
            raise ConfigError('No config')
        except json.JSONDecodeError:
            raise ConfigError('Malformed config')
  
  The read is the check. Two operations become
  one try/except block. Cleaner and correct.

  This pattern also handles the "file exists but
  is malformed" case — the try/except can catch
  multiple exceptions, telling you exactly what
  went wrong.