pythonlings 0.3.0__py3-none-any.whl

pythonlings/curriculum/exercises/context_managers/context_managers8.py

@@ -0,0 +1,45 @@
+# Exercise: Context Managers 8
+# I AM NOT DONE
+#
+# Challenge: implement a `Resource` class that tracks acquire/release.
+#
+# Requirements:
+#   * `__init__` sets `self.acquired` to False and `self.release_log` to [].
+#   * `__enter__` sets `self.acquired` to True and returns self.
+#   * `__exit__` sets `self.acquired` to False and appends the string
+#     "released" to `self.release_log`, then returns None.
+#
+# After that, implement `ManagedPool` using `contextlib.contextmanager`.
+# `ManagedPool(resource)` should:
+#   1. Call `resource.__enter__()` to acquire it.
+#   2. Yield the resource.
+#   3. Call `resource.__exit__(None, None, None)` to release it.
+#
+# Both pieces must work correctly for the checks to pass.
+
+from contextlib import contextmanager
+
+
+class Resource:
+    def __init__(self):
+        # Bug: attributes are missing — set acquired and release_log.
+        pass
+
+    def __enter__(self):
+        # Bug: missing — set acquired, return self.
+        pass
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        # Bug: missing — clear acquired, log "released".
+        pass
+
+
+@contextmanager
+def ManagedPool(resource):
+    # Bug: missing — acquire, yield resource, release.
+    pass
+
+
+r = Resource()
+with ManagedPool(r) as res:
+    in_block_acquired = res.acquired

pythonlings/curriculum/exercises/dataclasses/dataclasses1.py

@@ -0,0 +1,14 @@
+# Exercise: Dataclasses 1
+# I AM NOT DONE
+#
+# Make `Point` a dataclass with two integer fields, `x` and `y`.
+# Add the @dataclass decorator and the two typed field declarations.
+
+from dataclasses import dataclass
+
+
+class Point:
+    pass
+
+
+origin = Point(0, 0)

pythonlings/curriculum/exercises/dataclasses/dataclasses2.py

@@ -0,0 +1,23 @@
+# Exercise: Dataclasses 2
+# I AM NOT DONE
+#
+# Construct an instance of `Color` and read its fields.
+# Set `red=255`, `green=128`, `blue=0` when creating `orange`.
+# Then complete the `describe` call so it returns the string
+# "R=255 G=128 B=0".
+#
+# Hint: fields are plain attributes — use dot notation to read them.
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Color:
+    red: int
+    green: int
+    blue: int
+
+
+orange = Color(0, 0, 0)  # Bug: wrong values — use 255, 128, 0
+
+description = f"R=??? G=??? B=???"  # Bug: replace ??? with the field values

pythonlings/curriculum/exercises/dataclasses/dataclasses3.py

@@ -0,0 +1,21 @@
+# Exercise: Dataclasses 3
+# I AM NOT DONE
+#
+# Add a default value to the `unit` field of `Measurement` so that
+# creating `Measurement(9.8)` works without passing `unit` explicitly.
+# The default should be the string "m/s²".
+#
+# Hint: a default is set by writing `field_name: type = default_value`
+# after the required fields.
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Measurement:
+    value: float
+    unit: str  # Bug: no default — add = "m/s²" here
+
+
+gravity = Measurement(9.8)
+named = Measurement(100.0, "km/h")

pythonlings/curriculum/exercises/dataclasses/dataclasses4.py

@@ -0,0 +1,25 @@
+# Exercise: Dataclasses 4
+# I AM NOT DONE
+#
+# The `Basket` dataclass needs a `items` field that defaults to an
+# empty list.  You cannot use `items: list = []` directly — Python
+# forbids mutable defaults in dataclasses.
+#
+# Fix the `items` field declaration to use `field(default_factory=list)`
+# so each new Basket gets its own independent list.
+#
+# Hint: import `field` from `dataclasses` and write
+#   items: list = field(default_factory=list)
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Basket:
+    label: str
+    items: list = []  # Bug: mutable default — use field(default_factory=list)
+
+
+b1 = Basket("fruit")
+b2 = Basket("veggies")
+b1.items.append("apple")

pythonlings/curriculum/exercises/dataclasses/dataclasses5.py

@@ -0,0 +1,25 @@
+# Exercise: Dataclasses 5
+# I AM NOT DONE
+#
+# `@dataclass` generates `__init__` automatically from the field
+# declarations — you must NOT write your own `__init__`.
+#
+# Fix `Vector3` by removing the hand-written `__init__` and instead
+# declaring three typed fields `x`, `y`, `z` (all `float`).
+# The generated __init__ will accept them as positional arguments.
+#
+# Hint: just add the field declarations and delete the `__init__` method.
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Vector3:
+    # Bug: fields are missing; there is a hand-written __init__ below.
+    def __init__(self, x, y, z):
+        self.x = x
+        self.y = y
+        self.z = z
+
+
+v = Vector3(1.0, 2.0, 3.0)

pythonlings/curriculum/exercises/dataclasses/dataclasses6.py

@@ -0,0 +1,21 @@
+# Exercise: Dataclasses 6
+# I AM NOT DONE
+#
+# `@dataclass` generates `__repr__` and `__eq__` automatically.
+#
+# Fix `Book` so that:
+#   * Two Book instances with the same `title` and `pages` compare equal
+#     (the generated `__eq__` does this for you).
+#   * `repr(book)` contains both the title and page count.
+#
+# Right now `Book` is a plain class — add `@dataclass` and the two
+# typed field declarations `title: str` and `pages: int`.
+
+# Bug: missing @dataclass decorator and field declarations.
+class Book:
+    pass
+
+
+novel = Book("Dune", 412)
+copy = Book("Dune", 412)
+other = Book("Foundation", 255)

pythonlings/curriculum/exercises/dataclasses/dataclasses7.py

@@ -0,0 +1,27 @@
+# Exercise: Dataclasses 7
+# I AM NOT DONE
+#
+# A frozen dataclass is immutable: assigning to any field after
+# construction raises a `FrozenInstanceError`.
+#
+# Fix `Config` by adding `frozen=True` to the `@dataclass` decorator.
+# Fields: `host: str` and `port: int`.
+#
+# Hint: @dataclass(frozen=True)
+
+from dataclasses import dataclass
+
+
+@dataclass  # Bug: missing frozen=True
+class Config:
+    host: str
+    port: int
+
+
+cfg = Config("localhost", 8080)
+
+try:
+    cfg.port = 9090  # should raise because the dataclass is frozen
+    mutation_raised = False
+except Exception:
+    mutation_raised = True

pythonlings/curriculum/exercises/dataclasses/dataclasses8.py

@@ -0,0 +1,30 @@
+# Exercise: Dataclasses 8
+# I AM NOT DONE
+#
+# Challenge: add a method to a dataclass.
+#
+# `Rectangle` has two float fields, `width` and `height`.
+# Add two methods:
+#   * `area(self) -> float`  — returns width * height
+#   * `perimeter(self) -> float` — returns 2 * (width + height)
+#
+# The class already has the @dataclass decorator and the field
+# declarations.  Only the method bodies are missing — fill them in.
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Rectangle:
+    width: float
+    height: float
+
+    def area(self) -> float:
+        pass  # Bug: return the correct value
+
+    def perimeter(self) -> float:
+        pass  # Bug: return the correct value
+
+
+rect = Rectangle(4.0, 3.0)
+square = Rectangle(5.0, 5.0)

pythonlings/curriculum/exercises/datetime/datetime1.py

@@ -0,0 +1,8 @@
+# Exercise: Datetime 1
+# I AM NOT DONE
+#
+# Goal: Create a date for May 23, 2026.
+
+from datetime import date
+
+launch_day = ???

pythonlings/curriculum/exercises/datetime/datetime2.py

@@ -0,0 +1,9 @@
+# Exercise: Datetime 2
+# I AM NOT DONE
+#
+# Goal: Add seven days to the start date.
+
+from datetime import date, timedelta
+
+start = date(2026, 5, 23)
+next_week = ???

pythonlings/curriculum/exercises/datetime/datetime3.py

@@ -0,0 +1,9 @@
+# Exercise: Datetime 3
+# I AM NOT DONE
+#
+# Goal: Parse the timestamp string into a datetime object.
+
+from datetime import datetime
+
+raw = "2026-05-23 09:30"
+meeting = ???

pythonlings/curriculum/exercises/datetime/datetime4.py

@@ -0,0 +1,9 @@
+# Exercise: Datetime 4
+# I AM NOT DONE
+#
+# Goal: Format the date as DD/MM/YYYY.
+
+from datetime import date
+
+day = date(2026, 5, 23)
+formatted = ???

pythonlings/curriculum/exercises/datetime/datetime5.py

@@ -0,0 +1,10 @@
+# Exercise: Datetime 5
+# I AM NOT DONE
+#
+# Goal: Check whether the due date is after today.
+
+from datetime import date
+
+today = date(2026, 5, 23)
+due = date(2026, 6, 1)
+is_future = ???

pythonlings/curriculum/exercises/datetime/datetime6.py

@@ -0,0 +1,10 @@
+# Exercise: Datetime 6
+# I AM NOT DONE
+#
+# Goal: Compute the number of whole days between start and end.
+
+from datetime import date
+
+start = date(2026, 5, 1)
+end = date(2026, 5, 23)
+days_between = ???

pythonlings/curriculum/exercises/datetime/datetime7.py

@@ -0,0 +1,10 @@
+# Exercise: Datetime 7
+# I AM NOT DONE
+#
+# Goal: Combine a date and time into one datetime.
+
+from datetime import date, datetime, time
+
+day = date(2026, 5, 23)
+clock = time(14, 45)
+appointment = ???

pythonlings/curriculum/exercises/datetime/datetime8.py

@@ -0,0 +1,11 @@
+# Exercise: Datetime 8
+# I AM NOT DONE
+#
+# Goal: Parse ISO date strings and find the earliest and latest dates.
+
+from datetime import date
+
+raw_dates = ["2026-05-23", "2024-01-01", "2025-12-31"]
+parsed = [date.fromisoformat(value) for value in raw_dates]
+earliest = ???
+latest = ???

pythonlings/curriculum/exercises/decorators/decorators1.py

@@ -0,0 +1,19 @@
+# Exercise: Decorators 1
+# I AM NOT DONE
+#
+# `call_it` is a higher-order function: it takes a function as an argument
+# and calls it, returning whatever the function returns.
+#
+# Fill in the body — replace `pass` with the correct return statement.
+
+
+def call_it(func):
+    pass
+
+
+def say_hello():
+    return "hello"
+
+
+def give_seven():
+    return 7

pythonlings/curriculum/exercises/decorators/decorators10.py

@@ -0,0 +1,32 @@
+# Exercise: Decorators 10
+# I AM NOT DONE
+#
+# Implement the `memoize` decorator: it caches the result of each unique
+# set of arguments so that the wrapped function is called at most once
+# per distinct input.
+#
+# The cache should be stored in a dict as an attribute: wrapper.cache
+# Use the tuple of positional args as the cache key (assume no kwargs).
+#
+# Fill in the wrapper body — right now it ignores the cache entirely.
+
+import functools
+
+
+def memoize(func):
+    @functools.wraps(func)
+    def wrapper(*args):
+        # bug: always calls func, never checks or updates the cache
+        return func(*args)
+    wrapper.cache = {}
+    return wrapper
+
+
+call_count = 0
+
+
+@memoize
+def slow_square(n):
+    global call_count
+    call_count += 1
+    return n * n

pythonlings/curriculum/exercises/decorators/decorators2.py

@@ -0,0 +1,22 @@
+# Exercise: Decorators 2
+# I AM NOT DONE
+#
+# Complete the `shout` decorator: it wraps a function that returns a
+# string and makes the wrapper return that string in UPPERCASE.
+#
+# Hint: str.upper() converts a string to uppercase.
+
+
+def shout(func):
+    def wrapper():
+        result = func()
+        # return the result, uppercased
+        return result
+    return wrapper
+
+
+def greet():
+    return "hello"
+
+
+loud_greet = shout(greet)

pythonlings/curriculum/exercises/decorators/decorators3.py

@@ -0,0 +1,18 @@
+# Exercise: Decorators 3
+# I AM NOT DONE
+#
+# Apply the `stamp` decorator to `get_message` using the `@` syntax
+# so that calling get_message() returns "[STAMPED] hello".
+#
+# The decorator is already written — you only need to add the `@` line
+# directly above the `def get_message():` line.
+
+
+def stamp(func):
+    def wrapper():
+        return "[STAMPED] " + func()
+    return wrapper
+
+
+def get_message():
+    return "hello"

pythonlings/curriculum/exercises/decorators/decorators4.py

@@ -0,0 +1,24 @@
+# Exercise: Decorators 4
+# I AM NOT DONE
+#
+# The `double_result` decorator should wrap `func`, call it, and return
+# the return value multiplied by 2.
+#
+# Right now the wrapper does NOT return anything (returns None).
+# Fix the wrapper so it captures and returns double the wrapped function's result.
+
+
+def double_result(func):
+    def wrapper():
+        func()   # bug: the return value is thrown away
+    return wrapper
+
+
+@double_result
+def get_five():
+    return 5
+
+
+@double_result
+def get_ten():
+    return 10

pythonlings/curriculum/exercises/decorators/decorators5.py

@@ -0,0 +1,25 @@
+# Exercise: Decorators 5
+# I AM NOT DONE
+#
+# The `log_call` decorator should work with functions that take ANY arguments
+# (positional and keyword). The wrapper must accept and forward them.
+#
+# Replace the wrapper signature so it accepts *args and **kwargs, then
+# pass them through when calling func.
+
+
+def log_call(func):
+    def wrapper():   # bug: accepts no arguments
+        print(f"calling {func.__name__}")
+        return func()  # bug: forwards no arguments
+    return wrapper
+
+
+@log_call
+def add(a, b):
+    return a + b
+
+
+@log_call
+def greet(name, greeting="Hello"):
+    return f"{greeting}, {name}!"

pythonlings/curriculum/exercises/decorators/decorators6.py

@@ -0,0 +1,19 @@
+# Exercise: Decorators 6
+# I AM NOT DONE
+#
+# Without functools.wraps, a decorator hides the wrapped function's __name__
+# and __doc__.  Use @functools.wraps(func) on the inner wrapper to preserve them.
+#
+# Add the missing import and the @functools.wraps(func) line inside `preserve`.
+
+
+def preserve(func):
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+    return wrapper
+
+
+@preserve
+def compute(x, y):
+    """Return the sum of x and y."""
+    return x + y

pythonlings/curriculum/exercises/decorators/decorators7.py

@@ -0,0 +1,25 @@
+# Exercise: Decorators 7
+# I AM NOT DONE
+#
+# The `count_calls` decorator should track how many times the decorated
+# function has been called. The count is stored as an attribute on the
+# wrapper: wrapper.call_count, starting at 0 and incrementing on each call.
+#
+# Right now the count is never updated. Fix the wrapper to increment
+# wrapper.call_count before forwarding the call.
+
+import functools
+
+
+def count_calls(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        # bug: call_count is never incremented
+        return func(*args, **kwargs)
+    wrapper.call_count = 0
+    return wrapper
+
+
+@count_calls
+def add(a, b):
+    return a + b

pythonlings/curriculum/exercises/decorators/decorators8.py

@@ -0,0 +1,25 @@
+# Exercise: Decorators 8
+# I AM NOT DONE
+#
+# A decorator factory is a function that RETURNS a decorator.
+# `repeat(n)` should return a decorator that calls the wrapped function
+# n times and returns the last result.
+#
+# Complete the two missing inner functions so that repeat(n) works correctly.
+
+import functools
+
+
+def repeat(n):
+    # return a decorator here
+    pass
+
+
+@repeat(3)
+def say(word):
+    return word
+
+
+@repeat(1)
+def identity(x):
+    return x

pythonlings/curriculum/exercises/decorators/decorators9.py

@@ -0,0 +1,26 @@
+# Exercise: Decorators 9
+# I AM NOT DONE
+#
+# Decorators can be stacked: the one closest to `def` is applied first,
+# then the outer one wraps that result.
+#
+# Given the two decorators below, apply BOTH to `get_value` using the `@`
+# syntax so that calling get_value() returns "[B][A]42".
+#
+# Stack order matters: figure out which decorator goes on top.
+
+
+def add_a(func):
+    def wrapper():
+        return "[A]" + func()
+    return wrapper
+
+
+def add_b(func):
+    def wrapper():
+        return "[B]" + func()
+    return wrapper
+
+
+def get_value():
+    return "42"

pythonlings/curriculum/exercises/dictionaries/dictionaries1.py

@@ -0,0 +1,6 @@
+# Exercise: Dictionaries 1
+# I AM NOT DONE
+#
+# Create a dict called `ages` mapping "alice" to 30 and "bob" to 25.
+
+ages = ???

pythonlings/curriculum/exercises/dictionaries/dictionaries10.py

@@ -0,0 +1,17 @@
+# Exercise: Dictionaries 10
+# I AM NOT DONE
+#
+# Build a frequency dict — count how many times each word appears in `words`.
+#
+# Store the result in `freq`.  Keys are words, values are their counts.
+#
+# Expected:
+#   freq == {"the": 3, "cat": 2, "sat": 1, "on": 1, "mat": 1, "and": 1, "hat": 1}
+#
+# Hint: start with an empty dict and use .get() or setdefault() inside a loop.
+
+words = ["the", "cat", "sat", "on", "the", "mat", "and", "the", "cat", "hat"]
+
+freq = {}
+for ???:
+    ???

pythonlings/curriculum/exercises/dictionaries/dictionaries2.py

@@ -0,0 +1,9 @@
+# Exercise: Dictionaries 2
+# I AM NOT DONE
+#
+# Given the dict `capitals` below, set `france_capital` to the value
+# stored under the key "france".
+
+capitals = {"france": "Paris", "germany": "Berlin", "japan": "Tokyo"}
+
+france_capital = ???

pythonlings/curriculum/exercises/dictionaries/dictionaries3.py

@@ -0,0 +1,16 @@
+# Exercise: Dictionaries 3
+# I AM NOT DONE
+#
+# You have an existing dict `scores`. Do two things:
+#   1. Add a new key "diana" with value 91.
+#   2. Update "alice"'s value to 88 (she re-took the test).
+#
+# Modify `scores` in place — do not create a new dict.
+
+scores = {"alice": 75, "bob": 60, "carol": 82}
+
+# Add "diana" -> 91 here
+???
+
+# Update "alice" -> 88 here
+???

pythonlings/curriculum/exercises/dictionaries/dictionaries4.py

@@ -0,0 +1,15 @@
+# Exercise: Dictionaries 4
+# I AM NOT DONE
+#
+# Remove keys from a dict using two approaches:
+#   1. Use `del` to remove "banana" from `basket`.
+#   2. Use `.pop()` to remove "cherry" from `basket` and store the
+#      removed value in `cherry_count`.
+
+basket = {"apple": 5, "banana": 3, "cherry": 12, "date": 7}
+
+# Remove "banana" with del
+???
+
+# Remove "cherry" with .pop(), storing its value in cherry_count
+cherry_count = ???

pythonlings/curriculum/exercises/dictionaries/dictionaries5.py

@@ -0,0 +1,15 @@
+# Exercise: Dictionaries 5
+# I AM NOT DONE
+#
+# Given `inventory` below, produce three collections:
+#   `all_items`  — a list of all keys (the item names), in any order
+#   `all_counts` — a list of all values (the stock counts), in any order
+#   `all_pairs`  — a list of all (key, value) tuples, in any order
+#
+# Use .keys(), .values(), and .items() respectively, converting each to a list.
+
+inventory = {"pen": 10, "notebook": 5, "eraser": 8}
+
+all_items = ???
+all_counts = ???
+all_pairs = ???