How much does zuzu.codes cost?

The starter track is free — read all lessons and practice for free. Full access to every track (current and future) is $14.99/month. Cancel anytime.

How long does each track take?

Each track is designed as a 30-day challenge — one lesson per day, about 15 minutes each. Go at your own pace, but the structure is built around daily consistency.

What's the lesson format?

Each lesson is a student-teacher dialogue with code examples, followed by a hands-on code challenge in an in-browser editor. You read, you understand, then you write real code.

Do I need prior coding experience?

Our beginner track starts from absolute zero — no prior experience needed. Advanced tracks build on earlier ones, and the platform tells you exactly where to start.

How is zuzu.codes different from freeCodeCamp or Codecademy?

zuzu.codes uses a structured 30-day track format with dialogue-based teaching, an in-browser code editor, and gamification (XP, streaks, progress tracking). The format builds genuine understanding through daily practice.

Cache Repeat Search Queries with a Dict — Ai For Explorers

Day 19 · ~12 min●

You have a list of ten queries, but three of them are duplicates. Naively, you'd make ten search() calls. What is the smallest structure that lets you only pay for the unique ones?

A dict? Use the query string as the key and the result URLs as the value — if the key is already there, skip the search.

Exactly. A local dict acts as a cache that lives for the duration of the function call. Check before fetching; fetch only on miss:

python

cache = {}
for q in queries:
    if q not in cache:
        results = search(q, count=3)
        cache[q] = [r["url"] for r in results]
print(cache)

Ten queries in, three unique keys out — seven duplicate calls saved.

So the cache doesn't have to be fancy — a plain dict works because the query string is already hashable?

Exactly. Strings are hashable; dicts use them as keys; the lookup is O(1). No cache library, no Redis, no TTL. For within-function deduplication this is the entire pattern:

python

def cache_search_queries(queries: list) -> dict:
    cache = {}
    for q in queries:
        if q not in cache:
            results = search(q, count=3)
            cache[q] = [r["url"] for r in results]
    return cache

The output dict maps query -> list of URLs, with every duplicate query silently skipping the API call.

What about the unique-query order? If I give you ['a', 'b', 'a', 'c'], is the cache {a, b, c} or {a, c, b}?

{a, b, c} — insertion order. Python dicts preserve insertion order since 3.7, so the cache's keys reflect the order queries first appeared. That matters if you later iterate over cache.items() and want the output to match the original list's first appearances.

So three API calls for ten queries. The cache pays off immediately — the more duplicates in the input, the bigger the speedup.

Exactly. Caching is just a dict and a not-in check. The same shape scales to expensive agent calls too — if key not in cache is the universal pattern, whatever sits behind the colon.

Dict as a Within-Function Cache

TL;DR: check if key not in cache before calling; store the result on the miss path.

Strings are hashable — query works as a dict key directly
Insertion order preserved — iteration reflects first appearances
O(1) lookup — in on a dict is constant time

Check-then-fetch pattern

Step	Code
Lookup	`if q not in cache`
Fetch	`search(q, count=3)`
Store	`cache[q] = ...`

Skip libraries for in-function dedup — a dict and a conditional is the pattern.

Day 19 · ~12 min●

You have a list of ten queries, but three of them are duplicates. Naively, you'd make ten search() calls. What is the smallest structure that lets you only pay for the unique ones?

A dict? Use the query string as the key and the result URLs as the value — if the key is already there, skip the search.

Exactly. A local dict acts as a cache that lives for the duration of the function call. Check before fetching; fetch only on miss:

python

cache = {}
for q in queries:
    if q not in cache:
        results = search(q, count=3)
        cache[q] = [r["url"] for r in results]
print(cache)

Ten queries in, three unique keys out — seven duplicate calls saved.

So the cache doesn't have to be fancy — a plain dict works because the query string is already hashable?

Exactly. Strings are hashable; dicts use them as keys; the lookup is O(1). No cache library, no Redis, no TTL. For within-function deduplication this is the entire pattern:

python

def cache_search_queries(queries: list) -> dict:
    cache = {}
    for q in queries:
        if q not in cache:
            results = search(q, count=3)
            cache[q] = [r["url"] for r in results]
    return cache

The output dict maps query -> list of URLs, with every duplicate query silently skipping the API call.

What about the unique-query order? If I give you ['a', 'b', 'a', 'c'], is the cache {a, b, c} or {a, c, b}?

So three API calls for ten queries. The cache pays off immediately — the more duplicates in the input, the bigger the speedup.

Exactly. Caching is just a dict and a not-in check. The same shape scales to expensive agent calls too — if key not in cache is the universal pattern, whatever sits behind the colon.

Dict as a Within-Function Cache

TL;DR: check if key not in cache before calling; store the result on the miss path.

Strings are hashable — query works as a dict key directly
Insertion order preserved — iteration reflects first appearances
O(1) lookup — in on a dict is constant time

Check-then-fetch pattern

Step	Code
Lookup	`if q not in cache`
Fetch	`search(q, count=3)`
Store	`cache[q] = ...`

Skip libraries for in-function dedup — a dict and a conditional is the pattern.

def cache_search_queries(queries: list) -> dict: cache = {} for q in queries: if q not in cache: results = search(q, count=3) cache[q] = [r["url"] for r in results] return cache

Dict as a Within-Function Cache

TL;DR: check if key not in cache before calling; store the result on the miss path.

Strings are hashable — query works as a dict key directly

Insertion order preserved — iteration reflects first appearances

O(1) lookup — in on a dict is constant time

Check-then-fetch pattern

Step	Code
Lookup	`if q not in cache`
Fetch	`search(q, count=3)`
Store	`cache[q] = ...`

Skip libraries for in-function dedup — a dict and a conditional is the pattern.

def cache_search_queries(queries: list) -> dict: cache = {} for q in queries: if q not in cache: results = search(q, count=3) cache[q] = [r["url"] for r in results] return cache

Dict as a Within-Function Cache

TL;DR: check if key not in cache before calling; store the result on the miss path.

Strings are hashable — query works as a dict key directly

Insertion order preserved — iteration reflects first appearances

O(1) lookup — in on a dict is constant time

Check-then-fetch pattern

Step	Code
Lookup	`if q not in cache`
Fetch	`search(q, count=3)`
Store	`cache[q] = ...`

Skip libraries for in-function dedup — a dict and a conditional is the pattern.

Dict as a Within-Function Cache

Check-then-fetch pattern

Dict as a Within-Function Cache

Check-then-fetch pattern

Dict as a Within-Function Cache

Check-then-fetch pattern

Sign up to practice

Dict as a Within-Function Cache

Check-then-fetch pattern

Sign up to practice