# File Handling Techniques in Day 19 of 30 Days of Python: A Complete Guide

> Master Python file handling techniques on Day 19 of 30 Days of Python. Learn open functions, read write append operations, and parse JSON CSV XML files.

- Repository: [Asabeneh/30-Days-Of-Python](https://github.com/Asabeneh/30-Days-Of-Python)
- Tags: tutorial
- Published: 2026-03-06

---

**Day 19 of the 30 Days of Python curriculum covers essential file handling techniques including the `open()` function with various modes, reading methods like `read()` and `readlines()`, writing and appending operations, safe file deletion using the `os` module, and parsing popular formats such as JSON, CSV, and XML.**

The Asabeneh/30-Days-Of-Python repository provides a structured introduction to Python programming, with Day 19 focusing specifically on persistent data storage through file handling. This lesson demonstrates how to interact with the file system using Python's built-in functions and standard library modules to create, read, update, and delete files across multiple formats.

## Opening Files with `open()` and Context Managers

The foundation of Day 19's file handling instruction rests on Python's built-in `open()` function and the **context manager** protocol. According to the source material in [`19_Day_File_handling/19_file_handling.md`](https://github.com/Asabeneh/30-Days-Of-Python/blob/main/19_Day_File_handling/19_file_handling.md), the curriculum emphasizes using the `with` statement to ensure files are automatically closed after operations complete, preventing resource leaks and file corruption.

```python

# Safe file opening with automatic closure

with open('files/reading_file_example.txt') as f:
    content = f.read()
    print(content)

```

### Understanding File Modes

The tutorial explains six distinct mode parameters that control how Python interacts with the file system:

- **`r`** – Opens a file for **reading** (default mode, raises error if file doesn't exist)
- **`a`** – Opens for **appending**, creating the file if it doesn't exist
- **`w`** – Opens for **writing**, overwriting existing content or creating a new file
- **`x`** – **Exclusive creation**, failing if the file already exists
- **`t`** – **Text mode** (default), handling content as strings
- **`b`** – **Binary mode**, handling content as bytes for non-text files

## Reading File Contents

Day 19 introduces four distinct methods for retrieving data from text files, each suited to different processing scenarios. The [`19_file_handling.md`](https://github.com/Asabeneh/30-Days-Of-Python/blob/main/19_file_handling.md) file demonstrates these approaches using [`files/reading_file_example.txt`](https://github.com/Asabeneh/30-Days-Of-Python/blob/main/files/reading_file_example.txt) as a reference dataset.

**`read()`** returns the entire file content as a single string:

```python
with open('files/reading_file_example.txt') as f:
    content = f.read()
    print(content)  # Entire file as one string

```

**`readline()`** retrieves a single line, maintaining the file pointer position for subsequent reads:

```python
with open('files/reading_file_example.txt') as f:
    first_line = f.readline()
    print(first_line)  # Only the first line with newline character

```

**`readlines()`** returns a list where each element represents one line from the file:

```python
with open('files/reading_file_example.txt') as f:
    lines = f.readlines()
    print(lines)  # ['First line\n', 'Second line\n', ...]

```

**`splitlines()`** removes newline characters by splitting the string at line boundaries:

```python
with open('files/reading_file_example.txt') as f:
    lines = f.read().splitlines()
    print(lines)  # ['First line', 'Second line', ...] without \n

```

## Writing and Appending to Files

The curriculum distinguishes between **overwriting** existing content and **appending** to it through mode selection. When using mode `'w'`, the `write()` method replaces existing data entirely, while mode `'a'` adds content to the file's end.

```python

# Overwrite or create new file

with open('files/writing_file_example.txt', 'w') as f:
    f.write('New content replaces old data.\n')
    f.write('Second line of new content.\n')

# Append to existing file

with open('files/reading_file_example.txt', 'a') as f:
    f.write('This line is appended at the end.\n')

```

## Deleting Files Safely with `os.remove()`

Day 19 teaches defensive programming practices for file deletion using the `os` module. The recommended pattern checks for file existence before attempting removal to prevent `FileNotFoundError` exceptions.

```python
import os

path = 'files/temporary.txt'

if os.path.exists(path):
    os.remove(path)
    print(f'{path} deleted successfully')
else:
    print('File does not exist')

```

## Working with Structured Data Formats

Beyond plain text, the lesson covers parsing and writing industry-standard formats using Python's standard library and third-party packages.

### JSON Serialization

Using the `json` module, the tutorial demonstrates dictionary serialization with `json.dump()` and deserialization with `json.load()`:

```python
import json

person = {'name': 'Asabeneh', 'city': 'Helsinki'}

# Write JSON with formatting

with open('files/person.json', 'w', encoding='utf-8') as f:
    json.dump(person, f, ensure_ascii=False, indent=4)

# Read back into dictionary

with open('files/person.json') as f:
    data = json.load(f)
    print(data['name'])  # Asabeneh

```

### CSV Processing

The `csv` module's `DictReader` provides dictionary-based access to tabular data in `files/csv_example.csv`:

```python
import csv

with open('files/csv_example.csv', newline='') as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(row['name'], row['country'])

```

### XML Parsing

For XML documents like [`files/xml_example.xml`](https://github.com/Asabeneh/30-Days-Of-Python/blob/main/files/xml_example.xml), the curriculum uses `xml.etree.ElementTree` to navigate hierarchical data:

```python
import xml.etree.ElementTree as ET

tree = ET.parse('files/xml_example.xml')
root = tree.getroot()

print(root.tag)      # person

print(root.attrib)   # {'gender': 'female'}

for child in root:
    print(f'{child.tag}: {child.text}')

```

## Summary

- **File modes** (`r`, `a`, `w`, `x`, `t`, `b`) determine read, write, append, and binary operation capabilities when opening files with `open()`.
- **Context managers** (`with` statements) ensure automatic file closure and prevent resource leaks in production code.
- **Reading methods** include `read()` for full content, `readline()` for single lines, and `readlines()`/`splitlines()` for list-based processing.
- **Safe deletion** requires checking `os.path.exists()` before calling `os.remove()` to avoid runtime exceptions.
- **Structured formats** (JSON, CSV, XML) are handled through standard library modules (`json`, `csv`, `xml.etree.ElementTree`) for robust data exchange.

## Frequently Asked Questions

### What file modes are taught in Day 19 of 30 Days of Python?

Day 19 covers six primary modes: `r` (read), `a` (append), `w` (write), `x` (exclusive creation), `t` (text), and `b` (binary). These modes control whether Python opens a file for reading, writing, or appending, and whether the content is treated as text strings or binary bytes.

### How does the curriculum teach safe file deletion?

The tutorial recommends using `os.path.exists()` to verify a file's presence before calling `os.remove()`. This defensive pattern prevents `FileNotFoundError` exceptions and ensures idempotent deletion operations across different runtime environments.

### Which file formats are covered beyond plain text?

In addition to `.txt` files, Day 19 provides practical examples for **JSON** (using the `json` module), **CSV** (using `csv.DictReader`), **XML** (using `xml.etree.ElementTree`), and references **XLSX** handling for Excel spreadsheets, demonstrating real-world data persistence scenarios.

### Why is the `with` statement emphasized for file handling?

The `with` statement creates a **context manager** that automatically invokes `close()` on the file object when the block exits, even if exceptions occur. This eliminates manual resource management errors and is presented as the canonical pattern for production-grade file I/O in Python.