RUNTIME VALUE CONVERSIONS

Read and write one text file

Use an update mode to read and write through one UTF-8 handle, with an explicit seek whenever you switch direction.

On this page
Choose a mode · Write and inspect · Read and replace from the beginning · Append and reread · Direction changes and limits

Select Transpile → Runtime. Use a direct with open(..., encoding="utf-8") statement. These modes are a bounded Runtime profile. Successful seek is required between reading and writing, in either direction. Conversion itself never opens your source program's files.

Choose a mode

Mode	On opening	Where writes go
`"r+"`	Open an existing file at its beginning; fail if missing. Preserve its contents.	At the established cursor, overwriting bytes without truncating the remainder.
`"w+"`	Create a file, or immediately truncate an existing file to empty.	At the established cursor.
`"a+"`	Create if missing; preserve existing contents. Start at EOF.	Always at EOF, even after seeking elsewhere.
`"x+"`	Create only if absent; otherwise raise FileExistsError without modifying the existing file.	At the established cursor.

All four modes admit reads, line iteration, writes, writelines, tell, seek, flush, and close. Mode, encoding, errors, and newline options must be literals. Supported newlines are None and ""; decoding remains strict UTF-8.

Write and inspect

This example creates or overwrites update-demo.txt, writes two Unicode lines, then rewinds before reading them back.

def main():
    with open("update-demo.txt", "w+", encoding="utf-8", newline="") as f:
        f.writelines(["café\n", "ready\n"])
        f.seek(0)
        print(f.readline().strip())
        print(f.readline().strip())
    return 0

Expected output:

café
ready

Read and replace from the beginning

Read an existing file, then seek to zero before replacing its contents. This example replaces one ASCII digit with another, keeping the encoded byte length unchanged. It creates or overwrites status-demo.txt to make the input reproducible.

def main():
    with open("status-demo.txt", "w", encoding="utf-8", newline="") as f:
        f.write("status=0\ncafé\n")
    with open("status-demo.txt", "r+", encoding="utf-8", newline="") as f:
        text = f.read()
        f.seek(0)
        f.write(text.replace("status=0", "status=1"))
        f.seek(0)
        print(f.readline().strip())
        print(f.readline().strip())
    return 0

Expected output:

status=1
café

Use seek(0) or seek(0, 2) to switch from reading to writing. Nonzero bookmarks taken during reading replay reads only in this profile. Python's decoder cookies can include buffered newline state that changes a subsequent write position. Bookmarks taken after writing can establish a later write position, provided that position has not also been recorded during reading. See File bookmarks and exclusive creation for replay and iteration rules.

Append and reread

An append-update handle starts at EOF. Seek to the beginning to inspect existing content. A later write still appends, regardless of the seek target. This example resets append-demo.txt before opening it in append-update mode.

def main():
    with open("append-demo.txt", "w", encoding="utf-8", newline="") as f:
        f.write("first\n")
    with open("append-demo.txt", "a+", encoding="utf-8", newline="") as f:
        f.write("second\n")
        f.seek(0)
        print(f.read().splitlines())
    return 0

Expected output:

['first', 'second']

Direction changes and limits

After a nonempty write, seek before any read, readline, readlines, or iterator advance. After a read attempt that consumes input or reaches EOF, seek before write or writelines. This also applies through aliases, borrowed handles, and bound methods.
Without that seek, Runtime raises UnsupportedOperation, catchable as OSError, before the opposite operation changes the file or cursor. This is a deliberate restriction beyond Python's text-file API. It avoids assuming a CPython buffering position that the generated program does not share.
Tell and flush do not authorize a direction change. Invalid seeks do not authorize one either. Empty reads/writes on a fresh or just-seeked handle do not establish a direction; they still cannot bypass a direction already established by another operation.
A nonzero read-derived bookmark is supported for replaying reads, but cannot establish a write position. The same restriction applies to seek(0, 1) after reading at a nonzero position. Python may restore decoder lookahead beyond the apparent cursor; Runtime rejects writing there with UnsupportedOperation. Seek to zero or EOF before writing instead. Bookmark restrictions remain conservative when file contents change. Repeating tell/seek does not bypass this restriction.
A successful seek synchronizes the host stream, discards newline lookahead, and clears the direction restriction. Seeking to a bookmark restores the logical text position, including after a CR newline.
Writes overwrite encoded bytes; they do not insert text or shorten the rest of a file. Replacing text with a different encoded length can damage UTF-8 or leave a trailing suffix. For changed-length content, write a complete new output. Truncate and binary modes remain unsupported.
Existing per-open read-byte and per-context file-operation, memory, and work budgets still apply. Seeking or switching direction never resets them. All scope exits still close owned handles, including exceptions and terminal resource failures.
Files must be seekable for positioning. Host C long offset limits apply. Concurrent external edits, locking, transactional replacement, and portable numeric bookmark values are outside this profile.

Opening w+ truncates immediately. Exclusive x+ protects an existing destination but does not roll back a later partial write. Use Exceptions and cleanup for recovery and File-processing limits for resource policies.