Advanced Review

TL;DR

This advanced review will help you consolidate your understanding of core Python concepts like data structures, functions, and object-oriented programming. We'll also touch upon error handling and file I/O, which are crucial for building robust applications. By revisiting these areas, you'll strengthen your problem-solving skills and prepare for more complex challenges.

1. The Mental Model

Think of Python as a versatile toolbox. When you write advanced code, you're not just using one tool; you're orchestrating several, each designed for a specific job, to build a bigger, more sophisticated machine. This review helps you ensure all your tools are sharp and you know when and how to use them together effectively.

2. The Core Material

Revisiting Data Structures

You've worked with lists, tuples, dictionaries, and sets. Remember that choosing the right structure is key to efficient code.
- Lists: Ordered, mutable, allows duplicates. Great for collections that change.
- Tuples: Ordered, immutable, allows duplicates. Use for fixed collections of items, often for returning multiple values from a function.
- Dictionaries: Unordered (in older Pythons, ordered since 3.7), mutable, key-value pairs, unique keys. Ideal for fast lookups by a key.
- Sets: Unordered, mutable, unique elements. Excellent for membership testing and eliminating duplicates.

Functions and Scope

Functions are your building blocks. You know how to define them (def) and use return. Remember scope: variables defined inside a function are local to that function, meaning they don't exist outside it. Variables defined outside all functions are global.

global_var = "I'm global!"

def my_function():
    local_var = "I'm local!"
    print(local_var)
    print(global_var) # Can access global_var

my_function()
# print(local_var) # This would cause an error!

Object-Oriented Programming (OOP) Essentials

Photo by Rashed Paykary on Pexels

OOP helps you structure complex programs by thinking in terms of "objects" that combine data (attributes) and behavior (methods).
- Classes: Blueprints for creating objects. Define attributes and methods here.
- Objects (Instances): Actual items created from a class. Each object has its own state (attribute values).
- self: Represents the instance of the class. You must use self to access attributes and methods within a class.
- __init__: The constructor method. It's called automatically when you create a new object and is used to initialize its attributes.

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        return f"{self.name} barks!"

my_dog = Dog("Buddy", "Golden Retriever")
print(my_dog.name)
print(my_dog.bark())

Error Handling with try-except

Photo by Miguel Á. Padriñán on Pexels

Your programs should be robust. Use try-except blocks to gracefully handle potential errors (exceptions) instead of crashing.

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Oops! Cannot divide by zero.")
except TypeError:
    print("That was a type error!")
except Exception as e: # Catch any other error
    print(f"An unexpected error occurred: {e}")

File Input/Output (I/O)

Reading from and writing to files is fundamental. Always use with open(...) to ensure files are properly closed, even if errors occur.

# Writing to a file
with open("my_file.txt", "w") as file:
    file.write("Hello, Python!")

# Reading from a file
with open("my_file.txt", "r") as file:
    content = file.read()
    print(content)

Here's a diagram showing the general flow for handling potential errors in a function:

graph TD
    A["Function Call"] --> B{Potential Error?};
    B -- Yes --> C["try Block"];
    C --> D{"Code that might fail"};
    D -- Fails --> E["except Block"];
    E --> F["Handle Error (e.g., log, print message)"];
    D -- Succeeds --> G["Rest of try block (if any)"];
    G --> H["Function Continues"];
    F --> H;
    B -- No --> H;

3. Worked Example

Let's combine OOP, file I/O, and error handling. You want to create a Product class and then save a list of product objects to a file, handling potential file errors.

```python
class Product:
def init(self, product_id, name, price):
self.product_id = product_id
self.name = name
self.price = price

def __str__(self): # A nice string representation for printing
    return f"ID: {self.product_id}, Name: {self.name}, Price: