Python Files and File Handling

A tuple is an ordered, immutable sequence of values — like a list that cannot be changed after it is created.

You create a tuple with parentheses and comma-separated values. Once created, you cannot add, remove, or replace any element. This immutability is not a limitation — it is a guarantee: when you pass a tuple to a function, you can be certain the data won't be modified.

python
coordinates = (40.7128, -74.0060)
print(coordinates[0])   # 40.7128
print(coordinates[1])   # -74.0060

Indexing and slicing work exactly as they do for lists: t[0] for the first element, t[-1] for the last, t[1:3] for a slice.

---

A single-element tuple requires a trailing comma — otherwise Python treats the parentheses as grouping, not a tuple.

python
not_a_tuple = (42)       # int, not tuple
is_a_tuple  = (42,)      # tuple with one element

Packing and unpacking let you assign a tuple's elements to variables in one line. This is especially useful for returning multiple values from a function — Python bundles the values into a tuple automatically.

python
def min_max(numbers):
    return min(numbers), max(numbers)   # returns a tuple

lo, hi = min_max([3, 1, 7, 2])          # unpacks it
print(lo, hi)   # 1 7

Use tuples whenever the data is a fixed collection — coordinates, RGB colours, a (key, value) pair — and a list when the collection will grow or change.

Tuples show up constantly in Python's standard library — once you recognise the patterns, you'll use them everywhere.

zip() pairs elements from two lists into tuples, making it easy to process related data together. It stops at the shorter list, so both lists should be the same length.

python
names  = ['Alice', 'Bob', 'Carol']
scores = [88, 92, 75]

for name, score in zip(names, scores):
    print(f'{name}: {score}')
# Alice: 88
# Bob: 92
# Carol: 75

enumerate() wraps any iterable and yields (index, value) tuples — the cleanest way to loop when you need both position and value.

python
for i, name in enumerate(['Alice', 'Bob', 'Carol']):
    print(f'{i}: {name}')
# 0: Alice
# 1: Bob
# 2: Carol

---

Because tuples are immutable, Python can hash them — which means you can use a tuple as a dictionary key. Lists cannot be dictionary keys.

python
grid = {}
grid[(0, 0)] = 'start'
grid[(3, 4)] = 'exit'
print(grid[(0, 0)])   # 'start'

Finally, variable swapping with tuples eliminates the temporary variable. Python evaluates the right-hand side first, packs it into a tuple, then unpacks it on the left.

python
a, b = 10, 20
a, b = b, a
print(a, b)   # 20 10

Use zip() when combining two parallel lists, enumerate() when you need loop indices, tuple keys when your dictionary needs a composite key, and swap syntax whenever you'd otherwise reach for a temp variable.

A set is an unordered collection of unique values — no element can appear more than once, and there is no guaranteed order.

Create a set with curly braces {} when you know the values upfront, or with set() to convert another iterable. Be careful: {} alone creates an empty dict, not an empty set — use set() for an empty set.

python
colours = {'red', 'blue', 'green', 'red'}  # duplicate 'red' is dropped
print(colours)   # {'blue', 'green', 'red'} — order may vary

from_list = set([1, 2, 2, 3, 3, 3])
print(from_list)  # {1, 2, 3}

empty = set()     # not {} — that's a dict

The most common reason to reach for a set is fast membership testing. in on a set is O(1) — it doesn't matter if the set has 10 elements or 10 million.

python
allowed = {'admin', 'editor', 'viewer'}
role = 'editor'
print(role in allowed)   # True

---

Sets are mutable: you can add and remove elements after creation.

python
tags = {'python', 'beginner'}
tags.add('files')         # adds 'files'
tags.discard('missing')   # safe — no error if element absent
tags.remove('beginner')   # raises KeyError if absent — be certain it's there
print(tags)   # {'python', 'files'}

Use .discard() when you're not sure the element exists; use .remove() only when you are sure — it raises a KeyError otherwise.

Use a set whenever you need unique values, fast membership testing, or want to remove duplicates from a list.

Set operations let you compare and combine sets using simple operators — the same symbols used in mathematics.

Given two sets a and b:

• a | b — union: all elements in either set
• a & b — intersection: only elements in both sets
• a - b — difference: elements in a but not in b
• a ^ b — symmetric difference: elements in one set but not both

python
python_learners = {'Alice', 'Bob', 'Carol'}
js_learners     = {'Bob', 'Carol', 'Dave'}

print(python_learners | js_learners)  # {'Alice', 'Bob', 'Carol', 'Dave'}
print(python_learners & js_learners)  # {'Bob', 'Carol'}
print(python_learners - js_learners)  # {'Alice'}
print(python_learners ^ js_learners)  # {'Alice', 'Dave'}

---

One of the most practical applications of sets is removing duplicates from a list. Converting a list to a set drops all duplicates; converting back to a list gives you a deduplicated list.

python
visits = ['home', 'about', 'home', 'contact', 'about', 'home']
unique_pages = list(set(visits))
print(unique_pages)   # ['about', 'contact', 'home'] — order not guaranteed

Note that sets are unordered, so if you need a sorted result, call sorted() instead of list().

python
sorted_unique = sorted(set(visits))
print(sorted_unique)  # ['about', 'contact', 'home']

Use set operations any time you need to answer questions like "what do these two groups have in common?" or "what's in one group but not the other?" — they express the intent clearly and run efficiently.

The open() function returns a file object that lets you read or write a file — it takes at minimum a filename and returns a handle you can call methods on.

The two most common reading methods are .read(), which returns the entire file as a single string, and .readlines(), which returns a list of lines (each line includes its trailing newline character \n).

python
f = open('notes.txt')       # opens for reading by default
content = f.read()          # entire file as one string
f.close()                   # always close when done

f2 = open('notes.txt')
lines = f2.readlines()      # list of strings, one per line
f2.close()

Forget to call .close() and your program may hold the file open longer than necessary — or fail to flush written data.

---

The with statement solves this automatically. It is a context manager: it opens the file, runs the indented block, then closes the file for you — even if an error occurs inside the block.

python
with open('notes.txt') as f:
    content = f.read()
# file is closed here automatically
print(content)

If the file does not exist, open() raises a FileNotFoundError. You will learn to catch this in a later lesson — for now, make sure the filename is spelled correctly.

Use open() with with for all file reading — it is shorter, safer, and the standard Python idiom.

Iterating over a file object line by line with for line in file is the most memory-efficient way to read a large file — Python loads one line at a time instead of the whole file at once.

Each line includes its trailing newline character \n. Call .strip() on every line to remove both leading and trailing whitespace (including that newline) before processing.

python
lines = ['Alice,88\n', 'Bob,92\n', 'Carol,75\n']

for line in lines:
    clean = line.strip()     # 'Alice,88'
    print(clean)

Once a line is stripped, you can split it into fields using .split(',') for comma-separated data or .split() (no argument) to split on any whitespace.

python
for line in lines:
    name, score = line.strip().split(',')
    print(f'{name} scored {score}')

---

Combining these techniques lets you parse structured text files into Python data structures. Here the in-memory list of strings acts as a stand-in for a real file object — the same logic works with for line in file inside a with open(...) block.

python
records = []
for line in lines:
    parts = line.strip().split(',')
    records.append({'name': parts[0], 'score': int(parts[1])})
print(records)
# [{'name': 'Alice', 'score': 88}, {'name': 'Bob', 'score': 92}, ...]

Use line-by-line iteration whenever you are processing a file with one record per line — it is the standard pattern for text-based data.

Opening a file in 'w' mode creates the file if it does not exist, or overwrites it completely if it does. Opening in 'a' mode appends to the end of an existing file without erasing its content.

Use .write(string) to write a single string. Unlike print(), .write() does not add a newline automatically — you must include \n yourself.

python
lines = ['Line 1', 'Line 2', 'Line 3']

with open('output.txt', 'w') as f:
    for line in lines:
        f.write(line + '\n')

.writelines(iterable) accepts a list of strings and writes each one in turn — still no automatic newlines, so include \n in each string or join them yourself.

python
with open('output.txt', 'w') as f:
    f.writelines([line + '\n' for line in lines])

---

To add to an existing file without overwriting, use 'a' mode:

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

You can verify what was written by immediately opening the file again in 'r' mode and reading it back. In a code challenge the executor cannot write to the filesystem — instead, practice the logic on in-memory strings.

Use 'w' when you want a fresh file each run, and 'a' when you want to accumulate entries over multiple runs.

Reading CSV-style data into a list of dicts is one of the most common file-processing tasks in Python — it gives each row a name and makes the data easy to query.

The pattern: skip the header line if present, then strip and split each remaining line.

python
csv_lines = ['name,score', 'Alice,88', 'Bob,92', 'Carol,75']

records = []
for line in csv_lines[1:]:      # skip header
    name, score = line.split(',')
    records.append({'name': name, 'score': int(score)})

print(records)
# [{'name': 'Alice', 'score': 88}, ...]

You can also build a dict from the data when you need fast lookup by key:

python
score_map = {}
for line in csv_lines[1:]:
    name, score = line.split(',')
    score_map[name] = int(score)
print(score_map['Alice'])  # 88

---

When opening real files, you should always guard against FileNotFoundError using a try/except block. This prevents your program from crashing when a file is missing.

python
try:
    with open('data.csv') as f:
        content = f.read()
except FileNotFoundError:
    print('File not found — check the filename.')
    content = ''

The except clause catches the specific error and lets your program continue gracefully — returning an empty result, logging the problem, or asking the user for a valid path.

Use try/except around every open() call in production code — real files go missing, get renamed, or end up in the wrong directory all the time.