Writing and Appending Files in Python: Complete Guide for Beginner

Writing data to files is one of the most common tasks in Python programming. While reading files retrieves stored information, writing files allows programs to save new data permanently. Almost every real-world application writes information to files, including student management systems, banking software, web applications, data analytics tools, and machine learning projects.

Whenever a user submits a form, generates a report, saves settings, or records transaction details, the application writes that information into one or more files. Python makes this process simple through built-in file handling functions.

In this lesson, you will learn how to write data to files using the write() method, understand write mode (w), create new files, overwrite existing files, and explore practical examples from real-world applications.

Learning Objectives

After completing this lesson, you will be able to:

• Understand why writing files is important.
• Create new files using Python.
• Write text into files using the write() method.
• Understand write mode (w).
• Recognize how existing files are overwritten.
• Apply file writing in practical applications.

Why Writing Files is Important

Programs often need to save information so that it can be used later. Without file writing, data would disappear when the program ends.

Common uses include:

• Saving student records.
• Generating invoices.
• Recording user registrations.
• Creating log files.
• Saving application settings.
• Exporting reports.

Writing Files using the write() Method

The write() method writes text into a file.

Syntax

file.write(data)

The method writes the specified string into the file and returns the number of characters written.

Opening a File in Write Mode

Before writing data, the file must be opened in w mode.

Syntax

file = open("filename.txt", "w")

The w mode performs the following actions:

• Creates the file if it does not exist.
• Removes all existing contents if the file already exists.
• Allows new data to be written.

Example 1: Creating a New File

file = open("student.txt", "w")

file.write("Rahul")

file.close()

print("File Created Successfully")

Output

File Created Successfully

The file student.txt is created, and the text Rahul is written into it.

Contents of student.txt

Rahul

Writing Multiple Words

file = open("course.txt", "w")

file.write("Python File Handling")

file.close()

Contents of course.txt

Python File Handling

Writing Multiple Lines

You can include newline characters (\n) inside the string.

file = open("students.txt", "w")

file.write("Rahul\n")

file.write("Priya\n")

file.write("Amit")

file.close()

Contents of students.txt

Rahul
Priya
Amit

Understanding File Overwriting

The biggest characteristic of w mode is that it removes all existing data before writing new content.

Suppose student.txt initially contains:

Rahul
Python
92

Now execute:

file = open("student.txt", "w")

file.write("Neha")

file.close()

Contents of student.txt

Neha

All previous data has been removed because the file was opened in write mode.

Writing Numbers

The write() method accepts only strings. Numbers must be converted before writing.

marks = 95

file = open("marks.txt", "w")

file.write(str(marks))

file.close()

Contents of marks.txt

95

Real-World Applications

Application	Purpose
School Management	Save student information.
Hospital System	Store patient records.
Banking Software	Record transactions.
Data Analytics	Generate reports.
Inventory System	Store product details.
Website	Save user feedback.

Practical Example

file = open("employee.txt", "w")

file.write("Name: Neha\n")

file.write("Department: HR\n")

file.write("Salary: 50000")

file.close()

print("Employee Record Saved")

Output

Employee Record Saved

Contents of employee.txt

Name: Neha
Department: HR
Salary: 50000

Execution Flow

Consider the following program.

file = open("sample.txt", "w")

file.write("Hello Python")

file.close()

Execution Steps

1. Python opens or creates the file.
2. The file is opened in write mode.
3. Existing contents, if any, are removed.
4. The text is written into the file.
5. The file is saved and closed.

Contents of sample.txt

Hello Python

Common Beginner Mistakes

• Opening an important file in w mode without realizing that existing data will be deleted.
• Forgetting to close the file after writing.
• Trying to write integers or floats directly without converting them to strings.
• Forgetting to include \n when writing multiple lines.
• Using the wrong file mode for the required task.

Chunk Summary

In this section, you learned how to create files, write text using the write() method, understand write mode (w), overwrite existing files, and save multiple lines of data. You also explored practical examples, execution flow, and common beginner mistakes. In the next section, you will learn how to append data using append mode (a), write multiple lines efficiently using writelines(), compare write() and writelines(), and apply these techniques in real-world Python programs.

In the previous section, you learned how to create files and write data using the write() method. While write mode (w) is useful for creating new files or replacing existing contents, there are many situations where you want to keep the existing data and simply add new information. Python provides append mode (a) for this purpose.

In this section, you will learn how to append data to files, write multiple lines using the writelines() method, compare write() and writelines(), and apply these techniques in practical Python programs.

Appending Data using Append Mode (a)

The append mode opens a file for writing without deleting its existing contents. Any new data is added to the end of the file.

Syntax

file = open("filename.txt", "a")

If the file does not exist, Python automatically creates it.

Example

Suppose student.txt contains:

Rahul
Python

Python program:

file = open("student.txt", "a")

file.write("92")

file.close()

Contents of student.txt

Rahul
Python
92

The existing data remains unchanged, and the new data is added at the end.

Appending Multiple Lines

Use newline characters (\n) to add multiple lines.

file = open("students.txt", "a")

file.write("\nPriya")

file.write("\nAmit")

file.close()

Contents of students.txt

Rahul
Priya
Amit

The writelines() Method

The writelines() method writes multiple strings from an iterable, such as a list, into a file.

Syntax

file.writelines(iterable)

Unlike write(), this method expects a collection of strings.

Example

students = [
    "Rahul\n",
    "Priya\n",
    "Amit\n"
]

file = open("students.txt", "w")

file.writelines(students)

file.close()

Contents of students.txt

Rahul
Priya
Amit

Important Note about writelines()

The writelines() method does not automatically insert newline characters. If you want each value to appear on a new line, include \n in each string.

Incorrect Example

names = [
    "Rahul",
    "Priya",
    "Amit"
]

file = open("names.txt", "w")

file.writelines(names)

file.close()

Contents of names.txt

RahulPriyaAmit

Correct Example

names = [
    "Rahul\n",
    "Priya\n",
    "Amit\n"
]

file = open("names.txt", "w")

file.writelines(names)

file.close()

Contents of names.txt

Rahul
Priya
Amit

Difference Between write() and writelines()

Feature	write()	writelines()
Writes	Single string	Multiple strings
Input	String	Iterable of strings
Automatic New Line	No	No
Common Use	Writing one value	Writing many lines

Practical Example 1: Student Records

students = [
    "Rahul\n",
    "Priya\n",
    "Amit\n"
]

file = open("students.txt", "w")

file.writelines(students)

file.close()

print("Student Records Saved")

Output

Student Records Saved

Practical Example 2: Daily Log File

file = open("log.txt", "a")

file.write("Application Started\n")

file.close()

Each time the program runs, a new log entry is added without removing previous records.

Practical Example 3: Saving Product Names

products = [
    "Laptop\n",
    "Mouse\n",
    "Keyboard\n"
]

file = open("products.txt", "w")

file.writelines(products)

file.close()

Contents of products.txt

Laptop
Mouse
Keyboard

Best Practices

• Use w mode only when replacing existing data is acceptable.
• Use a mode when existing information should be preserved.
• Use writelines() when writing multiple strings.
• Include \n manually when each value should appear on a new line.
• Always close the file after writing.

Execution Flow

Consider the following program.

file = open("notes.txt", "a")

file.write("Python File Handling\n")

file.close()

Execution Steps

1. Python opens the file in append mode.
2. If the file does not exist, it is created.
3. The file pointer moves to the end of the file.
4. The new text is written after the existing contents.
5. The file is saved and closed.

Contents of notes.txt

Existing Notes
Python File Handling

Common Beginner Mistakes

• Using w mode instead of a mode and accidentally deleting existing data.
• Forgetting to include \n when writing multiple lines.
• Passing integers directly to write() without converting them to strings.
• Assuming writelines() automatically inserts line breaks.
• Leaving files open after writing.

Chunk Summary

In this section, you learned how to append data using append mode (a), write multiple lines using the writelines() method, and understand the differences between write() and writelines(). You also explored practical examples, best practices, execution flow, and common beginner mistakes. In the next section, you will learn how to write user input to files, generate reports, write binary files, handle writing errors, improve performance, and apply advanced file writing techniques in real-world applications.

In the previous section, you learned how to write data using the write() method, append new information using append mode (a), and write multiple strings using the writelines() method. In real-world applications, however, data is often entered by users, generated automatically, or collected from other systems before being written to files. Python also supports writing binary files and handling errors that may occur during file operations.

In this section, you will learn how to write user input to files, generate reports, write binary files, handle file writing errors, improve performance, and explore practical real-world applications.

Writing User Input to a File

Many applications collect information from users and save it for future use.

Example

name = input("Enter your name: ")

file = open("users.txt", "a")

file.write(name + "\n")

file.close()

print("Record Saved Successfully")

Sample Output

Enter your name: Rahul

Record Saved Successfully

Contents of users.txt

Rahul

Writing Multiple User Records

file = open("students.txt", "a")

for i in range(3):
    name = input("Enter Student Name: ")
    file.write(name + "\n")

file.close()

print("All Records Saved")

Sample Output

Enter Student Name: Rahul

Enter Student Name: Priya

Enter Student Name: Amit

All Records Saved

Generating Reports

Python programs often generate reports and save them into text files.

Example

file = open("report.txt", "w")

file.write("Monthly Sales Report\n")
file.write("--------------------\n")
file.write("Total Sales : 150\n")
file.write("Revenue     : ₹450000\n")

file.close()

Contents of report.txt

Monthly Sales Report
--------------------
Total Sales : 150
Revenue     : ₹450000

Writing Large Files Efficiently

When writing large amounts of data, avoid opening and closing the file repeatedly. Open the file once, write all data, and then close it.

Efficient Example

file = open("numbers.txt", "w")

for number in range(1, 101):
    file.write(str(number) + "\n")

file.close()

This program writes the numbers 1 to 100 into a file efficiently.

Writing Binary Files

Binary files such as images, audio files, PDFs, and videos must be written using binary mode.

Example

data = b"Python"

file = open("sample.bin", "wb")

file.write(data)

file.close()

Result

A binary file named sample.bin is created containing the byte data.

Error Handling While Writing Files

Sometimes writing to a file may fail due to invalid paths, insufficient permissions, or storage issues. Python’s try and except statements can handle such errors gracefully.

Example

try:
    file = open("student.txt", "w")

    file.write("Python File Handling")

    file.close()

    print("File Saved Successfully")

except Exception as error:
    print("Error:", error)

Output

File Saved Successfully

If an error occurs, Python displays the error message instead of terminating the program abruptly.

Performance Tips

• Open a file only once when writing multiple records.
• Use writelines() for writing collections of strings.
• Close files immediately after writing.
• Avoid opening and closing the same file inside loops.
• Use binary mode only when working with binary data.

Real-World Applications

Application	Purpose
Student Management	Save admission records.
Employee Management	Store employee details.
Banking Software	Save transaction history.
Inventory System	Generate stock reports.
Website	Store contact form submissions.
Data Analytics	Export processed results.

Practical Example

file = open("employees.txt", "w")

employees = [
    "Rahul\n",
    "Neha\n",
    "Priya\n"
]

file.writelines(employees)

file.close()

print("Employee List Saved")

Output

Employee List Saved

Contents of employees.txt

Rahul
Neha
Priya

Execution Flow

Consider the following program.

name = input("Enter Name: ")

file = open("users.txt", "a")

file.write(name + "\n")

file.close()

Execution Steps

1. The program accepts user input.
2. The file is opened in append mode.
3. The entered name is written at the end of the file.
4. The file is saved.
5. The file is closed.

Sample Output

Enter Name: Rahul

Contents of users.txt

Rahul

Common Beginner Mistakes

• Opening and closing a file repeatedly inside a loop.
• Using write mode (w) instead of append mode (a) for adding new records.
• Writing non-string values without converting them using str().
• Ignoring errors that occur during file writing.
• Using text mode for binary data.

Chunk Summary

In this section, you learned how to write user input to files, generate reports, efficiently write large amounts of data, create binary files, and handle writing errors using try and except. You also explored performance tips, practical applications, execution flow, and common beginner mistakes. In the final section, you will review the complete lesson through a lesson summary, key takeaways, FAQs, coding exercises, interview questions, a mini project, and a preview of the next lesson on Working with CSV and JSON Files.

Lesson Summary

In this lesson, you learned how to write and append data to files in Python. Writing files allows programs to permanently store information such as user records, reports, logs, transaction details, and application settings. It is one of the most frequently used operations in real-world software development.

You began by understanding the importance of writing files and learned how to create new files using write mode (w). You explored the write() method, learned how to write single and multiple lines, and understood how write mode overwrites existing file contents.

Next, you learned how to preserve existing data using append mode (a). You explored the writelines() method, compared it with write(), and learned how to efficiently write multiple strings into a file.

Finally, you learned how to write user input into files, generate reports, write binary files, handle writing errors using try and except, and improve file writing performance using best practices.

These skills are essential for developing applications that need to save information permanently, including management systems, websites, desktop applications, automation scripts, and data analytics projects.

Key Takeaways

• Use write() to write a single string into a file.
• Open files in w mode to create or overwrite files.
• Open files in a mode to preserve existing data while adding new information.
• Use writelines() to write multiple strings.
• Include \n manually when writing multiple lines.
• Convert numbers to strings before writing.
• Use wb mode for writing binary files.
• Use try and except to handle writing errors.
• Open a file once when writing multiple records.
• Always close files after writing.

Frequently Asked Questions (FAQs)

1. Which mode is used to write data into a file?

The w mode is used to write data into a file.

2. What happens if a file already exists in w mode?

All existing contents are removed before new data is written.

3. Which mode should be used to preserve existing data?

The a (append) mode.

4. What is the difference between write() and writelines()?

write() writes a single string, whereas writelines() writes multiple strings from an iterable.

5. Does writelines() automatically add new lines?

No. You must include \n manually.

6. Can numbers be written directly using write()?

No. Numbers should first be converted into strings using str().

7. Which mode is used for writing binary files?

The wb mode.

8. Why should files be closed after writing?

Closing a file saves all changes and releases system resources.

9. Why is append mode useful?

It allows new information to be added without deleting existing data.

10. How can writing errors be handled?

By using try and except statements.

Coding Exercises

1. Create a file and write your name into it.
2. Create a file containing five city names.
3. Overwrite an existing file with new content.
4. Append three new lines to an existing file.
5. Write numbers from 1 to 20 into a file.
6. Use writelines() to save a list of student names.
7. Accept user input and store it in a file.
8. Create a simple sales report and save it.
9. Create a binary file using wb mode.
10. Handle file writing errors using try and except.

Interview Questions

1. What is the purpose of the write() method?
2. Explain the difference between w mode and a mode.
3. What happens when an existing file is opened in write mode?
4. How does writelines() differ from write()?
5. Why must newline characters be added manually?
6. How do you write numbers into a file?
7. Which mode is used for binary file writing?
8. Why should files always be closed?
9. How do you append data without deleting existing contents?
10. What are the best practices for writing files?

Mini Project: Student Record Writer

Create a Python program that stores student records in a text file.

Your program should:

• Accept student name, course, and marks from the user.
• Store the information in a file.
• Append new student records without deleting previous ones.
• Display a success message after saving each record.
• Handle invalid file operations using try and except.

Sample Output

========== STUDENT RECORD WRITER ==========

Enter Student Name : Rahul

Enter Course : Python

Enter Marks : 92

Record Saved Successfully

------------------------------------------

Enter Student Name : Priya

Enter Course : Data Analytics

Enter Marks : 95

Record Saved Successfully

==========================================

What’s Next?

Congratulations! You have learned how to create files, write data, append new information, write multiple lines, generate reports, save user input, write binary files, and handle writing errors in Python. These skills enable you to build applications that permanently store and manage data.

In the next lesson, you will learn Working with CSV and JSON Files: Complete Guide for Beginners. You will explore Python’s csv and json modules, learn how to read and write structured data, and understand how CSV and JSON files are widely used in data analytics, APIs, web development, and data exchange.