pythonlings 0.3.0__py3-none-any.whl

pythonlings/curriculum/checks/tuples/tuples3.py

@@ -0,0 +1,4 @@
+assert x == 10, f"x should be 10, got {x!r}"
+assert y == 20, f"y should be 20, got {y!r}"
+assert z == 30, f"z should be 30, got {z!r}"
+print("tuples3 ✓")

pythonlings/curriculum/checks/tuples/tuples4.py

@@ -0,0 +1,3 @@
+assert isinstance(solo, tuple), f"solo should be a tuple, got {type(solo).__name__!r}"
+assert solo == (42,), f"solo should be (42,), got {solo!r}"
+print("tuples4 ✓")

pythonlings/curriculum/checks/tuples/tuples5.py

@@ -0,0 +1,4 @@
+assert original == (10, 20, 30), "original must not be changed"
+assert isinstance(updated, tuple), "updated should be a tuple"
+assert updated == (10, 99, 30), f"updated should be (10, 99, 30), got {updated!r}"
+print("tuples5 ✓")

pythonlings/curriculum/checks/tuples/tuples6.py

@@ -0,0 +1,5 @@
+assert isinstance(result, tuple), "min_max should return a tuple"
+assert result == (1, 9), f"min_max([4,1,7,2,9,3]) should return (1, 9), got {result!r}"
+lo, hi = min_max([3, 3, 3])
+assert lo == 3 and hi == 3, "min_max should work when all values are equal"
+print("tuples6 ✓")

pythonlings/curriculum/checks/tuples/tuples7.py

@@ -0,0 +1,3 @@
+assert a == 99, f"a should be 99 after swap, got {a!r}"
+assert b == 7, f"b should be 7 after swap, got {b!r}"
+print("tuples7 ✓")

pythonlings/curriculum/checks/tuples/tuples8.py

@@ -0,0 +1,4 @@
+assert passing == [85, 92, 60, 74], (
+    f"passing should be [85, 92, 60, 74], got {passing!r}"
+)
+print("tuples8 ✓")

pythonlings/curriculum/checks/tuples/tuples9.py

@@ -0,0 +1,5 @@
+assert grid[(0, 0)] == "origin", f"grid[(0,0)] should be 'origin', got {grid.get((0,0))!r}"
+assert grid[(1, 0)] == "right", f"grid[(1,0)] should be 'right', got {grid.get((1,0))!r}"
+assert grid[(0, 1)] == "up", f"grid[(0,1)] should be 'up', got {grid.get((0,1))!r}"
+assert label == "right", f"label should be 'right', got {label!r}"
+print("tuples9 ✓")

pythonlings/curriculum/checks/type_hints/type_hints1.py

@@ -0,0 +1,3 @@
+assert "count" in __annotations__, "count should have a type annotation"
+assert __annotations__["count"] is int, "count should be annotated as int"
+print("type_hints1 ✓")

pythonlings/curriculum/checks/type_hints/type_hints2.py

@@ -0,0 +1,5 @@
+hints = greet.__annotations__
+assert hints.get("name") is str, "name should be annotated as str"
+assert hints.get("times") is int, "times should be annotated as int"
+assert hints.get("return") is str, "the return type should be str"
+print("type_hints2 ✓")

pythonlings/curriculum/checks/type_hints/type_hints3.py

@@ -0,0 +1,5 @@
+hints = total.__annotations__
+assert hints.get("scores") == list[int], "scores should be annotated as list[int]"
+assert hints.get("labels") == dict[str, int], "labels should be annotated as dict[str, int]"
+assert hints.get("return") is int, "the return type should be int"
+print("type_hints3 ✓")

pythonlings/curriculum/checks/type_hints/type_hints4.py

@@ -0,0 +1,5 @@
+hints = find_index.__annotations__
+assert hints.get("items") == "list[str]", "items should be annotated as list[str]"
+assert hints.get("target") == "str", "target should be annotated as str"
+assert hints.get("return") == "int | None", "return type should be int | None"
+print("type_hints4 ✓")

pythonlings/curriculum/checks/type_hints/type_hints5.py

@@ -0,0 +1,6 @@
+hints = bounding_box.__annotations__
+assert hints.get("points") == list[tuple[float, float]], \
+    "points should be annotated as list[tuple[float, float]]"
+assert hints.get("return") == tuple[float, float, float, float], \
+    "return type should be tuple[float, float, float, float]"
+print("type_hints5 ✓")

pythonlings/curriculum/checks/type_hints/type_hints6.py

@@ -0,0 +1,7 @@
+assert "Vector" in dir() or "Vector" in globals(), "Vector type alias must be defined"
+assert Vector == list[float], "Vector should equal list[float]"
+hints = scale.__annotations__
+assert hints.get("v") == list[float], "v should be annotated as Vector (list[float])"
+assert hints.get("factor") is float, "factor should be annotated as float"
+assert hints.get("return") == list[float], "return type should be Vector (list[float])"
+print("type_hints6 ✓")

pythonlings/curriculum/checks/type_hints/type_hints7.py

@@ -0,0 +1,9 @@
+import typing
+
+hints = apply_twice.__annotations__
+expected_callable = typing.Callable[[int], int]
+assert hints.get("func") == expected_callable, \
+    f"func should be annotated as Callable[[int], int], got {hints.get('func')}"
+assert hints.get("value") is int, "value should be annotated as int"
+assert hints.get("return") is int, "return type should be int"
+print("type_hints7 ✓")

pythonlings/curriculum/checks/type_hints/type_hints8.py

@@ -0,0 +1,9 @@
+hints = summarise.__annotations__
+assert hints.get("records") == "list[dict[str, int]]", \
+    "records should be annotated as list[dict[str, int]]"
+assert hints.get("key") == "str", "key should be annotated as str"
+assert hints.get("default") == "int | None", \
+    "default should be annotated as int | None"
+assert hints.get("return") == "dict[str, int | None]", \
+    "return type should be dict[str, int | None]"
+print("type_hints8 ✓")

pythonlings/curriculum/checks/variables/variables1.py

@@ -0,0 +1,7 @@
+assert isinstance(a, int), "a should be an integer"
+assert isinstance(b, float), "b should be a float"
+assert isinstance(c, str), "c should be a string"
+assert a == 0
+assert b == 0.0
+assert c == ""
+print("variables1 ✓")

pythonlings/curriculum/checks/variables/variables10.py

@@ -0,0 +1,4 @@
+assert area == 12, f"area should be 12, got {area}"
+assert perimeter == 14, f"perimeter should be 14, got {perimeter}"
+assert abs(diagonal - 5.0) < 1e-9, f"diagonal should be 5.0, got {diagonal}"
+print("variables10 ✓")

pythonlings/curriculum/checks/variables/variables2.py

@@ -0,0 +1,19 @@
+sum_ab = a + b
+diff_ab = a - b
+product_ab = a * b
+quotient_ab = a / b
+remainder_ab = a % b
+sum_ac = str(a) + c
+product_ac = c * b
+
+assert isinstance(a, int), "a should be an integer"
+assert isinstance(b, int), "b should be an integer"
+assert isinstance(c, str), "c should be a string"
+assert sum_ab == 13, "sum_ab should be 13"
+assert diff_ab == 7, "diff_ab should be 7"
+assert product_ab == 30, "product_ab should be 30"
+assert quotient_ab == 3.3333333333333335
+assert remainder_ab == 1
+assert sum_ac == "10hello"
+assert product_ac == "hellohellohello"
+print("variables2 ✓")

pythonlings/curriculum/checks/variables/variables3.py

@@ -0,0 +1,4 @@
+assert count == 7 and isinstance(count, int), "count should be int 7"
+assert ratio == 0.5 and isinstance(ratio, float), "ratio should be float 0.5"
+assert is_ready is True, "is_ready should be True"
+print("variables3 ✓")

pythonlings/curriculum/checks/variables/variables4.py

@@ -0,0 +1,2 @@
+assert score == 42, f"score should be 42, got {score}"
+print("variables4 ✓")

pythonlings/curriculum/checks/variables/variables5.py

@@ -0,0 +1,2 @@
+assert total == 48, f"total should be 48, got {total}"
+print("variables5 ✓")

pythonlings/curriculum/checks/variables/variables6.py

@@ -0,0 +1,4 @@
+assert x == 1, f"x should be 1, got {x}"
+assert y == 2, f"y should be 2, got {y}"
+assert x + y == 3, "x + y should equal 3"
+print("variables6 ✓")

pythonlings/curriculum/checks/variables/variables7.py

@@ -0,0 +1,3 @@
+assert a == 20, f"a should be 20 after swap, got {a}"
+assert b == 10, f"b should be 10 after swap, got {b}"
+print("variables7 ✓")

pythonlings/curriculum/checks/variables/variables8.py

@@ -0,0 +1,4 @@
+assert kind is float, f"kind should be float (the type), got {kind}"
+assert as_int == 3 and isinstance(as_int, int), f"as_int should be int 3, got {as_int!r}"
+assert as_str == "42" and isinstance(as_str, str), f"as_str should be str '42', got {as_str!r}"
+print("variables8 ✓")

pythonlings/curriculum/checks/variables/variables9.py

@@ -0,0 +1,3 @@
+assert TAX_RATE == 0.2, f"TAX_RATE should be 0.2, got {TAX_RATE}"
+assert total_price == 60.0, f"total_price should be 60.0, got {total_price}"
+print("variables9 ✓")

pythonlings/curriculum/exercises/async/async1.py

@@ -0,0 +1,7 @@
+# Exercise: Async 1
+# I AM NOT DONE
+#
+# Goal: Complete the coroutine so it returns "hello async".
+
+async def greet():
+    return ???

pythonlings/curriculum/exercises/async/async10.py

@@ -0,0 +1,14 @@
+# Exercise: Async 10
+# I AM NOT DONE
+#
+# Goal: Build a small async pipeline that fetches names and joins them.
+
+import asyncio
+
+async def fetch_name(name):
+    await asyncio.sleep(0)
+    return name.upper()
+
+async def fetch_all(names):
+    upper_names = ???
+    return ",".join(upper_names)

pythonlings/curriculum/exercises/async/async2.py

@@ -0,0 +1,10 @@
+# Exercise: Async 2
+# I AM NOT DONE
+#
+# Goal: Await another coroutine and return its value.
+
+async def get_message():
+    return "ready"
+
+async def main():
+    return ???

pythonlings/curriculum/exercises/async/async3.py

@@ -0,0 +1,10 @@
+# Exercise: Async 3
+# I AM NOT DONE
+#
+# Goal: Await asyncio.sleep before returning "awake".
+
+import asyncio
+
+async def wake_up():
+    ???
+    return "awake"

pythonlings/curriculum/exercises/async/async4.py

@@ -0,0 +1,15 @@
+# Exercise: Async 4
+# I AM NOT DONE
+#
+# Goal: Use asyncio.gather to run two coroutines and return both results.
+
+import asyncio
+
+async def first():
+    return "a"
+
+async def second():
+    return "b"
+
+async def collect():
+    return ???

pythonlings/curriculum/exercises/async/async5.py

@@ -0,0 +1,13 @@
+# Exercise: Async 5
+# I AM NOT DONE
+#
+# Goal: Create a task, await it, and return its result.
+
+import asyncio
+
+async def compute():
+    return 21 * 2
+
+async def run_task():
+    task = ???
+    return await task

pythonlings/curriculum/exercises/async/async6.py

@@ -0,0 +1,14 @@
+# Exercise: Async 6
+# I AM NOT DONE
+#
+# Goal: Consume an async generator with async for.
+
+async def numbers():
+    for value in [1, 2, 3]:
+        yield value
+
+async def collect_numbers():
+    result = []
+    async for value in numbers():
+        ???
+    return result

pythonlings/curriculum/exercises/async/async7.py

@@ -0,0 +1,13 @@
+# Exercise: Async 7
+# I AM NOT DONE
+#
+# Goal: Use asyncio.wait_for to apply a timeout to a coroutine.
+
+import asyncio
+
+async def quick():
+    await asyncio.sleep(0)
+    return "done"
+
+async def with_timeout():
+    return ???

pythonlings/curriculum/exercises/async/async8.py

@@ -0,0 +1,11 @@
+# Exercise: Async 8
+# I AM NOT DONE
+#
+# Goal: Run async work from synchronous code with asyncio.run.
+
+import asyncio
+
+async def answer():
+    return 42
+
+result = ???

pythonlings/curriculum/exercises/async/async9.py

@@ -0,0 +1,13 @@
+# Exercise: Async 9
+# I AM NOT DONE
+#
+# Goal: Gather doubled values from several async calls.
+
+import asyncio
+
+async def double(value):
+    await asyncio.sleep(0)
+    return value * 2
+
+async def double_all(values):
+    return ???

pythonlings/curriculum/exercises/classes/classes1.py

@@ -0,0 +1,13 @@
+# Exercise: Classes 1
+# I AM NOT DONE
+#
+# Define a class called `Cat`.
+# The class body can be a single `pass` statement — it just needs to exist.
+# Then create an instance of it and assign it to `my_cat`.
+
+# Replace ??? with the class body (a single `pass`).
+class Cat:
+    ???
+
+
+my_cat = Cat()

pythonlings/curriculum/exercises/classes/classes10.py

@@ -0,0 +1,22 @@
+# Exercise: Classes 10
+# I AM NOT DONE
+#
+# `Circle.pi` should be a class attribute (shared by all instances),
+# not set inside __init__. Move `pi = 3.14159` to be a class-level
+# attribute. The `area` method already uses `self.pi` so it will work
+# once the attribute is accessible on the instance via the class.
+#
+# Right now `pi` is only set inside __init__ incorrectly — remove the
+# `pi = 3.14159` line from inside __init__ and put it at class level.
+
+class Circle:
+    def __init__(self, radius):
+        pi = 3.14159        # wrong: local variable, not a class attribute
+        self.radius = radius
+
+    def area(self):
+        return self.pi * self.radius ** 2
+
+
+c1 = Circle(1)
+c2 = Circle(5)

pythonlings/curriculum/exercises/classes/classes11.py

@@ -0,0 +1,24 @@
+# Exercise: Classes 11
+# I AM NOT DONE
+#
+# Add a class method `from_string` to Temperature that parses a string
+# like "36.6C" and returns a new Temperature instance with the numeric
+# value. For example, Temperature.from_string("100C") should return
+# Temperature(100.0).
+#
+# The method signature is:
+#   @classmethod
+#   def from_string(cls, s):
+#       ...
+#
+# Hint: float(s[:-1]) strips the trailing "C" and converts to float.
+
+class Temperature:
+    def __init__(self, degrees):
+        self.degrees = degrees
+
+    # Add from_string here
+
+
+t = Temperature.from_string("36.6C")
+boiling = Temperature.from_string("100C")

pythonlings/curriculum/exercises/classes/classes12.py

@@ -0,0 +1,33 @@
+# Exercise: Classes 12
+# I AM NOT DONE
+#
+# Complete the BankAccount class so that all of the following work:
+#
+#   account = BankAccount("Alice", 100)
+#   account.deposit(50)       -> balance becomes 150
+#   account.withdraw(30)      -> balance becomes 120
+#   account.withdraw(200)     -> raises ValueError ("insufficient funds")
+#   str(account)              -> "BankAccount(Alice, balance=120)"
+#
+# Four things to fix:
+#  1. `deposit` currently does nothing — make it add `amount` to balance.
+#  2. `withdraw` currently does nothing — make it subtract `amount` from
+#     balance, and raise ValueError("insufficient funds") if amount > balance.
+#  3. `__str__` currently returns "" — return the correct string.
+#  4. The class is missing `__init__` entirely — add it to store
+#     `owner` and `balance` as instance attributes.
+
+class BankAccount:
+    def deposit(self, amount):
+        pass
+
+    def withdraw(self, amount):
+        pass
+
+    def __str__(self):
+        return ""
+
+
+account = BankAccount("Alice", 100)
+account.deposit(50)
+account.withdraw(30)

pythonlings/curriculum/exercises/classes/classes2.py

@@ -0,0 +1,13 @@
+# Exercise: Classes 2
+# I AM NOT DONE
+#
+# Give the Dog class an __init__ that stores its `name` argument
+# on the instance as `self.name`.
+
+class Dog:
+    def __init__(self, name):
+        # store name on the instance
+        pass
+
+
+rex = Dog("Rex")

pythonlings/curriculum/exercises/classes/classes3.py

@@ -0,0 +1,13 @@
+# Exercise: Classes 3
+# I AM NOT DONE
+#
+# The Point class should store both `x` and `y` as instance attributes
+# in its __init__. Right now only `x` is stored. Add `self.y = y`.
+
+class Point:
+    def __init__(self, x, y):
+        self.x = x
+        # also store y on the instance
+
+
+p = Point(3, 7)

pythonlings/curriculum/exercises/classes/classes4.py

@@ -0,0 +1,16 @@
+# Exercise: Classes 4
+# I AM NOT DONE
+#
+# Add a method `area` to the Rectangle class that returns
+# `self.width * self.height`. Right now it returns 0.
+
+class Rectangle:
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+
+    def area(self):
+        return 0
+
+
+rect = Rectangle(4, 5)

pythonlings/curriculum/exercises/classes/classes5.py

@@ -0,0 +1,18 @@
+# Exercise: Classes 5
+# I AM NOT DONE
+#
+# Add an `increment` method to Counter that adds 1 to `self.count`.
+# The method currently does nothing — replace `pass` with the right line.
+
+class Counter:
+    def __init__(self):
+        self.count = 0
+
+    def increment(self):
+        pass
+
+
+c = Counter()
+c.increment()
+c.increment()
+c.increment()

pythonlings/curriculum/exercises/classes/classes6.py

@@ -0,0 +1,15 @@
+# Exercise: Classes 6
+# I AM NOT DONE
+#
+# Give the `speed` parameter in Car.__init__ a default value of 0,
+# so that `Car("Tesla")` works without passing a speed.
+# Right now `speed` has no default, so the call below raises a TypeError.
+
+class Car:
+    def __init__(self, brand, speed):
+        self.brand = brand
+        self.speed = speed
+
+
+slow = Car("Tesla")
+fast = Car("Ferrari", 200)

pythonlings/curriculum/exercises/classes/classes7.py

@@ -0,0 +1,18 @@
+# Exercise: Classes 7
+# I AM NOT DONE
+#
+# The `greet` method should call `self.get_name()` to get the name
+# and return the greeting string. Replace ??? with the correct call.
+
+class Greeter:
+    def __init__(self, name):
+        self.name = name
+
+    def get_name(self):
+        return self.name
+
+    def greet(self):
+        return f"Hello, {???}!"
+
+
+g = Greeter("Alice")

pythonlings/curriculum/exercises/classes/classes8.py

@@ -0,0 +1,14 @@
+# Exercise: Classes 8
+# I AM NOT DONE
+#
+# Add a `__str__` method to the Book class so that
+# `str(book)` returns the string "Book: <title> by <author>".
+# Right now the class has no __str__, so str() returns the default repr.
+
+class Book:
+    def __init__(self, title, author):
+        self.title = title
+        self.author = author
+
+
+book = Book("1984", "Orwell")

pythonlings/curriculum/exercises/classes/classes9.py

@@ -0,0 +1,18 @@
+# Exercise: Classes 9
+# I AM NOT DONE
+#
+# Add a `__repr__` method to Color so that repr(c) returns
+# "Color(r=<r>, g=<g>, b=<b>)" using the actual values.
+# The __str__ is already provided; you only need to add __repr__.
+
+class Color:
+    def __init__(self, r, g, b):
+        self.r = r
+        self.g = g
+        self.b = b
+
+    def __str__(self):
+        return f"rgb({self.r}, {self.g}, {self.b})"
+
+
+c = Color(255, 128, 0)

pythonlings/curriculum/exercises/collections/collections1.py

@@ -0,0 +1,11 @@
+# Exercise: Collections 1
+# -----------------------
+# I AM NOT DONE
+#
+# Use collections.Counter to count how many times each word appears
+# in `words`. Store the resulting Counter in `counts`.
+
+from collections import Counter
+
+words = ["apple", "banana", "apple", "cherry", "banana", "apple"]
+counts = ???

pythonlings/curriculum/exercises/collections/collections10.py

@@ -0,0 +1,37 @@
+# Exercise: Collections 10
+# ------------------------
+# I AM NOT DONE
+#
+# Combine what you have learned to analyse a dataset end-to-end.
+#
+# `log` is a list of (category, value) pairs representing web-server
+# requests: category is the endpoint group, value is the response time.
+#
+# Your tasks:
+#   1. Use `defaultdict(list)` named `grouped` to group response times
+#      by category.
+#   2. Build a `Counter` named `hit_counts` that maps each category to
+#      the number of requests it received.
+#   3. Store in `top_category` the name of the single most-requested
+#      category (the first element returned by `.most_common(1)`).
+#   4. Store in `avg_times` a plain dict mapping each category to the
+#      average (mean) response time for that category (sum / count).
+#      Use regular division — no imports needed.
+
+from collections import defaultdict, Counter
+
+log = [
+    ("api",    120), ("web",  45), ("api",   95), ("db",  300),
+    ("web",     60), ("api", 110), ("db",   280), ("web",  55),
+    ("api",     85), ("db",  310), ("web",   50), ("api", 100),
+]
+
+grouped = ???
+for category, value in log:
+    ???
+
+hit_counts = ???
+
+top_category = ???
+
+avg_times = ???

pythonlings/curriculum/exercises/collections/collections2.py

@@ -0,0 +1,18 @@
+# Exercise: Collections 2
+# -----------------------
+# I AM NOT DONE
+#
+# `Counter.most_common(n)` returns the n most frequent elements as a list
+# of (element, count) pairs, highest count first.
+#
+# Given `votes`, build a Counter called `tally` and then store in
+# `top2` the two most common candidates (call `.most_common(2)`).
+
+from collections import Counter
+
+votes = [
+    "Alice", "Bob", "Alice", "Carol", "Bob", "Alice",
+    "Carol", "Bob", "Alice", "Carol",
+]
+tally = Counter(votes)
+top2 = ???

pythonlings/curriculum/exercises/collections/collections3.py

@@ -0,0 +1,17 @@
+# Exercise: Collections 3
+# -----------------------
+# I AM NOT DONE
+#
+# `defaultdict(int)` is handy for counting: accessing a missing key
+# automatically starts its count at 0.
+#
+# Use a `defaultdict(int)` to count how many times each character
+# appears in `text`. Store the defaultdict in `char_counts`.
+# Do NOT use Counter — iterate over the string and increment manually.
+
+from collections import defaultdict
+
+text = "mississippi"
+char_counts = ???
+for ch in text:
+    ???