Writing Files

Intermediate ~25 min read

Creating and writing files is essential for saving program output, generating reports, logging events, and persisting data. Python provides intuitive methods for writing text and binary files. Understanding the difference between write mode ('w') which overwrites and append mode ('a') which adds to existing content is crucial - choosing wrong can destroy your data!

Write Modes

The mode parameter in open() determines how files are created and written. Write mode ('w') creates a new file or completely overwrites an existing one - all previous content is lost! Append mode ('a') is safer when you want to add to existing content. Exclusive create mode ('x') prevents accidental overwrites.

# File Write Modes

# 1. Write mode ('w') - creates new or OVERWRITES existing!
print("=== Write Mode ('w') ===")
with open("output.txt", "w") as f:
    f.write("First write.\n")
    f.write("This is new content.")

# Read it back
with open("output.txt", "r") as f:
    print(f.read())
print()

# Write again - previous content is GONE!
with open("output.txt", "w") as f:
    f.write("Completely new content!")

with open("output.txt", "r") as f:
    print(f"After second write: {f.read()}")
print()

# 2. Append mode ('a') - adds to end of file
print("=== Append Mode ('a') ===")
with open("log.txt", "w") as f:
    f.write("Log started\n")

# Append multiple times
for i in range(1, 4):
    with open("log.txt", "a") as f:
        f.write(f"Entry {i}: Something happened\n")

with open("log.txt", "r") as f:
    print(f.read())
print()

# 3. Exclusive create ('x') - fails if file exists
print("=== Exclusive Create ('x') ===")
import os
if os.path.exists("unique.txt"):
    os.remove("unique.txt")

with open("unique.txt", "x") as f:
    f.write("This file is brand new!")
print("Created unique.txt successfully")

try:
    with open("unique.txt", "x") as f:
        f.write("Try again")
except FileExistsError:
    print("Error: File already exists! Cannot use 'x' mode.")
print()

# 4. Read/Write mode ('r+', 'w+')
print("=== Read/Write Modes ===")
with open("readwrite.txt", "w+") as f:
    f.write("Original content")
    f.seek(0)  # Go back to start to read
    print(f"r+ mode: {f.read()}")

# Cleanup
for fname in ["output.txt", "log.txt", "unique.txt", "readwrite.txt"]:
    os.remove(fname)
print("\n(Cleaned up files)")

Output

Click Run to execute your code

Danger Zone! Write mode ('w') destroys existing content without warning! If you open an important file in write mode, all its data is gone the moment you call open() - even before you write anything. Always double-check your mode when working with existing files.

Write Methods

Python provides two main methods for writing: write() writes a single string and returns the number of characters written, while writelines() writes a list of strings. Important: neither method adds newlines automatically - you must include \n yourself!

# File Write Methods

# 1. write() - Write a string
print("=== write() Method ===")
with open("demo.txt", "w") as f:
    f.write("Hello, World!\n")
    f.write("Second line\n")
    chars_written = f.write("Third line")
    print(f"Last write: {chars_written} characters")

with open("demo.txt", "r") as f:
    print(f"Content:\n{f.read()}")
print()

# 2. writelines() - Write a list of strings
print("=== writelines() Method ===")
lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open("lines.txt", "w") as f:
    f.writelines(lines)

with open("lines.txt", "r") as f:
    print(f"writelines result:\n{f.read()}")
print()

# 3. writelines() doesn't add newlines!
print("=== writelines() Without Newlines ===")
words = ["apple", "banana", "cherry"]
with open("words.txt", "w") as f:
    f.writelines(words)  # No newlines!

with open("words.txt", "r") as f:
    print(f"Result: {f.read()}")
print()

# 4. Adding newlines to writelines
print("=== writelines() With Newlines ===")
words = ["apple", "banana", "cherry"]
with open("words2.txt", "w") as f:
    # Add newlines using list comprehension
    f.writelines(line + "\n" for line in words)

with open("words2.txt", "r") as f:
    print(f"Result:\n{f.read()}")
print()

# 5. write() returns character count
print("=== Write Return Value ===")
with open("count.txt", "w") as f:
    count1 = f.write("Short")
    count2 = f.write("A longer string here")
    print(f"First write: {count1} chars")
    print(f"Second write: {count2} chars")

# Cleanup
import os
for fname in ["demo.txt", "lines.txt", "words.txt", "words2.txt", "count.txt"]:
    os.remove(fname)
print("\n(Cleaned up files)")

Output

Click Run to execute your code

write() vs writelines():
write(string) - Writes one string, returns character count
writelines(list) - Writes list of strings, returns None
Neither adds newlines! You must include \n in your strings.
For large data, writelines() with a generator is memory-efficient.

Writing Binary Files

Binary mode ('wb') writes raw bytes instead of text. This is essential for images, audio, compressed files, and any non-text data. You must write bytes or bytearray objects, not strings. Use encode() to convert strings to bytes, or the struct module for structured binary data.

# Writing Binary Files

import os

# 1. Write bytes to a file
print("=== Write Bytes ===")
with open("data.bin", "wb") as f:
    # Write a bytes literal
    f.write(b"Hello Binary!")
    # Write raw bytes
    f.write(bytes([0, 1, 2, 255, 254, 253]))

# Read back
with open("data.bin", "rb") as f:
    data = f.read()
    print(f"Type: {type(data)}")
    print(f"Content: {data}")
    print(f"Length: {len(data)} bytes")
print()

# 2. Write bytearray (mutable bytes)
print("=== Write Bytearray ===")
data = bytearray([72, 101, 108, 108, 111])  # "Hello" in ASCII
data.append(33)  # Add "!"
with open("array.bin", "wb") as f:
    f.write(data)

with open("array.bin", "rb") as f:
    print(f"Read back: {f.read()}")
print()

# 3. Write at specific positions
print("=== Write at Positions ===")
with open("positions.bin", "wb") as f:
    f.write(b"0123456789")

# Modify using r+b (read/write binary)
with open("positions.bin", "r+b") as f:
    f.seek(5)  # Go to position 5
    f.write(b"XXX")  # Overwrite 3 bytes

with open("positions.bin", "rb") as f:
    print(f"Modified: {f.read()}")
print()

# 4. Encoding strings to bytes
print("=== Encode Strings to Bytes ===")
text = "Python Unicode: café ñ"
with open("encoded.bin", "wb") as f:
    encoded = text.encode("utf-8")
    f.write(encoded)
    print(f"Encoded bytes: {encoded}")

with open("encoded.bin", "rb") as f:
    raw = f.read()
    decoded = raw.decode("utf-8")
    print(f"Decoded: {decoded}")
print()

# 5. Write structured binary data
print("=== Structured Binary Data ===")
import struct

# Pack integers into bytes
numbers = [100, 200, 300]
with open("numbers.bin", "wb") as f:
    for num in numbers:
        # 'i' = 4-byte signed integer
        packed = struct.pack('i', num)
        f.write(packed)

# Read back
with open("numbers.bin", "rb") as f:
    while True:
        data = f.read(4)
        if not data:
            break
        num = struct.unpack('i', data)[0]
        print(f"Read number: {num}")

# Cleanup
for fname in ["data.bin", "array.bin", "positions.bin", "encoded.bin", "numbers.bin"]:
    os.remove(fname)
print("\n(Cleaned up binary files)")

Output

Click Run to execute your code

When to Use Binary Mode:
- Images (PNG, JPEG, GIF)
- Audio/Video files
- Compressed archives (ZIP, GZIP)
- Executables and compiled code
- Network protocols and serialized data
- Any file where exact byte representation matters

Formatted File Output

Often you need to write formatted data - tables, reports, or structured text. Python offers several ways to format output: f-strings for inline formatting, format() for templates, and even print() with the file parameter. For efficiency with many lines, join them into one string before writing.

# Formatted File Output

import os

# 1. print() to file
print("=== print() to File ===")
with open("output.txt", "w") as f:
    print("Hello, File!", file=f)
    print("Line 2", file=f)
    print(1, 2, 3, sep="-", file=f)

with open("output.txt", "r") as f:
    print(f.read())
print()

# 2. f-strings for formatting
print("=== f-string Formatting ===")
name = "Alice"
score = 95.5
level = 3

with open("formatted.txt", "w") as f:
    f.write(f"Player: {name}\n")
    f.write(f"Score: {score:.1f}\n")
    f.write(f"Level: {level:03d}\n")

with open("formatted.txt", "r") as f:
    print(f.read())
print()

# 3. format() method
print("=== format() Method ===")
template = "Name: {}, Age: {}, City: {}\n"
people = [
    ("Alice", 30, "New York"),
    ("Bob", 25, "London"),
    ("Charlie", 35, "Paris")
]

with open("people.txt", "w") as f:
    for person in people:
        f.write(template.format(*person))

with open("people.txt", "r") as f:
    print(f.read())
print()

# 4. Tabular data with formatting
print("=== Formatted Table ===")
data = [
    ("Product", "Price", "Qty"),
    ("Apple", 1.50, 10),
    ("Banana", 0.75, 25),
    ("Orange", 2.00, 15)
]

with open("table.txt", "w") as f:
    for row in data:
        if isinstance(row[1], str):  # Header row
            f.write(f"{row[0]:<12}{row[1]:<10}{row[2]:<8}\n")
            f.write("-" * 30 + "\n")
        else:
            f.write(f"{row[0]:<12}${row[1]:<9.2f}{row[2]:<8}\n")

with open("table.txt", "r") as f:
    print(f.read())
print()

# 5. Multiple writes with join
print("=== join() for Efficiency ===")
lines = ["Line 1", "Line 2", "Line 3", "Line 4"]

# Efficient: join then single write
with open("joined.txt", "w") as f:
    f.write("\n".join(lines))

with open("joined.txt", "r") as f:
    print(f.read())

# Cleanup
for fname in ["output.txt", "formatted.txt", "people.txt", "table.txt", "joined.txt"]:
    os.remove(fname)
print("\n(Cleaned up files)")

Output

Click Run to execute your code

Common Mistakes

1. Accidentally overwriting important files

# DISASTER - overwrites config file!
with open("config.txt", "w") as f:
    f.write("debug=true")  # Lost all other settings!

# Safe approach - read first, modify, write back
with open("config.txt", "r") as f:
    content = f.read()
# Modify content...
with open("config.txt", "w") as f:
    f.write(modified_content)

# Or use append mode to add settings
with open("config.txt", "a") as f:
    f.write("\ndebug=true")

2. Forgetting newlines with writelines()

# Wrong - creates one long line!
lines = ["apple", "banana", "cherry"]
with open("fruits.txt", "w") as f:
    f.writelines(lines)  # Result: "applebananacherry"

# Correct - add newlines
lines = ["apple\n", "banana\n", "cherry\n"]
with open("fruits.txt", "w") as f:
    f.writelines(lines)

# Or use generator expression
lines = ["apple", "banana", "cherry"]
with open("fruits.txt", "w") as f:
    f.writelines(line + "\n" for line in lines)

3. Writing strings to binary files

# Wrong - TypeError: a bytes-like object is required
with open("data.bin", "wb") as f:
    f.write("Hello")  # Error!

# Correct - encode string to bytes
with open("data.bin", "wb") as f:
    f.write("Hello".encode("utf-8"))

# Or use bytes literal
with open("data.bin", "wb") as f:
    f.write(b"Hello")

4. Not flushing or closing files

# Wrong - data may not be written yet!
f = open("log.txt", "w")
f.write("Important data")
# Program crashes here - data may be lost!

# Correct - use 'with' statement
with open("log.txt", "w") as f:
    f.write("Important data")
# Automatically closed and flushed

# Or manually flush for long-running programs
f = open("log.txt", "w")
f.write("Log entry")
f.flush()  # Force write to disk now

5. Writing many small strings inefficiently

# Slow - many small write calls
with open("output.txt", "w") as f:
    for i in range(10000):
        f.write(f"Line {i}\n")  # 10000 write calls!

# Fast - build string first, single write
lines = [f"Line {i}" for i in range(10000)]
with open("output.txt", "w") as f:
    f.write("\n".join(lines))  # One write call!

# Or use writelines with generator
with open("output.txt", "w") as f:
    f.writelines(f"Line {i}\n" for i in range(10000))

Exercise: Log File Writer

Task: Create a simple log file writer that appends timestamped entries.

Requirements:

Write a function that appends log entries with timestamps
Each entry should be on its own line
Include the log level (INFO, WARNING, ERROR)
Demonstrate with multiple log entries

Output

Click Run to execute your code

Show Solution

from datetime import datetime
import os

def log_message(filename, level, message):
    """Append a timestamped log entry to a file."""
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    entry = f"[{timestamp}] {level}: {message}\n"

    with open(filename, "a") as f:
        f.write(entry)

# Test the logger
log_file = "app.log"

# Write some log entries
log_message(log_file, "INFO", "Application started")
log_message(log_file, "INFO", "User logged in: alice")
log_message(log_file, "WARNING", "Low memory: 85% used")
log_message(log_file, "ERROR", "Database connection failed")
log_message(log_file, "INFO", "Retrying connection...")
log_message(log_file, "INFO", "Connection restored")

# Read and display the log
print("=== Log Contents ===")
with open(log_file, "r") as f:
    print(f.read())

# Cleanup
os.remove(log_file)

Summary

Write mode: open("file", "w") - overwrites existing content
Append mode: open("file", "a") - adds to end of file
Exclusive create: open("file", "x") - fails if file exists
Write string: f.write("text") - returns char count
Write list: f.writelines(["a", "b"]) - no auto newlines!
Binary write: open("file", "wb") with bytes
Print to file: print("text", file=f)
Force flush: f.flush() - writes buffer to disk
Always use: with open(...) as f: for auto-close
Efficiency: Join strings before writing for better performance

What's Next?

Now that you can read and write files, let's learn about context managers - the Pythonic way to handle resources. The with statement ensures files are properly closed even when errors occur, and you can create your own context managers for other resources!

Previous Reading Files

Next Context Managers

Write Modes

Write Methods

Writing Binary Files

Formatted File Output

Common Mistakes

1. Accidentally overwriting important files

2. Forgetting newlines with writelines()

3. Writing strings to binary files

4. Not flushing or closing files

5. Writing many small strings inefficiently

Exercise: Log File Writer

Summary

What's Next?

Enjoying these tutorials?