Python expects try to be immediately followed by except, finally, or else, not by other statements.

❌ Your Code:

try:
    x = 1 / 0
print("testing whether this will be printed or not")
except ZeroDivisionError:
    print("Can't divide by zero.")

🧨 What happens?

This code will raise a SyntaxError — specifically:

SyntaxError: expected 'except' or 'finally' block

Because:

• The line print("testing...") is outside the try block.
• Python expects try to be immediately followed by except, finally, or else, not by other statements.

---

FastAPI’s dependency system and Python internals

def get_db():
    db = {"name": "fake_db"}
    try:
        yield db
    finally:
        print("Closing database connection...")

@app.get("/blacklist")
async def get_blacklist(db: dict = Depends(get_db)):
    return {"db_name": db["name"]}

✅ 1. Why is finally executed after the response is sent back?

In FastAPI, when you use a Depends(...) function that includes a yield, FastAPI treats it as a generator dependency — meaning:

🔁 FastAPI’s execution flow:

@app.get("/something")
def handler(resource = Depends(get_resource)):
    # Step 1: FastAPI calls get_resource() up to yield
    # Step 2: It passes yielded value to the route
    # Step 3: Route handler runs and response is returned
    # Step 4: FastAPI resumes get_resource(), runs finally

In short:
FastAPI doesn't call your dependency like a regular function.
It uses your generator like a context manager, and the finally is part of the teardown step, after your route finishes responding.

---

🔧 Analogy: It’s like a with block

with open("file.txt") as f:
    data = f.read()
# after this, file is automatically closed

Similarly, FastAPI handles your generator-dependency with:

try:
    db = yield fake_db
finally:
    db.close()

It makes sure to wait until your route is finished before running the cleanup (finally).

---

✅ 2. What is a generator in Python?

👉 Definition:

A generator is a special type of function that:

• uses yield instead of return
• can pause and resume execution
• produces values lazily, one at a time

---

🧪 Example:

def count_up_to(n):
    i = 1
    while i <= n:
        yield i  # pause here and return i
        i += 1

c = count_up_to(3)
print(next(c))  # → 1
print(next(c))  # → 2
print(next(c))  # → 3

Output:

1
2
3

Each call to next() resumes the generator right after the last yield.

---

🔍 Key features of generators:

Feature	Description
yield	Temporarily returns a value and pauses the function
next()	Resumes execution until next yield
finally	Runs when generator is closed or exhausted
StopIteration	Raised when no more yield left

---

✅ In FastAPI:

• yield is used in dependencies to open a resource, and
• finally is used to clean up the resource after the response

---

✅ 3. Generator vs. Iterator

Feature	Generator	Iterator
What is it?	A type of iterator built using yield	A general interface with __iter__ and __next__
How to create?	With a function using yield	By defining a class with __iter__ and __next__
Memory usage	Efficient — lazy (one item at a time)	Can be lazy or not, depends on implementation
Syntax	Short and elegant	Verbose — boilerplate required
State handling	Handled automatically by Python	You manage state manually
One-time use?	Yes (can't restart once exhausted)	Usually yes, unless re-implemented

Great observation — you're absolutely right! Generators and iterators are closely related, but they are not the same. Let's compare them thoroughly:

---

✅ TL;DR

Feature	Generator	Iterator
What is it?	A type of iterator built using yield	A general interface with __iter__ and __next__
How to create?	With a function using yield	By defining a class with __iter__ and __next__
Memory usage	Efficient — lazy (one item at a time)	Can be lazy or not, depends on implementation
Syntax	Short and elegant	Verbose — boilerplate required
State handling	Handled automatically by Python	You manage state manually
One-time use?	Yes (can't restart once exhausted)	Usually yes, unless re-implemented

---

✅ What is an iterator?

An object is an iterator if it implements:

• __iter__() → returns the iterator object itself
• __next__() → returns the next value, or raises StopIteration

🧪 Example:

class Counter:
    def __init__(self, max):
        self.max = max
        self.current = 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.current > self.max:
            raise StopIteration
        value = self.current
        self.current += 1
        return value

c = Counter(3)
for i in c:
    print(i)

Output:

1
2
3

---

✅ What is a generator?

A generator is a function that automatically builds an iterator by using yield. Python takes care of the internal state and iterator protocol for you.

🧪 Same behavior as above with generator:

def counter(max):
    current = 1
    while current <= max:
        yield current
        current += 1

c = counter(3)
for i in c:
    print(i)

Output:

1
2
3

Same result, but with much simpler syntax.

---

✅ Generators are Iterators

This is important:

gen = (x for x in range(3))
print(iter(gen) is gen)  # ✅ True

Generators implement the iterator protocol, so:

• you can call next() on them
• they raise StopIteration when done

But not all iterators are generators — for example, class-based iterators.

---

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

#한컴AI아카데미 #AI개발자 #AI개발자교육 #한글과컴퓨터 #한국생산성본부 #스나이퍼팩토리 #부트캠프 #AI전문가양성 #개발자교육 #개발자취업