Temporary Files & Directories

Reviewed & published by Brayan K

The tempfile module creates files and directories in a safe, unique, platform-correct location for short-lived scratch data — and the high-level helpers clean themselves up automatically.

Part of the free Python course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

Whenever you need a place to stash intermediate data, generate a report before moving it, or test file-handling code, tempfile is the right and safe choice — never a hardcoded path.

What You'll Learn in This Lesson

• Scratch files with TemporaryFile
• Files with a real path via NamedTemporaryFile
• Self-cleaning folders with TemporaryDirectory
• Manual control with mkstemp and mkdtemp
• Why with-blocks guarantee cleanup
• Why you should never hardcode /tmp

1 TemporaryFile and NamedTemporaryFile

TemporaryFile gives you a scratch file you read and write through the file object — it vanishes when closed. Open it in "w+" mode to write then seek(0) and read back:

import tempfile

with tempfile.TemporaryFile(mode="w+") as f:
    f.write("scratch data")
    f.seek(0)                          # rewind to the start
    print("Read back:", f.read())
print("File auto-deleted after the with block")

NamedTemporaryFile additionally gives you a real path via .name, so other code can open it while it's alive:

import tempfile
import os

with tempfile.NamedTemporaryFile(mode="w+", suffix=".txt") as f:
    f.write("line1\nline2\n")
    f.flush()
    print("Has a real path:", os.path.basename(f.name).endswith(".txt"))
    f.seek(0)
    print("Lines:", len(f.readlines()))

import tempfile

with tempfile.TemporaryFile(mode="w+") as f:
    f.write("scratch data")
    f.seek(0)
    print("Read back:", f.read())
print("File auto-deleted after the with block")

# Expected output:
# Read back: scratch data
# File auto-deleted after the with block

2 TemporaryDirectory: A Self-Cleaning Folder

TemporaryDirectory creates a whole folder you can fill with files. The instant the with block ends, the directory and everything inside it is deleted — perfect for tests and multi-file scratch work:

import tempfile
import os
from pathlib import Path

with tempfile.TemporaryDirectory() as d:
    p = Path(d) / "notes.txt"
    p.write_text("hello temp dir")
    print("Exists inside block:", p.exists())
    print("Content:", p.read_text())
    saved = d

print("Dir removed after block:", not os.path.exists(saved))

The variable d is the path to the new directory. Pairing it with pathlib.Path makes building child paths clean and cross-platform.

import tempfile
import os
from pathlib import Path

with tempfile.TemporaryDirectory() as d:
    p = Path(d) / "notes.txt"
    p.write_text("hello temp dir")
    print("Exists inside block:", p.exists())
    print("Content:", p.read_text())
    saved = d

print("Dir removed after block:", not os.path.exists(saved))

# Expected output:
# Exists inside block: True
# Content: hello temp dir
# Dir removed after block: True

3 mkstemp: Manual Control (You Clean Up)

When you need a temp file that outlives a single block, use mkstemp(). It returns a low-level file descriptor and a path — but does not auto-delete. You must remove it yourself, ideally in a finally so cleanup always runs:

import tempfile
import os

fd, path = tempfile.mkstemp(suffix=".dat")
try:
    with os.fdopen(fd, "w") as f:      # wrap the descriptor
        f.write("manual cleanup needed")
    print("Created:", path.endswith(".dat"))
    print("Size:", os.path.getsize(path), "bytes")
finally:
    os.remove(path)                    # YOU must delete it
print("Cleaned up:", not os.path.exists(path))

import tempfile
import os

fd, path = tempfile.mkstemp(suffix=".dat")
try:
    with os.fdopen(fd, "w") as f:
        f.write("manual cleanup needed")
    print("Created:", path.endswith(".dat"))
    print("Size:", os.path.getsize(path), "bytes")
finally:
    os.remove(path)
print("Cleaned up:", not os.path.exists(path))

# Expected output:
# Created: True
# Size: 21 bytes
# Cleaned up: True

🎯 Your Turn: Fill in the Blanks

Replace each ___ so a temp directory holds a file of numbers, which you read back and sum.

import tempfile
from pathlib import Path

with tempfile.___() as d:        # hint: a self-cleaning folder
    f = Path(d) / "data.txt"
    f.write_text("42\n99\n7\n")
    numbers = [int(x) for x in f.read_text().split()]
    print("Sum:", ___(numbers))   # hint: total of a list

# Expected output:
# Sum: 148

⚠️ Common Errors

❌ Hardcoding a temp path

f = open("/tmp/scratch.txt", "w")   # breaks on Windows, may clash

with tempfile.NamedTemporaryFile(mode="w") as f:
    ...

f.write("data")
print(f.read())     # empty! cursor is at the end

✅ Seek back to the start

f.write("data")
f.seek(0)
print(f.read())     # 'data'

❌ Forgetting to delete an mkstemp file

mkstemp does not clean up. Without an os.remove(path) (ideally in finally), you leak files into the temp directory. Use the with-based helpers unless you truly need manual control.

🎯 Mini Challenge: Build & Total Reports

In a temporary directory, write three report files each holding a value=... line, then glob them back, extract the numbers, and print the grand total. The folder cleans itself up.

import tempfile
from pathlib import Path

with tempfile.TemporaryDirectory() as d:
    base = Path(d)
    for i in range(1, 4):
        (base / f"report_{i}.txt").write_text(f"value={i * 100}")

    files = sorted(base.glob("*.txt"))
    print("Created", len(files), "files")
    total = sum(int(p.read_text().split("=")[1]) for p in files)
    print("Total value:", total)

print("All cleaned up automatically")

# Expected output:
# Created 3 files
# Total value: 600
# All cleaned up automatically

📚 Keep Learning

• • tempfile — Generate temporary files and directories
• • pathlib — Object-oriented filesystem paths
• • os.fdopen — Wrap a file descriptor

Frequently Asked Questions

Lesson complete — you handle temp data safely!

You can create scratch files with TemporaryFile, named files with a real path via NamedTemporaryFile, self-cleaning folders with TemporaryDirectory, and take manual control with mkstemp/mkdtemp — and you'll never hardcode /tmp again.

Practice quiz

Continue this course

• Previous: contextlib: contextmanager, suppress, ExitStack
• Next: Finding Files with glob & fnmatch — Match file paths with wildcards using glob and fnmatch
• Quick reference: Python cheat sheet

Frequently asked questions

Why not just hardcode a path like /tmp/myfile.txt?

Hardcoding paths is fragile and unsafe. The temp directory differs across operating systems (it isn't /tmp on Windows). A fixed name can clash with another program or another run of yours, and predictable temp names are a classic security hole. tempfile picks a safe, unique location for you and works on every platform.

What's the difference between TemporaryFile and NamedTemporaryFile?

TemporaryFile may not have a visible filesystem name and is ideal for pure scratch data you only access through the file object. NamedTemporaryFile guarantees a real path (its .name attribute) that other code or processes can open while it's alive. Use Named when something else needs to find the file by path.

Do temporary files clean themselves up?

The objects used with 'with' do. TemporaryFile, NamedTemporaryFile, and TemporaryDirectory all delete themselves when the with-block exits — even if an exception is raised. The lower-level mkstemp() and mkdtemp() do NOT auto-clean; they hand you a path and you're responsible for removing it yourself.

When should I use mkstemp/mkdtemp instead?

Use them when you need a temp file or directory whose lifetime extends beyond a single with-block — for example, a file you create now and hand off to another part of the program to delete later. They give you full manual control, at the cost of having to clean up yourself, usually inside a try/finally.