Skip to main content

Reading Text Files: `read()`, `readline()`, and `readlines()`

In the last article, we learned how to open files using different modes. Now, let's focus on the primary reason you'd open a file in read mode ('r'): to get data out of it. Python's file objects provide several methods for reading content, each suited for different situations.

This article will cover the three main methods for reading text files: read(), readline(), and readlines(), and we'll discuss the most common and efficient way to read a file line by line.

📚 Prerequisites​

You should understand how to open a file using the with open(...) syntax. For the following examples, assume we have a file named haiku.txt with this content:

An old silent pond...
A frog jumps into the pond,
splash! Silence again.

🎯 Article Outline: What You'll Master​

In this article, you will learn:

  • ✅ file.read(): How to read the entire content of a file into a single string.
  • ✅ file.readline(): How to read a file one line at a time.
  • ✅ file.readlines(): How to read all lines of a file into a list of strings.
  • ✅ The Pythonic Way: The most efficient and recommended method for processing a text file line by line.

🧠 Section 1: file.read() - Reading Everything at Once​

The .read() method is the simplest way to get content from a file. It reads from the current position until the end of the file and returns everything as a single string.

When to use it: This method is best for files that are small enough to comfortably fit into your computer's memory.

Example:

# read_entire_file.py

with open('haiku.txt', 'r') as f:
    content = f.read()

print("--- Output of .read() ---")
print(content)
print(f"Type of content: {type(content)}")

# Output:
# --- Output of .read() ---
# An old silent pond...
# A frog jumps into the pond,
# splash! Silence again.
#
# Type of content: <class 'str'>

The Danger: Be very careful using .read() on potentially large files. If you try to read a 5 GB log file into memory on a machine with only 4 GB of RAM, your program will likely crash.

💻 Section 2: file.readline() - Reading a Single Line​

The .readline() method provides more control by reading only one line from the file at a time, stopping at the newline character (\n). It returns the line as a string.

Each time you call .readline(), it reads the next line in the file. When it reaches the end of the file, it will return an empty string ('').

When to use it: This is useful when you're only interested in the first few lines of a file or when you're processing a very large file and need to manage memory carefully.

Example:

# read_one_line.py

with open('haiku.txt', 'r') as f:
    line1 = f.readline()
    line2 = f.readline()

# .strip() is used to remove the trailing newline character
print(f"Line 1: {line1.strip()}")
print(f"Line 2: {line2.strip()}")

# Output:
# Line 1: An old silent pond...
# Line 2: A frog jumps into the pond,

🛠️ Section 3: file.readlines() - Reading All Lines into a List​

The .readlines() method reads all the lines from a file and returns them as a list of strings. Each string in the list represents one line from the file and includes the trailing newline character (\n).

When to use it: This is convenient when you need to have all the lines available in a list structure, perhaps to sort them or access them by index. Like .read(), this method should only be used on files small enough to fit into memory.

Example:

# read_all_lines.py

with open('haiku.txt', 'r') as f:
    lines_list = f.readlines()

print("--- Output of .readlines() ---")
print(lines_list)
print(f"\nThe third line is: {lines_list[2].strip()}")

# Output:
# --- Output of .readlines() ---
# ['An old silent pond...\n', 'A frog jumps into the pond,\n', 'splash! Silence again.']
#
# The third line is: splash! Silence again.

🚀 Section 4: The Best of Both Worlds - Iterating Over the File​

So, .read() and .readlines() can use too much memory, and using .readline() in a manual while loop is a bit clumsy. What's the best way to process a large file line by line?

The most Pythonic, readable, and memory-efficient way is to iterate directly over the file object in a for loop. Python handles the memory management for you, reading the file one line at a time under the hood.

This is the recommended approach for most line-by-line processing tasks.

Example:

# iterate_over_file.py

print("--- Reading line by line with a for loop ---")
with open('haiku.txt', 'r') as f:
    for line in f:
        # The 'line' variable contains one line from the file per iteration
        print(f"Processing line: {line.strip()}")

# Output:
# --- Reading line by line with a for loop ---
# Processing line: An old silent pond...
# Processing line: A frog jumps into the pond,
# Processing line: splash! Silence again.

This code gives you the memory efficiency of .readline() with the clean syntax of a for loop.

✨ Conclusion & Key Takeaways​

You now have a complete toolkit for reading text files in Python. Choosing the right method depends on the size of the file and what you need to do with its content.

Let's summarize the key takeaways:

  • file.read(): Reads the whole file into one string. Best for small files.
  • file.readlines(): Reads the whole file into a list of strings. Best for small files when you need a list.
  • file.readline(): Reads one line at a time. Good for memory control but can be verbose.
  • for line in file:: The preferred, Pythonic way to process any file line by line. It's both readable and memory-efficient.

Challenge Yourself: Create a text file with a list of names, one name per line. Write a Python script that reads the file and prints out only the names that are longer than 5 characters. Use the recommended for line in file: approach.

➡️ Next Steps​

Now that you've mastered reading files, the next logical step is to learn the different ways to write to them. In the next article, we'll cover "Writing Text Files: write() and writelines()."

Happy reading!