File Built-in Methods in Python: Complete Guide for Beginners

You opened a file and read through it. Now you need to read it again from the beginning, but when you call read() a second time, you get an empty string. Frustrating, right?

Here's what's happening: Python files are objects with a position pointer, like a cursor. Once you read to the end, the pointer stays there. Understanding file methods and how they move this pointer is key to efficient file handling.

This guide breaks down the essential file methods you'll actually use, with practical examples showing when and how to use each one. Whether you're a student learning Python or a developer working with files, mastering these methods makes your code cleaner and more efficient.

Understanding File Objects in Python

When you open a file with open(), Python creates a file object. This object has built-in methods for reading, writing, and navigating through the file. Think of it like a book with a bookmark—the file has content, and the pointer is your bookmark showing where you currently are.

Different methods do different things: some read data, some write data, and some move the pointer around. Understanding how each method affects the pointer position is crucial. Once you get this concept, file handling becomes much easier.

Just like understanding different file types in Python, knowing which method to use for which task saves time and prevents errors.

Essential Reading Methods

read() - Read Entire File or Specified Bytes

The read() method reads the entire file content as a single string and moves the pointer to the end.

with open('file.txt', 'r') as file:
    content = file.read()  # Reads everything
    print(content)
    
# Read specific number of characters
with open('file.txt', 'r') as file:
    first_10 = file.read(10)  # Reads first 10 characters
    next_10 = file.read(10)   # Reads next 10 characters

Use when: You need the entire file content at once and the file isn't too large.

Caution: Can use lots of memory with large files. A 1GB file will try to load 1GB into memory.

readline() - Read Single Line

Reads one line at a time (up to the newline character \n). Each call reads the next line.

with open('file.txt', 'r') as file:
    line1 = file.readline()  # First line
    line2 = file.readline()  # Second line
    line3 = file.readline()  # Third line

Use when: Processing files line by line, especially large files where loading everything into memory isn't practical.

Tip: Use .strip() to remove the newline character at the end.

readlines() - Read All Lines as List

Reads the entire file and returns a list where each line is a separate string.

with open('file.txt', 'r') as file:
    lines = file.readlines()  # Returns ['line1\n', 'line2\n', ...]
    for line in lines:
        print(line.strip())

Difference from read(): Returns a list of strings instead of one big string.

Use when: You need all lines as separate items and the file isn't too large.

Iterating Over File Object (Best Practice)

The most Pythonic and memory-efficient way to read line by line:

with open('file.txt', 'r') as file:
    for line in file:
        print(line.strip())

This doesn't load the entire file into memory. It reads one line at a time as needed. Python's elegant syntax makes this the cleanest approach for large files.

Essential Writing Methods

write() - Write String to File

Writes a string to the file. It doesn't automatically add newlines—you must add \n manually.

with open('output.txt', 'w') as file:
    file.write("First line\n")
    file.write("Second line\n")
    # Returns number of characters written

Use when: Writing strings or single lines to a file.

Remember: 'w' mode overwrites the entire file. Use 'a' mode to append.

writelines() - Write List of Strings

Takes a list of strings and writes them all to the file. Doesn't add newlines automatically.

lines = ["First line\n", "Second line\n", "Third line\n"]

with open('output.txt', 'w') as file:
    file.writelines(lines)

More efficient than calling write() multiple times in a loop.

Use when: Writing multiple lines from a list.

Common mistake: Forgetting to add \n to each string.

print() to Files

You can use the print() function to write to files. It automatically adds newlines.

with open('output.txt', 'w') as file:
    print("First line", file=file)
    print("Second line", file=file)

Advantage: Simpler syntax and automatic newlines.

File Navigation Methods

seek() - Move File Pointer

Changes the position of the file pointer. Most commonly used to go back to the beginning of a file.

with open('file.txt', 'r') as file:
    content = file.read()  # Read entire file
    print(content)
    
    file.seek(0)  # Go back to beginning
    content = file.read()  # Read entire file again
    print(content)

Use when: You need to reread a file without closing and reopening it.

Syntax: seek(offset, whence) where whence is 0 (start), 1 (current), or 2 (end). In text mode, only seek(0) is reliable.

tell() - Get Current Position

Returns the current position of the file pointer in bytes from the start.

with open('file.txt', 'r') as file:
    print(file.tell())  # 0 (at start)
    file.read(10)
    print(file.tell())  # 10 (after reading 10 chars)

Use when: Debugging file operations or tracking your position.

Combine with seek(): Save a position, do something, then return to that position.

truncate() - Resize File

Resizes the file to a specified size. If no size given, uses current pointer position.

with open('file.txt', 'r+') as file:
    file.truncate(100)  # Keep only first 100 bytes

Use when: You need to shorten a file or clear content from a specific point.

File State and Control Methods

close() - Close File

Closes the file and frees system resources. The file object becomes unusable after closing.

file = open('file.txt', 'r')
content = file.read()
file.close()  # Must close manually

Better practice: Use the with statement (shown in all examples above) which automatically closes files, even if errors occur. Understanding proper file handling and resource management is crucial for writing reliable code.

flush() - Force Write to Disk

Forces Python to write buffered data to disk immediately. Normally Python buffers writes for efficiency.

with open('log.txt', 'a') as file:
    file.write("Important log entry\n")
    file.flush()  # Ensure it's written to disk now

Use when: You need to ensure data is saved immediately, like in logging applications.

readable(), writable(), seekable() - Check File Capabilities

These methods check what operations are possible on the file.

with open('file.txt', 'r') as file:
    print(file.readable())   # True
    print(file.writable())   # False (opened in read mode)
    print(file.seekable())   # True (regular files support seek)

Use when: Verifying file capabilities before attempting operations.

File Attributes

Files have useful attributes (not methods—no parentheses needed):

with open('data.txt', 'r') as file:
    print(file.name)    # 'data.txt'
    print(file.mode)    # 'r'
    print(file.closed)  # False (still open in with block)

Practical Examples and Common Patterns

Reading Large Files in Chunks

For very large files, read in manageable chunks:

with open('huge_file.txt', 'r') as file:
    while True:
        chunk = file.read(1024)  # Read 1024 bytes at a time
        if not chunk:
            break
        process(chunk)

Reading and Writing Simultaneously

Open in 'r+' mode to read and write:

with open('file.txt', 'r+') as file:
    content = file.read()
    file.seek(0)
    file.write(content.upper())

Appending to Existing Files

Use 'a' mode to add to the end without erasing content:

with open('log.txt', 'a') as file:
    file.write("New log entry\n")

Common Mistakes and Best Practices

Common Mistakes

• Forgetting to close files: Always use with statement instead of manual close().
• Using read() on huge files: This loads everything into memory. Use iteration or readline() instead.
• Not handling exceptions: File operations can fail. Use try-except blocks.
• Forgetting newlines: write() doesn't add them automatically.
• Assuming seek() works everywhere: In text mode, only seek(0) is reliable.

Best Practices

Always use with statement:

# Good
with open('file.txt', 'r') as file:
    content = file.read()

# Bad
file = open('file.txt', 'r')
content = file.read()
file.close()  # Easy to forget!

Choose the right method for file size:

• Small files: read() or readlines()
• Large files: iterate over file object
• Unknown size: iterate to be safe

Handle errors gracefully:

try:
    with open('file.txt', 'r') as file:
        content = file.read()
except FileNotFoundError:
    print("File doesn't exist!")
except PermissionError:
    print("No permission to read file!")

Always specify encoding:

with open('file.txt', 'r', encoding='utf-8') as file:
    content = file.read()

Method Selection Guide

Quick reference for choosing the right method:

• Reading entire small file: read()
• Processing line by line: Iterate over file object
• Need all lines as list: readlines()
• Writing single string: write()
• Writing multiple lines: writelines() or loop with write()
• Reread file: seek(0) then read again
• Check current position: tell()
• Ensure data saved: flush()

Frequently Asked Questions

What's the difference between read() and readlines()?

read() returns the entire file as a single string. readlines() returns a list where each line is a separate item.

Why use readline() instead of readlines()?

readline() is memory-efficient for large files—it reads one line at a time. readlines() loads the entire file into memory.

Do I always need to call close()?

Yes, but use the with statement instead—it closes automatically, even if errors occur.

What happens if I call read() twice?

The second call returns an empty string because the pointer is at the end. Use seek(0) to go back to the beginning.

Why doesn't write() add newlines?

Python doesn't assume you want newlines. Add \n manually or use the print() function with file= parameter.

Conclusion

File methods give you powerful control over file operations. The most commonly used are read(), write(), and seek(). Always use the with statement for automatic resource management.

Choose methods based on file size: read() for small files, iteration for large files. Practice with different methods to understand when each is best. Start with basic read/write operations, then explore navigation methods like seek() and tell(). These fundamentals apply across all Python file operations and will serve you throughout your programming journey.