Encoding and Context Managers

🗂️ File Handling: Encoding and Context Managers

The Magic Locker Story 🔐

Imagine you have a special locker at school. This locker is magical because:

• It can store your secret diary in any language (encoding)
• It locks itself automatically when you walk away (context managers)
• It never forgets to close, even if you trip and fall!

That’s exactly what Python’s file handling with encoding and context managers does!

📚 What We’ll Learn

graph TD
    A["File Handling Magic"] --> B["File Encoding"]
    A --> C["String Encoding/Decoding"]
    A --> D["Custom Context Managers"]
    A --> E["contextlib Module"]

    B --> B1["UTF-8, Latin-1, etc."]
    C --> C1["Bytes ↔ Strings"]
    D --> D1["Your Own __enter__/__exit__"]
    E --> E1["Easy @contextmanager"]

1️⃣ File Encoding: Speaking Different Languages

The Translator Analogy

Think of a file like a letter. But what if your friend speaks Japanese and you speak English? You need a translator!

Encoding is that translator. It tells Python HOW to read or write the characters.

Common Encodings

Example: Writing with Encoding

# Writing a file with UTF-8 encoding
with open("hello.txt", "w",
          encoding="utf-8") as f:
    f.write("Hello! 你好! مرحبا!")

What happened?

• We told Python: “Use UTF-8 translator”
• Now it can save Chinese, Arabic, English - all together!

Example: Reading with Encoding

# Reading the same file back
with open("hello.txt", "r",
          encoding="utf-8") as f:
    content = f.read()
    print(content)
# Output: Hello! 你好! مرحبا!

⚠️ Common Mistake

# WRONG: Encoding mismatch!
with open("hello.txt", "r",
          encoding="ascii") as f:
    content = f.read()
# ERROR! ASCII can't read Chinese!

Rule: Use the SAME encoding to read as you used to write!

2️⃣ String Encoding and Decoding

The Secret Code Analogy

Remember passing secret notes in class? You’d write “HELLO” as “8-5-12-12-15” (numbers for letters).

That’s encoding! And turning numbers back to letters is decoding.

Strings vs Bytes

Encoding: String → Bytes

# Turn text into bytes
message = "Hello 🌟"
encoded = message.encode("utf-8")
print(encoded)
# Output: b'Hello \xf0\x9f\x8c\x9f'

Translation: The star emoji became weird-looking bytes that computers love!

Decoding: Bytes → String

# Turn bytes back into text
encoded = b'Hello \xf0\x9f\x8c\x9f'
decoded = encoded.decode("utf-8")
print(decoded)
# Output: Hello 🌟

Real-World Use Case

# Receiving data from internet
raw_data = b'\xc2\xa1Hola!'
text = raw_data.decode("utf-8")
print(text)
# Output: ¡Hola!

Error Handling Options

# What if bytes are broken?
bad_bytes = b'\xff\xfe'

# Option 1: Replace bad characters
text = bad_bytes.decode(
    "utf-8",
    errors="replace"
)
print(text)  # Output: ��

# Option 2: Ignore bad characters
text = bad_bytes.decode(
    "utf-8",
    errors="ignore"
)
print(text)  # Output: (empty)

3️⃣ Custom Context Managers

The Automatic Door Analogy

Imagine a store with automatic doors:

1. You approach → Door opens (__enter__)
2. You shop → Do your thing
3. You leave → Door closes (__exit__)

Even if you run out scared, the door STILL closes!

The Problem Without Context Managers

# DANGEROUS: What if error happens?
f = open("data.txt", "w")
f.write("Important stuff")
# If error happens here...
f.close()  # This never runs!

Creating Your Own Context Manager

class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None

    def __enter__(self):
        # Door opens!
        print("Opening file...")
        self.file = open(
            self.filename,
            self.mode
        )
        return self.file

    def __exit__(self, exc_type,
                 exc_val, exc_tb):
        # Door closes! Always!
        print("Closing file...")
        if self.file:
            self.file.close()
        return False  # Don't hide errors

Using Your Context Manager

with FileManager("test.txt", "w") as f:
    f.write("Hello!")
    # Even if error here...

# Output:
# Opening file...
# Closing file...

Magic! The file closes automatically!

Another Example: Timer

import time

class Timer:
    def __enter__(self):
        self.start = time.time()
        return self

    def __exit__(self, *args):
        self.end = time.time()
        print(f"Took {self.end - self.start:.2f}s")
        return False

# Using it
with Timer():
    time.sleep(1)
# Output: Took 1.00s

4️⃣ The contextlib Module

The Easy Button 🔴

Remember our FileManager class? That was 15 lines of code!

Python says: “That’s too much work. Here’s an easy button!”

@contextmanager Decorator

from contextlib import contextmanager

@contextmanager
def file_manager(filename, mode):
    # __enter__ part
    print("Opening...")
    f = open(filename, mode)
    try:
        yield f  # Give file to user
    finally:
        # __exit__ part
        print("Closing...")
        f.close()

Same result, less code!

with file_manager("test.txt", "w") as f:
    f.write("Easy!")
# Output:
# Opening...
# Closing...

How yield Works Here

graph TD
    A["with statement starts"] --> B["Code before yield runs"]
    B --> C["yield gives value to 'as'"]
    C --> D["Your code in 'with' runs"]
    D --> E["finally block runs"]
    E --> F["with statement ends"]

Other contextlib Tools

closing() - Auto-close anything

from contextlib import closing
from urllib.request import urlopen

with closing(urlopen("http://example.com")) as page:
    content = page.read()
# Page automatically closed!

suppress() - Ignore specific errors

from contextlib import suppress

# Without suppress
try:
    x = int("not a number")
except ValueError:
    pass

# With suppress (cleaner!)
with suppress(ValueError):
    x = int("not a number")

redirect_stdout() - Capture prints

from contextlib import redirect_stdout
import io

f = io.StringIO()
with redirect_stdout(f):
    print("Hello!")

captured = f.getvalue()
print(f"Captured: {captured}")
# Output: Captured: Hello!

🎯 Putting It All Together

Here’s a real-world example combining everything:

from contextlib import contextmanager

@contextmanager
def safe_file(filename,
              encoding="utf-8"):
    """Open file safely with encoding"""
    print(f"📂 Opening {filename}")
    f = None
    try:
        f = open(filename, "w",
                 encoding=encoding)
        yield f
    except Exception as e:
        print(f"❌ Error: {e}")
        raise
    finally:
        if f:
            f.close()
            print(f"📁 Closed {filename}")

# Using it
with safe_file("diary.txt") as diary:
    diary.write("Today was fun! 🎉")
    diary.write("\n今日は楽しかった!")

Output:

📂 Opening diary.txt
📁 Closed diary.txt

🌟 Key Takeaways

1. Encoding = The translator between human text and computer bytes

   • Always specify encoding (use utf-8 by default)

2. String ↔ Bytes = .encode() and .decode()

   • Strings for humans, bytes for computers

3. Custom Context Managers = __enter__ and __exit__

   • Automatic cleanup, even with errors!

4. contextlib = The easy way

   • @contextmanager turns functions into context managers
   • suppress(), closing(), redirect_stdout() are your friends

🚀 You Did It!

You now understand:

• ✅ How files speak different languages (encoding)
• ✅ How to translate between strings and bytes
• ✅ How to build automatic doors (context managers)
• ✅ The easy shortcuts in contextlib

Remember: The with statement is like a responsible friend who ALWAYS cleans up, no matter what! 🎉